gitpane 1.0.0__py3-none-any.whl

gitpane/controller/navigation_controller.py

@@ -0,0 +1,658 @@
+"""Move a repository window to another repository, a submodule or its parent."""
+
+from __future__ import annotations
+
+import os
+import uuid
+from dataclasses import dataclass, replace
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QObject, QSignalBlocker, Qt, QTimer, Signal
+from PySide6.QtWidgets import QDialog, QMessageBox
+from shiboken6 import isValid
+
+from gitpane.account.authentication import transfer_account
+from gitpane.config import ConsoleOperation
+from gitpane.controller.session_registry import NavigationKind, RepositorySession, keep_streamed_commits
+from gitpane.history.file_history import WindowCapability
+from gitpane.history.history_filter import HISTORY_FILTER_INITIAL_MODE
+from gitpane.history.repository_value import RequestIdentity
+from gitpane.operation.diagnostic import Diagnostic
+from gitpane.operation.operation_status import OperationStatus
+from gitpane.preference.preference_store import saved_recent_identity
+from gitpane.submodule.submodule_discovery import OPEN_AGAIN_RETRY_SENTENCE, declared_directory, initialization_command
+from gitpane.system.path_identity import canonical_path
+from gitpane.transport.git_refusal import refused_https_url
+from gitpane.transport.refusal_notice import SUBMODULE_NOTICE_SUBJECT_TEXT, account_notice
+from gitpane.ui.console.error_dialog import ErrorDialog
+from gitpane.ui.console.operation_dialog import OperationDialog
+from gitpane.ui.welcome.invalid_repository_prompt import InvalidRepositoryPrompt
+from gitpane.ui.window_control.dialog_modality import open_window_modal, prepare_message_box
+from gitpane.worktree.worktree_snapshot import WorktreeKey
+
+if TYPE_CHECKING:
+    from gitpane.account.authentication import AuthenticationService
+    from gitpane.controller.account_controller import AccountController
+    from gitpane.controller.close_readiness import CloseReadiness
+    from gitpane.controller.history_read_controller import HistoryReadController
+    from gitpane.controller.opening_controller import OpeningController
+    from gitpane.controller.operation_policy import OperationPolicy
+    from gitpane.controller.rebase_controller import RebaseController
+    from gitpane.controller.reference_read_controller import ReferenceReadController
+    from gitpane.controller.refresh_controller import RefreshController
+    from gitpane.controller.replay_controller import ReplayController
+    from gitpane.controller.session_registry import SessionRegistry, StreamedHistory
+    from gitpane.controller.staging_session_registry import StagingSessionRegistry
+    from gitpane.controller.transport_controller import TransportController
+    from gitpane.history.repository import GitRepository
+    from gitpane.history.repository_value import Commit, HistorySnapshot, RepositoryContext, RepositoryFailure
+    from gitpane.operation.diagnostic import DiagnosticLog
+    from gitpane.preference.preference_store import PreferenceStore
+    from gitpane.reference.reference_edit import ReferenceService
+    from gitpane.reference.reference_snapshot import ReferenceSnapshot
+    from gitpane.submodule.submodule_discovery import SubmoduleEntry, SubmoduleInitRun, SubmoduleService, SubmoduleSnapshot
+    from gitpane.ui.repository.repository_window import ViewAnchor
+
+
+@dataclass
+class NavigationFamily:
+    """The family one walk into another repository read, bound to the session, identity and family read it started from.
+
+    It only spares the new window a second read of the same family for display. It is never a proof for a write:
+    every child write reads that child again.
+    """
+
+    session: RepositorySession
+    identity: RequestIdentity
+    generation: int
+    family: SubmoduleSnapshot | None = None
+
+
+SWITCH_OPENING_STATUS = "Opening {directory}…"
+SWITCH_PENDING_STATUS = "Already opening {directory}. Choose again once it is open."
+SWITCH_WAITING_STATUS = "{directory} opens here once Git has finished in the current repository."
+SWITCH_MISSING_STATUS = "The folder {directory} no longer exists. The current repository is still open."
+FORGET_OPERATION = "Save recent repositories"
+SWITCH_REFUSED_TITLE = "Change repository"
+SWITCH_REFUSED_TEXT = "The window \"{title}\" is still open on this repository. Close it, then choose the repository again."
+# Names a dialog of the window that has no title of its own when the change of repository is refused because of it.
+UNTITLED_RELATED_WINDOW_TITLE = "Untitled dialog"
+
+
+class NavigationController(QObject):
+    """The changes of repository of every repository window: a walk into a submodule, a repository chosen in the switch menu, the reads they own until the window shows the new repository."""
+
+    # Asks for the closing of the session a published change of repository leaves behind, with the id of the window that
+    # keeps going on the new repository. Closing a session belongs to the shutdown, which sits above this controller.
+    repository_close_requested = Signal(str)
+
+    def __init__(self, *, session_registry_controller: SessionRegistry, operation_policy_controller: OperationPolicy, staging_session_registry_controller: StagingSessionRegistry, reference_read_controller: ReferenceReadController,
+                 refresh_controller: RefreshController, history_read_controller: HistoryReadController, account_controller: AccountController, opening_controller: OpeningController, transport_controller: TransportController,
+                 replay_controller: ReplayController, rebase_controller: RebaseController, close_readiness_controller: CloseReadiness, preference: PreferenceStore, repository: GitRepository, reference: ReferenceService,
+                 authentication: AuthenticationService, diagnostic_log: DiagnosticLog | None, submodule: SubmoduleService, parent: QObject | None = None) -> None:
+        """Receive the services and the lower controllers a change of repository works with; the wiring builds it after the close readiness, and closes the session a published change leaves behind when this controller asks it through a signal."""
+        super().__init__(parent)
+        self.session_registry_controller = session_registry_controller
+        self.operation_policy_controller = operation_policy_controller
+        self.staging_session_registry_controller = staging_session_registry_controller
+        self.reference_read_controller = reference_read_controller
+        self.refresh_controller = refresh_controller
+        self.history_read_controller = history_read_controller
+        self.account_controller = account_controller
+        self.opening_controller = opening_controller
+        self.transport_controller = transport_controller
+        self.replay_controller = replay_controller
+        self.rebase_controller = rebase_controller
+        self.close_readiness_controller = close_readiness_controller
+        self.preference = preference
+        self.repository = repository
+        self.reference = reference
+        self.authentication = authentication
+        self.diagnostic_log = diagnostic_log
+        self.submodule = submodule
+        # The prompt offering to remove a recent repository whose folder is gone, at most one per window.
+        self.invalid_repository_prompt_by_session: dict[str, InvalidRepositoryPrompt] = {}
+        self.submodule_output_by_id: dict[str, OperationDialog] = {}
+        self.submodule_run_by_navigation: dict[str, SubmoduleInitRun] = {}
+        self.navigation_target_by_session: dict[str, str] = {}
+        self.navigation_context_by_id: dict[str, tuple[RepositoryContext, Commit | None]] = {}
+        self.navigation_snapshot_by_id: dict[str, HistorySnapshot] = {}
+        self.navigation_commits_by_id: dict[str, list[Commit]] = {}
+        self.navigation_streamed_history_by_id: dict[str, StreamedHistory] = {}
+        self.navigation_family_by_id: dict[str, NavigationFamily] = {}
+        self.navigation_kind_by_id: dict[str, NavigationKind] = {}
+        self.anchor_by_window: dict[str, dict[WorktreeKey, ViewAnchor]] = {}
+        self.navigation_resume_by_target: dict[str, HistorySnapshot] = {}
+
+    def navigation_opened(self, identity: RequestIdentity, context: RepositoryContext, commit: Commit | None) -> None:
+        """Read the references of a repository a navigation opened, then its history, while that navigation still owns it.
+
+        Connected before the opening's own slot, which ignores the identities a navigation owns, so the two never act on
+        the same read. A repository other than the one the navigation asked for ends the navigation.
+        """
+        owner_id = self.session_registry_controller.navigation_owner_by_id.get(identity.session_id)
+        if owner_id is None:
+            return
+        target_dir = self.navigation_target_by_session.get(owner_id)
+        if target_dir is None or canonical_path(context.repository_dir) != canonical_path(target_dir):
+            kind = self.navigation_kind_by_id.get(identity.session_id, NavigationKind.SUBMODULE)
+            self._navigation_failed(identity.session_id, kind.target_mismatch_text)
+            return
+        self.navigation_context_by_id[identity.session_id] = (context, commit)
+        target_id = identity.session_id
+
+        def target_references_read(snapshot: ReferenceSnapshot | None, error: Exception | None) -> None:
+            """Build the target's history from its own capture, only while this very walk still owns the target."""
+            if self.session_registry_controller.navigation_owner_by_id.get(target_id) != owner_id or self.repository.identity_by_session.get(target_id) != identity:
+                return
+            self.repository.read_snapshot(identity, reference_snapshot=snapshot if error is None else None)
+
+        self.reference.read(context, self.repository.git_filename, identity.generation, target_references_read)
+
+    def navigation_snapshot_read(self, identity: RequestIdentity, snapshot: HistorySnapshot) -> None:
+        """Keep the capture of a repository a navigation reads, then find the commits its window will show.
+
+        Connected before the history read's own slot, which ignores the identities a navigation owns: the two never act
+        on the same capture.
+        """
+        if identity.session_id not in self.session_registry_controller.navigation_owner_by_id:
+            return
+        if snapshot.error:
+            self._navigation_failed(identity.session_id, snapshot.error)
+        elif snapshot.complete and identity.session_id not in self.navigation_snapshot_by_id:
+            self.navigation_snapshot_by_id[identity.session_id] = snapshot
+            self.navigation_commits_by_id[identity.session_id] = []
+            owner_id = self.session_registry_controller.navigation_owner_by_id[identity.session_id]
+            context, _commit = self.navigation_context_by_id[identity.session_id]
+            # A repository chosen in the switch menu opens like a new window: no remembered filter applies to it.
+            anchor = None
+            if self.navigation_kind_by_id.get(identity.session_id) is NavigationKind.SUBMODULE:
+                anchor = self.anchor_by_window.get(owner_id, {}).get(WorktreeKey.from_context(context))
+            filter_text = anchor.filter_text if anchor else ""
+            filter_mode = anchor.filter_mode if anchor else HISTORY_FILTER_INITIAL_MODE
+            streamed_history = self.navigation_streamed_history_by_id.get(identity.session_id)
+            commits = streamed_history.complete_commits(snapshot) if streamed_history is not None and not filter_text else None
+            if commits is not None:
+                # Tied to the owner's history list: a window closed before the next turn takes the answer with it,
+                # instead of publishing into a list that no longer exists.
+                QTimer.singleShot(0, self.session_registry_controller.window_by_session[owner_id].commit_list, lambda: self.navigation_matching_read(identity, commits, len(commits), True))
+                return
+            self.repository.read_filter_matches(snapshot, filter_text, filter_mode, identity)
+
+    def navigate_repository(self, session_id: str, repository_dir: str) -> None:
+        """Revalidate a declared target and explain refusals while retaining the current view."""
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE) or session_id in self.navigation_target_by_session:
+            return
+        session = self.session_registry_controller.session_by_id[session_id]
+        if canonical_path(repository_dir) == canonical_path(session.repository_context.repository_dir):
+            return
+        snapshot = self.refresh_controller.submodule_snapshot_by_session.get(session_id)
+        if snapshot is None or not any(entry.repository_dir and canonical_path(entry.repository_dir) == canonical_path(repository_dir) for entry in snapshot.entries):
+            return
+        showing_window = self.opening_controller.window_showing_folder(repository_dir, other_than=session_id)
+        if showing_window is not None:
+            self.opening_controller.bring_forward(showing_window)
+            return
+        if not self.close_readiness_controller.navigation_ready(session_id):
+            self.session_registry_controller.navigation_request_by_session[session_id] = (session, repository_dir, NavigationKind.SUBMODULE)
+            self.close_readiness_controller.show_close_wait(session_id, navigation=True)
+            self.close_readiness_controller.close_timer.start()
+            return
+        self.anchor_by_window.setdefault(session_id, {})[WorktreeKey.from_context(session.repository_context)] = self.session_registry_controller.window_by_session[session_id].capture_anchor()
+        target_id = uuid.uuid4().hex
+        self.session_registry_controller.navigation_owner_by_id[target_id] = session_id
+        self.navigation_target_by_session[session_id] = repository_dir
+        self.navigation_kind_by_id[target_id] = NavigationKind.SUBMODULE
+        observation = NavigationFamily(session, self.session_registry_controller.identity_by_session[session_id], self.refresh_controller.submodule_read_generation_by_session.get(session_id, 0))
+        self.navigation_family_by_id[target_id] = observation
+        self.session_registry_controller.window_by_session[session_id].statusBar().showMessage("Reading submodules…")
+
+        def prepared(family: SubmoduleSnapshot | None, error: Exception | None) -> None:
+            """Recheck declarations and path components before reading the target repository."""
+            if self.session_registry_controller.navigation_owner_by_id.get(target_id) != session_id:
+                return
+            if self.session_registry_controller.session_by_id.get(session_id) is not observation.session:
+                self._navigation_failed(target_id, "The requesting window changed repository. Open the submodule again.")
+                return
+            if error is not None or family is None:
+                self._navigation_failed(target_id, str(error))
+                return
+            # A newer family read or a refresh of the source window started after this walk: the new window reads its family again instead.
+            if self.session_registry_controller.identity_by_session.get(session_id) == observation.identity and self.refresh_controller.submodule_read_generation_by_session.get(session_id, 0) == observation.generation:
+                observation.family = family
+            for entry in family.entries:
+                if not entry.repository_dir or canonical_path(entry.repository_dir) != canonical_path(repository_dir):
+                    continue
+                try:
+                    if entry.parent_dir is not None:
+                        declared_directory(entry.parent_dir, entry.path)
+                except (OSError, ValueError) as failure:
+                    self._navigation_failed(target_id, str(failure))
+                    return
+                self.refresh_controller.submodule_snapshot_by_session[session_id] = family
+                partial = self.submodule.has_incomplete_initialization(entry.repository_dir)
+                if entry.availability == "not initialized" or entry.availability == "initialized" and partial:
+                    self._initialize_submodule(target_id, entry)
+                    return
+                if entry.availability != "initialized":
+                    command = ""
+                    hint = ""
+                    if entry.availability == "occupied" and entry.parent_dir is not None:
+                        powershell = os.name == "nt"
+                        command = initialization_command(self.repository.git_filename, entry.parent_dir, entry.path, powershell=powershell)
+                        hint = "After clearing the folder, run this command in " + ("PowerShell:" if powershell else "your terminal:")
+                    self._navigation_failed(target_id, entry.cause or "The submodule path is not available.", recovery_command=command, recovery_hint=hint)
+                    return
+                self.repository.open_repository(repository_dir, RequestIdentity(target_id, session.generation + 1))
+                return
+            self._navigation_failed(target_id, "The declared repository is no longer available. Refresh the repository to retry.")
+
+        self.submodule.read(session.repository_context, self.repository.git_filename, prepared, snapshot.root_dir)
+
+    def switch_repository(self, session_id: str, repository_dir: str) -> None:
+        """Open a repository chosen in the switch menu in the same window.
+
+        The current repository stays displayed and usable until the chosen one has been read; only then does the window
+        change, through the same publication as a walk into a submodule. Choosing the displayed repository does nothing.
+        While the chosen repository is being read, another choice is refused, since that read cannot be taken back.
+        While the change still waits for Git in the current repository, nothing has started yet: the last choice
+        replaces the waiting one, and the status bar names the repository that will open.
+        """
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            return
+        session = self.session_registry_controller.session_by_id[session_id]
+        current_dir = session.repository_context.repository_dir
+        # Menu entries are saved resolved, so the text alone recognizes the current repository without touching the disk.
+        if saved_recent_identity(repository_dir) == saved_recent_identity(current_dir):
+            return
+        window = self.session_registry_controller.window_by_session[session_id]
+        opening_dir = self.navigation_target_by_session.get(session_id)
+        if opening_dir is not None:
+            window.statusBar().showMessage(SWITCH_PENDING_STATUS.format(directory=opening_dir))
+            return
+        # A folder that no longer exists is not handed to Git: the current repository stays, and the entry may be removed.
+        # It is checked before any path is resolved, since resolving a folder on an unreachable drive freezes the window.
+        if not os.path.isdir(repository_dir):
+            self._offer_invalid_repository_removal(session_id, repository_dir)
+            return
+        if canonical_path(repository_dir) == canonical_path(current_dir):
+            return
+        showing_window = self.opening_controller.window_showing_folder(repository_dir, other_than=session_id)
+        if showing_window is not None:
+            self.opening_controller.bring_forward(showing_window)
+            return
+        # Changing the repository closes every window tied to the current one, with what the user typed in it: the user closes them instead.
+        related_title = self._open_related_window_title(session_id)
+        if related_title:
+            self._refuse_switch(session_id, related_title)
+            return
+        # Git may still be writing in the current repository: the change waits, then resumes through this same method.
+        if not self.close_readiness_controller.navigation_ready(session_id):
+            self.session_registry_controller.navigation_request_by_session[session_id] = (session, repository_dir, NavigationKind.SWITCH)
+            self.close_readiness_controller.show_close_wait(session_id, navigation=True)
+            window.statusBar().showMessage(SWITCH_WAITING_STATUS.format(directory=repository_dir))
+            self.close_readiness_controller.close_timer.start()
+            return
+        target_id = uuid.uuid4().hex
+        self.session_registry_controller.navigation_owner_by_id[target_id] = session_id
+        self.navigation_target_by_session[session_id] = repository_dir
+        self.navigation_kind_by_id[target_id] = NavigationKind.SWITCH
+        window.statusBar().showMessage(SWITCH_OPENING_STATUS.format(directory=repository_dir))
+        self.repository.open_repository(repository_dir, RequestIdentity(target_id, session.generation + 1))
+
+    def _offer_invalid_repository_removal(self, session_id: str, repository_dir: str) -> None:
+        """Say that the chosen repository has no folder any more, and offer to remove it from the recent history.
+
+        As in Git Extensions, every other recent entry whose folder is gone can be removed at once. The other entries are
+        checked only now that the chosen one turned out to be missing, never when the menu opens, so a disconnected
+        drive in the history cannot slow down the menu. They are the entries the menu listed, compared as saved text:
+        one folder check each, with no path resolved again and no rereading of the stored preferences.
+        """
+        if session_id in self.invalid_repository_prompt_by_session:
+            return
+        window = self.session_registry_controller.window_by_session[session_id]
+        window.statusBar().showMessage(SWITCH_MISSING_STATUS.format(directory=repository_dir))
+        chosen_identity = saved_recent_identity(repository_dir)
+        absent_dirs = [repository_dir]
+        for recent_dir in window.recent_dirs:
+            if saved_recent_identity(recent_dir) == chosen_identity or os.path.isdir(recent_dir):
+                continue
+            absent_dirs.append(recent_dir)
+        prompt = InvalidRepositoryPrompt(repository_dir, len(absent_dirs), window)
+        self.invalid_repository_prompt_by_session[session_id] = prompt
+        prompt.remove_selected_requested.connect(lambda: self._forget_repositories(session_id, [repository_dir]))
+        prompt.remove_all_requested.connect(lambda: self._forget_repositories(session_id, absent_dirs))
+
+        def finish() -> None:
+            """Forget the prompt once answered, unless a newer one already replaced it."""
+            if self.invalid_repository_prompt_by_session.get(session_id) is prompt:
+                self.invalid_repository_prompt_by_session.pop(session_id, None)
+            prompt.deleteLater()
+
+        prompt.finished.connect(finish)
+        open_window_modal(prompt)
+
+    def _forget_repositories(self, session_id: str, repository_dirs: list[str]) -> None:
+        """Remove these entries from the recent history, never any folder.
+
+        The menus of every window and the open chooser follow through the usual preference change relay. A refused save
+        is explained in the status bar of the window and written to the log.
+        """
+        try:
+            self.preference.forget(repository_dirs)
+        except OSError as error:
+            diagnostic = Diagnostic(FORGET_OPERATION, repository_dirs[0] if repository_dirs else "", self.repository.git_filename, [], str(error)).prepare()
+            window = self.session_registry_controller.window_by_session.get(session_id)
+            if window is not None and isValid(window):
+                window.statusBar().showMessage(diagnostic.cause)
+            if self.diagnostic_log is not None:
+                self.diagnostic_log.write(diagnostic)
+
+    def _open_related_window_title(self, session_id: str) -> str:
+        """Name a window still open on the repository of this view, which has to be closed before the view changes repository.
+
+        Every dialog and console of the window has the window as parent, finished consoles and confirmations included;
+        the Staging window is separate but opened from this view. Nothing is closed on the user's behalf, since these
+        windows hold what the user typed or still has to read. Settings is not checked: it is shared by every window and
+        has no Qt parent, so it stays on the repository it was opened for, whose path its local section shows. File
+        history windows are separate views with their own repository. An empty result means nothing is in the way.
+        """
+        window = self.session_registry_controller.window_by_session.get(session_id)
+        if window is None or not isValid(window):
+            return ""
+        for dialog in window.findChildren(QDialog):
+            if dialog.isVisible():
+                return dialog.windowTitle() or UNTITLED_RELATED_WINDOW_TITLE
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if session is None:
+            return ""
+        staging = self.staging_session_registry_controller.staging_by_key.get(WorktreeKey.from_context(session.repository_context))
+        if staging is None or staging.commit_push_session_id != session_id:
+            return ""
+        staging_window = staging.window
+        if staging_window is None or not isValid(staging_window) or not staging_window.isVisible():
+            return ""
+        return staging_window.windowTitle()
+
+    def _refuse_switch(self, session_id: str, title: str) -> None:
+        """Explain that the repository stays because a window tied to it is still open, in the status bar and in a message."""
+        window = self.session_registry_controller.window_by_session[session_id]
+        text = SWITCH_REFUSED_TEXT.format(title=title)
+        window.statusBar().showMessage(text)
+        message = QMessageBox(QMessageBox.Icon.Information, SWITCH_REFUSED_TITLE, text, QMessageBox.StandardButton.Ok, window)
+        prepare_message_box(message, SWITCH_REFUSED_TITLE)
+        message.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
+        open_window_modal(message)
+
+    def _initialize_submodule(self, target_id: str, entry: SubmoduleEntry) -> None:
+        """Keep the source window intact while displaying supervised initialization output."""
+        session_id = self.session_registry_controller.navigation_owner_by_id[target_id]
+        session = self.session_registry_controller.session_by_id[session_id]
+        window = self.session_registry_controller.window_by_session[session_id]
+        window.statusBar().showMessage("Initializing…")
+        window.show_submodule_initializing(entry.repository_dir)
+
+        def current() -> bool:
+            """Reject results after closure or a replacement repository session."""
+            return self.session_registry_controller.navigation_owner_by_id.get(target_id) == session_id and self.session_registry_controller.session_by_id.get(session_id) is session
+
+        def complete(run: SubmoduleInitRun) -> None:
+            """Open only after complete recursive validation, retaining partial failures for retry."""
+            output = self.submodule_output_by_id.get(run.operation_id)
+            if output is not None and isValid(output):
+                output.show_result(OperationStatus(run.status))
+            if not current():
+                return
+            if run.status != OperationStatus.SUCCESS.value or run.validation_status != OperationStatus.SUCCESS.value:
+                window.show_submodules(self.refresh_controller.submodule_snapshot_by_session[session_id])
+                # The console of a failure never closes by itself and already shows Git's lines and the cause: an error
+                # window opened after it would only cover it. Without a visible console, that window is the only place
+                # where the failure can be read.
+                console_shown = output is not None and isValid(output) and output.isVisible()
+                # A refused credential manager opens the install window, which already says what to do while the console
+                # keeps its red line: no error window comes on top of it.
+                install_window_shown = run.credential_manager_refusal is not None and self.account_controller.offer_credential_manager_install(run.credential_manager_refusal, window)
+                self._navigation_failed(target_id, run.diagnostic.detail if run.diagnostic else "Submodule initialization did not complete. " + OPEN_AGAIN_RETRY_SENTENCE,
+                                        show_window=not console_shown and not install_window_shown)
+                self._offer_account_after_submodule_refusal(session_id, entry, run)
+                return
+            self.refresh_controller.submodule_snapshot_by_session[session_id] = run.snapshot
+            observation = self.navigation_family_by_id.get(target_id)
+            if observation is not None:
+                # The family read before initialization showed the child as missing; the one validated at its end replaces it.
+                observation.family = run.snapshot
+            self.repository.open_repository(entry.repository_dir, RequestIdentity(target_id, session.generation + 1))
+
+        run = self.submodule.initialize(session.repository_context, self.repository.git_filename, entry, complete,
+                                        session_id=session_id, generation=session.generation, is_current=current)
+        self.submodule_run_by_navigation[target_id] = run
+        output = OperationDialog(run.trace, "Initialize submodule", window, preference=self.preference, console_operation=ConsoleOperation.SUBMODULE_INIT)
+        self.submodule_output_by_id[run.operation_id] = output
+        output.abort_requested.connect(lambda: self.submodule.cancel(run.operation_id))
+        output.finished.connect(run.trace.close)
+        output.set_running()
+        open_window_modal(output, keeps_window_buttons=True)
+
+    def _offer_account_after_submodule_refusal(self, session_id: str, entry: SubmoduleEntry, run: SubmoduleInitRun) -> None:
+        """Open Settings on Accounts when a submodule initialization was refused for an HTTPS account.
+
+        The run keeps no URL, so the address comes from Git's own refusal line; the account named is the one this
+        address would use now, or none when the account list cannot be read.
+        """
+        if run.diagnostic is None:
+            return
+        url = refused_https_url(run.diagnostic.stderr)
+        if not url:
+            return
+        try:
+            account = transfer_account(self.authentication.account_for_endpoint(url), url)
+        except (OSError, ValueError, TypeError, KeyError):
+            account = transfer_account(None, url)
+        notice = account_notice(run.diagnostic, account, SUBMODULE_NOTICE_SUBJECT_TEXT.format(path=entry.path))
+        if notice is not None:
+            self.account_controller.offer_account_after_refusal(session_id, notice)
+
+    def _abandon_navigation(self, target_id: str) -> tuple[str | None, str, NavigationKind | None]:
+        """Drop everything an unpublished change of repository read or planned, leaving the source window as it is.
+
+        Returns the window that asked for the change, the folder it was going to and the kind of change, so the caller
+        can explain why it stopped; the window is None when it no longer waits for this change. A wait message the
+        change left in the window is replaced by the real rebase state, since the repository stays.
+        """
+        run = self.submodule_run_by_navigation.pop(target_id, None)
+        if run is not None:
+            run.open_status = OperationStatus.FAILED.value
+        owner_id = self.session_registry_controller.navigation_owner_by_id.pop(target_id, None)
+        kind = self.navigation_kind_by_id.pop(target_id, None)
+        self.navigation_family_by_id.pop(target_id, None)
+        self.navigation_context_by_id.pop(target_id, None)
+        self.navigation_snapshot_by_id.pop(target_id, None)
+        self.navigation_commits_by_id.pop(target_id, None)
+        self.navigation_streamed_history_by_id.pop(target_id, None)
+        self.navigation_resume_by_target.pop(target_id, None)
+        self.repository.cancel(target_id)
+        self.repository.context_by_session.pop(target_id, None)
+        if owner_id is None:
+            return None, "", kind
+        directory = self.navigation_target_by_session.pop(owner_id, "")
+        self.close_readiness_controller.clear_navigation_wait(owner_id)
+        return owner_id, directory, kind
+
+    def _navigation_failed(self, target_id: str, cause: str, *, recovery_command: str = "", recovery_hint: str = "", show_window: bool = True) -> None:
+        """Discard unpublished reads and explain recovery while retaining the source repository.
+
+        The status bar always says the change of repository failed. With ``show_window`` false the caller's own console
+        already shows the failure and has written it to the --log file, so no error window opens over it and the
+        diagnostic is not written a second time.
+        """
+        owner_id, directory, kind = self._abandon_navigation(target_id)
+        if owner_id is None:
+            return
+        if kind is None:
+            kind = NavigationKind.SUBMODULE
+        window = self.session_registry_controller.window_by_session.get(owner_id)
+        if window is not None:
+            window.statusBar().showMessage(kind.failure_status.format(directory=directory))
+            if not show_window:
+                return
+            diagnostic = Diagnostic(kind.operation_label, directory, "", [], cause).prepare()
+            dialog = ErrorDialog(diagnostic, window, recovery_command=recovery_command, recovery_hint=recovery_hint)
+            self.session_registry_controller.dialogs.append(dialog)
+            dialog.finished.connect(lambda: self.session_registry_controller.dialogs.remove(dialog) if dialog in self.session_registry_controller.dialogs else None)
+            dialog.finished.connect(dialog.deleteLater)
+            open_window_modal(dialog)
+            if self.diagnostic_log is not None:
+                self.diagnostic_log.write(diagnostic)
+
+    def publish_repository(self, target_id: str, snapshot: HistorySnapshot) -> None:
+        """Replace all repository state together after target validation succeeds."""
+        owner_id = self.session_registry_controller.navigation_owner_by_id.get(target_id)
+        if owner_id not in self.session_registry_controller.window_by_session or target_id not in self.navigation_context_by_id:
+            self._navigation_failed(target_id, "The requesting window is closed.")
+            return
+        if snapshot.error:
+            self._navigation_failed(target_id, snapshot.error)
+            return
+        if not self.close_readiness_controller.navigation_ready(owner_id):
+            self.navigation_resume_by_target[target_id] = snapshot
+            self.close_readiness_controller.show_close_wait(owner_id, navigation=True)
+            self.close_readiness_controller.close_timer.start()
+            return
+        if self.navigation_kind_by_id.get(target_id) is NavigationKind.SWITCH:
+            # The current repository stayed usable while the chosen one was read, so a dialog may have opened on it
+            # meanwhile; publishing now would close it with its content. The change gives up instead, remembering nothing.
+            related_title = self._open_related_window_title(owner_id)
+            if related_title:
+                self._abandon_navigation(target_id)
+                self._refuse_switch(owner_id, related_title)
+                return
+        run = self.submodule_run_by_navigation.get(target_id)
+        if run is not None and snapshot.head_oid != run.intent.expected_oid:
+            self._navigation_failed(target_id, "The submodule checkout changed before opening. The current repository is still open. Refresh and retry.")
+            return
+        run = self.submodule_run_by_navigation.pop(target_id, None)
+        if run is not None:
+            run.open_status = OperationStatus.SUCCESS.value
+        observation = self.navigation_family_by_id.pop(target_id, None)
+        # The family this walk read still describes the source window only if nothing replaced that window's session,
+        # identity or family read since the walk started; otherwise the new window reads its family again.
+        family = None
+        if (observation is not None and observation.session is self.session_registry_controller.session_by_id.get(owner_id) and observation.identity == self.session_registry_controller.identity_by_session.get(owner_id)
+                and observation.generation == self.refresh_controller.submodule_read_generation_by_session.get(owner_id, 0)):
+            family = observation.family
+        context, commit = self.navigation_context_by_id.pop(target_id)
+        commits = self.navigation_commits_by_id.pop(target_id)
+        streamed_history = self.navigation_streamed_history_by_id.pop(target_id, None)
+        self.navigation_snapshot_by_id.pop(target_id, None)
+        self.session_registry_controller.navigation_owner_by_id.pop(target_id)
+        kind = self.navigation_kind_by_id.pop(target_id, NavigationKind.SUBMODULE)
+        self.navigation_target_by_session.pop(owner_id, None)
+        window = self.session_registry_controller.window_by_session[owner_id]
+        previous = self.session_registry_controller.session_by_id[owner_id]
+        generation = previous.generation + 1
+        self.repository_close_requested.emit(owner_id)
+        self.repository.cancel(target_id)
+        self.repository.context_by_session.pop(target_id, None)
+        identity = RequestIdentity(owner_id, generation)
+        session = RepositorySession(owner_id, context, self.repository)
+        session.generation = generation
+        self.session_registry_controller.session_by_id[owner_id] = session
+        self.session_registry_controller.window_by_session[owner_id] = window
+        self.session_registry_controller.identity_by_session[owner_id] = identity
+        self.session_registry_controller.generation_by_session[owner_id] = generation
+        self.repository.context_by_session[owner_id] = context
+        self.repository.identity_by_session[owner_id] = identity
+        self.repository.executable_by_session[owner_id] = self.repository.git_filename
+        session.selection_changed.connect(lambda oid: window.diff_panel.clear_selection("Loading diff…"))
+        session.selection_changed.connect(lambda oid: window.file_tree_panel.clear_selection("Loading tree…"))
+        session.closed.connect(window.file_tree_panel.clear_selection)
+        session.navigation_requested.connect(lambda oid: self.history_read_controller.read_navigation(owner_id, oid))
+        # The window has seen nothing of this worktree's pause state yet. A walk into a submodule asks no observation of
+        # its own and relies on the automatic one of its first worktree read; an observation made for an earlier visit,
+        # less than the refresh interval ago, would hold that one back, and a quick return to a parent paused in a rebase
+        # or a replay would then show neither its banner nor its rebase window.
+        new_key = WorktreeKey.from_context(context)
+        self.rebase_controller.rebase_observed_at_by_key.pop(new_key, None)
+        self.replay_controller.replay_observed_at_by_key.pop(new_key, None)
+        switched = kind is NavigationKind.SWITCH
+        if switched:
+            # A repository chosen in the switch menu opens like a new window: no position, filter or submodule family
+            # of the repository left behind may come back, now or when the window later reads its family again.
+            self.anchor_by_window.pop(owner_id, None)
+            self.refresh_controller.submodule_snapshot_by_session.pop(owner_id, None)
+        window.show_repository(context, fresh=switched)
+        anchor = None if switched else self.anchor_by_window.get(owner_id, {}).get(WorktreeKey.from_context(context))
+        selected_oid = anchor.selected_oid if anchor else (commit.oid if commit else None)
+        window.clear_commit_selection()
+        with QSignalBlocker(window.filter_edit):
+            window.filter_edit.setText(anchor.filter_text if anchor else "")
+        window.show_filter_mode(anchor.filter_mode if anchor else HISTORY_FILTER_INITIAL_MODE)
+        session.filter_text = window.filter_edit.text()
+        snapshot.generation = generation
+        session.snapshot = snapshot
+        session.streamed_history = streamed_history
+        self.repository.snapshot_by_session[owner_id] = snapshot
+        missing_selection = anchor is not None and selected_oid is not None and not any(item.oid == selected_oid for item in commits)
+        if missing_selection:
+            with QSignalBlocker(window):
+                window.show_matches(snapshot, commits, session.filter_text, selected_oid)
+                window.restore_anchor(anchor)
+                window.clear_commit_selection()
+            window.statusBar().showMessage("The previously selected commit is no longer available. Select a commit to continue.")
+        else:
+            window.show_matches(snapshot, commits, session.filter_text, selected_oid)
+            if anchor is not None:
+                window.restore_anchor(anchor)
+        # A remote read the previous repository started for the Fetch menu was dropped with its session and never
+        # releases the button: the busy state follows the transports of the repository shown now.
+        window.set_fetch_busy(self.transport_controller.fetch_busy_for(context.common_git_dir))
+        if switched:
+            # As when a window opens: the pause banners of the new repository are read now rather than at the next
+            # working-tree count, and a paused rebase offers its dialog. The automatic observation that follows is held
+            # back by the rebase refresh interval, so the state is not read twice.
+            self.rebase_controller.observe_rebase(owner_id, open_paused=True)
+        if family is not None:
+            family_generation = self.refresh_controller.submodule_read_generation_by_session.get(owner_id, 0) + 1
+            self.refresh_controller.submodule_read_generation_by_session[owner_id] = family_generation
+            self.refresh_controller.publish_submodule_family(owner_id, family, identity, family_generation)
+        elif not switched:
+            self.session_registry_controller.window_by_session[owner_id].show_submodules(self.refresh_controller.submodule_snapshot_by_session[owner_id])
+        # The capture the target's history was built from becomes the new window's branch list once its reference files
+        # are checked unchanged; only its generation changes, to the new window's.
+        previous = replace(snapshot.reference_snapshot, generation=generation) if snapshot.reference_snapshot is not None else None
+        self.reference_read_controller.read_references(owner_id, previous=previous)
+        if WindowCapability.MANAGE in session.capabilities and not context.is_bare:
+            # The window shows no count of this worktree yet (a switch cleared it, a walk still shows the previous
+            # repository's), and a worktree read earlier in the run answers with what it already had.
+            self.staging_session_registry_controller.staging_session(context).refresh(announce=True)
+        if family is None:
+            self.refresh_controller.read_submodules(owner_id)
+        diagnostic = self.opening_controller.remember_repository(context.repository_dir)
+        if switched:
+            # A window just opened takes its reading proportions from the preferences, not from the repository left behind.
+            window.apply_reading_preference(self.preference.value_by_key)
+        if diagnostic is not None:
+            self.opening_controller.show_preference_failure(diagnostic, window)
+
+    def navigation_commit_batch_read(self, identity: RequestIdentity, commits: list[Commit]) -> None:
+        """Keep the rows a navigation's history read just parsed, so the window it replaces can show them without reading Git again."""
+        if identity.session_id not in self.session_registry_controller.navigation_owner_by_id:
+            return
+        snapshot = self.repository.snapshot_by_session.get(identity.session_id)
+        if snapshot is not None:
+            previous = self.navigation_streamed_history_by_id.get(identity.session_id)
+            self.navigation_streamed_history_by_id[identity.session_id] = keep_streamed_commits(previous, snapshot, commits)
+
+    def navigation_matching_read(self, identity: RequestIdentity, commits: list[Commit], scanned_count: int, complete: bool) -> None:
+        """Gather the commits found for a navigation, then replace the window's repository once the last ones arrive."""
+        if identity.session_id not in self.session_registry_controller.navigation_owner_by_id:
+            return
+        self.navigation_commits_by_id[identity.session_id].extend(commits)
+        if complete:
+            self.publish_repository(identity.session_id, self.navigation_snapshot_by_id[identity.session_id])
+
+    def navigation_read_failed(self, identity: RequestIdentity, failure: RepositoryFailure) -> None:
+        """Give up a navigation whose repository read failed, keeping the window on the repository it shows."""
+        if identity.session_id not in self.session_registry_controller.navigation_owner_by_id:
+            return
+        self._navigation_failed(identity.session_id, failure.cause)