synodic-client 0.0.1.dev62__tar.gz → 0.0.1.dev64__tar.gz

{synodic_client-0.0.1.dev62 → synodic_client-0.0.1.dev64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: synodic_client
-Version: 0.0.1.dev62
+Version: 0.0.1.dev64
 Author-Email: Synodic Software <contact@synodic.software>
 License: LGPL-3.0-or-later
 Project-URL: homepage, https://github.com/synodic/synodic-client

{synodic_client-0.0.1.dev62 → synodic_client-0.0.1.dev64}/pyproject.toml

@@ -15,7 +15,7 @@ dependencies = [
     "velopack>=0.0.1444.dev49733",
     "typer>=0.24.1",
 ]
-version = "0.0.1.dev62"
+version = "0.0.1.dev64"
 
 [project.license]
 text = "LGPL-3.0-or-later"

{synodic_client-0.0.1.dev62 → synodic_client-0.0.1.dev64}/synodic_client/application/bootstrap.py

@@ -18,12 +18,14 @@ import sys
 from synodic_client.config import set_dev_mode
 from synodic_client.logging import configure_logging
 from synodic_client.protocol import extract_uri_from_args
+from synodic_client.subprocess_patch import apply as _apply_subprocess_patch
 from synodic_client.updater import initialize_velopack
 
 # Parse flags early so logging uses the right filename and level.
 _dev_mode = '--dev' in sys.argv[1:]
 _debug = '--debug' in sys.argv[1:]
 set_dev_mode(_dev_mode)
+_apply_subprocess_patch()
 
 configure_logging(debug=_debug)
 initialize_velopack()

synodic_client-0.0.1.dev64/synodic_client/application/config_store.py

@@ -0,0 +1,65 @@
+"""Centralized configuration store.
+
+Provides a single source of truth for :class:`ResolvedConfig` so that
+every consumer (ToolsView, SettingsWindow, UpdateController,
+ToolUpdateOrchestrator) always reads the same snapshot and receives
+change notifications through a Qt signal.
+"""
+
+from __future__ import annotations
+
+from PySide6.QtCore import QObject, Signal
+
+from synodic_client.resolution import ResolvedConfig, resolve_config, update_user_config
+
+
+class ConfigStore(QObject):
+    """Observable wrapper around :class:`ResolvedConfig`.
+
+    All config mutations go through :meth:`update` (which persists to
+    disk) or :meth:`set` (which replaces without persisting).  Both
+    emit :attr:`changed` so every connected consumer stays in sync.
+
+    Typical usage::
+
+        store = ConfigStore(initial_config)
+        store.changed.connect(some_consumer.on_config_changed)
+        store.update(auto_apply=False)   # persists + emits
+    """
+
+    changed = Signal(object)
+    """Emitted with the new ``ResolvedConfig`` after every mutation."""
+
+    def __init__(self, config: ResolvedConfig | None = None, parent: QObject | None = None) -> None:
+        """Create a new store, optionally seeded with *config*."""
+        super().__init__(parent)
+        self._config = config if config is not None else resolve_config()
+
+    @property
+    def config(self) -> ResolvedConfig:
+        """The current configuration snapshot."""
+        return self._config
+
+    def update(self, **changes: object) -> ResolvedConfig:
+        """Persist *changes* to disk and broadcast the new config.
+
+        Wraps :func:`~synodic_client.resolution.update_user_config`.
+
+        Args:
+            **changes: Field-name / value pairs forwarded to
+                :func:`update_user_config`.
+
+        Returns:
+            The fresh :class:`ResolvedConfig`.
+        """
+        self._config = update_user_config(**changes)
+        self.changed.emit(self._config)
+        return self._config
+
+    def set(self, config: ResolvedConfig) -> None:
+        """Replace the config without persisting and notify listeners.
+
+        Use for externally resolved configs (e.g. passed at startup).
+        """
+        self._config = config
+        self.changed.emit(self._config)

{synodic_client-0.0.1.dev62 → synodic_client-0.0.1.dev64}/synodic_client/application/qt.py

@@ -15,6 +15,7 @@ from porringer.schema import LocalConfiguration
 from PySide6.QtCore import QEvent, QObject, Qt, QTimer
 from PySide6.QtWidgets import QApplication, QWidget
 
+from synodic_client.application.config_store import ConfigStore
 from synodic_client.application.icon import app_icon
 from synodic_client.application.init import run_startup_preamble
 from synodic_client.application.instance import SingleInstance
@@ -31,6 +32,7 @@ from synodic_client.resolution import (
     resolve_config,
     resolve_update_config,
 )
+from synodic_client.subprocess_patch import apply as _apply_subprocess_patch
 from synodic_client.updater import initialize_velopack
 
 
@@ -72,6 +74,23 @@ def _process_uri(uri: str, handler: Callable[[str], None]) -> None:
             handler(manifests[0])
 
 
+def _cancel_all_tasks(loop: asyncio.AbstractEventLoop) -> None:
+    """Cancel every pending asyncio task on *loop*.
+
+    Called synchronously from the ``aboutToQuit`` handler.  Each task
+    receives a cancellation request; when the event loop processes its
+    remaining iterations the ``CancelledError`` propagates and the
+    tasks finish cleanly.
+    """
+    _logger = logging.getLogger(__name__)
+    pending = [t for t in asyncio.all_tasks(loop) if not t.done()]
+    if not pending:
+        return
+    _logger.info('Cancelling %d pending async task(s)', len(pending))
+    for task in pending:
+        task.cancel()
+
+
 def _install_exception_hook(logger: logging.Logger) -> None:
     """Redirect unhandled exceptions to the log file.
 
@@ -163,6 +182,7 @@ def application(*, uri: str | None = None, dev_mode: bool = False, debug: bool =
     """
     # Activate dev-mode namespacing before anything reads config paths.
     set_dev_mode(dev_mode)
+    _apply_subprocess_patch()
 
     # Configure logging before Velopack so install/uninstall hooks and
     # first-run diagnostics are captured in the log file.
@@ -197,8 +217,9 @@ def application(*, uri: str | None = None, dev_mode: bool = False, debug: bool =
         sys.exit(0)
     instance.start_server()
 
-    _screen = Screen(porringer, config)
-    _tray = TrayScreen(app, client, _screen.window, config=config)
+    _store = ConfigStore(config)
+    _screen = Screen(porringer, _store)
+    _tray = TrayScreen(app, client, _screen.window, store=_store)
 
     # Keep install preview windows alive until the app exits
     _install_windows: list[InstallPreviewWindow] = []
@@ -208,7 +229,7 @@ def application(*, uri: str | None = None, dev_mode: bool = False, debug: bool =
         window = InstallPreviewWindow(
             porringer,
             manifest_url,
-            config=config,
+            config=_store.config,
         )
         _install_windows.append(window)
         window.show()
@@ -221,6 +242,18 @@ def application(*, uri: str | None = None, dev_mode: bool = False, debug: bool =
     if uri:
         _process_uri(uri, _handle_install_uri)
 
+    # --- Graceful shutdown ---
+    # aboutToQuit fires synchronously when app.quit() is called but
+    # before the event loop stops, giving us a window to cancel
+    # in-flight async tasks and stop timers.
+
+    def _on_about_to_quit() -> None:
+        logger.info('Application shutting down — cancelling async tasks')
+        _tray.shutdown()
+        _cancel_all_tasks(loop)
+
+    app.aboutToQuit.connect(_on_about_to_quit)
+
     # qasync integrates the asyncio event loop with Qt's event loop,
     # enabling async/await usage in the GUI layer without dedicated threads.
     with loop:

{synodic_client-0.0.1.dev62 → synodic_client-0.0.1.dev64}/synodic_client/application/schema.py

@@ -51,3 +51,24 @@ class ToolUpdateResult:
     failed: int = 0
     updated_packages: set[str] = field(default_factory=set)
     """Package names that were successfully upgraded."""
+
+
+@dataclass(frozen=True, slots=True)
+class UpdateTarget:
+    """Identifies the scope of a manual tool update.
+
+    Passed to the shared completion handler so it can clear the correct
+    updating state and derive timestamp keys.  ``None`` (the default in
+    the handler) means the update was periodic / automatic.
+
+    When *package* is empty the update targeted an entire plugin;
+    otherwise it targeted one specific package within the plugin.
+    *plugin* always carries the signal key (possibly composite
+    ``"plugin:tag"``).
+    """
+
+    plugin: str
+    """Signal key for the plugin (may be composite ``"name:tag"``)."""
+
+    package: str = ''
+    """Package name, or empty when the whole plugin was updated."""

{synodic_client-0.0.1.dev62 → synodic_client-0.0.1.dev64}/synodic_client/application/screen/projects.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import asyncio
 import logging
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from porringer.api import API
 from porringer.backend.command.core.discovery import DiscoveredPlugins
@@ -22,9 +23,11 @@ from synodic_client.application.data import DataCoordinator
 from synodic_client.application.screen.install import SetupPreviewWidget
 from synodic_client.application.screen.schema import PreviewPhase
 from synodic_client.application.screen.sidebar import ManifestSidebar
-from synodic_client.application.screen.spinner import SpinnerWidget
+from synodic_client.application.screen.spinner import LoadingIndicator
 from synodic_client.application.theme import COMPACT_MARGINS
-from synodic_client.resolution import ResolvedConfig
+
+if TYPE_CHECKING:
+    from synodic_client.application.config_store import ConfigStore
 
 logger = logging.getLogger(__name__)
 
@@ -41,7 +44,7 @@ class ProjectsView(QWidget):
     def __init__(
         self,
         porringer: API,
-        config: ResolvedConfig,
+        store: ConfigStore,
         parent: QWidget | None = None,
         *,
         coordinator: DataCoordinator | None = None,
@@ -50,14 +53,14 @@ class ProjectsView(QWidget):
 
         Args:
             porringer: The porringer API instance.
-            config: Resolved configuration.
+            store: The centralised :class:`ConfigStore`.
             parent: Optional parent widget.
             coordinator: Shared data coordinator for validated directory
                 data.
         """
         super().__init__(parent)
         self._porringer = porringer
-        self._config = config
+        self._store = store
         self._coordinator = coordinator
         self._refresh_in_progress = False
         self._pending_select: Path | None = None
@@ -91,9 +94,10 @@ class ProjectsView(QWidget):
         self._empty_placeholder.setStyleSheet('color: grey; font-size: 13px;')
         self._stack.addWidget(self._empty_placeholder)
 
-        outer.addLayout(right, stretch=1)
+        self._loading_indicator = LoadingIndicator('Loading projects\u2026')
+        self._stack.addWidget(self._loading_indicator)
 
-        self._loading_spinner = SpinnerWidget('Loading projects\u2026', parent=self)
+        outer.addLayout(right, stretch=1)
 
     # --- Public API ---
 
@@ -106,7 +110,8 @@ class ProjectsView(QWidget):
     async def _async_refresh(self) -> None:
         """Refresh the sidebar and stacked widgets from the porringer cache."""
         self._refresh_in_progress = True
-        self._loading_spinner.start()
+        self._loading_indicator.start()
+        self._stack.setCurrentWidget(self._loading_indicator)
         self._sidebar.set_enabled(False)
 
         try:
@@ -161,13 +166,13 @@ class ProjectsView(QWidget):
                     widget.load(
                         str(path),
                         project_directory=path if path.is_dir() else path.parent,
-                        detect_updates=self._config.detect_updates,
+                        detect_updates=self._store.config.detect_updates,
                     )
 
         except Exception:
             logger.exception('Failed to refresh projects')
         finally:
-            self._loading_spinner.stop()
+            self._loading_indicator.stop()
             self._sidebar.set_enabled(True)
             self._refresh_in_progress = False
 
@@ -194,7 +199,7 @@ class ProjectsView(QWidget):
                     self._porringer,
                     self,
                     show_close=False,
-                    config=self._config,
+                    config=self._store.config,
                 )
                 widget._discovered_plugins = discovered
                 widget.install_finished.connect(self._on_install_finished)

{synodic_client-0.0.1.dev62 → synodic_client-0.0.1.dev64}/synodic_client/application/screen/screen.py

@@ -34,6 +34,7 @@ from PySide6.QtWidgets import (
     QWidget,
 )
 
+from synodic_client.application.config_store import ConfigStore
 from synodic_client.application.data import DataCoordinator
 from synodic_client.application.icon import app_icon
 from synodic_client.application.screen.plugin_row import (
@@ -50,7 +51,7 @@ from synodic_client.application.screen.schema import (
     ProjectInstance,
     RefreshData,
 )
-from synodic_client.application.screen.spinner import SpinnerWidget
+from synodic_client.application.screen.spinner import LoadingIndicator
 from synodic_client.application.screen.update_banner import UpdateBanner
 from synodic_client.application.theme import (
     COMPACT_MARGINS,
@@ -65,7 +66,6 @@ from synodic_client.application.theme import (
     SEARCH_INPUT_STYLE,
     SETTINGS_GEAR_STYLE,
 )
-from synodic_client.resolution import ResolvedConfig, update_user_config
 
 logger = logging.getLogger(__name__)
 
@@ -111,7 +111,7 @@ class ToolsView(QWidget):
     def __init__(
         self,
         porringer: API,
-        config: ResolvedConfig,
+        store: ConfigStore,
         parent: QWidget | None = None,
         *,
         coordinator: DataCoordinator | None = None,
@@ -120,7 +120,7 @@ class ToolsView(QWidget):
 
         Args:
             porringer: The porringer API instance.
-            config: Resolved configuration (for auto-update toggles).
+            store: The centralised :class:`ConfigStore`.
             parent: Optional parent widget.
             coordinator: Shared data coordinator.  When provided, the
                 view delegates plugin/directory fetching to the
@@ -128,7 +128,7 @@ class ToolsView(QWidget):
         """
         super().__init__(parent)
         self._porringer = porringer
-        self._config = config
+        self._store = store
         self._coordinator = coordinator
         self._section_widgets: list[QWidget] = []
         self._filter_chips: dict[str, FilterChip] = {}
@@ -197,7 +197,8 @@ class ToolsView(QWidget):
         self._scroll.setWidget(self._container)
         outer.addWidget(self._scroll)
 
-        self._loading_spinner = SpinnerWidget('Loading tools\u2026', parent=self)
+        self._loading_indicator = LoadingIndicator('Loading tools\u2026')
+        outer.addWidget(self._loading_indicator)
 
         # Periodic timer to refresh relative timestamps (every 60s)
         self._timestamp_timer = QTimer(self)
@@ -224,10 +225,10 @@ class ToolsView(QWidget):
         toolbar.addWidget(check_btn)
         self._check_btn = check_btn
 
-        update_all_btn = QPushButton('Update All')
-        update_all_btn.setToolTip('Upgrade all auto-update-enabled plugins now')
-        update_all_btn.clicked.connect(self.update_all_requested.emit)
-        toolbar.addWidget(update_all_btn)
+        self._update_all_btn = QPushButton('Update All')
+        self._update_all_btn.setToolTip('Upgrade all auto-update-enabled plugins now')
+        self._update_all_btn.clicked.connect(self.update_all_requested.emit)
+        toolbar.addWidget(self._update_all_btn)
 
         return toolbar
 
@@ -248,7 +249,10 @@ class ToolsView(QWidget):
         background task so the widget tree renders immediately.
         """
         self._refresh_in_progress = True
-        self._loading_spinner.start()
+        self._scroll.hide()
+        self._loading_indicator.start()
+        self._check_btn.setEnabled(False)
+        self._update_all_btn.setEnabled(False)
         need_deferred_check = False
 
         try:
@@ -259,7 +263,10 @@ class ToolsView(QWidget):
             logger.exception('Failed to refresh tools')
             need_deferred_check = False
         finally:
-            self._loading_spinner.stop()
+            self._loading_indicator.stop()
+            self._scroll.show()
+            self._check_btn.setEnabled(True)
+            self._update_all_btn.setEnabled(True)
             self._refresh_in_progress = False
 
         # Fire-and-forget: detect updates in the background, then patch
@@ -372,7 +379,7 @@ class ToolsView(QWidget):
         """Clear existing widgets and rebuild the tool/package tree."""
         self._clear_section_widgets()
 
-        auto_update_map = self._config.plugin_auto_update or {}
+        auto_update_map = self._store.config.plugin_auto_update or {}
         kind_buckets = self._bucket_by_kind(
             data.plugins,
             data.packages_map,
@@ -439,7 +446,7 @@ class ToolsView(QWidget):
 
         auto_val = auto_update_map.get(plugin.name, True)
         plugin_updates = self._updates_available.get(plugin.name, {})
-        tool_timestamps = self._config.last_tool_updates or {}
+        tool_timestamps = self._store.config.last_tool_updates or {}
         default_exe = data.default_runtime_executable
 
         # Sort: default runtime first, then descending by tag
@@ -527,7 +534,7 @@ class ToolsView(QWidget):
         plugin_manifest = data.manifest_packages.get(plugin.name, set())
         raw_packages = data.packages_map.get(plugin.name, [])
         display_packages = self._build_display_packages(raw_packages, plugin_manifest)
-        tool_timestamps = self._config.last_tool_updates or {}
+        tool_timestamps = self._store.config.last_tool_updates or {}
 
         if display_packages:
             for pkg in display_packages:
@@ -1062,7 +1069,7 @@ class ToolsView(QWidget):
 
     def _on_auto_update_toggled(self, plugin_name: str, enabled: bool) -> None:
         """Persist the plugin-level auto-update toggle change to config."""
-        mapping = dict(self._config.plugin_auto_update or {})
+        mapping = dict(self._store.config.plugin_auto_update or {})
 
         if enabled:
             mapping.pop(plugin_name, None)
@@ -1070,7 +1077,7 @@ class ToolsView(QWidget):
             mapping[plugin_name] = False
 
         new_value = mapping if mapping else None
-        self._config = update_user_config(plugin_auto_update=new_value)
+        self._store.update(plugin_auto_update=new_value)
         logger.info('Auto-update for %s set to %s', plugin_name, enabled)
 
     def _on_package_auto_update_toggled(
@@ -1080,7 +1087,7 @@ class ToolsView(QWidget):
         enabled: bool,
     ) -> None:
         """Persist a per-package auto-update override to the nested config dict."""
-        mapping = dict(self._config.plugin_auto_update or {})
+        mapping = dict(self._store.config.plugin_auto_update or {})
         current = mapping.get(plugin_name)
 
         if isinstance(current, dict):
@@ -1096,7 +1103,7 @@ class ToolsView(QWidget):
             mapping.pop(plugin_name, None)
 
         new_value = mapping if mapping else None
-        self._config = update_user_config(plugin_auto_update=new_value)
+        self._store.update(plugin_auto_update=new_value)
         logger.info(
             'Auto-update for %s/%s set to %s',
             plugin_name,
@@ -1382,17 +1389,17 @@ class MainWindow(QMainWindow):
     def __init__(
         self,
         porringer: API | None = None,
-        config: ResolvedConfig | None = None,
+        store: ConfigStore | None = None,
     ) -> None:
         """Initialize the main window.
 
         Args:
             porringer: Optional porringer API instance for manifest display.
-            config: Resolved configuration for plugin auto-update state.
+            store: The centralised :class:`ConfigStore`.
         """
         super().__init__()
         self._porringer = porringer
-        self._config = config
+        self._store = store
         self._coordinator: DataCoordinator | None = DataCoordinator(porringer) if porringer is not None else None
         self.setWindowTitle('Synodic Client')
         self.setMinimumSize(*MAIN_WINDOW_MIN_SIZE)
@@ -1438,12 +1445,12 @@ class MainWindow(QMainWindow):
 
     def show(self) -> None:
         """Show the window, initializing UI lazily on first show."""
-        if self._tabs is None and self._porringer is not None and self._config is not None:
+        if self._tabs is None and self._porringer is not None and self._store is not None:
             self._tabs = QTabWidget(self)
 
             self._projects_view = ProjectsView(
                 self._porringer,
-                self._config,
+                self._store,
                 self,
                 coordinator=self._coordinator,
             )
@@ -1451,7 +1458,7 @@ class MainWindow(QMainWindow):
 
             self._tools_view = ToolsView(
                 self._porringer,
-                self._config,
+                self._store,
                 self,
                 coordinator=self._coordinator,
             )
@@ -1500,16 +1507,16 @@ class Screen:
     def __init__(
         self,
         porringer: API | None = None,
-        config: ResolvedConfig | None = None,
+        store: ConfigStore | None = None,
     ) -> None:
         """Initialize the screen.
 
         Args:
             porringer: Optional porringer API instance.
-            config: Resolved configuration.
+            store: The centralised :class:`ConfigStore`.
         """
         self._porringer = porringer
-        self._config = config
+        self._store = store
 
     @property
     def window(self) -> MainWindow:
@@ -1519,5 +1526,5 @@ class Screen:
             The MainWindow instance.
         """
         if self._window is None:
-            self._window = MainWindow(self._porringer, self._config)
+            self._window = MainWindow(self._porringer, self._store)
         return self._window

{synodic_client-0.0.1.dev62 → synodic_client-0.0.1.dev64}/synodic_client/application/screen/settings.py

@@ -28,12 +28,12 @@ from PySide6.QtWidgets import (
     QWidget,
 )
 
+from synodic_client.application.config_store import ConfigStore
 from synodic_client.application.icon import app_icon
 from synodic_client.application.screen import _format_relative_time
 from synodic_client.application.screen.card import CardFrame
 from synodic_client.application.theme import SETTINGS_WINDOW_MIN_SIZE, UPDATE_STATUS_CHECKING_STYLE
 from synodic_client.logging import log_path, set_debug_level
-from synodic_client.resolution import ResolvedConfig, update_user_config
 from synodic_client.schema import GITHUB_REPO_URL
 from synodic_client.startup import is_startup_registered, register_startup, remove_startup
 
@@ -43,14 +43,11 @@ logger = logging.getLogger(__name__)
 class SettingsWindow(QMainWindow):
     """Application settings window with grouped card sections.
 
-    All controls persist changes immediately via :func:`update_user_config`
-    and emit :attr:`settings_changed` so that the tray and updater can
-    react.  The signal carries the new :class:`ResolvedConfig`.
+    All controls persist changes immediately via the shared
+    :class:`ConfigStore`, which broadcasts the new :class:`ResolvedConfig`
+    to every connected consumer.
     """
 
-    settings_changed = Signal(object)
-    """Emitted with the new ``ResolvedConfig`` whenever a setting is changed and persisted."""
-
     check_updates_requested = Signal()
     """Emitted when the user clicks the *Check for Updates* button."""
 
@@ -74,19 +71,19 @@ class SettingsWindow(QMainWindow):
 
     def __init__(
         self,
-        config: ResolvedConfig,
+        store: ConfigStore,
         version: str = '',
         parent: QWidget | None = None,
     ) -> None:
         """Initialise the settings window.
 
         Args:
-            config: The current resolved configuration snapshot.
+            store: The centralised configuration store.
             version: The application version string to display.
             parent: Optional parent widget.
         """
         super().__init__(parent)
-        self._config = config
+        self._store = store
         self._version = version
         self.setWindowTitle('Synodic Settings')
         self.setMinimumSize(*SETTINGS_WINDOW_MIN_SIZE)
@@ -254,7 +251,7 @@ class SettingsWindow(QMainWindow):
 
         Signals are blocked during the update to prevent feedback loops.
         """
-        config = self._config
+        config = self._store.config
 
         with self._block_signals():
             # Channel: index 0 = Stable, 1 = Development
@@ -305,15 +302,6 @@ class SettingsWindow(QMainWindow):
         """Re-enable the *Check for Updates* button after a check completes."""
         self._check_updates_btn.setEnabled(True)
 
-    def update_config(self, config: ResolvedConfig) -> None:
-        """Replace the internal config snapshot without emitting signals.
-
-        Called by controllers that persist timestamps so that the next
-        :meth:`sync_from_config` sees fresh data instead of the stale
-        snapshot captured at construction time.
-        """
-        self._config = config
-
     def set_last_checked(self, timestamp: str) -> None:
         """Update the *last updated* label from an ISO 8601 timestamp."""
         relative = _format_relative_time(timestamp)
@@ -331,7 +319,11 @@ class SettingsWindow(QMainWindow):
         # adjustSize() only reaches the minimum.  Compute the ideal
         # height from the content widget directly.
         content_hint = self._scroll_content.sizeHint()
-        margins = self._scroll_content.layout().contentsMargins()
+        layout = self._scroll_content.layout()
+        if layout is None:
+            super().show()
+            return
+        margins = layout.contentsMargins()
         ideal_w = max(content_hint.width() + margins.left() + margins.right(), self.minimumWidth())
         ideal_h = max(content_hint.height() + margins.top() + margins.bottom(), self.minimumHeight())
         self.resize(ideal_w, ideal_h)
@@ -349,8 +341,7 @@ class SettingsWindow(QMainWindow):
         Args:
             **changes: Field-name / value pairs to persist.
         """
-        self._config = update_user_config(**changes)
-        self.settings_changed.emit(self._config)
+        self._store.update(**changes)
 
     @contextmanager
     def _block_signals(self) -> Iterator[None]:
@@ -406,13 +397,12 @@ class SettingsWindow(QMainWindow):
         self._persist(auto_apply=checked)
 
     def _on_auto_start_changed(self, checked: bool) -> None:
-        self._config = update_user_config(auto_start=checked)
+        self._store.update(auto_start=checked)
         if getattr(sys, 'frozen', False):
             if checked:
                 register_startup(sys.executable)
             else:
                 remove_startup()
-        self.settings_changed.emit(self._config)
 
     def _on_debug_logging_changed(self, checked: bool) -> None:
         set_debug_level(enabled=checked)