synodic-client 0.0.1.dev74__tar.gz → 0.0.1.dev76__tar.gz

{synodic_client-0.0.1.dev74 → synodic_client-0.0.1.dev76}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: synodic_client
-Version: 0.0.1.dev74
+Version: 0.0.1.dev76
 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.dev74 → synodic_client-0.0.1.dev76}/pyproject.toml

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

{synodic_client-0.0.1.dev74 → synodic_client-0.0.1.dev76}/synodic_client/application/debug.py

@@ -17,6 +17,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 from synodic_client.config import is_dev_mode
+from synodic_client.operations.schema import DEBUG_ACTIONS
 
 if TYPE_CHECKING:
     from porringer.api import API
@@ -32,19 +33,7 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
-_ACTIONS: dict[str, str] = {
-    'check_update': 'Trigger a self-update check.',
-    'tool_update': 'Run tool/package updates for all plugins.',
-    'refresh_data': 'Mark cached data as stale (next refresh re-fetches).',
-    'show_main': 'Show and raise the main window.',
-    'show_settings': 'Show the settings window.',
-    'apply_update': 'Apply a downloaded update and restart.',
-    'list_projects': 'List cached project directories with validation status.',
-    'add_project': 'Add a directory to the project cache. Arg: <path>',
-    'remove_project': 'Remove a directory from the project cache. Arg: <path>',
-    'project_status': 'Dump per-action preview status. Arg (optional): <path>',
-    'select_project': 'Select a project in the sidebar. Arg: <path>',
-}
+_ACTIONS = DEBUG_ACTIONS
 
 
 @dataclasses.dataclass
@@ -164,49 +153,39 @@ class DebugHandler:
 
     def _handle_list_projects(self) -> str:
         """List all cached project directories with validation status."""
-        from synodic_client.operations.project import list_projects
+        from synodic_client.operations.project import run_project_action
 
-        projects = list_projects(self._s.porringer)
-        return json.dumps({'projects': [dataclasses.asdict(p) for p in projects]})
+        return json.dumps(run_project_action('list_projects', None, self._s.porringer))
 
     def _handle_add_project(self, arg: str | None) -> str:
         """Add a directory to the porringer cache."""
-        if not arg:
-            return json.dumps({'error': 'add_project requires a path argument'})
-
-        from synodic_client.operations.project import add_project
+        from synodic_client.operations.project import run_project_action
 
-        try:
-            add_project(self._s.porringer, arg)
-        except (NotADirectoryError, ValueError) as exc:
-            return json.dumps({'error': str(exc)})
+        result = run_project_action('add_project', arg, self._s.porringer)
 
-        if self._s.coordinator is not None:
-            self._s.coordinator.invalidate()
-
-        projects_view = self._s.main_window._projects_view
-        if projects_view is not None:
-            projects_view.refresh()
+        if 'error' not in result:
+            if self._s.coordinator is not None:
+                self._s.coordinator.invalidate()
+            projects_view = self._s.main_window._projects_view
+            if projects_view is not None:
+                projects_view.refresh()
 
-        return json.dumps({'ok': True, 'action': 'add_project', 'path': arg})
+        return json.dumps(result)
 
     def _handle_remove_project(self, arg: str | None) -> str:
         """Remove a directory from the porringer cache."""
-        if not arg:
-            return json.dumps({'error': 'remove_project requires a path argument'})
+        from synodic_client.operations.project import run_project_action
 
-        from synodic_client.operations.project import remove_project
+        result = run_project_action('remove_project', arg, self._s.porringer)
 
-        remove_project(self._s.porringer, arg)
-
-        if self._s.coordinator is not None:
-            self._s.coordinator.invalidate()
-
-        projects_view = self._s.main_window._projects_view
-        if projects_view is not None:
-            projects_view.refresh()
+        if 'error' not in result:
+            if self._s.coordinator is not None:
+                self._s.coordinator.invalidate()
+            projects_view = self._s.main_window._projects_view
+            if projects_view is not None:
+                projects_view.refresh()
 
-        return json.dumps({'ok': True, 'action': 'remove_project', 'path': arg})
+        return json.dumps(result)
 
     def _handle_project_status(self, arg: str | None) -> str:
         """Dump per-action preview status for a project."""
@@ -243,9 +222,11 @@ class DebugHandler:
                 entry['installer'] = act.installer
             actions.append(entry)
 
-        needed = sum(1 for s in model.action_states if s.status == 'Needed')
-        satisfied = sum(1 for s in model.action_states if '\u2713' in s.status)
-        pending = sum(1 for s in model.action_states if s.status == 'Pending')
+        from synodic_client.operations.schema import classify_status
+
+        needed = sum(1 for s in model.action_states if classify_status(s.status) == 'needed')
+        satisfied = sum(1 for s in model.action_states if classify_status(s.status) == 'satisfied')
+        pending = sum(1 for s in model.action_states if classify_status(s.status) == 'pending')
         upgradable = len(model.upgradable_keys)
 
         return json.dumps({

{synodic_client-0.0.1.dev74 → synodic_client-0.0.1.dev76}/synodic_client/application/qt.py

@@ -13,7 +13,6 @@ from collections.abc import Callable
 
 import qasync
 from porringer.api import API
-from porringer.schema import LocalConfiguration
 from PySide6.QtCore import QEvent, QObject, Qt, QTimer
 from PySide6.QtWidgets import QApplication, QWidget
 
@@ -29,12 +28,9 @@ from synodic_client.application.uri import parse_uri
 from synodic_client.client import Client
 from synodic_client.config import set_dev_mode
 from synodic_client.logging import configure_logging, log_path, set_debug_level
+from synodic_client.operations.bootstrap import init_services
 from synodic_client.protocol import extract_uri_from_args
-from synodic_client.resolution import (
-    ResolvedConfig,
-    resolve_config,
-    resolve_update_config,
-)
+from synodic_client.resolution import ResolvedConfig
 from synodic_client.subprocess_patch import apply as _apply_subprocess_patch
 from synodic_client.updater import initialize_velopack
 
@@ -42,27 +38,14 @@ from synodic_client.updater import initialize_velopack
 def _init_services(logger: logging.Logger) -> tuple[Client, API, ResolvedConfig]:
     """Create and configure core services.
 
+    Delegates to :func:`~synodic_client.operations.bootstrap.init_services`
+    and adds GUI-specific debug logging.
+
     Returns:
         A (Client, porringer API, resolved config) tuple.
     """
-    config = resolve_config()
-    client = Client()
-
-    local_config = LocalConfiguration()
-    porringer = API(local_config)
-
-    update_config = resolve_update_config(config)
-    client.initialize_updater(update_config)
+    client, porringer, config = init_services()
 
-    cached_dirs = porringer.cache.list_directories()
-
-    logger.info(
-        'Synodic Client v%s started (channel: %s, source: %s, cached_projects: %d)',
-        client.version,
-        update_config.channel.name,
-        update_config.repo_url,
-        len(cached_dirs),
-    )
     logger.debug(
         'Resolved config: update_source=%s update_channel=%s auto_update=%dm tool_update=%dm '
         'auto_apply=%s auto_start=%s debug_logging=%s prerelease_packages=%s plugin_auto_update=%s',

{synodic_client-0.0.1.dev74 → synodic_client-0.0.1.dev76}/synodic_client/application/screen/__init__.py

@@ -9,9 +9,19 @@ from __future__ import annotations
 import re
 from datetime import UTC, datetime
 
-from porringer.schema import SetupAction, SetupActionResult, SkipReason
+from porringer.schema import SetupAction, SetupActionResult
 from porringer.schema.plugin import PluginKind
 
+from synodic_client.operations.schema import (
+    SKIP_REASON_LABELS as SKIP_REASON_LABELS,
+)
+from synodic_client.operations.schema import (
+    resolve_action_status as resolve_action_status,
+)
+from synodic_client.operations.schema import (
+    skip_reason_label as skip_reason_label,
+)
+
 _SECONDS_PER_MINUTE = 60
 _MINUTES_PER_HOUR = 60
 _HOURS_PER_DAY = 24
@@ -48,22 +58,6 @@ def plugin_kind_group_label(kind: PluginKind) -> str:
     return PLUGIN_KIND_GROUP_LABELS.get(kind, kind.name.replace('_', ' ').title())
 
 
-SKIP_REASON_LABELS: dict[SkipReason, str] = {
-    SkipReason.ALREADY_INSTALLED: 'Already installed',
-    SkipReason.NOT_INSTALLED: 'Not installed',
-    SkipReason.ALREADY_LATEST: 'Already latest',
-    SkipReason.NO_PROJECT_DIRECTORY: 'No project directory',
-    SkipReason.UPDATE_AVAILABLE: 'Update available',
-}
-
-
-def skip_reason_label(reason: SkipReason | None) -> str:
-    """Return a human-readable label for a skip reason."""
-    if reason is None:
-        return 'Skipped'
-    return SKIP_REASON_LABELS.get(reason, reason.name.replace('_', ' ').capitalize())
-
-
 def format_cli_command(
     action: SetupAction,
     *,

{synodic_client-0.0.1.dev74 → synodic_client-0.0.1.dev76}/synodic_client/application/screen/action_card.py

@@ -14,7 +14,7 @@ from __future__ import annotations
 import logging
 
 from porringer.backend.command.core.action_builder import PHASE_ORDER
-from porringer.schema import SetupAction, SetupActionResult, SkipReason
+from porringer.schema import SetupAction, SetupActionResult
 from porringer.schema.plugin import PluginKind
 from PySide6.QtCore import Qt, QTimer, Signal
 from PySide6.QtGui import QColor
@@ -443,56 +443,47 @@ class ActionCard(QFrame):
     # Public API — dry-run check result
     # ------------------------------------------------------------------
 
-    def set_check_result(self, result: SetupActionResult) -> None:
+    def set_check_result(self, result: SetupActionResult, status: str) -> None:
         """Update the card with a dry-run check result.
 
-        Handles these cases:
-
-        * **Skipped (update available)** — amber "Update available" badge.
-        * **Skipped (other)** — muted satisfied badge.
-        * **Failed** — red "Failed" badge with diagnostic tooltip.
-        * **Bare command** (kind=None, success=True) — keeps "Pending".
-        * **Project sync** (kind=PROJECT, success=True) — "Ready".
-        * **Needed** — default blue badge.
+        The *status* string is pre-resolved by the operations layer via
+        :func:`resolve_action_status`.  This method maps it to the
+        appropriate style and updates the version / tooltip columns.
 
         Args:
             result: The action check result from the preview worker.
+            status: Pre-resolved human-readable status label.
         """
         if self._is_skeleton:
             return
 
         self._stop_spinner()
 
-        if result.skipped and result.skip_reason == SkipReason.UPDATE_AVAILABLE:
-            label = skip_reason_label(result.skip_reason)
-            self._status_label.setText(label)
-            self._status_label.setStyleSheet(ACTION_CARD_STATUS_UPDATE)
-        elif result.skipped:
-            label = '\u2713 ' + skip_reason_label(result.skip_reason)
-            self._status_label.setText(label)
-            self._status_label.setStyleSheet(ACTION_CARD_STATUS_SATISFIED)
-        elif not result.success:
-            label = 'Failed'
-            self._status_label.setText(label)
-            self._status_label.setStyleSheet(ACTION_CARD_STATUS_FAILED)
+        # Status-to-style mapping
+        _STATUS_STYLES: dict[str, str] = {
+            'Update available': ACTION_CARD_STATUS_UPDATE,
+            'Failed': ACTION_CARD_STATUS_FAILED,
+            'Pending': ACTION_CARD_STATUS_PENDING,
+            'Ready': ACTION_CARD_STATUS_SATISFIED,
+            'Needed': ACTION_CARD_STATUS_NEEDED,
+        }
+
+        style = _STATUS_STYLES.get(status, ACTION_CARD_STATUS_SATISFIED)
+        display = status
+
+        # Satisfied (skipped) statuses get a checkmark prefix
+        if result.skipped and status not in _STATUS_STYLES:
+            display = f'\u2713 {status}'
+
+        if not result.success and status == 'Failed':
             logger.warning(
                 'Dry-run check failed for %s: %s',
                 self._action.description if self._action else '(unknown)',
                 result.message or 'unknown error',
             )
-        elif self._action is not None and self._action.kind is None:
-            # Bare command — porringer returns success=True; keep Pending.
-            label = 'Pending'
-            self._status_label.setText(label)
-            self._status_label.setStyleSheet(ACTION_CARD_STATUS_PENDING)
-        elif self._action is not None and self._action.kind == PluginKind.PROJECT:
-            label = 'Ready'
-            self._status_label.setText(label)
-            self._status_label.setStyleSheet(ACTION_CARD_STATUS_SATISFIED)
-        else:
-            label = 'Needed'
-            self._status_label.setText(label)
-            self._status_label.setStyleSheet(ACTION_CARD_STATUS_NEEDED)
+
+        self._status_label.setText(display)
+        self._status_label.setStyleSheet(style)
 
         # Surface diagnostic detail (e.g. SCM URL mismatch) as a tooltip
         if result.message:
@@ -641,6 +632,7 @@ class ActionCardList(QWidget):
 
         self._cards: list[ActionCard] = []
         self._action_map: dict[SetupAction, ActionCard] = {}
+        self._index_map: dict[int, ActionCard] = {}
 
     # ------------------------------------------------------------------
     # Skeleton loading
@@ -692,6 +684,14 @@ class ActionCardList(QWidget):
             self._cards.append(card)
             self._action_map[act] = card
 
+        # Build original-index → card mapping so callers can look up by
+        # the action index porringer emits, which is independent of the
+        # display sort order.
+        for original_index, act in enumerate(actions):
+            card = self._action_map.get(act)
+            if card is not None:
+                self._index_map[original_index] = card
+
     # ------------------------------------------------------------------
     # Card lookup
     # ------------------------------------------------------------------
@@ -706,6 +706,15 @@ class ActionCardList(QWidget):
         """Return the number of cards (including skeletons)."""
         return len(self._cards)
 
+    def card_for_action_index(self, action_index: int) -> ActionCard | None:
+        """Return the card for the given original action index.
+
+        The index corresponds to the action's position in the unsorted
+        list passed to :meth:`populate`, matching the indices emitted
+        by porringer's ``ActionCompletedEvent``.
+        """
+        return self._index_map.get(action_index)
+
     def get_card(self, action: SetupAction) -> ActionCard | None:
         """Look up the card for a given action.
 
@@ -736,3 +745,4 @@ class ActionCardList(QWidget):
             card.deleteLater()
         self._cards.clear()
         self._action_map.clear()
+        self._index_map.clear()

{synodic_client-0.0.1.dev74 → synodic_client-0.0.1.dev76}/synodic_client/application/screen/install.py

@@ -27,7 +27,6 @@ from porringer.schema import (
     SubActionProgress,
     SyncStrategy,
 )
-from porringer.schema.plugin import PluginKind
 from PySide6.QtCore import Qt, QTimer, Signal
 from PySide6.QtGui import QShowEvent
 from PySide6.QtWidgets import (
@@ -45,7 +44,6 @@ from PySide6.QtWidgets import (
 )
 
 from synodic_client.application.package_state import PackageStateStore
-from synodic_client.application.screen import skip_reason_label
 from synodic_client.application.screen.action_card import ActionCardList
 from synodic_client.application.screen.card import CardFrame
 from synodic_client.application.screen.install_workers import run_install, run_preview
@@ -615,28 +613,13 @@ class SetupPreviewWidget(QWidget):
         if preview.metadata:
             self.metadata_ready.emit(preview)
 
-    def _on_action_checked(self, row: int, result: SetupActionResult) -> None:
+    def _on_action_checked(self, row: int, result: SetupActionResult, status: str) -> None:
         """Update the model and action card with a dry-run result."""
         m = self._model
-        if result.skipped and result.skip_reason == SkipReason.UPDATE_AVAILABLE:
-            label = skip_reason_label(result.skip_reason)
-            if 0 <= row < len(m.action_states):
-                m.upgradable_keys.add(m.action_states[row].action)
-        elif result.skipped:
-            label = skip_reason_label(result.skip_reason)
-        elif not result.success:
-            label = 'Failed'
-        else:
-            # Bare commands (kind=None) and PROJECT actions always return
-            # success=True from porringer's dry_run_action.  Don't
-            # overwrite their initial status to "Needed".
-            action = m.action_states[row].action if 0 <= row < len(m.action_states) else None
-            if action is not None and action.kind is None:
-                label = 'Pending'
-            elif action is not None and action.kind == PluginKind.PROJECT:
-                label = 'Ready'
-            else:
-                label = 'Needed'
+        label = status
+
+        if result.skipped and result.skip_reason == SkipReason.UPDATE_AVAILABLE and 0 <= row < len(m.action_states):
+            m.upgradable_keys.add(m.action_states[row].action)
 
         if 0 <= row < len(m.action_states):
             m.action_states[row].status = label
@@ -655,9 +638,9 @@ class SetupPreviewWidget(QWidget):
         # Update the card widget
         if m.preview and 0 <= row < len(m.preview.actions):
             action = m.preview.actions[row]
-            card = self._card_list.get_card(action)
+            card = self._card_list.card_for_action_index(row)
             if card is not None:
-                card.set_check_result(result)
+                card.set_check_result(result, status)
 
             # Record in shared store so ToolsView can reflect the update
             if self._package_store is not None and action.installer and action.package:
@@ -696,15 +679,20 @@ class SetupPreviewWidget(QWidget):
                 finalized,
             )
 
-        # Compute summary
+        # Compute summary using the shared operations-layer classifier
+        from collections import Counter
+
+        from synodic_client.operations.schema import classify_status
+
         total = len(m.action_states)
-        needed = sum(1 for s in m.action_states if s.status == 'Needed')
+        counts = Counter(classify_status(s.status) for s in m.action_states)
+        needed = counts.get('needed', 0)
+        satisfied = counts.get('satisfied', 0)
+        pending = counts.get('pending', 0)
+        ready = counts.get('ready', 0)
+        unavailable = counts.get('unavailable', 0)
+        failed = counts.get('failed', 0)
         upgradable = len(m.upgradable_keys)
-        unavailable = sum(1 for s in m.action_states if s.status == 'Not installed')
-        failed = sum(1 for s in m.action_states if s.status == 'Failed')
-        pending = sum(1 for s in m.action_states if s.status == 'Pending')
-        ready = sum(1 for s in m.action_states if s.status == 'Ready')
-        satisfied = total - needed - upgradable - unavailable - failed - pending - ready
 
         parts: list[str] = []
         _counts: list[tuple[int, str]] = [

synodic_client-0.0.1.dev76/synodic_client/application/screen/install_workers.py

@@ -0,0 +1,152 @@
+"""Async worker coroutines for install and preview operations.
+
+Contains ``run_install``, ``run_preview``, and supporting helpers that
+stream porringer events back to the GUI via callbacks.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from pathlib import Path
+
+from porringer.api import API
+from porringer.backend.command.core.discovery import DiscoveredPlugins
+from porringer.schema import (
+    ActionCompletedEvent,
+    ActionStartedEvent,
+    ManifestLoadedEvent,
+    SetupAction,
+    SetupActionResult,
+    SetupParameters,
+    SetupResults,
+    SubActionProgressEvent,
+)
+
+from synodic_client.application.screen.schema import (
+    InstallCallbacks,
+    InstallConfig,
+    PreviewCallbacks,
+    PreviewConfig,
+)
+from synodic_client.application.uri import safe_rmtree
+from synodic_client.operations.install import preview_manifest_stream
+from synodic_client.operations.schema import (
+    PreviewActionChecked,
+    PreviewManifestParsed,
+    PreviewPluginsQueried,
+    PreviewReady,
+)
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# run_install — execute setup actions via porringer
+# ---------------------------------------------------------------------------
+
+
+async def run_install(
+    porringer: API,
+    manifest_path: Path,
+    config: InstallConfig | None = None,
+    callbacks: InstallCallbacks | None = None,
+    *,
+    plugins: DiscoveredPlugins | None = None,
+) -> SetupResults:
+    """Execute setup actions via porringer and stream progress.
+
+    Runs on the caller's event loop (typically the qasync main-thread
+    loop).  Callbacks are invoked between ``await`` points so the GUI
+    stays responsive without cross-thread signalling.
+    """
+    cfg = config or InstallConfig()
+    cb = callbacks or InstallCallbacks()
+    params = SetupParameters(
+        paths=[manifest_path],
+        project_directory=cfg.project_directory,
+        strategy=cfg.strategy,
+        prerelease_packages=cfg.prerelease_packages,
+    )
+    actions: list[SetupAction] = []
+    collected: list[SetupActionResult] = []
+    manifest_result: SetupResults | None = None
+
+    async for event in porringer.sync.execute_stream(params, plugins=plugins):
+        if isinstance(event, ManifestLoadedEvent):
+            manifest_result = event.manifest
+            actions = list(event.manifest.actions)
+
+        elif isinstance(event, ActionStartedEvent) and cb.on_action_started is not None:
+            cb.on_action_started(event.action)
+
+        elif isinstance(event, SubActionProgressEvent) and cb.on_sub_progress is not None:
+            cb.on_sub_progress(event.action, event.sub_action)
+
+        elif isinstance(event, ActionCompletedEvent):
+            collected.append(event.result)
+            if cb.on_progress is not None:
+                cb.on_progress(event.action, event.result)
+
+    return SetupResults(
+        actions=actions,
+        results=collected,
+        manifest_path=manifest_result.manifest_path if manifest_result else None,
+        metadata=manifest_result.metadata if manifest_result else None,
+    )
+
+
+# ---------------------------------------------------------------------------
+# run_preview — dry-run preview of a manifest
+# ---------------------------------------------------------------------------
+
+
+async def run_preview(
+    porringer: API,
+    url: str,
+    *,
+    config: PreviewConfig | None = None,
+    callbacks: PreviewCallbacks | None = None,
+    plugins: DiscoveredPlugins | None = None,
+) -> None:
+    """Download a manifest and perform a dry-run preview.
+
+    Delegates to :func:`preview_manifest_stream` in the operations
+    layer, then routes each :data:`PreviewEvent` to the appropriate
+    callback.
+    """
+    logger.info('run_preview starting for: %s', url)
+    cb = callbacks or PreviewCallbacks()
+    cfg = config or PreviewConfig()
+    temp_dir: str | None = None
+    try:
+        async for event in preview_manifest_stream(
+            porringer,
+            url,
+            project_directory=cfg.project_directory,
+            prerelease_packages=cfg.prerelease_packages,
+            discovered=plugins,
+        ):
+            if isinstance(event, PreviewManifestParsed):
+                temp_dir = event.temp_dir or None
+                if cb.on_manifest_parsed is not None:
+                    cb.on_manifest_parsed(event.manifest, event.manifest_path, event.temp_dir)
+
+            elif isinstance(event, PreviewPluginsQueried) and cb.on_plugins_queried is not None:
+                cb.on_plugins_queried(event.availability, event.capabilities)
+
+            elif isinstance(event, PreviewReady):
+                if cb.on_preview_ready is not None:
+                    cb.on_preview_ready(event.manifest, event.manifest_path, event.temp_dir)
+
+            elif isinstance(event, PreviewActionChecked) and cb.on_action_checked is not None:
+                cb.on_action_checked(event.index, event.result, event.status)
+
+    except asyncio.CancelledError:
+        if temp_dir:
+            safe_rmtree(temp_dir)
+        raise
+    except Exception:
+        if temp_dir:
+            safe_rmtree(temp_dir)
+        raise

{synodic_client-0.0.1.dev74 → synodic_client-0.0.1.dev76}/synodic_client/application/screen/schema.py

@@ -323,8 +323,8 @@ class PreviewCallbacks:
     on_preview_ready: Callable[[SetupResults, str, str], None] | None = None
     """``(SetupResults, manifest_path, temp_dir)`` — CLI commands resolved."""
 
-    on_action_checked: Callable[[int, SetupActionResult], None] | None = None
-    """``(row_index, SetupActionResult)`` — per-action dry-run result."""
+    on_action_checked: Callable[[int, SetupActionResult, str], None] | None = None
+    """``(row_index, SetupActionResult, status)`` — per-action dry-run result with resolved status."""
 
 
 @dataclass(frozen=True, slots=True)
@@ -333,10 +333,3 @@ class PreviewConfig:
 
     project_directory: Path | None = None
     prerelease_packages: set[str] | None = None
-
-
-@dataclass(slots=True)
-class _DispatchState:
-    """Mutable accumulator for :func:`_dispatch_preview_event`."""
-
-    got_parsed: bool = False