feat: BL plugin menu in BECDockArea

Automatically generated by python-semantic-release

CHANGELOG.md

@@ -1,6 +1,41 @@
 # CHANGELOG
 
 
+## v3.9.1 (2026-05-12)
+
+### Bug Fixes
+
+- Logpanel fixture overwriting xread
+  ([`3c7834b`](https://github.com/bec-project/bec_widgets/commit/3c7834b492a5d2da13689f58b20caf38dda9ac1d))
+
+- **scan_control**: Restore scan parameters from history are fetched on demand with button
+  ([`acd35a2`](https://github.com/bec-project/bec_widgets/commit/acd35a278660ce4962167af6237b5d12007f0774))
+
+
+## v3.9.0 (2026-05-12)
+
+### Bug Fixes
+
+- Test bw-generate-cli
+  ([`085f9fa`](https://github.com/bec-project/bec_widgets/commit/085f9fa271a0a8e339bff83f235011ac4a9d29ea))
+
+- **dock_area**: Icon fetching for toolbar import optimised
+  ([`79931fa`](https://github.com/bec-project/bec_widgets/commit/79931faf554fd0978c54d6562aa1b5fc4ab823b2))
+
+- **jupyter_console_widget**: Widget_handler API fix
+  ([`6b3cebe`](https://github.com/bec-project/bec_widgets/commit/6b3cebe9cbdb5c02ae2aa14b0f624a51c9c2ca4c))
+
+### Features
+
+- Move to lazy widget import
+  ([`5cc8242`](https://github.com/bec-project/bec_widgets/commit/5cc82425f07d76e881ae59a121a3af77f227bfee))
+
+### Testing
+
+- Fix available scans endpoint operation
+  ([`bb1544e`](https://github.com/bec-project/bec_widgets/commit/bb1544ecb70612267e2b03ba041c6f656789d63c))
+
+
 ## v3.8.1 (2026-05-11)
 
 ### Bug Fixes

bec_widgets/cli/designer_plugins.py

@@ -0,0 +1,171 @@
+# This file was automatically generated by generate_cli.py
+# type: ignore
+from __future__ import annotations
+
+# pylint: skip-file
+
+designer_plugins = {
+    "AbortButton": ("bec_widgets.widgets.control.buttons.button_abort.button_abort", "AbortButton"),
+    "BECColorMapWidget": (
+        "bec_widgets.widgets.utility.visual.colormap_widget.colormap_widget",
+        "BECColorMapWidget",
+    ),
+    "BECMainWindow": ("bec_widgets.widgets.containers.main_window.main_window", "BECMainWindow"),
+    "BECProgressBar": (
+        "bec_widgets.widgets.progress.bec_progressbar.bec_progressbar",
+        "BECProgressBar",
+    ),
+    "BECQueue": ("bec_widgets.widgets.services.bec_queue.bec_queue", "BECQueue"),
+    "BECShell": ("bec_widgets.widgets.editors.bec_console.bec_console", "BECShell"),
+    "BECSpinBox": ("bec_widgets.widgets.utility.spinbox.decimal_spinbox", "BECSpinBox"),
+    "BECStatusBox": ("bec_widgets.widgets.services.bec_status_box.bec_status_box", "BECStatusBox"),
+    "BecConsole": ("bec_widgets.widgets.editors.bec_console.bec_console", "BecConsole"),
+    "ColorButton": ("bec_widgets.widgets.utility.visual.color_button.color_button", "ColorButton"),
+    "ColorButtonNative": (
+        "bec_widgets.widgets.utility.visual.color_button_native.color_button_native",
+        "ColorButtonNative",
+    ),
+    "ColormapSelector": (
+        "bec_widgets.widgets.utility.visual.colormap_selector.colormap_selector",
+        "ColormapSelector",
+    ),
+    "DapComboBox": ("bec_widgets.widgets.dap.dap_combo_box.dap_combo_box", "DapComboBox"),
+    "DarkModeButton": (
+        "bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button",
+        "DarkModeButton",
+    ),
+    "DeviceBrowser": (
+        "bec_widgets.widgets.services.device_browser.device_browser",
+        "DeviceBrowser",
+    ),
+    "DeviceComboBox": (
+        "bec_widgets.widgets.control.device_input.device_combobox.device_combobox",
+        "DeviceComboBox",
+    ),
+    "DeviceLineEdit": (
+        "bec_widgets.widgets.control.device_input.device_line_edit.device_line_edit",
+        "DeviceLineEdit",
+    ),
+    "Heatmap": ("bec_widgets.widgets.plots.heatmap.heatmap", "Heatmap"),
+    "IDEExplorer": ("bec_widgets.widgets.utility.ide_explorer.ide_explorer", "IDEExplorer"),
+    "Image": ("bec_widgets.widgets.plots.image.image", "Image"),
+    "LMFitDialog": ("bec_widgets.widgets.dap.lmfit_dialog.lmfit_dialog", "LMFitDialog"),
+    "LogPanel": ("bec_widgets.widgets.utility.logpanel.logpanel", "LogPanel"),
+    "Minesweeper": ("bec_widgets.widgets.games.minesweeper", "Minesweeper"),
+    "MonacoWidget": ("bec_widgets.widgets.editors.monaco.monaco_widget", "MonacoWidget"),
+    "MotorMap": ("bec_widgets.widgets.plots.motor_map.motor_map", "MotorMap"),
+    "MultiWaveform": ("bec_widgets.widgets.plots.multi_waveform.multi_waveform", "MultiWaveform"),
+    "PdfViewerWidget": ("bec_widgets.widgets.utility.pdf_viewer.pdf_viewer", "PdfViewerWidget"),
+    "PositionIndicator": (
+        "bec_widgets.widgets.control.device_control.position_indicator.position_indicator",
+        "PositionIndicator",
+    ),
+    "PositionerBox": (
+        "bec_widgets.widgets.control.device_control.positioner_box.positioner_box.positioner_box",
+        "PositionerBox",
+    ),
+    "PositionerBox2D": (
+        "bec_widgets.widgets.control.device_control.positioner_box.positioner_box_2d.positioner_box_2d",
+        "PositionerBox2D",
+    ),
+    "PositionerControlLine": (
+        "bec_widgets.widgets.control.device_control.positioner_box.positioner_control_line.positioner_control_line",
+        "PositionerControlLine",
+    ),
+    "PositionerGroup": (
+        "bec_widgets.widgets.control.device_control.positioner_group.positioner_group",
+        "PositionerGroup",
+    ),
+    "ResetButton": ("bec_widgets.widgets.control.buttons.button_reset.button_reset", "ResetButton"),
+    "ResumeButton": (
+        "bec_widgets.widgets.control.buttons.button_resume.button_resume",
+        "ResumeButton",
+    ),
+    "RingProgressBar": (
+        "bec_widgets.widgets.progress.ring_progress_bar.ring_progress_bar",
+        "RingProgressBar",
+    ),
+    "SBBMonitor": ("bec_widgets.widgets.editors.sbb_monitor.sbb_monitor", "SBBMonitor"),
+    "ScanControl": ("bec_widgets.widgets.control.scan_control.scan_control", "ScanControl"),
+    "ScanMetadata": ("bec_widgets.widgets.editors.scan_metadata.scan_metadata", "ScanMetadata"),
+    "ScanProgressBar": (
+        "bec_widgets.widgets.progress.scan_progressbar.scan_progressbar",
+        "ScanProgressBar",
+    ),
+    "ScatterWaveform": (
+        "bec_widgets.widgets.plots.scatter_waveform.scatter_waveform",
+        "ScatterWaveform",
+    ),
+    "SignalComboBox": (
+        "bec_widgets.widgets.control.device_input.signal_combobox.signal_combobox",
+        "SignalComboBox",
+    ),
+    "SignalLabel": ("bec_widgets.widgets.utility.signal_label.signal_label", "SignalLabel"),
+    "SignalLineEdit": (
+        "bec_widgets.widgets.control.device_input.signal_line_edit.signal_line_edit",
+        "SignalLineEdit",
+    ),
+    "SpinnerWidget": ("bec_widgets.widgets.utility.spinner.spinner", "SpinnerWidget"),
+    "StopButton": ("bec_widgets.widgets.control.buttons.stop_button.stop_button", "StopButton"),
+    "TextBox": ("bec_widgets.widgets.editors.text_box.text_box", "TextBox"),
+    "ToggleSwitch": ("bec_widgets.widgets.utility.toggle.toggle", "ToggleSwitch"),
+    "Waveform": ("bec_widgets.widgets.plots.waveform.waveform", "Waveform"),
+    "WebsiteWidget": ("bec_widgets.widgets.editors.website.website", "WebsiteWidget"),
+    "WidgetFinderComboBox": (
+        "bec_widgets.widgets.utility.widget_finder.widget_finder",
+        "WidgetFinderComboBox",
+    ),
+}
+
+widget_icons = {
+    "AbortButton": "cancel",
+    "BECColorMapWidget": "palette",
+    "BECMainWindow": "widgets",
+    "BECProgressBar": "page_control",
+    "BECQueue": "edit_note",
+    "BECShell": "hub",
+    "BECSpinBox": "123",
+    "BECStatusBox": "widgets",
+    "BecConsole": "terminal",
+    "ColorButton": "colors",
+    "ColorButtonNative": "colors",
+    "ColormapSelector": "palette",
+    "DapComboBox": "data_exploration",
+    "DarkModeButton": "dark_mode",
+    "DeviceBrowser": "lists",
+    "DeviceComboBox": "list_alt",
+    "DeviceLineEdit": "edit_note",
+    "Heatmap": "dataset",
+    "IDEExplorer": "widgets",
+    "Image": "image",
+    "LMFitDialog": "monitoring",
+    "LogPanel": "browse_activity",
+    "Minesweeper": "videogame_asset",
+    "MonacoWidget": "code",
+    "MotorMap": "my_location",
+    "MultiWaveform": "ssid_chart",
+    "PdfViewerWidget": "picture_as_pdf",
+    "PositionIndicator": "horizontal_distribute",
+    "PositionerBox": "switch_right",
+    "PositionerBox2D": "switch_right",
+    "PositionerControlLine": "switch_left",
+    "PositionerGroup": "grid_view",
+    "ResetButton": "restart_alt",
+    "ResumeButton": "resume",
+    "RingProgressBar": "track_changes",
+    "SBBMonitor": "train",
+    "ScanControl": "tune",
+    "ScanMetadata": "list_alt",
+    "ScanProgressBar": "timelapse",
+    "ScatterWaveform": "scatter_plot",
+    "SignalComboBox": "list_alt",
+    "SignalLabel": "scoreboard",
+    "SignalLineEdit": "vital_signs",
+    "SpinnerWidget": "progress_activity",
+    "StopButton": "dangerous",
+    "TextBox": "chat",
+    "ToggleSwitch": "toggle_on",
+    "Waveform": "show_chart",
+    "WebsiteWidget": "travel_explore",
+    "WidgetFinderComboBox": "frame_inspect",
+}

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -206,7 +206,6 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
 
     def _populate_registry_widgets(self):
         try:
-            widget_handler.update_available_widgets()
             items = sorted(widget_handler.widget_classes.keys())
         except Exception as exc:
             print(f"Failed to load registered widgets: {exc}")
@@ -335,20 +334,13 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
 
         If kwargs does not contain `object_name`, it will default to the provided shortcut.
         """
-        # Ensure registry is loaded
-        widget_handler.update_available_widgets()
-        cls = widget_handler.widget_classes.get(widget_type)
-        if cls is None:
-            raise ValueError(f"Unknown registered widget type: {widget_type}")
-
         if kwargs is None:
             kwargs = {"object_name": shortcut}
         else:
             kwargs = dict(kwargs)
             kwargs.setdefault("object_name", shortcut)
 
-        # Instantiate and add
+        widget = widget_handler.create_widget(widget_type, **kwargs)
-        widget = cls(**kwargs)
         if not isinstance(widget, QWidget):
             raise TypeError(
                 f"Instantiated object for type '{widget_type}' is not a QWidget: {type(widget)}"

bec_widgets/utils/bec_plugin_helper.py

@@ -4,6 +4,7 @@ import importlib.metadata
 import inspect
 import pkgutil
 import traceback
+from functools import lru_cache
 from importlib import util as importlib_util
 from importlib.machinery import FileFinder, ModuleSpec, SourceFileLoader
 from types import ModuleType
@@ -11,7 +12,11 @@ from typing import Generator
 
 from bec_lib.logger import bec_logger
 
-from bec_widgets.utils.plugin_utils import BECClassContainer, BECClassInfo
+from bec_widgets.utils.plugin_utils import (
+    BECClassContainer,
+    BECClassInfo,
+    rpc_widget_registry_from_source,
+)
 
 logger = bec_logger.logger
 
@@ -53,6 +58,14 @@ def _submodule_by_name(module: ModuleType, name: str):
     return None
 
 
+def _submodule_spec_by_name(module: ModuleType, name: str) -> ModuleSpec | None:
+    for module_info in pkgutil.iter_modules(module.__path__):
+        if module_info.name != name or not isinstance(module_info.module_finder, FileFinder):
+            continue
+        return module_info.module_finder.find_spec(module_info.name)
+    return None
+
+
 def _get_widgets_from_module(module: ModuleType) -> BECClassContainer:
     """Find any BECWidget subclasses in the given module and return them with their info."""
     from bec_widgets.utils.bec_widget import BECWidget  # avoid circular import
@@ -90,16 +103,64 @@ def get_plugin_client_module() -> ModuleType | None:
     return _submodule_by_name(plugin, "client") if (plugin := user_widget_plugin()) else None
 
 
+def get_plugin_designer_module() -> ModuleType | None:
+    """If there is a plugin repository installed, return the designer module."""
+    return (
+        _submodule_by_name(plugin, "designer_plugins") if (plugin := user_widget_plugin()) else None
+    )
+
+
+@lru_cache
+def get_plugin_rpc_widget_registry() -> dict[str, tuple[str, str]]:
+    """If there is a plugin repository installed, return the RPC widget registry."""
+    plugin = user_widget_plugin()
+    if plugin is None:
+        return {}
+
+    client_spec = _submodule_spec_by_name(plugin, "client")
+    if client_spec is not None and client_spec.origin:
+        try:
+            return rpc_widget_registry_from_source(client_spec.origin)
+        except (OSError, SyntaxError) as exc:
+            logger.warning(f"Could not parse plugin RPC widget registry: {exc}")
+
+    client_module = get_plugin_client_module()
+    if client_module is None:
+        return {}
+    registry = {}
+    for plugin_name, plugin_class in inspect.getmembers(client_module, inspect.isclass):
+        if hasattr(plugin_class, "_IMPORT_MODULE"):
+            registry[plugin_name] = (plugin_class._IMPORT_MODULE, plugin_class.__name__)
+    return registry
+
+
+@lru_cache
+def get_plugin_designer_registry() -> dict[str, tuple[str, str]]:
+    """If there is a plugin repository installed, return the designer plugin registry."""
+    designer_module = get_plugin_designer_module()
+    if designer_module and hasattr(designer_module, "designer_plugins"):
+        return designer_module.designer_plugins
+    return {}
+
+
+@lru_cache
+def get_plugin_widget_icons() -> dict[str, str]:
+    """If there is a plugin repository installed, return the designer widget icon registry."""
+    designer_module = get_plugin_designer_module()
+    if designer_module and hasattr(designer_module, "widget_icons"):
+        return designer_module.widget_icons
+    return {}
+
+
 def get_all_plugin_widgets() -> BECClassContainer:
     """If there is a plugin repository installed, load all widgets from it."""
     if plugin := user_widget_plugin():
         return _all_widgets_from_all_submods(plugin)
-    else:
+    return BECClassContainer()
-        return BECClassContainer()
 
 
 if __name__ == "__main__":  # pragma: no cover
-
+    widgets = get_plugin_rpc_widget_registry()
     client = get_plugin_client_module()
     print(get_all_plugin_widgets())
     ...

bec_widgets/utils/generate_cli.py

@@ -14,7 +14,11 @@ import isort
 from bec_lib.logger import bec_logger
 from qtpy.QtCore import Property as QtProperty
 
-from bec_widgets.utils.generate_designer_plugin import DesignerPluginGenerator, plugin_filenames
+from bec_widgets.utils.generate_designer_plugin import (
+    DesignerPluginGenerator,
+    DesignerPluginInfo,
+    plugin_filenames,
+)
 from bec_widgets.utils.plugin_utils import BECClassContainer, get_custom_classes
 
 logger = bec_logger.logger
@@ -250,6 +254,58 @@ class {class_name}(RPCBase):\n"""
             file.write(formatted_content)
 
 
+def write_designer_plugins(plugin_infos: list[DesignerPluginInfo], file_name: str):
+    """
+    Write a registry of Qt widget classes with designer plugins.
+
+    Args:
+        plugin_infos(list[DesignerPluginInfo]): The designer plugin metadata to write.
+        file_name(str): The name of the file to write to.
+    """
+    plugin_infos = sorted(plugin_infos, key=lambda info: info.plugin_name_pascal)
+    content = """# This file was automatically generated by generate_cli.py
+# type: ignore
+from __future__ import annotations
+
+# pylint: skip-file
+
+designer_plugins = {
+"""
+    for info in plugin_infos:
+        widget_module = info.plugin_class.__module__
+        widget_class = info.plugin_name_pascal
+        content += f'    "{info.plugin_name_pascal}": ("{widget_module}", "{widget_class}"),\n'
+
+    content += """
+}
+
+widget_icons = {
+"""
+    for info in plugin_infos:
+        content += f'    "{info.plugin_name_pascal}": "{info.icon_name}",\n'
+
+    content += """
+}
+"""
+
+    try:
+        formatted_content = black.format_str(content, mode=black.Mode(line_length=100))
+    except black.NothingChanged:
+        formatted_content = content
+
+    config = isort.Config(
+        profile="black",
+        line_length=100,
+        multi_line_output=3,
+        include_trailing_comma=False,
+        known_first_party=["bec_widgets"],
+    )
+    formatted_content = isort.code(formatted_content, config=config)
+
+    with open(file_name, "w", encoding="utf-8") as file:
+        file.write(formatted_content)
+
+
 def main():
     """
     Main entry point for the script, controlled by command line arguments.
@@ -303,6 +359,8 @@ def main():
     else:
         non_overwrite_classes = []
 
+    designer_plugin_infos = []
+
     for cls in rpc_classes.plugins:
         logger.info(f"Writing bec-designer plugin files for {cls.__name__}...")
 
@@ -310,21 +368,30 @@ def main():
             logger.error(
                 f"Not writing plugin files for {cls.__name__} because a built-in widget with that name exists"
             )
+            continue
 
         plugin = DesignerPluginGenerator(cls)
-        if not hasattr(plugin, "info"):
+        if not hasattr(plugin, "info") or plugin.excluded:
             continue
 
         def _exists(file: str):
             return os.path.exists(os.path.join(plugin.info.base_path, file))
 
         if any(_exists(file) for file in plugin_filenames(plugin.info.plugin_name_snake)):
+            if _exists(plugin.filenames.plugin):
+                designer_plugin_infos.append(plugin.info)
             logger.debug(
                 f"Skipping generation of extra plugin files for {plugin.info.plugin_name_snake} - at least one file out of 'plugin.py', 'pyproject', and 'register_{plugin.info.plugin_name_snake}.py' already exists."
             )
             continue
 
         plugin.run()
+        designer_plugin_infos.append(plugin.info)
+
+    # Write designer_plugins.py with plugin import metadata for all widgets with designer plugins.
+    designer_plugins_path = module_dir / client_subdir / "designer_plugins.py"
+    logger.info(f"Generating designer plugin registry at {designer_plugins_path}")
+    write_designer_plugins(designer_plugin_infos, str(designer_plugins_path))
 
 
 if __name__ == "__main__":  # pragma: no cover

bec_widgets/utils/generate_designer_plugin.py

@@ -29,6 +29,7 @@ class DesignerPluginInfo:
         self.plugin_name_pascal = plugin_class.__name__
         self.plugin_name_snake = pascal_to_snake(self.plugin_name_pascal)
         self.widget_import = f"from {plugin_class.__module__} import {self.plugin_name_pascal}"
+        self.icon_name = getattr(plugin_class, "ICON_NAME", "")
         plugin_module = (
             ".".join(plugin_class.__module__.split(".")[:-1]) + f".{self.plugin_name_snake}_plugin"
         )
@@ -63,6 +64,10 @@ class DesignerPluginGenerator:
     def filenames(self):
         return plugin_filenames(self.info.plugin_name_snake)
 
+    @property
+    def excluded(self):
+        return self._excluded
+
     def run(self, validate=True):
         if self._excluded:
             print(f"Plugin {self.widget.__name__} is excluded from generation.")

bec_widgets/utils/plugin_utils.py

@@ -1,56 +1,22 @@
 from __future__ import annotations
 
+import ast
 import importlib
 import inspect
 import os
 from dataclasses import dataclass
+from functools import lru_cache
+from pathlib import Path
 from typing import TYPE_CHECKING, Iterable
 
-from bec_lib.plugin_helper import _get_available_plugins
-from qtpy.QtWidgets import QWidget
-
-from bec_widgets.utils.bec_connector import BECConnector
-from bec_widgets.utils.bec_widget import BECWidget
-
 if TYPE_CHECKING:  # pragma: no cover
+    from qtpy.QtWidgets import QWidget
+
+    from bec_widgets.utils.bec_connector import BECConnector
+    from bec_widgets.utils.bec_widget import BECWidget
     from bec_widgets.widgets.containers.auto_update.auto_updates import AutoUpdates
 
 
-def get_plugin_widgets() -> dict[str, BECConnector]:
-    """
-    Get all available widgets from the plugin directory. Widgets are classes that inherit from BECConnector.
-    The plugins are provided through python plugins and specified in the respective pyproject.toml file using
-    the following key:
-
-        [project.entry-points."bec.widgets.user_widgets"]
-        plugin_widgets = "path.to.plugin.module"
-
-    e.g.
-        [project.entry-points."bec.widgets.user_widgets"]
-        plugin_widgets = "pxiii_bec.bec_widgets.widgets"
-
-        assuming that the widgets module for the package pxiii_bec is located at pxiii_bec/bec_widgets/widgets and
-        contains the widgets to be loaded within the pxiii_bec/bec_widgets/widgets/__init__.py file.
-
-    Returns:
-        dict[str, BECConnector]: A dictionary of widget names and their respective classes.
-    """
-    modules = _get_available_plugins("bec.widgets.user_widgets")
-    loaded_plugins = {}
-    print(modules)
-    for module in modules:
-        mods = inspect.getmembers(module, predicate=_filter_plugins)
-        for name, mod_cls in mods:
-            if name in loaded_plugins:
-                print(f"Duplicated widgets plugin {name}.")
-            loaded_plugins[name] = mod_cls
-    return loaded_plugins
-
-
-def _filter_plugins(obj):
-    return inspect.isclass(obj) and issubclass(obj, BECConnector)
-
-
 def get_plugin_auto_updates() -> dict[str, type[AutoUpdates]]:
     """
     Get all available auto update classes from the plugin directory. AutoUpdates must inherit from AutoUpdate and be
@@ -66,6 +32,8 @@ def get_plugin_auto_updates() -> dict[str, type[AutoUpdates]]:
     Returns:
         dict[str, AutoUpdates]: A dictionary of widget names and their respective classes.
     """
+    from bec_lib.plugin_helper import _get_available_plugins
+
     modules = _get_available_plugins("bec.widgets.auto_updates")
     loaded_plugins = {}
     for module in modules:
@@ -168,6 +136,11 @@ class BECClassContainer:
 
 def _collect_classes_from_package(repo_name: str, package: str) -> BECClassContainer:
     """Collect classes from a package subtree (for example ``widgets`` or ``applications``)."""
+    from qtpy.QtWidgets import QWidget
+
+    from bec_widgets.utils.bec_connector import BECConnector
+    from bec_widgets.utils.bec_widget import BECWidget
+
     collection = BECClassContainer()
     try:
         anchor_module = importlib.import_module(f"{repo_name}.{package}")
@@ -194,17 +167,18 @@ def _collect_classes_from_package(repo_name: str, package: str) -> BECClassConta
 
             for name in dir(module):
                 obj = getattr(module, name)
+                if not isinstance(obj, type):
+                    continue
                 if not hasattr(obj, "__module__") or obj.__module__ != module.__name__:
                     continue
-                if isinstance(obj, type):
+                class_info = BECClassInfo(name=name, module=module.__name__, file=path, obj=obj)
-                    class_info = BECClassInfo(name=name, module=module.__name__, file=path, obj=obj)
+                if issubclass(obj, BECConnector):
-                    if issubclass(obj, BECConnector):
+                    class_info.is_connector = True
-                        class_info.is_connector = True
+                if issubclass(obj, QWidget) or issubclass(obj, BECWidget):
-                    if issubclass(obj, QWidget) or issubclass(obj, BECWidget):
+                    class_info.is_widget = True
-                        class_info.is_widget = True
+                if hasattr(obj, "PLUGIN") and obj.PLUGIN:
-                    if hasattr(obj, "PLUGIN") and obj.PLUGIN:
+                    class_info.is_plugin = True
-                        class_info.is_plugin = True
+                collection.add_class(class_info)
-                    collection.add_class(class_info)
     return collection
 
 
@@ -229,3 +203,89 @@ def get_custom_classes(
     for package in selected_packages:
         collection += _collect_classes_from_package(repo_name, package)
     return collection
+
+
+def _get_designer_registry() -> dict[str, tuple[str, str]]:
+    from bec_widgets.cli.designer_plugins import designer_plugins
+
+    return designer_plugins
+
+
+def _resolve_widget_from_registry(import_path: str, widget_name: str) -> type[QWidget]:
+    widget = importlib.import_module(import_path)
+    return getattr(widget, widget_name)
+
+
+def designer_plugin_exists(name: str) -> bool:
+    from bec_widgets.utils.bec_plugin_helper import get_plugin_designer_registry
+
+    internal_registry = _get_designer_registry()
+    external_registry = get_plugin_designer_registry()
+    return name in internal_registry or name in external_registry
+
+
+def get_designer_plugin(name: str, raise_on_missing: bool = True) -> type[QWidget] | None:
+    from bec_widgets.utils.bec_plugin_helper import get_plugin_designer_registry
+
+    internal_registry = _get_designer_registry()
+    external_registry = get_plugin_designer_registry()
+    if name in external_registry:
+        import_path, widget_name = external_registry[name]
+        return _resolve_widget_from_registry(import_path, widget_name)
+    if name in internal_registry:
+        import_path, widget_name = internal_registry[name]
+        return _resolve_widget_from_registry(import_path, widget_name)
+
+    if raise_on_missing:
+        raise ValueError(
+            f"Designer plugin {name} not found in either internal or external registry."
+        )
+    return None
+
+
+def rpc_widget_registry_from_source(path: str | Path) -> dict[str, tuple[str, str]]:
+    """Parse a generated RPC client module and return its widget registry."""
+    source_path = Path(path)
+    module_node = ast.parse(source_path.read_text(encoding="utf-8"), filename=str(source_path))
+    registry = {}
+    for node in module_node.body:
+        if not isinstance(node, ast.ClassDef):
+            continue
+        for item in node.body:
+            if not isinstance(item, ast.Assign):
+                continue
+            if not any(
+                isinstance(target, ast.Name) and target.id == "_IMPORT_MODULE"
+                for target in item.targets
+            ):
+                continue
+            if isinstance(item.value, ast.Constant) and isinstance(item.value.value, str):
+                registry[node.name] = (item.value.value, node.name)
+            break
+    return registry
+
+
+@lru_cache
+def get_rpc_widget_registry() -> dict[str, tuple[str, str]]:
+    client_path = Path(__file__).resolve().parents[1] / "cli" / "client.py"
+    return rpc_widget_registry_from_source(client_path)
+
+
+@lru_cache
+def rpc_widget_registry() -> dict[str, tuple[str, str]]:
+    from bec_widgets.utils.bec_plugin_helper import get_plugin_rpc_widget_registry
+
+    internal_registry = get_rpc_widget_registry()
+    external_registry = get_plugin_rpc_widget_registry()
+    return {**external_registry, **internal_registry}
+
+
+def get_rpc_widget(name: str, raise_on_missing: bool = True) -> type[QWidget] | None:
+    registry = rpc_widget_registry()
+    if name in registry:
+        import_path, widget_name = registry[name]
+        return _resolve_widget_from_registry(import_path, widget_name)
+
+    if raise_on_missing:
+        raise ValueError(f"RPC widget {name} not found in registry.")
+    return None

bec_widgets/utils/rpc_widget_handler.py

@@ -1,42 +1,34 @@
 from __future__ import annotations
 
-from bec_widgets.cli.client_utils import IGNORE_WIDGETS
+from typing import TYPE_CHECKING
-from bec_widgets.utils.bec_plugin_helper import get_all_plugin_widgets
+
-from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.plugin_utils import get_rpc_widget, rpc_widget_registry
-from bec_widgets.utils.plugin_utils import get_custom_classes
+
+if TYPE_CHECKING:  # pragma: no cover
+    from bec_widgets.utils.bec_widget import BECWidget
 
 
 class RPCWidgetHandler:
     """Handler class for creating widgets from RPC messages."""
 
     def __init__(self):
-        self._widget_classes = None
+        self._widget_registry = None
 
     @property
-    def widget_classes(self) -> dict[str, type[BECWidget]]:
+    def widget_classes(self) -> dict[str, tuple[str, str]]:
         """
         Get the available widget classes.
 
         Returns:
             dict: The available widget classes.
         """
-        if self._widget_classes is None:
+        registry = rpc_widget_registry()
-            self.update_available_widgets()
+        if not registry:
-        return self._widget_classes  # type: ignore
+            return {}
+        return registry
 
-    def update_available_widgets(self):
+    @staticmethod
-        """
+    def create_widget(widget_type, **kwargs) -> BECWidget:
-        Update the available widgets.
-
-        Returns:
-            None
-        """
-        self._widget_classes = (
-            get_custom_classes("bec_widgets", packages=("widgets", "applications"))
-            + get_all_plugin_widgets()
-        ).as_dict(IGNORE_WIDGETS)
-
-    def create_widget(self, widget_type, **kwargs) -> BECWidget:
         """
         Create a widget from an RPC message.
 
@@ -48,9 +40,9 @@ class RPCWidgetHandler:
         Returns:
             widget(BECWidget): The created widget.
         """
-        widget_class = self.widget_classes.get(widget_type)  # type: ignore
+        widget = get_rpc_widget(widget_type, raise_on_missing=False)
-        if widget_class:
+        if widget:
-            return widget_class(**kwargs)
+            return widget(**kwargs)
         raise ValueError(f"Unknown widget type: {widget_type}")
 
 

bec_widgets/utils/ui_loader.py

@@ -1,10 +1,8 @@
 from bec_lib.logger import bec_logger
-from qtpy import PYQT6, PYSIDE6
+from qtpy import PYSIDE6
 from qtpy.QtCore import QFile, QIODevice
 
-from bec_widgets.utils.bec_plugin_helper import get_all_plugin_widgets
+from bec_widgets.utils.plugin_utils import get_designer_plugin
-from bec_widgets.utils.generate_designer_plugin import DesignerPluginInfo
-from bec_widgets.utils.plugin_utils import get_custom_classes
 
 logger = bec_logger.logger
 
@@ -12,16 +10,14 @@ if PYSIDE6:
     from qtpy.QtUiTools import QUiLoader
 
     class CustomUiLoader(QUiLoader):
-        def __init__(self, baseinstance, custom_widgets: dict | None = None):
+        def __init__(self, baseinstance):
             super().__init__(baseinstance)
-            self.custom_widgets = custom_widgets or {}
-
             self.baseinstance = baseinstance
 
         def createWidget(self, class_name, parent=None, name=""):
-            if class_name in self.custom_widgets:
+            widget = get_designer_plugin(class_name, raise_on_missing=False)
-                widget = self.custom_widgets[class_name](self.baseinstance)
+            if widget is not None:
-                return widget
+                return widget(self.baseinstance)
             return super().createWidget(class_name, self.baseinstance, name)
 
 
@@ -31,16 +27,9 @@ class UILoader:
     def __init__(self, parent=None):
         self.parent = parent
 
-        self.custom_widgets = (
+        if not PYSIDE6:
-            get_custom_classes("bec_widgets") + get_all_plugin_widgets()
-        ).as_dict()
-
-        if PYSIDE6:
-            self.loader = self.load_ui_pyside6
-        elif PYQT6:
-            self.loader = self.load_ui_pyqt6
-        else:
             raise ImportError("No compatible Qt bindings found.")
+        self.loader = self.load_ui_pyside6
 
     def load_ui_pyside6(self, ui_file, parent=None):
         """
@@ -53,7 +42,7 @@ class UILoader:
             QWidget: The loaded widget.
         """
         parent = parent or self.parent
-        loader = CustomUiLoader(parent, self.custom_widgets)
+        loader = CustomUiLoader(parent)
         file = QFile(ui_file)
         if not file.open(QIODevice.ReadOnly):
             raise IOError(f"Cannot open file: {ui_file}")
@@ -61,71 +50,6 @@ class UILoader:
         file.close()
         return widget
 
-    def load_ui_pyqt6(self, ui_file, parent=None):
-        """
-        Specific loader for PyQt6 using loadUi.
-        Args:
-            ui_file(str): Path to the .ui file.
-            parent(QWidget): Parent widget.
-
-        Returns:
-            QWidget: The loaded widget.
-        """
-        from PyQt6.uic.Loader.loader import DynamicUILoader
-
-        class CustomDynamicUILoader(DynamicUILoader):
-            def __init__(self, package, custom_widgets: dict = None):
-                super().__init__(package)
-                self.custom_widgets = custom_widgets or {}
-
-            def _handle_custom_widgets(self, el):
-                """Handle the <customwidgets> element."""
-
-                def header2module(header):
-                    """header2module(header) -> string
-
-                    Convert paths to C++ header files to according Python modules
-                    >>> header2module("foo/bar/baz.h")
-                    'foo.bar.baz'
-                    """
-
-                    if header.endswith(".h"):
-                        header = header[:-2]
-
-                    mpath = []
-                    for part in header.split("/"):
-                        # Ignore any empty parts or those that refer to the current
-                        # directory.
-                        if part not in ("", "."):
-                            if part == "..":
-                                # We should allow this for Python3.
-                                raise SyntaxError(
-                                    "custom widget header file name may not contain '..'."
-                                )
-
-                            mpath.append(part)
-
-                    return ".".join(mpath)
-
-                for custom_widget in el:
-                    classname = custom_widget.findtext("class")
-                    header = custom_widget.findtext("header")
-                    if header:
-                        header = self._translate_bec_widgets_header(header)
-                    self.factory.addCustomWidget(
-                        classname,
-                        custom_widget.findtext("extends") or "QWidget",
-                        header2module(header),
-                    )
-
-            def _translate_bec_widgets_header(self, header):
-                for name, value in self.custom_widgets.items():
-                    if header == DesignerPluginInfo.pascal_to_snake(name):
-                        return value.__module__
-                return header
-
-        return CustomDynamicUILoader("", self.custom_widgets).loadUi(ui_file, parent)
-
     def load_ui(self, ui_file, parent=None):
         """
         Universal UI loader method.

bec_widgets/widgets/containers/dock_area/dock_area.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+from functools import lru_cache
 from typing import Literal, Mapping, Sequence
 
 import slugify
@@ -19,9 +20,13 @@ from qtpy.QtWidgets import (
 
 import bec_widgets.widgets.containers.qt_ads as QtAds
 from bec_widgets import BECWidget, SafeProperty, SafeSlot
-from bec_widgets.applications.views.view import ViewTourSteps
+from bec_widgets.cli.designer_plugins import widget_icons
-from bec_widgets.utils.bec_dispatcher import BECDispatcher
+from bec_widgets.utils.bec_plugin_helper import (
+    get_plugin_rpc_widget_registry,
+    get_plugin_widget_icons,
+)
 from bec_widgets.utils.colors import apply_theme
+from bec_widgets.utils.plugin_utils import get_rpc_widget_registry
 from bec_widgets.utils.rpc_decorator import rpc_timeout
 from bec_widgets.utils.rpc_widget_handler import widget_handler
 from bec_widgets.utils.toolbars.actions import (
@@ -65,22 +70,7 @@ from bec_widgets.widgets.containers.dock_area.toolbar_components.workspace_actio
     WorkspaceConnection,
     workspace_bundle,
 )
-from bec_widgets.widgets.containers.main_window.main_window import BECMainWindowNoRPC
 from bec_widgets.widgets.containers.qt_ads import CDockWidget
-from bec_widgets.widgets.control.device_control.positioner_box import PositionerBox, PositionerBox2D
-from bec_widgets.widgets.control.scan_control import ScanControl
-from bec_widgets.widgets.editors.bec_console.bec_console import BecConsole, BECShell
-from bec_widgets.widgets.plots.heatmap.heatmap import Heatmap
-from bec_widgets.widgets.plots.image.image import Image
-from bec_widgets.widgets.plots.motor_map.motor_map import MotorMap
-from bec_widgets.widgets.plots.multi_waveform.multi_waveform import MultiWaveform
-from bec_widgets.widgets.plots.scatter_waveform.scatter_waveform import ScatterWaveform
-from bec_widgets.widgets.plots.waveform.waveform import Waveform
-from bec_widgets.widgets.progress.ring_progress_bar.ring_progress_bar import RingProgressBar
-from bec_widgets.widgets.services.bec_queue.bec_queue import BECQueue
-from bec_widgets.widgets.services.bec_status_box.bec_status_box import BECStatusBox
-from bec_widgets.widgets.utility.logpanel.logpanel import LogPanel
-from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
 
 logger = bec_logger.logger
 
@@ -90,6 +80,19 @@ PROFILE_STATE_KEYS = {key: SETTINGS_KEYS[key] for key in ("geom", "state", "ads_
 StartupProfile = Literal["restore", "skip"] | str | None
 
 
+@lru_cache
+def _plugin_toolbar_actions() -> dict[str, tuple[str, str, str]]:
+    plugin_registry = get_plugin_rpc_widget_registry()
+    internal_registry = get_rpc_widget_registry()
+    plugin_icons = get_plugin_widget_icons()
+
+    return {
+        widget_name: (plugin_icons.get(widget_name, "widgets"), f"Add {widget_name}", widget_name)
+        for widget_name in sorted(plugin_registry)
+        if widget_name not in internal_registry
+    }
+
+
 class BECDockArea(DockAreaWidget):
     RPC = True
     PLUGIN = False
@@ -144,6 +147,10 @@ class BECDockArea(DockAreaWidget):
         self._mode = mode
 
         # Toolbar
+        from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import (
+            DarkModeButton,
+        )
+
         self.dark_mode_button = DarkModeButton(parent=self, toolbar=True)
         self.dark_mode_button.setVisible(enable_profile_management)
         self._setup_toolbar()
@@ -342,39 +349,42 @@ class BECDockArea(DockAreaWidget):
         self.toolbar = ModularToolBar(parent=self)
 
         plot_actions = {
-            "waveform": (Waveform.ICON_NAME, "Add Waveform", "Waveform"),
+            "waveform": (widget_icons["Waveform"], "Add Waveform", "Waveform"),
             "scatter_waveform": (
-                ScatterWaveform.ICON_NAME,
+                widget_icons["ScatterWaveform"],
                 "Add Scatter Waveform",
                 "ScatterWaveform",
             ),
-            "multi_waveform": (MultiWaveform.ICON_NAME, "Add Multi Waveform", "MultiWaveform"),
+            "multi_waveform": (
-            "image": (Image.ICON_NAME, "Add Image", "Image"),
+                widget_icons["MultiWaveform"],
-            "motor_map": (MotorMap.ICON_NAME, "Add Motor Map", "MotorMap"),
+                "Add Multi Waveform",
-            "heatmap": (Heatmap.ICON_NAME, "Add Heatmap", "Heatmap"),
+                "MultiWaveform",
+            ),
+            "image": (widget_icons["Image"], "Add Image", "Image"),
+            "motor_map": (widget_icons["MotorMap"], "Add Motor Map", "MotorMap"),
+            "heatmap": (widget_icons["Heatmap"], "Add Heatmap", "Heatmap"),
         }
         device_actions = {
-            "scan_control": (ScanControl.ICON_NAME, "Add Scan Control", "ScanControl"),
+            "scan_control": (widget_icons["ScanControl"], "Add Scan Control", "ScanControl"),
-            "positioner_box": (PositionerBox.ICON_NAME, "Add Device Box", "PositionerBox"),
+            "positioner_box": (widget_icons["PositionerBox"], "Add Device Box", "PositionerBox"),
             "positioner_box_2D": (
-                PositionerBox2D.ICON_NAME,
+                widget_icons["PositionerBox2D"],
                 "Add Device 2D Box",
                 "PositionerBox2D",
             ),
         }
         util_actions = {
-            "queue": (BECQueue.ICON_NAME, "Add Scan Queue", "BECQueue"),
+            "queue": (widget_icons["BECQueue"], "Add Scan Queue", "BECQueue"),
-            "status": (BECStatusBox.ICON_NAME, "Add BEC Status Box", "BECStatusBox"),
+            "status": (widget_icons["BECStatusBox"], "Add BEC Status Box", "BECStatusBox"),
             "progress_bar": (
-                RingProgressBar.ICON_NAME,
+                widget_icons["RingProgressBar"],
                 "Add Circular ProgressBar",
                 "RingProgressBar",
             ),
-            "terminal": (BecConsole.ICON_NAME, "Add Terminal", "BecConsole"),
+            "terminal": (widget_icons["BecConsole"], "Add Terminal", "BecConsole"),
-            "bec_shell": (BECShell.ICON_NAME, "Add BEC Shell", "BECShell"),
+            "bec_shell": (widget_icons["BECShell"], "Add BEC Shell", "BECShell"),
-            "log_panel": (LogPanel.ICON_NAME, "Add LogPanel - Disabled", "LogPanel"),
+            "sbb_monitor": (widget_icons["SBBMonitor"], "Add SBB Monitor", "SBBMonitor"),
-            "sbb_monitor": ("train", "Add SBB Monitor", "SBBMonitor"),
+            "log_panel": (widget_icons["LogPanel"], "Add LogPanel", "LogPanel"),
-            "log_panel": (LogPanel.ICON_NAME, "Add LogPanel", "LogPanel"),
         }
 
         # Create expandable menu actions (original behavior)
@@ -399,6 +409,10 @@ class BECDockArea(DockAreaWidget):
         _build_menu("menu_devices", "Add Device Control ", device_actions)
         _build_menu("menu_utils", "Add Utils ", util_actions)
 
+        plugin_actions = _plugin_toolbar_actions()
+        if plugin_actions:
+            _build_menu("menu_plugins", "Add Plugins ", plugin_actions)
+
         # Create flat toolbar bundles for each widget type
         def _build_flat_bundles(category: str, mapping: dict[str, tuple[str, str, str]]):
             bundle = ToolbarBundle(f"flat_{category}", self.toolbar.components)
@@ -469,14 +483,16 @@ class BECDockArea(DockAreaWidget):
         bda.add_action("dark_mode")
         self.toolbar.add_bundle(bda)
 
-        self._apply_toolbar_layout()
+        # Store mappings on self for use in _hook_toolbar and _apply_toolbar_layout
-
-        # Store mappings on self for use in _hook_toolbar
         self._ACTION_MAPPINGS = {
             "menu_plots": plot_actions,
             "menu_devices": device_actions,
             "menu_utils": util_actions,
         }
+        if plugin_actions:
+            self._ACTION_MAPPINGS["menu_plugins"] = plugin_actions
+
+        self._apply_toolbar_layout()
 
     def _hook_toolbar(self):
         def _connect_menu(menu_key: str):
@@ -485,7 +501,8 @@ class BECDockArea(DockAreaWidget):
 
             # first two items not needed for this part
             for key, (_, _, widget_type) in mapping.items():
-                act = menu.actions[key].action
+                toolbar_action = menu.actions[key]
+                act = toolbar_action.action
                 if key == "terminal":
                     act.triggered.connect(
                         lambda _, t=widget_type: self.new(widget=t, closable=True, startup_cmd=None)
@@ -496,12 +513,18 @@ class BECDockArea(DockAreaWidget):
                             widget=t, closable=True, show_settings_action=False
                         )
                     )
+                elif menu_key == "menu_plugins":
+                    act.triggered.connect(
+                        lambda _, t=widget_type, a=toolbar_action: self._new_plugin_widget(t, a)
+                    )
                 else:
                     act.triggered.connect(lambda _, t=widget_type: self.new(widget=t))
 
         _connect_menu("menu_plots")
         _connect_menu("menu_devices")
         _connect_menu("menu_utils")
+        if "menu_plugins" in self._ACTION_MAPPINGS:
+            _connect_menu("menu_plugins")
 
         def _connect_flat_actions(mapping: dict[str, tuple[str, str, str]]):
             for action_id, (_, _, widget_type) in mapping.items():
@@ -516,6 +539,10 @@ class BECDockArea(DockAreaWidget):
         self.toolbar.components.get_action("attach_all").action.triggered.connect(self.attach_all)
         self.toolbar.components.get_action("screenshot").action.triggered.connect(self.screenshot)
 
+    def _new_plugin_widget(self, widget_type: str, toolbar_action: MaterialIconAction) -> None:
+        # Created as helper method for simple tests
+        self.new(widget=widget_type, dock_icon=toolbar_action.get_icon())
+
     def _set_editable(self, editable: bool) -> None:
         self.workspace_is_locked = not editable
         self._editable = editable
@@ -1117,14 +1144,10 @@ class BECDockArea(DockAreaWidget):
         if mode_key == "user":
             bundles = ["spacer_bundle", "workspace", "dock_actions"]
         elif mode_key == "creator":
-            bundles = [
+            bundles = ["menu_plots", "menu_devices", "menu_utils"]
-                "menu_plots",
+            if "menu_plugins" in getattr(self, "_ACTION_MAPPINGS", {}):
-                "menu_devices",
+                bundles.append("menu_plugins")
-                "menu_utils",
+            bundles += ["spacer_bundle", "workspace", "dock_actions"]
-                "spacer_bundle",
-                "workspace",
-                "dock_actions",
-            ]
         elif mode_key == "plot":
             bundles = ["flat_plots", "spacer_bundle", "workspace", "dock_actions"]
         elif mode_key == "device":
@@ -1198,6 +1221,8 @@ class BECDockArea(DockAreaWidget):
         )
         step_ids.append(step_id)
 
+        from bec_widgets.applications.views.view import ViewTourSteps
+
         return ViewTourSteps(view_title="Dock Area Workspace", step_ids=step_ids)
 
     def cleanup(self):
@@ -1218,6 +1243,9 @@ class BECDockArea(DockAreaWidget):
 if __name__ == "__main__":  # pragma: no cover
     import sys
 
+    from bec_widgets.utils.bec_dispatcher import BECDispatcher
+    from bec_widgets.widgets.containers.main_window.main_window import BECMainWindowNoRPC
+
     app = QApplication(sys.argv)
     apply_theme("dark")
     dispatcher = BECDispatcher(gui_id="ads")

bec_widgets/widgets/control/scan_control/scan_control.py

@@ -26,7 +26,6 @@ from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.widgets.control.buttons.stop_button.stop_button import StopButton
 from bec_widgets.widgets.control.scan_control.scan_group_box import ScanGroupBox
 from bec_widgets.widgets.editors.scan_metadata.scan_metadata import ScanMetadata
-from bec_widgets.widgets.utility.toggle.toggle import ToggleSwitch
 
 
 class ScanParameterConfig(BaseModel):
@@ -84,7 +83,6 @@ class ScanControl(BECWidget, QWidget):
         self.kwarg_boxes = []
         self.expert_mode = False  # TODO implement in the future versions
         self.previous_scan = None
-        self.last_scan_found = None
 
         # Widget Default Parameters
         self.config.default_scan = default_scan
@@ -123,17 +121,12 @@ class ScanControl(BECWidget, QWidget):
         scan_selection_layout.addWidget(self.comboBox_scan_selection, 1)
         self.scan_selection_group.layout().addLayout(scan_selection_layout)
 
-        # Label to reload the last scan parameters within scan selection group box
+        # Button to reload the last scan parameters on demand.
-        self.toggle_layout = QHBoxLayout()
+        self.last_scan_button = QPushButton(
-        self.toggle_layout.addSpacerItem(
+            "Restore last scan parameters", self.scan_selection_group
-            QSpacerItem(0, 0, QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
         )
-        self.last_scan_label = QLabel("Restore last scan parameters", self.scan_selection_group)
+        self.last_scan_button.clicked.connect(self.request_last_executed_scan_parameters)
-        self.toggle = ToggleSwitch(parent=self.scan_selection_group, checked=False)
+        self.scan_selection_group.layout().addWidget(self.last_scan_button)
-        self.toggle.enabled.connect(self.request_last_executed_scan_parameters)
-        self.toggle_layout.addWidget(self.last_scan_label)
-        self.toggle_layout.addWidget(self.toggle)
-        self.scan_selection_group.layout().addLayout(self.toggle_layout)
         self.scan_selection_group.setSizePolicy(
             QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Fixed
         )
@@ -206,7 +199,6 @@ class ScanControl(BECWidget, QWidget):
         """Callback for scan selection combo box"""
         selected_scan_name = self.comboBox_scan_selection.currentText()
         self.scan_selected.emit(selected_scan_name)
-        self.request_last_executed_scan_parameters()
         self.restore_scan_parameters(selected_scan_name)
 
     @SafeSlot()
@@ -215,10 +207,6 @@ class ScanControl(BECWidget, QWidget):
         """
         Requests the last executed scan parameters from BEC and restores them to the scan control widget.
         """
-        self.last_scan_found = False
-        if not self.toggle.checked:
-            return
-
         current_scan = self.comboBox_scan_selection.currentText()
         history = (
             self.client.connector.xread(
@@ -246,8 +234,6 @@ class ScanControl(BECWidget, QWidget):
             if merged and self.kwarg_boxes:
                 for box in self.kwarg_boxes:
                     box.set_parameters(merged)
-
-            self.last_scan_found = True
             break
 
     @SafeProperty(str)
@@ -496,8 +482,6 @@ class ScanControl(BECWidget, QWidget):
         Args:
             scan_name(str): Name of the scan to restore the parameters for.
         """
-        if self.last_scan_found is True:
-            return
         scan_params = self.config.scans.get(scan_name, None)
         if scan_params is None and self.previous_scan is None:
             return

bec_widgets/widgets/plots/heatmap/heatmap.py

@@ -2,21 +2,16 @@ from __future__ import annotations
 
 import json
 from dataclasses import dataclass
-from typing import Literal
+from typing import TYPE_CHECKING, Literal
 
 import numpy as np
 import pyqtgraph as pg
 from bec_lib import bec_logger, messages
 from bec_lib.endpoints import MessageEndpoints
+from bec_lib.utils.import_utils import lazy_import, lazy_import_from
 from pydantic import BaseModel, Field, field_validator
 from qtpy.QtCore import QObject, Qt, QThread, QTimer, Signal
 from qtpy.QtGui import QTransform
-from scipy.interpolate import (
-    CloughTocher2DInterpolator,
-    LinearNDInterpolator,
-    NearestNDInterpolator,
-)
-from scipy.spatial import cKDTree
 from toolz import partition
 
 from bec_widgets.utils.bec_connector import ConnectionConfig
@@ -32,6 +27,22 @@ from bec_widgets.widgets.plots.plot_base import PlotBase
 logger = bec_logger.logger
 
 
+if TYPE_CHECKING:
+    from scipy.interpolate import (
+        CloughTocher2DInterpolator,
+        LinearNDInterpolator,
+        NearestNDInterpolator,
+    )
+    from scipy.spatial import cKDTree
+else:
+
+    CloughTocher2DInterpolator, LinearNDInterpolator, NearestNDInterpolator = lazy_import_from(
+        "scipy.interpolate",
+        ["CloughTocher2DInterpolator", "LinearNDInterpolator", "NearestNDInterpolator"],
+    )
+    cKDTree = lazy_import_from("scipy.spatial", ["cKDTree"])
+
+
 class HeatmapDeviceSignal(BaseModel):
     """The configuration of a signal in the scatter waveform widget."""
 

bec_widgets/widgets/plots/waveform/waveform.py

@@ -10,6 +10,7 @@ from bec_lib.device import Positioner
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.lmfit_serializer import serialize_lmfit_params, serialize_param_object
 from bec_lib.scan_data_container import ScanDataContainer
+from bec_lib.utils.import_utils import lazy_import
 from pydantic import Field, ValidationError, field_validator
 from qtpy.QtCore import Qt, QTimer, Signal
 from qtpy.QtWidgets import (
@@ -54,13 +55,7 @@ _DAP_PARAM = object()
 if TYPE_CHECKING:  # pragma: no cover
     import lmfit  # type: ignore
 else:
-    try:
+    lmfit = lazy_import("lmfit")
-        import lmfit  # type: ignore
-    except Exception as e:  # pragma: no cover
-        logger.warning(
-            f"lmfit could not be imported: {e}. Custom DAP functionality will be unavailable."
-        )
-        lmfit = None
 
 
 # noinspection PyDataclass

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bec_widgets"
-version = "3.8.1"
+version = "3.9.1"
 description = "BEC Widgets"
 requires-python = ">=3.11"
 classifiers = [
@@ -59,6 +59,8 @@ dev = [
 qtermwidget = ["pyside6_qtermwidget"]
 
 
+
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"

tests/unit_tests/test_bec_plugin_helper.py

@@ -2,7 +2,10 @@ from importlib.machinery import FileFinder, SourceFileLoader
 from types import ModuleType
 from unittest import mock
 
-from bec_widgets.utils.bec_plugin_helper import _all_widgets_from_all_submods
+from bec_widgets.utils.bec_plugin_helper import (
+    _all_widgets_from_all_submods,
+    get_plugin_widget_icons,
+)
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.plugin_utils import BECClassContainer, BECClassInfo
 
@@ -69,3 +72,29 @@ def test_all_widgets_from_module_no_widgets():
         widgets = _all_widgets_from_all_submods(module).as_dict()
 
     assert widgets == {}
+
+
+def test_get_plugin_widget_icons_from_designer_module():
+    designer_module = mock.MagicMock(spec=ModuleType)
+    designer_module.widget_icons = {"PluginWidget": "star"}
+
+    get_plugin_widget_icons.cache_clear()
+    try:
+        with mock.patch(
+            "bec_widgets.utils.bec_plugin_helper.get_plugin_designer_module",
+            return_value=designer_module,
+        ):
+            assert get_plugin_widget_icons() == {"PluginWidget": "star"}
+    finally:
+        get_plugin_widget_icons.cache_clear()
+
+
+def test_get_plugin_widget_icons_without_designer_module():
+    get_plugin_widget_icons.cache_clear()
+    try:
+        with mock.patch(
+            "bec_widgets.utils.bec_plugin_helper.get_plugin_designer_module", return_value=None
+        ):
+            assert get_plugin_widget_icons() == {}
+    finally:
+        get_plugin_widget_icons.cache_clear()

tests/unit_tests/test_dock_area.py

@@ -11,6 +11,7 @@ from qtpy.QtGui import QPixmap
 from qtpy.QtWidgets import QDialog, QMessageBox, QWidget
 
 import bec_widgets.widgets.containers.dock_area.basic_dock_area as basic_dock_module
+import bec_widgets.widgets.containers.dock_area.dock_area as dock_area_module
 import bec_widgets.widgets.containers.dock_area.profile_utils as profile_utils
 from bec_widgets.widgets.containers.dock_area.basic_dock_area import (
     DockAreaWidget,
@@ -68,6 +69,13 @@ def temp_profile_dir():
     return os.environ["BECWIDGETS_PROFILE_DIR"]
 
 
+@pytest.fixture
+def clear_plugin_toolbar_actions_cache():
+    dock_area_module._plugin_toolbar_actions.cache_clear()
+    yield
+    dock_area_module._plugin_toolbar_actions.cache_clear()
+
+
 @pytest.fixture
 def module_profile_factory(monkeypatch, tmp_path):
     """Provide a helper to create synthetic module-level (read-only) profiles."""
@@ -239,7 +247,7 @@ class TestBasicDockArea:
         assert basic_dock_area.widget_map(bec_widgets_only=False)["panel_bec"] is panel_bec
 
     def test_new_widget_string_creates_widget(self, basic_dock_area, qtbot):
-        basic_dock_area.new("DarkModeButton")
+        basic_dock_area.new("RingProgressBar")
         qtbot.waitUntil(lambda: len(basic_dock_area.dock_list()) > 0, timeout=1000)
 
         assert basic_dock_area.widget_list()
@@ -623,7 +631,7 @@ class TestDockManagement:
         initial_count = len(advanced_dock_area.dock_list())
 
         # Create a widget by string name
-        widget = advanced_dock_area.new("DarkModeButton")
+        widget = advanced_dock_area.new("RingProgressBar")
 
         # Wait for the dock to be created (since it's async)
         qtbot.wait(200)
@@ -691,7 +699,7 @@ class TestDockManagement:
         initial_count = len(widget_map)
 
         # Create a widget
-        advanced_dock_area.new("DarkModeButton")
+        advanced_dock_area.new("RingProgressBar")
         qtbot.wait(200)
 
         # Check widget map updated
@@ -705,7 +713,7 @@ class TestDockManagement:
         initial_count = len(widget_list)
 
         # Create a widget
-        advanced_dock_area.new("DarkModeButton")
+        advanced_dock_area.new("RingProgressBar")
         qtbot.wait(200)
 
         # Check widget list updated
@@ -715,8 +723,8 @@ class TestDockManagement:
     def test_delete_all(self, advanced_dock_area, qtbot):
         """Test delete_all functionality."""
         # Create multiple widgets
-        advanced_dock_area.new("DarkModeButton")
+        advanced_dock_area.new("RingProgressBar")
-        advanced_dock_area.new("DarkModeButton")
+        advanced_dock_area.new("RingProgressBar")
 
         # Wait for docks to be created
         qtbot.wait(200)
@@ -772,7 +780,7 @@ class TestWorkspaceLocking:
     def test_lock_workspace_property_setter(self, advanced_dock_area, qtbot):
         """Test workspace_is_locked property setter."""
         # Create a dock first
-        advanced_dock_area.new("DarkModeButton")
+        advanced_dock_area.new("RingProgressBar")
         qtbot.wait(200)
 
         # Initially unlocked
@@ -887,8 +895,8 @@ class TestToolbarFunctionality:
     def test_attach_all_action(self, advanced_dock_area, qtbot):
         """Test attach_all toolbar action."""
         # Create floating docks
-        advanced_dock_area.new("DarkModeButton", start_floating=True)
+        advanced_dock_area.new("RingProgressBar", start_floating=True)
-        advanced_dock_area.new("DarkModeButton", start_floating=True)
+        advanced_dock_area.new("RingProgressBar", start_floating=True)
 
         qtbot.wait(200)
 
@@ -916,7 +924,7 @@ class TestToolbarFunctionality:
         # Floating entry
         settings.setArrayIndex(0)
         settings.setValue("object_name", "FloatingWaveform")
-        settings.setValue("widget_class", "DarkModeButton")
+        settings.setValue("widget_class", "RingProgressBar")
         settings.setValue("closable", True)
         settings.setValue("floatable", True)
         settings.setValue("movable", True)
@@ -934,7 +942,7 @@ class TestToolbarFunctionality:
         # Anchored entry
         settings.setArrayIndex(1)
         settings.setValue("object_name", "EmbeddedWaveform")
-        settings.setValue("widget_class", "DarkModeButton")
+        settings.setValue("widget_class", "RingProgressBar")
         settings.setValue("closable", True)
         settings.setValue("floatable", True)
         settings.setValue("movable", True)
@@ -985,6 +993,64 @@ class TestToolbarFunctionality:
                 # Verify save was called with the filename
                 mock_screenshot.save.assert_called_once_with(str(screenshot_path))
 
+    def test_plugin_toolbar_actions_empty_when_no_plugins(self, clear_plugin_toolbar_actions_cache):
+        """Test that no plugin toolbar actions are produced when no plugin widgets exist."""
+        with patch(
+            "bec_widgets.widgets.containers.dock_area.dock_area.get_plugin_rpc_widget_registry",
+            return_value={},
+        ):
+            plugin_actions = dock_area_module._plugin_toolbar_actions()
+
+        assert plugin_actions == {}
+
+    def test_plugin_toolbar_actions_include_available_plugins(
+        self, clear_plugin_toolbar_actions_cache
+    ):
+        """Test that plugin toolbar actions are built from RPC widgets and generated icons."""
+        plugin_registry = {
+            "FakePluginWidget": ("fake_plugin.widgets.fake_plugin_widget", "FakePluginWidget")
+        }
+        with (
+            patch(
+                "bec_widgets.widgets.containers.dock_area.dock_area.get_plugin_rpc_widget_registry",
+                return_value=plugin_registry,
+            ),
+            patch(
+                "bec_widgets.widgets.containers.dock_area.dock_area.get_plugin_widget_icons",
+                return_value={"FakePluginWidget": "star"},
+            ),
+        ):
+            plugin_actions = dock_area_module._plugin_toolbar_actions()
+
+        assert plugin_actions == {
+            "FakePluginWidget": ("star", "Add FakePluginWidget", "FakePluginWidget")
+        }
+
+    def test_plugin_toolbar_actions_ignore_builtin_name_collisions(
+        self, clear_plugin_toolbar_actions_cache
+    ):
+        """Test that plugin widgets shadowed by built-ins are not added to the plugin menu."""
+        plugin_registry = {"Waveform": ("fake_plugin.widgets.waveform", "Waveform")}
+        with patch(
+            "bec_widgets.widgets.containers.dock_area.dock_area.get_plugin_rpc_widget_registry",
+            return_value=plugin_registry,
+        ):
+            plugin_actions = dock_area_module._plugin_toolbar_actions()
+
+        assert plugin_actions == {}
+
+    def test_new_plugin_widget_passes_toolbar_icon_to_new(self):
+        """Test that plugin widget creation passes the toolbar icon to dock creation."""
+        dock_area = MagicMock()
+        toolbar_action = MagicMock()
+        dock_icon = object()
+        toolbar_action.get_icon.return_value = dock_icon
+
+        BECDockArea._new_plugin_widget(dock_area, "FakePluginWidget", toolbar_action)
+
+        toolbar_action.get_icon.assert_called_once_with()
+        dock_area.new.assert_called_once_with(widget="FakePluginWidget", dock_icon=dock_icon)
+
 
 class TestDockSettingsDialog:
     """Test dock settings dialog functionality."""
@@ -1760,9 +1826,9 @@ class TestProfileManagement:
         settings = open_runtime_settings("test_manifest")
 
         # Create real docks
-        advanced_dock_area.new("DarkModeButton")
+        advanced_dock_area.new("RingProgressBar")
-        advanced_dock_area.new("DarkModeButton")
+        advanced_dock_area.new("RingProgressBar")
-        advanced_dock_area.new("DarkModeButton")
+        advanced_dock_area.new("RingProgressBar")
 
         # Wait for docks to be created
         qtbot.wait(1000)
@@ -1870,7 +1936,7 @@ class TestWorkspaceProfileOperations:
         settings.beginWriteArray("manifest/widgets", 1)
         settings.setArrayIndex(0)
         settings.setValue("object_name", "test_widget")
-        settings.setValue("widget_class", "DarkModeButton")
+        settings.setValue("widget_class", "RingProgressBar")
         settings.setValue("closable", True)
         settings.setValue("floatable", True)
         settings.setValue("movable", True)
@@ -1976,7 +2042,7 @@ class TestWorkspaceProfileOperations:
         settings.beginWriteArray("manifest/widgets", 1)
         settings.setArrayIndex(0)
         settings.setValue("object_name", "source_widget")
-        settings.setValue("widget_class", "DarkModeButton")
+        settings.setValue("widget_class", "RingProgressBar")
         settings.setValue("closable", True)
         settings.setValue("floatable", True)
         settings.setValue("movable", True)
@@ -1985,7 +2051,7 @@ class TestWorkspaceProfileOperations:
 
         advanced_dock_area.load_profile(source_profile)
         qtbot.wait(500)
-        advanced_dock_area.new("DarkModeButton")
+        advanced_dock_area.new("RingProgressBar")
         qtbot.wait(500)
 
         class StubDialog:
@@ -2029,7 +2095,7 @@ class TestWorkspaceProfileOperations:
             settings.beginWriteArray("manifest/widgets", 1)
             settings.setArrayIndex(0)
             settings.setValue("object_name", f"{profile}_widget")
-            settings.setValue("widget_class", "DarkModeButton")
+            settings.setValue("widget_class", "RingProgressBar")
             settings.setValue("closable", True)
             settings.setValue("floatable", True)
             settings.setValue("movable", True)
@@ -2038,7 +2104,7 @@ class TestWorkspaceProfileOperations:
 
         advanced_dock_area.load_profile(profile_a)
         qtbot.wait(500)
-        advanced_dock_area.new("DarkModeButton")
+        advanced_dock_area.new("RingProgressBar")
         qtbot.wait(500)
 
         advanced_dock_area.load_profile(profile_b)
@@ -2468,8 +2534,8 @@ class TestModeTransitions:
     def test_mode_switching_preserves_existing_docks(self, advanced_dock_area, qtbot):
         """Test that mode switching doesn't affect existing docked widgets."""
         # Create some widgets
-        advanced_dock_area.new("DarkModeButton")
+        advanced_dock_area.new("RingProgressBar")
-        advanced_dock_area.new("DarkModeButton")
+        advanced_dock_area.new("RingProgressBar")
         qtbot.wait(200)
 
         initial_dock_count = len(advanced_dock_area.dock_list())

tests/unit_tests/test_generate_cli_client.py

@@ -5,7 +5,8 @@ import black
 import isort
 import pytest
 
-from bec_widgets.utils.generate_cli import ClientGenerator
+from bec_widgets.utils.generate_cli import ClientGenerator, write_designer_plugins
+from bec_widgets.utils.generate_designer_plugin import DesignerPluginInfo
 from bec_widgets.utils.plugin_utils import BECClassContainer, BECClassInfo
 
 # pylint: disable=missing-function-docstring
@@ -59,6 +60,14 @@ class MockViewWithContent:
         """Activate view."""
 
 
+class MockDesignerWidgetBase:
+    ICON_NAME = "mock_icon"
+
+
+class MockDesignerWidget(MockDesignerWidgetBase):
+    pass
+
+
 def test_client_generator_with_black_formatting():
     generator = ClientGenerator(base=True)
     container = BECClassContainer()
@@ -285,3 +294,18 @@ c = a + b"""
         content = file.read()
 
     assert corrected in content
+
+
+def test_write_designer_plugins(tmp_path):
+    file_name = tmp_path / "designer_plugins.py"
+
+    write_designer_plugins([DesignerPluginInfo(MockDesignerWidget)], str(file_name))
+
+    with open(file_name, "r", encoding="utf-8") as file:
+        content = file.read()
+
+    assert '"MockDesignerWidget":' in content
+    assert '"tests.unit_tests.test_generate_cli_client"' in content
+    assert '"MockDesignerWidget"' in content
+    assert '"MockDesignerWidget": "mock_icon"' in content
+    assert "MockDesignerWidgetPlugin" not in content

tests/unit_tests/test_logpanel.py

@@ -62,8 +62,8 @@ TEST_LOG_MESSAGES = [
 
 
 @pytest.fixture
-def log_panel(qtbot, mocked_client):
+def log_panel(qtbot, mocked_client, monkeypatch):
-    mocked_client.connector.xread = lambda *_, **__: TEST_LOG_MESSAGES
+    monkeypatch.setattr(mocked_client.connector, "xread", lambda *_, **__: TEST_LOG_MESSAGES)
     widget = LogPanel()
     qtbot.addWidget(widget)
     qtbot.waitExposed(widget)

tests/unit_tests/test_monaco_editor.py

@@ -14,7 +14,9 @@ from .test_scan_control import available_scans_message
 @pytest.fixture
 def monaco_widget(qtbot, mocked_client):
     widget = MonacoWidget(client=mocked_client)
-    mocked_client.connector.set(MessageEndpoints.available_scans(), available_scans_message)
+    mocked_client.connector.set_and_publish(
+        MessageEndpoints.available_scans(), available_scans_message
+    )
     qtbot.addWidget(widget)
     qtbot.waitExposed(widget)
     yield widget
@@ -62,7 +64,9 @@ def test_monaco_widget_get_scan_control_code(monaco_widget: MonacoWidget, qtbot,
     """
     Test that the MonacoWidget can get scan control code from the dialog.
     """
-    mocked_client.connector.set(MessageEndpoints.available_scans(), available_scans_message)
+    mocked_client.connector.set_and_publish(
+        MessageEndpoints.available_scans(), available_scans_message
+    )
 
     scan_control_dialog = ScanControlDialog(client=mocked_client)
     qtbot.addWidget(scan_control_dialog)

tests/unit_tests/test_rpc_widget_handler.py

@@ -1,7 +1,6 @@
 from unittest.mock import patch
 
-from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils import plugin_utils
-from bec_widgets.utils.plugin_utils import BECClassContainer, BECClassInfo
 from bec_widgets.utils.rpc_widget_handler import RPCWidgetHandler
 
 
@@ -10,21 +9,22 @@ def test_rpc_widget_handler():
     assert "Image" in handler.widget_classes
     assert "RingProgressBar" in handler.widget_classes
     assert "BECDockArea" in handler.widget_classes
-
+    assert isinstance(handler.widget_classes["Image"], tuple)
-
-class _TestPluginWidget(BECWidget): ...
 
 
 @patch(
-    "bec_widgets.utils.rpc_widget_handler.get_all_plugin_widgets",
+    "bec_widgets.utils.bec_plugin_helper.get_plugin_rpc_widget_registry",
-    return_value=BECClassContainer(
+    return_value={
-        [
+        "Image": ("plugin.module", "PluginImage"),
-            BECClassInfo(name="DeviceComboBox", obj=_TestPluginWidget, module="", file=""),
+        "NewPluginWidget": ("plugin.module", "NewPluginWidget"),
-            BECClassInfo(name="NewPluginWidget", obj=_TestPluginWidget, module="", file=""),
+    },
-        ]
-    ),
 )
 def test_duplicate_plugins_not_allowed(_):
-    handler = RPCWidgetHandler()
+    plugin_utils.rpc_widget_registry.cache_clear()
-    assert handler.widget_classes["DeviceComboBox"] is not _TestPluginWidget
+
-    assert handler.widget_classes["NewPluginWidget"] is _TestPluginWidget
+    try:
+        handler = RPCWidgetHandler()
+        assert handler.widget_classes["Image"] != ("plugin.module", "PluginImage")
+        assert handler.widget_classes["NewPluginWidget"] == ("plugin.module", "NewPluginWidget")
+    finally:
+        plugin_utils.rpc_widget_registry.cache_clear()

tests/unit_tests/test_scan_control.py

@@ -256,7 +256,9 @@ scan_history = ScanHistoryMessage(
 
 @pytest.fixture(scope="function")
 def scan_control(qtbot, mocked_client):  # , mock_dev):
-    mocked_client.connector.set(MessageEndpoints.available_scans(), available_scans_message)
+    mocked_client.connector.set_and_publish(
+        MessageEndpoints.available_scans(), available_scans_message
+    )
     mocked_client.connector.xadd(
         topic=MessageEndpoints.scan_history(), msg_dict={"data": scan_history}
     )
@@ -501,12 +503,47 @@ def test_changing_scans_remember_parameters(scan_control, mocked_client):
     assert grid_kwargs["burst_at_each_point"] == kwargs["burst_at_each_point"]
 
 
-@pytest.mark.skip(reason="Unreliable - GH issue #1134")
+def test_scan_selection_does_not_fetch_last_scan_parameters(
-def test_get_scan_parameters_from_redis(scan_control, mocked_client):
+    scan_control, mocked_client, monkeypatch
+):
+    xread = MagicMock(wraps=mocked_client.connector.xread)
+    monkeypatch.setattr(mocked_client.connector, "xread", xread)
+
+    scan_control.comboBox_scan_selection.setCurrentText("line_scan")
+    assert scan_control.comboBox_scan_selection.currentText() == "line_scan"
+
+    scan_control.comboBox_scan_selection.setCurrentText("grid_scan")
+
+    xread.assert_not_called()
+
+
+def test_restore_last_scan_parameters_button_fetches_on_demand(
+    scan_control, mocked_client, monkeypatch
+):
+    xread = MagicMock(wraps=mocked_client.connector.xread)
+    monkeypatch.setattr(mocked_client.connector, "xread", xread)
+
+    scan_control.comboBox_scan_selection.setCurrentText("grid_scan")
+    scan_control.comboBox_scan_selection.setCurrentText("line_scan")
+    xread.assert_not_called()
+
+    scan_control.last_scan_button.click()
+
+    xread.assert_called_once_with(
+        MessageEndpoints.scan_history(), from_start=True, user_id=scan_control.object_name
+    )
+    args, kwargs = scan_control.get_scan_parameters(bec_object=False)
+    assert args == ["samx", 0.0, 2.0]
+    assert kwargs["steps"] == 10
+    assert kwargs["relative"] is False
+    assert kwargs["exp_time"] == 2
+
+
+def test_get_scan_parameters_from_redis(scan_control):
     scan_name = "line_scan"
     scan_control.comboBox_scan_selection.setCurrentText(scan_name)
 
-    scan_control.toggle.checked = True
+    scan_control.last_scan_button.click()
 
     args, kwargs = scan_control.get_scan_parameters(bec_object=False)
 
@@ -586,8 +623,7 @@ def test_scan_metadata_is_passed_to_scan_function(scan_control: ScanControl):
     scans.grid_scan.assert_called_once_with(metadata=TEST_MD)
 
 
-@pytest.mark.skip(reason="Unreliable - GH issue #1134")
+def test_restore_parameters_with_fewer_arg_bundles(scan_control):
-def test_restore_parameters_with_fewer_arg_bundles(scan_control, qtbot):
     """
     Ensure that when more argument bundles are present than exist in the
     stored history, restoring parameters regenerates the arg box to the
@@ -603,8 +639,7 @@ def test_restore_parameters_with_fewer_arg_bundles(scan_control, qtbot):
     assert scan_control.arg_box.count_arg_rows() == 3
 
     # Trigger restore of parameters from history
-    scan_control.toggle.checked = True
+    scan_control.last_scan_button.click()
-    qtbot.wait(200)
 
     # After restore, arg_box should have only one bundle (the history size)
     assert scan_control.arg_box.count_arg_rows() == 1