@codingame/monaco-vscode-workbench-service-override 37.1.0 → 37.3.0

package/vscode/src/vs/sessions/contrib/layout/browser/singlePane/singlePaneDraftSessionStrategy.js

@@ -0,0 +1,423 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
+import { IAgentWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesService';
+import { EmptyFileEditorInput } from '../../../editor/browser/emptyFileEditorInput.js';
+import { DetailPanelTarget } from './singlePaneDetailPanelCoordinator.js';
+import { isChangesEditorInput, isMainPartEmpty, isEditorWithoutDockedDetails, isFileEditorInput } from './singlePaneSharedHelpers.js';
+import { SinglePaneLayoutStrategy } from './singlePaneLayoutStrategy.js';
+import { SessionVisibilityProfile } from './singlePaneVisibilityProfileStore.js';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+import { ISessionChangesService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/sessionChangesService.service';
+
+let SinglePaneDraftSessionStrategy = class SinglePaneDraftSessionStrategy extends SinglePaneLayoutStrategy {
+    constructor(
+        ctx,
+        _detailPanel,
+        _visibilityStore,
+        _layoutService,
+        _sessionsService,
+        _editorService,
+        _editorGroupsService,
+        _sessionChangesService,
+        _logService
+    ) {
+        super(ctx);
+        this._detailPanel = _detailPanel;
+        this._visibilityStore = _visibilityStore;
+        this._layoutService = _layoutService;
+        this._sessionsService = _sessionsService;
+        this._editorService = _editorService;
+        this._editorGroupsService = _editorGroupsService;
+        this._sessionChangesService = _sessionChangesService;
+        this._logService = _logService;
+        this._detailHiddenTransiently = false;
+        this._detailHiddenByEditor = false;
+        this._changingVisibility = false;
+        this._registerQuickChatVisibility();
+        this._registerEntryEditorHide();
+        this._registerSidePaneOpenEditorHide();
+        this._registerLastEditorClose();
+        this._registerDetailPanel();
+    }
+    _registerEntryEditorHide() {
+        const editorSetChanged = observableSignalFromEvent(this, Event.any(
+            this._editorService.onDidActiveEditorChange,
+            this._editorService.onDidEditorsChange,
+            this._editorService.onDidCloseEditor,
+            this._ctx.onDidEndSessionLayoutRestore
+        ));
+        let activeNewSessionKey;
+        let previousDraftKey;
+        this._register(this._editorService.onWillOpenEditor(event => {
+            if (!this._ctx.isRestoringSessionLayout && !this._layoutService.isEditorPartAutoVisibilitySuppressed()) {
+                this._replacementDraftKey = undefined;
+            }
+            if (!this._getActiveNewSessionKey()) {
+                return;
+            }
+            if (!(event.editor instanceof EmptyFileEditorInput)) {
+                this._pendingEntryHideSessionKey = undefined;
+            }
+        }));
+        const applyPendingEntry = () => {
+            const pendingSessionKey = this._pendingEntryHideSessionKey;
+            if (!pendingSessionKey || this._ctx.isRestoringSessionLayout) {
+                return;
+            }
+            if (this._getActiveNewSessionKey() !== pendingSessionKey) {
+                this._pendingEntryHideSessionKey = undefined;
+                return;
+            }
+            const editors = this._getMainPartEditors();
+            if (editors.length === 0) {
+                return;
+            }
+            if (!editors.every(
+                editor => editor instanceof EmptyFileEditorInput || isChangesEditorInput(editor, this._sessionChangesService)
+            )) {
+                return;
+            }
+            const hasEmptyFiles = ( editors.some(editor => editor instanceof EmptyFileEditorInput));
+            this._pendingEntryHideSessionKey = undefined;
+            if (this._replacementDraftKey === pendingSessionKey) {
+                return;
+            }
+            if (!this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+                return;
+            }
+            const suppression = this._layoutService.suppressEditorPartAutoVisibility();
+            try {
+                if (hasEmptyFiles && !this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
+                    this._layoutService.setPartHidden(false, Parts.AUXILIARYBAR_PART);
+                }
+                this._layoutService.setPartHidden(true, Parts.EDITOR_PART);
+            } finally {
+                suppression.dispose();
+            }
+        };
+        this._register(autorun(reader => {
+            editorSetChanged.read(reader);
+            const session = this._sessionsService.activeSession.read(reader);
+            const draftKey = session && !session.isCreated.read(reader) ? ( session.resource.toString()) : undefined;
+            if (draftKey !== previousDraftKey) {
+                this._replacementDraftKey = previousDraftKey ? draftKey : undefined;
+                previousDraftKey = draftKey;
+                if (this._replacementDraftKey) {
+                    this._logService.trace(
+                        `[SinglePaneLayout] Preserving draft composition: session=${this._replacementDraftKey} editor=${this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)} details=${this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)}`
+                    );
+                }
+            }
+            const sessionKey = this._readActiveNewSessionKey(reader);
+            if (!sessionKey) {
+                activeNewSessionKey = undefined;
+                this._pendingEntryHideSessionKey = undefined;
+                return;
+            }
+            if (activeNewSessionKey !== sessionKey) {
+                activeNewSessionKey = sessionKey;
+                this._pendingSidePaneOpenHideSessionKey = undefined;
+                this._pendingEntryHideSessionKey = sessionKey;
+            }
+            applyPendingEntry();
+        }));
+    }
+    _registerQuickChatVisibility() {
+        this._register(autorun(reader => {
+            const activeSession = this._sessionsService.activeSession.read(reader);
+            if (!activeSession || !(activeSession.isQuickChat?.read(reader) ?? false)) {
+                this._activeQuickChatKey = undefined;
+                this._pendingEditorRestoreKey = undefined;
+                return;
+            }
+            const sessionKey = ( activeSession.resource.toString());
+            const multipleSessionsVisible = this._ctx.multipleSessionsVisibleObs.read(reader);
+            if (this._activeQuickChatKey !== sessionKey) {
+                this._activeQuickChatKey = sessionKey;
+                const hasSavedWorkingSet = this._ctx.hasSavedWorkingSet(activeSession.resource);
+                this._pendingEditorRestoreKey = !multipleSessionsVisible && hasSavedWorkingSet ? sessionKey : undefined;
+                if (!multipleSessionsVisible && hasSavedWorkingSet) {
+                    this._applyQuickChatSharedVisibility();
+                }
+                this._detailPanel.sync(DetailPanelTarget.Files);
+            }
+        }));
+        this._register(this._ctx.onDidEndSessionLayoutRestore(() => {
+            const activeSession = this._sessionsService.activeSession.get();
+            const sessionKey = activeSession?.resource.toString();
+            if (!activeSession || !(activeSession.isQuickChat?.get() ?? false) || this._ctx.multipleSessionsVisibleObs.get()) {
+                return;
+            }
+            this._logService.trace(
+                `[SinglePaneLayout] No workspace layout restore settled: session=${sessionKey} width=${this._layoutService.getSize(Parts.EDITOR_PART).width} editor=${this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)} details=${this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)}`
+            );
+            if (this._pendingEditorRestoreKey !== sessionKey) {
+                return;
+            }
+            this._pendingEditorRestoreKey = undefined;
+            if (isMainPartEmpty(this._editorGroupsService)) {
+                this._hideQuickChatSidePaneTransiently();
+                return;
+            }
+            this._applyQuickChatSharedVisibility();
+        }));
+        this._register(this._layoutService.onDidChangePartVisibility(event => {
+            if (event.partId !== Parts.EDITOR_PART && event.partId !== Parts.AUXILIARYBAR_PART) {
+                return;
+            }
+            this._captureQuickChatSharedVisibility();
+        }));
+        this._register(
+            this._editorService.onDidEditorsChange(() => this._captureQuickChatSharedVisibility())
+        );
+    }
+    _captureQuickChatSharedVisibility() {
+        if (this._changingVisibility || this._ctx.isRestoringSessionLayout || this._ctx.multipleSessionsVisibleObs.get() || this._layoutService.isEditorMaximized() || this._layoutService.isVisible(Parts.CUSTOM_VIEW_GRID_PART) || isMainPartEmpty(this._editorGroupsService)) {
+            return;
+        }
+        const activeSession = this._sessionsService.activeSession.get();
+        if (!activeSession || !(activeSession.isQuickChat?.get() ?? false)) {
+            return;
+        }
+        this._visibilityStore.set(SessionVisibilityProfile.Existing, {
+            editorVisible: this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow),
+            auxiliaryBarVisible: false
+        });
+    }
+    _hideQuickChatSidePaneTransiently() {
+        this._changingVisibility = true;
+        try {
+            this._layoutService.hideSidePane();
+        } finally {
+            this._changingVisibility = false;
+        }
+    }
+    _applyQuickChatSharedVisibility() {
+        const sharedState = this._visibilityStore.get(SessionVisibilityProfile.Existing);
+        const sidePaneVisible = sharedState.editorVisible || sharedState.auxiliaryBarVisible;
+        const suppression = this._layoutService.suppressEditorPartAutoVisibility();
+        this._changingVisibility = true;
+        try {
+            if (this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
+                this._layoutService.setPartHidden(true, Parts.AUXILIARYBAR_PART);
+            }
+            if (sidePaneVisible !== this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+                this._layoutService.setPartHidden(!sidePaneVisible, Parts.EDITOR_PART);
+            }
+        } finally {
+            this._changingVisibility = false;
+            suppression.dispose();
+        }
+    }
+    _registerSidePaneOpenEditorHide() {
+        const applyPendingSidePaneOpen = () => {
+            const pendingSessionKey = this._pendingSidePaneOpenHideSessionKey;
+            if (!pendingSessionKey || this._ctx.isRestoringSessionLayout) {
+                return;
+            }
+            if (this._getActiveNewSessionKey() !== pendingSessionKey) {
+                this._pendingSidePaneOpenHideSessionKey = undefined;
+                return;
+            }
+            const editors = this._getMainPartEditors();
+            if (editors.length === 0) {
+                return;
+            }
+            this._pendingSidePaneOpenHideSessionKey = undefined;
+            if (!editors.every(
+                editor => editor instanceof EmptyFileEditorInput || isChangesEditorInput(editor, this._sessionChangesService)
+            )) {
+                return;
+            }
+            const suppression = this._layoutService.suppressEditorPartAutoVisibility();
+            try {
+                if (!this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
+                    this._layoutService.setPartHidden(false, Parts.AUXILIARYBAR_PART);
+                }
+                if (this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+                    this._layoutService.setPartHidden(true, Parts.EDITOR_PART);
+                }
+            } finally {
+                suppression.dispose();
+            }
+        };
+        this._register(this._editorService.onWillOpenEditor(event => {
+            if (!this._getActiveNewSessionKey()) {
+                return;
+            }
+            if (!(event.editor instanceof EmptyFileEditorInput)) {
+                this._pendingSidePaneOpenHideSessionKey = undefined;
+            }
+        }));
+        this._register(Event.any(
+            this._editorService.onDidActiveEditorChange,
+            this._editorService.onDidEditorsChange,
+            this._editorService.onDidCloseEditor,
+            this._ctx.onDidEndSessionLayoutRestore
+        )(applyPendingSidePaneOpen));
+        this._register(this._layoutService.onDidToggleSidePane((
+            {
+                before,
+                after
+            }
+        ) => {
+            const sessionKey = this._getActiveNewSessionKey();
+            if (!sessionKey) {
+                return;
+            }
+            const opened = !before.editor && !before.auxiliaryBar && (after.editor || after.auxiliaryBar);
+            if (!opened) {
+                this._pendingSidePaneOpenHideSessionKey = undefined;
+                return;
+            }
+            this._pendingEntryHideSessionKey = undefined;
+            this._pendingSidePaneOpenHideSessionKey = sessionKey;
+            applyPendingSidePaneOpen();
+        }));
+        this._register(autorun(reader => {
+            const activeSessionKey = this._readActiveNewSessionKey(reader);
+            if (this._pendingSidePaneOpenHideSessionKey && this._pendingSidePaneOpenHideSessionKey !== activeSessionKey) {
+                this._pendingSidePaneOpenHideSessionKey = undefined;
+            }
+        }));
+    }
+    _registerLastEditorClose() {
+        this._register(this._editorService.onDidCloseEditor(() => {
+            if (!this._getActiveNewSessionKey() || this._ctx.multipleSessionsVisibleObs.get() || this._ctx.isRestoringSessionLayout || this._layoutService.isEditorPartAutoVisibilitySuppressed() || !isMainPartEmpty(this._editorGroupsService)) {
+                return;
+            }
+            this._pendingEntryHideSessionKey = undefined;
+            this._pendingSidePaneOpenHideSessionKey = undefined;
+            this._layoutService.hideSidePane();
+        }));
+    }
+    _getMainPartEditors() {
+        return this._editorGroupsService.mainPart.groups.flatMap(group => [...group.editors]);
+    }
+    _getActiveNewSessionKey() {
+        const session = this._sessionsService.activeSession.get();
+        if (!session || session.isCreated.get() || session.isQuickChat?.get() || !session.workspace.get() || this._ctx.multipleSessionsVisibleObs.get()) {
+            return undefined;
+        }
+        return ( session.resource.toString());
+    }
+    _readActiveNewSessionKey(reader) {
+        const session = this._sessionsService.activeSession.read(reader);
+        if (!session || session.isCreated.read(reader) || (session.isQuickChat?.read(reader) ?? false) || !session.workspace.read(reader) || this._ctx.multipleSessionsVisibleObs.read(reader)) {
+            return undefined;
+        }
+        return ( session.resource.toString());
+    }
+    _registerDetailPanel() {
+        const activeEditorObs = observableFromEvent(
+            this,
+            this._editorService.onDidActiveEditorChange,
+            () => this._editorService.activeEditor
+        );
+        const editorPartVisibleObs = observableFromEvent(
+            this,
+            this._layoutService.onDidChangePartVisibility,
+            () => this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)
+        );
+        const editorMaximizedObs = observableFromEvent(
+            this,
+            this._layoutService.onDidChangeEditorMaximized,
+            () => this._layoutService.isEditorMaximized()
+        );
+        let previousActiveEditor;
+        let previousEditorPartVisible = false;
+        let previousEditorSessionKey;
+        this._register(autorun(reader => {
+            const activeSession = this._sessionsService.activeSession.read(reader);
+            if (!activeSession) {
+                previousActiveEditor = undefined;
+                previousEditorPartVisible = false;
+                previousEditorSessionKey = undefined;
+                return;
+            }
+            const isQuickChat = activeSession.isQuickChat?.read(reader) ?? false;
+            const workspace = activeSession.workspace.read(reader);
+            if (isQuickChat || !workspace || activeSession.isCreated.read(reader)) {
+                previousActiveEditor = undefined;
+                previousEditorPartVisible = false;
+                previousEditorSessionKey = undefined;
+                return;
+            }
+            const activeEditor = activeEditorObs.read(reader);
+            const editorPartVisible = editorPartVisibleObs.read(reader);
+            const sessionKey = ( activeSession.resource.toString());
+            const emptyFilesShown = activeEditor instanceof EmptyFileEditorInput && editorPartVisible && this._replacementDraftKey !== sessionKey && !this._ctx.isRestoringSessionLayout && (activeEditor !== previousActiveEditor || !previousEditorPartVisible || sessionKey !== previousEditorSessionKey);
+            previousActiveEditor = activeEditor;
+            previousEditorPartVisible = editorPartVisible;
+            previousEditorSessionKey = sessionKey;
+            const target = this._computeTarget(reader, activeEditor, editorMaximizedObs, editorPartVisible);
+            const revealOnly = this._ctx.multipleSessionsVisibleObs.read(reader);
+            this._syncDetailVisibility(target, revealOnly, emptyFilesShown);
+            this._detailPanel.sync(target);
+        }));
+        this._register(this._layoutService.onDidChangePartVisibility(event => {
+            if (event.partId === Parts.AUXILIARYBAR_PART && event.source !== "resize") {
+                this._detailHiddenTransiently = false;
+                this._detailHiddenByEditor = false;
+            }
+        }));
+    }
+    _syncDetailVisibility(target, revealOnly, emptyFilesShown) {
+        const detailVisible = this._layoutService.isVisible(Parts.AUXILIARYBAR_PART);
+        if (emptyFilesShown && !detailVisible) {
+            this._detailHiddenTransiently = false;
+            this._detailHiddenByEditor = false;
+            this._layoutService.setAuxiliaryBarHiddenForResize(false);
+            return;
+        }
+        if (this._ctx.isRestoringSessionLayout || target === DetailPanelTarget.Preserve) {
+            return;
+        }
+        if (target === DetailPanelTarget.Hidden || target === DetailPanelTarget.EditorHidden) {
+            if ((target === DetailPanelTarget.EditorHidden || !revealOnly) && detailVisible) {
+                this._detailHiddenTransiently = true;
+                this._detailHiddenByEditor = target === DetailPanelTarget.EditorHidden;
+                this._layoutService.setAuxiliaryBarHiddenForResize(true);
+            }
+            return;
+        }
+        if (!this._detailHiddenTransiently || (revealOnly && !this._detailHiddenByEditor) || !this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+            return;
+        }
+        this._detailHiddenTransiently = false;
+        this._detailHiddenByEditor = false;
+        this._layoutService.setAuxiliaryBarHiddenForResize(false);
+    }
+    _computeTarget(reader, activeEditor, editorMaximizedObs, editorPartVisible) {
+        if (activeEditor && isEditorWithoutDockedDetails(activeEditor)) {
+            return editorPartVisible ? DetailPanelTarget.EditorHidden : DetailPanelTarget.Files;
+        }
+        if (editorMaximizedObs.read(reader)) {
+            return DetailPanelTarget.Changes;
+        }
+        if (!activeEditor) {
+            return DetailPanelTarget.Files;
+        }
+        if (isChangesEditorInput(activeEditor, this._sessionChangesService)) {
+            return DetailPanelTarget.ChangesForced;
+        }
+        if (isFileEditorInput(activeEditor)) {
+            return DetailPanelTarget.FilesForced;
+        }
+        return DetailPanelTarget.Preserve;
+    }
+};
+SinglePaneDraftSessionStrategy = ( __decorate([( __param(3, IAgentWorkbenchLayoutService)), ( __param(4, ISessionsService)), ( __param(5, IEditorService)), ( __param(6, IEditorGroupsService)), ( __param(7, ISessionChangesService)), ( __param(8, ILogService))], SinglePaneDraftSessionStrategy));
+
+export { SinglePaneDraftSessionStrategy };

package/vscode/src/vs/sessions/contrib/layout/browser/singlePane/singlePaneExistingSessionStrategy.d.ts

@@ -0,0 +1,62 @@
+import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IAgentWorkbenchLayoutService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service";
+import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
+import { ISessionChangesService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesService";
+import { SinglePaneDetailPanelCoordinator } from "./singlePaneDetailPanelCoordinator.js";
+import { SinglePaneDockedTabsCoordinator } from "./singlePaneDockedTabsCoordinator.js";
+import { ISinglePaneLayoutContext, SinglePaneLayoutStrategy } from "./singlePaneLayoutStrategy.js";
+import { SinglePaneVisibilityProfileStore } from "./singlePaneVisibilityProfileStore.js";
+/** Command that toggles the single-pane detail panel (auxiliary bar) from the editor header. */
+export declare const TOGGLE_DETAILS_COMMAND_ID = "workbench.action.agentSessions.toggleDetails";
+/**
+ * Behaviour for the **Existing Session** lifecycle stage — a created, workspace-backed
+ * session:
+ *  - the shared Existing Session Editor visibility profile, applied on entry and captured
+ *    while the user adjusts it;
+ *  - detecting a New→Existing submit and, at that moment, capturing the *current* on-screen
+ *    composition into **both** the New and Existing profiles so the view never jumps;
+ *  - the detail-panel mapping while an Existing Session is active;
+ *  - the Toggle Details command (kind-agnostic — it also applies while a New Session's docked
+ *    tabs are visible — hosted here since Existing is the steady-state default);
+ *  - owning (constructing/disposing) the shared {@link SinglePaneDockedTabsCoordinator}, whose
+ *    managed-tabs reconcile pipeline and detail-only editor-area collapse must stay
+ *    single-instance across the New→Existing submit transition — see its doc comment.
+ */
+export declare class SinglePaneExistingSessionStrategy extends SinglePaneLayoutStrategy {
+    private readonly _visibilityStore;
+    private readonly _detailPanel;
+    private readonly _layoutService;
+    private readonly _sessionsService;
+    private readonly _editorService;
+    private readonly _editorGroupsService;
+    private readonly _sessionChangesService;
+    private _managedTabs;
+    private _detailHiddenTransiently;
+    private _detailHiddenByEditor;
+    private _changingDetailTransiently;
+    constructor(ctx: ISinglePaneLayoutContext, _visibilityStore: SinglePaneVisibilityProfileStore, _detailPanel: SinglePaneDetailPanelCoordinator, _layoutService: IAgentWorkbenchLayoutService, _sessionsService: ISessionsService, _editorService: IEditorService, _editorGroupsService: IEditorGroupsService, _sessionChangesService: ISessionChangesService);
+    /** Toggle the detail panel and return whether it is now visible. */
+    toggleDetails(): boolean;
+    private _registerEmptyGroupClose;
+    /**
+     * Constructs and owns the shared managed-tabs coordinator, and registers this strategy's
+     * "activate Changes on submit" supplement to it. Deferred to `LifecyclePhase.Restored` by
+     * the controller (mirrors the original managed-tabs/editor-collapse strategies' timing) so
+     * the reconcile pipeline only starts once the workbench's restored editor group exists.
+     */
+    registerManagedTabs(managedTabs: SinglePaneDockedTabsCoordinator): void;
+    private get managedTabs();
+    private _registerVisibility;
+    private _captureExistingProfileIfApplicable;
+    /** Seeds the Existing profile from the on-screen composition for an in-place lifecycle transition. */
+    private _captureExistingProfile;
+    private _apply;
+    private _reveal;
+    private _registerDetailPanel;
+    private _syncDetailVisibility;
+    private _setDetailHiddenTransiently;
+    private _computeTarget;
+    private _registerManagedTabsSupplement;
+    private _registerToggleDetailsAction;
+}