@codingame/monaco-vscode-workbench-service-override 37.2.0 → 37.3.1

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

@@ -0,0 +1,435 @@
+
+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 { KeyMod, KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerAction2, Action2, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { IsSessionsWindowContext, IsAuxiliaryWindowContext, IsTopRightEditorGroupContext, MainEditorAreaVisibleContext, AuxiliaryBarVisibleContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { GroupModelChangeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+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 { SinglePaneLayoutEnabledContext, HasDockedDetailsContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+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 { isMainPartEmpty, isEditorWithoutDockedDetails, isChangesEditorInput, isFileEditorInput } from './singlePaneSharedHelpers.js';
+import { SinglePaneLayoutStrategy } from './singlePaneLayoutStrategy.js';
+import { SessionVisibilityProfile } from './singlePaneVisibilityProfileStore.js';
+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';
+
+const TOGGLE_DETAILS_COMMAND_ID = "workbench.action.agentSessions.toggleDetails";
+const singlePaneHeaderToggleDetailsOrder = 10;
+let SinglePaneExistingSessionStrategy = class SinglePaneExistingSessionStrategy extends SinglePaneLayoutStrategy {
+    constructor(
+        ctx,
+        _visibilityStore,
+        _detailPanel,
+        _layoutService,
+        _sessionsService,
+        _editorService,
+        _editorGroupsService,
+        _sessionChangesService
+    ) {
+        super(ctx);
+        this._visibilityStore = _visibilityStore;
+        this._detailPanel = _detailPanel;
+        this._layoutService = _layoutService;
+        this._sessionsService = _sessionsService;
+        this._editorService = _editorService;
+        this._editorGroupsService = _editorGroupsService;
+        this._sessionChangesService = _sessionChangesService;
+        this._detailHiddenTransiently = false;
+        this._detailHiddenByEditor = false;
+        this._changingDetailTransiently = false;
+        this._registerVisibility();
+        this._registerEmptyGroupClose();
+        this._registerDetailPanel();
+        this._register(this._registerToggleDetailsAction());
+    }
+    toggleDetails() {
+        const nowVisible = !this._layoutService.isVisible(Parts.AUXILIARYBAR_PART);
+        this._layoutService.setPartHidden(!nowVisible, Parts.AUXILIARYBAR_PART);
+        return nowVisible;
+    }
+    _registerEmptyGroupClose() {
+        this._register(this._editorService.onDidEditorsChange(event => {
+            if (!event || event.event.kind !== GroupModelChangeKind.EDITOR_CLOSE) {
+                return;
+            }
+            const session = this._sessionsService.activeSession.get();
+            if (this._ctx.isRestoringSessionLayout || this._ctx.multipleSessionsVisibleObs.get() || this._layoutService.isEditorPartAutoVisibilitySuppressed() || !session || session.isQuickChat?.get() || !session.isCreated.get() || !session.workspace.get() || !isMainPartEmpty(this._editorGroupsService)) {
+                return;
+            }
+            this._layoutService.hideSidePane();
+        }));
+    }
+    registerManagedTabs(managedTabs) {
+        this._managedTabs = managedTabs;
+        this._registerManagedTabsSupplement();
+    }
+    get managedTabs() {
+        if (!this._managedTabs) {
+            throw ( new Error(
+                "SinglePaneExistingSessionStrategy: managed tabs accessed before registerManagedTabs()"
+            ));
+        }
+        return this._managedTabs;
+    }
+    _registerVisibility() {
+        let initialized = false;
+        let wasExistingActive = false;
+        let previousQuickChatResource;
+        let previousIsCreated;
+        let previousSession;
+        let togglingSidePane = false;
+        this._register(autorun(reader => {
+            const multipleSessionsVisible = this._ctx.multipleSessionsVisibleObs.read(reader);
+            const activeSession = this._sessionsService.activeSession.read(reader);
+            const isQuickChat = activeSession?.isQuickChat?.read(reader) ?? false;
+            const wasQuickChatActive = previousQuickChatResource !== undefined;
+            const isWorkspaceConversion = !isQuickChat && !!activeSession && isEqual(previousQuickChatResource, activeSession.resource);
+            previousQuickChatResource = isQuickChat ? activeSession?.resource : undefined;
+            if (isWorkspaceConversion) {
+                this._captureExistingProfile();
+            }
+            if (multipleSessionsVisible) {
+                const workspace = activeSession?.workspace.read(reader);
+                const isCreated = activeSession?.isCreated.read(reader);
+                if (!isWorkspaceConversion && activeSession && !isQuickChat && workspace && isCreated === true) {
+                    this._ctx.withSessionLayoutRestore(
+                        () => this._reveal(this._visibilityStore.get(SessionVisibilityProfile.Existing))
+                    );
+                }
+                wasExistingActive = false;
+                return;
+            }
+            if (!activeSession) {
+                return;
+            }
+            if (isQuickChat) {
+                wasExistingActive = false;
+                return;
+            }
+            const isCreated = activeSession.isCreated.read(reader);
+            const sessionChanged = previousSession !== undefined && !isEqual(previousSession.resource, activeSession.resource);
+            const isSubmit = !wasQuickChatActive && previousIsCreated === false && isCreated && (previousSession === activeSession || previousSession?.isCreated.read(undefined) === true);
+            if (isSubmit) {
+                this._captureExistingProfile();
+            }
+            if (isCreated) {
+                if (!isSubmit && !isWorkspaceConversion && (!initialized || !wasExistingActive || wasQuickChatActive || sessionChanged)) {
+                    this._ctx.withSessionLayoutRestore(
+                        () => this._apply(this._visibilityStore.get(SessionVisibilityProfile.Existing))
+                    );
+                }
+                wasExistingActive = true;
+            } else {
+                wasExistingActive = false;
+            }
+            previousIsCreated = isCreated;
+            previousSession = activeSession;
+            initialized = true;
+        }));
+        this._register(this._layoutService.onDidChangePartVisibility(e => {
+            if (e.partId !== Parts.EDITOR_PART && e.partId !== Parts.AUXILIARYBAR_PART) {
+                return;
+            }
+            if (togglingSidePane || (e.partId === Parts.AUXILIARYBAR_PART && this._changingDetailTransiently)) {
+                return;
+            }
+            this._captureExistingProfileIfApplicable();
+        }));
+        this._register(this._layoutService.onWillToggleSidePane(() => {
+            togglingSidePane = true;
+        }));
+        this._register(this._layoutService.onDidToggleSidePane(() => {
+            try {
+                this._captureExistingProfileIfApplicable();
+            } finally {
+                togglingSidePane = false;
+            }
+        }));
+    }
+    _captureExistingProfileIfApplicable() {
+        if (this._ctx.isRestoringSessionLayout || this._ctx.multipleSessionsVisibleObs.get()) {
+            return;
+        }
+        const activeSession = this._sessionsService.activeSession.get();
+        if (!activeSession || activeSession.isQuickChat?.get() || !activeSession.isCreated.get() || this._layoutService.isEditorMaximized() || this._layoutService.isVisible(Parts.CUSTOM_VIEW_GRID_PART)) {
+            return;
+        }
+        this._captureExistingProfile();
+    }
+    _captureExistingProfile() {
+        const state = {
+            editorVisible: this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow),
+            auxiliaryBarVisible: this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)
+        };
+        this._visibilityStore.set(SessionVisibilityProfile.Existing, state);
+    }
+    _apply(state) {
+        const suppression = this._layoutService.suppressEditorPartAutoVisibility();
+        try {
+            if (!state.editorVisible && this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+                this._layoutService.setPartHidden(true, Parts.EDITOR_PART);
+            }
+            if (!state.auxiliaryBarVisible && this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
+                this._layoutService.setPartHidden(true, Parts.AUXILIARYBAR_PART);
+            }
+            if (state.auxiliaryBarVisible && !this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
+                this._layoutService.setPartHidden(false, Parts.AUXILIARYBAR_PART);
+            }
+            if (state.editorVisible && !this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+                this._layoutService.setPartHidden(false, Parts.EDITOR_PART);
+            }
+        } finally {
+            suppression.dispose();
+        }
+    }
+    _reveal(state) {
+        const suppression = this._layoutService.suppressEditorPartAutoVisibility();
+        try {
+            if (state.auxiliaryBarVisible && !this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
+                this._layoutService.setPartHidden(false, Parts.AUXILIARYBAR_PART);
+            }
+            if (state.editorVisible && !this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+                this._layoutService.setPartHidden(false, Parts.EDITOR_PART);
+            }
+        } finally {
+            suppression.dispose();
+        }
+    }
+    _registerDetailPanel() {
+        const activeEditorObs = observableFromEvent(
+            this,
+            this._editorService.onDidActiveEditorChange,
+            () => this._editorService.activeEditor
+        );
+        const mainPartEmptyObs = observableFromEvent(this, Event.any(
+            this._editorService.onDidActiveEditorChange,
+            this._editorService.onDidEditorsChange,
+            this._editorService.onDidCloseEditor
+        ), () => isMainPartEmpty(this._editorGroupsService));
+        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 initialized = false;
+        let wasExistingActive = false;
+        let activeSessionKey;
+        let pendingSessionKey;
+        let pendingOutgoingEditor;
+        let previousActiveEditor;
+        let previousEditorPartVisible = false;
+        let previousEditorSessionKey;
+        let previousQuickChatResource;
+        const sync = reader => {
+            const activeSession = this._sessionsService.activeSession.read(reader);
+            const isQuickChat = activeSession?.isQuickChat?.read(reader) ?? false;
+            const isWorkspaceConversion = !isQuickChat && !!activeSession && isEqual(previousQuickChatResource, activeSession.resource);
+            if (!isWorkspaceConversion) {
+                previousQuickChatResource = isQuickChat ? activeSession?.resource : undefined;
+            }
+            if (!activeSession || isQuickChat || !activeSession.workspace.read(reader) || !activeSession.isCreated.read(reader)) {
+                wasExistingActive = false;
+                previousActiveEditor = undefined;
+                previousEditorPartVisible = false;
+                previousEditorSessionKey = undefined;
+                return;
+            }
+            previousQuickChatResource = undefined;
+            const sessionKey = ( activeSession.resource.toString());
+            const sessionChanged = activeSessionKey !== undefined && activeSessionKey !== sessionKey;
+            if (!wasExistingActive || sessionChanged) {
+                activeSessionKey = sessionKey;
+                wasExistingActive = true;
+                if (initialized && !isWorkspaceConversion) {
+                    pendingSessionKey = sessionKey;
+                    pendingOutgoingEditor = this._editorService.activeEditor;
+                }
+                initialized = true;
+            }
+            if (isWorkspaceConversion) {
+                pendingSessionKey = undefined;
+                pendingOutgoingEditor = undefined;
+                this._detailHiddenTransiently = false;
+                this._detailHiddenByEditor = false;
+            }
+            const activeEditor = activeEditorObs.read(reader);
+            const mainPartEmpty = mainPartEmptyObs.read(reader);
+            const editorMaximized = editorMaximizedObs.read(reader);
+            const editorPartVisible = editorPartVisibleObs.read(reader);
+            if (pendingSessionKey && activeEditor && activeEditor !== pendingOutgoingEditor) {
+                pendingSessionKey = undefined;
+                pendingOutgoingEditor = undefined;
+            }
+            if (pendingSessionKey) {
+                return;
+            }
+            const emptyFilesShown = activeEditor instanceof EmptyFileEditorInput && editorPartVisible && (activeEditor !== previousActiveEditor || !previousEditorPartVisible || sessionKey !== previousEditorSessionKey);
+            previousActiveEditor = activeEditor;
+            previousEditorPartVisible = editorPartVisible;
+            previousEditorSessionKey = sessionKey;
+            const target = this._computeTarget(activeEditor, mainPartEmpty, editorMaximized, editorPartVisible);
+            const revealOnly = this._ctx.multipleSessionsVisibleObs.read(reader);
+            if (!isWorkspaceConversion) {
+                this._syncDetailVisibility(target, revealOnly, emptyFilesShown);
+            }
+            this._detailPanel.sync(target);
+        };
+        this._register(autorun(sync));
+        this._register(this._ctx.onDidEndSessionLayoutRestore(() => {
+            const activeSession = this._sessionsService.activeSession.get();
+            if (!activeSession || ( activeSession.resource.toString()) !== pendingSessionKey) {
+                return;
+            }
+            pendingSessionKey = undefined;
+            pendingOutgoingEditor = undefined;
+            sync(undefined);
+        }));
+        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._setDetailHiddenTransiently(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._setDetailHiddenTransiently(true);
+            }
+            return;
+        }
+        if (!this._detailHiddenTransiently || (revealOnly && !this._detailHiddenByEditor) || !this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+            return;
+        }
+        this._detailHiddenTransiently = false;
+        this._detailHiddenByEditor = false;
+        this._setDetailHiddenTransiently(false);
+    }
+    _setDetailHiddenTransiently(hidden) {
+        this._changingDetailTransiently = true;
+        try {
+            this._layoutService.setAuxiliaryBarHiddenForResize(hidden);
+        } finally {
+            this._changingDetailTransiently = false;
+        }
+    }
+    _computeTarget(activeEditor, mainPartEmpty, editorMaximized, editorPartVisible) {
+        if (mainPartEmpty) {
+            return this._ctx.isRestoringSessionLayout ? DetailPanelTarget.Preserve : DetailPanelTarget.Hidden;
+        }
+        if (activeEditor && isEditorWithoutDockedDetails(activeEditor)) {
+            return editorPartVisible ? DetailPanelTarget.EditorHidden : DetailPanelTarget.Changes;
+        }
+        if (editorMaximized) {
+            return DetailPanelTarget.Changes;
+        }
+        if (!activeEditor) {
+            return DetailPanelTarget.Changes;
+        }
+        if (isChangesEditorInput(activeEditor, this._sessionChangesService)) {
+            return DetailPanelTarget.ChangesForced;
+        }
+        if (isFileEditorInput(activeEditor)) {
+            return DetailPanelTarget.FilesForced;
+        }
+        return DetailPanelTarget.Preserve;
+    }
+    _registerManagedTabsSupplement() {
+        let previousSessionKey;
+        let previousIsCreated;
+        let previousSession;
+        let changesActivationPendingForSession;
+        this._register(autorun(reader => {
+            const session = this._sessionsService.activeSession.read(reader);
+            const isQuickChat = session?.isQuickChat?.read(reader) ?? false;
+            const isCreated = session && !isQuickChat ? session.isCreated.read(reader) : false;
+            const sessionKey = session?.resource.toString();
+            const isSubmit = !isQuickChat && previousIsCreated === false && isCreated && (previousSession === session || previousSession?.isCreated.read(undefined) === true);
+            if (isSubmit) {
+                changesActivationPendingForSession = sessionKey;
+            } else if (sessionKey !== previousSessionKey) {
+                changesActivationPendingForSession = undefined;
+            }
+            if (session && !isQuickChat && isCreated) {
+                const target = this.managedTabs.readTarget(reader);
+                const hasChanges = (session.changes.read(reader).length ?? 0) > 0;
+                const ensureChangesActive = changesActivationPendingForSession === sessionKey && hasChanges;
+                if (ensureChangesActive) {
+                    changesActivationPendingForSession = undefined;
+                }
+                if (isSubmit || ensureChangesActive) {
+                    this.managedTabs.queueReconcile(target, {
+                        openDefaultsIfEmpty: isSubmit,
+                        ensureChangesActive
+                    });
+                }
+            }
+            previousIsCreated = session && !isQuickChat ? isCreated : undefined;
+            previousSession = session;
+            previousSessionKey = sessionKey;
+        }));
+    }
+    _registerToggleDetailsAction() {
+        const that = this;
+        return registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: TOGGLE_DETAILS_COMMAND_ID,
+                    title: ( localize2(4094, "Toggle Details")),
+                    icon: Codicon.listSelection,
+                    f1: false,
+                    toggled: AuxiliaryBarVisibleContext,
+                    keybinding: {
+                        weight: KeybindingWeight.SessionsContrib,
+                        primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.KeyL,
+                        when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( IsAuxiliaryWindowContext.toNegated()), SinglePaneLayoutEnabledContext))
+                    },
+                    menu: {
+                        id: MenuId.EditorTitleLayout,
+                        group: "navigation",
+                        order: singlePaneHeaderToggleDetailsOrder,
+                        when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( IsAuxiliaryWindowContext.toNegated()), IsTopRightEditorGroupContext, SinglePaneLayoutEnabledContext, MainEditorAreaVisibleContext, HasDockedDetailsContext))
+                    }
+                });
+            }
+            run() {
+                that.toggleDetails();
+            }
+        });
+    }
+};
+SinglePaneExistingSessionStrategy = ( __decorate([( __param(3, IAgentWorkbenchLayoutService)), ( __param(4, ISessionsService)), ( __param(5, IEditorService)), ( __param(6, IEditorGroupsService)), ( __param(7, ISessionChangesService))], SinglePaneExistingSessionStrategy));
+
+export { SinglePaneExistingSessionStrategy, TOGGLE_DETAILS_COMMAND_ID };

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

@@ -0,0 +1,46 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+/**
+ * Shared controller state that single-pane layout strategies read/coordinate
+ * through. Implemented by the single-pane layout controller; the concrete
+ * services each strategy needs are injected into the strategy directly via DI.
+ */
+export interface ISinglePaneLayoutContext {
+    /** `> 0` while a session-switch layout restore is in progress. */
+    readonly isRestoringSessionLayout: boolean;
+    /** Runs `work` while a session-switch layout restore is held. */
+    withSessionLayoutRestore(work: () => void | Promise<unknown>): void;
+    /** Fires when a session-switch layout restore fully settles, so strategies reconcile off the settled state rather than the transient changes during the restore. */
+    readonly onDidEndSessionLayoutRestore: Event<void>;
+    /** `true` while the whole side pane (editor + aux bar) is being toggled together. */
+    readonly togglingSidePane: boolean;
+    readonly multipleSessionsVisibleObs: IObservable<boolean>;
+    readonly activeSessionResourceObs: IObservable<URI | undefined>;
+    hasSavedWorkingSet(sessionResource: URI): boolean;
+}
+/**
+ * Base class for a single-pane layout behaviour, owning its own disposables.
+ *
+ * Exactly two concrete strategies extend this — one per session lifecycle stage:
+ * {@link import('./singlePaneDraftSessionStrategy.js').SinglePaneDraftSessionStrategy} (workspace-backed
+ * and workspace-less drafts) and {@link import('./singlePaneExistingSessionStrategy.js').SinglePaneExistingSessionStrategy}
+ * (a created, workspace-backed session). Each owns the full vertical slice of behaviour for its stage:
+ * side-pane visibility, the detail-panel (Changes/Files) mapping, and — for the two workspace
+ * stages — the managed docked tabs and detail-only editor-area collapse.
+ *
+ * Shared mechanics (the managed-tabs reconcile pipeline + editor-area collapse and the Existing
+ * Editor-visibility-profile storage) live in non-strategy coordinator classes in this
+ * folder — see `singlePaneDockedTabsCoordinator.ts`, `singlePaneDetailPanelCoordinator.ts`, and
+ * `singlePaneVisibilityProfileStore.ts`. The shared detail coordinator owns only content selection
+ * and context publication; each lifecycle strategy owns Auxiliary Bar visibility. The shared mechanics are owned by
+ * {@link import('./singlePaneExistingSessionStrategy.js').SinglePaneExistingSessionStrategy}
+ * (the docked-tabs coordinator, since its reconcile pipeline is shared across the New→Existing
+ * submit transition) or by the controller (the visibility-profile store, since it backs one
+ * combined storage blob for both workspace stages).
+ */
+export declare abstract class SinglePaneLayoutStrategy extends Disposable {
+    protected readonly _ctx: ISinglePaneLayoutContext;
+    constructor(_ctx: ISinglePaneLayoutContext);
+}

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

@@ -0,0 +1,11 @@
+
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+
+class SinglePaneLayoutStrategy extends Disposable {
+    constructor(_ctx) {
+        super();
+        this._ctx = _ctx;
+    }
+}
+
+export { SinglePaneLayoutStrategy };

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

@@ -0,0 +1,11 @@
+import { EditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput";
+import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { ISessionChangesService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesService";
+/** Whether every group in the main editor part is empty (used by both the detail-panel and side-pane-visibility logic to detect an empty side pane). */
+export declare function isMainPartEmpty(editorGroupsService: IEditorGroupsService): boolean;
+/** Whether `editor` is (or shows) a managed Changes multi-diff for some session. Shared by the New/Existing detail-panel mapping. */
+export declare function isChangesEditorInput(editor: EditorInput, sessionChangesService: ISessionChangesService): boolean;
+/** Whether `editor` is a file-like editor (the empty Files placeholder, a real file, or a markdown preview). Shared by the New/Existing detail-panel mapping. */
+export declare function isFileEditorInput(editor: EditorInput): boolean;
+/** Whether `editor` owns its full presentation and must hide the docked Details panel. */
+export declare function isEditorWithoutDockedDetails(editor: EditorInput): boolean;

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

@@ -0,0 +1,43 @@
+
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { DiffEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/diffEditorInput';
+import { BrowserEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/browserView/common/browserEditorInput';
+import { CustomEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/customEditor/browser/customEditorInput';
+import { FileEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/files/browser/editors/fileEditorInput';
+import { MultiDiffEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput';
+import { WebviewInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/webviewPanel/browser/webviewEditorInput';
+import { EmptyFileEditorInput } from '../../../editor/browser/emptyFileEditorInput.js';
+
+const MARKDOWN_EDITOR_VIEW_TYPES = ( new Set([
+    "markdown.preview",
+    "vscode.markdown.editor",
+    "vscode.markdown.preview.editor"
+]));
+const PULL_REQUEST_OVERVIEW_VIEW_TYPE = "PullRequestOverview";
+const ISSUE_OVERVIEW_VIEW_TYPE = "IssueOverview";
+function isMainPartEmpty(editorGroupsService) {
+    for (const group of editorGroupsService.mainPart.groups) {
+        if (!group.isEmpty) {
+            return false;
+        }
+    }
+    return true;
+}
+function isChangesEditorInput(editor, sessionChangesService) {
+    if (editor instanceof DiffEditorInput || editor instanceof MultiDiffEditorInput) {
+        return true;
+    }
+    const resource = editor.resource;
+    return !!resource && sessionChangesService.getSessionResource(resource) !== undefined;
+}
+function isFileEditorInput(editor) {
+    if (editor instanceof WebviewInput) {
+        return ( MARKDOWN_EDITOR_VIEW_TYPES.has(editor.viewType)) || ( MARKDOWN_EDITOR_VIEW_TYPES.has(editor.providerId ?? "")) || (editor instanceof CustomEditorInput && editor.resource?.scheme === Schemas.untitled);
+    }
+    return editor instanceof EmptyFileEditorInput || editor instanceof FileEditorInput || editor.resource?.scheme === Schemas.untitled;
+}
+function isEditorWithoutDockedDetails(editor) {
+    return editor instanceof BrowserEditorInput || (editor instanceof CustomEditorInput && editor.resource?.scheme !== Schemas.untitled) || (editor instanceof WebviewInput && (editor.viewType === PULL_REQUEST_OVERVIEW_VIEW_TYPE || editor.providerId === PULL_REQUEST_OVERVIEW_VIEW_TYPE || editor.viewType === ISSUE_OVERVIEW_VIEW_TYPE || editor.providerId === ISSUE_OVERVIEW_VIEW_TYPE));
+}
+
+export { isChangesEditorInput, isEditorWithoutDockedDetails, isFileEditorInput, isMainPartEmpty };

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

@@ -0,0 +1,21 @@
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+export interface ISidePaneVisibilityState {
+    readonly editorVisible: boolean;
+    readonly auxiliaryBarVisible: boolean;
+}
+export declare enum SessionVisibilityProfile {
+    New = 0,
+    Existing = 1
+}
+/**
+ * Persists the Existing Session Editor/Details visibility profile.
+ */
+export declare class SinglePaneVisibilityProfileStore {
+    private readonly _storageService;
+    private _profiles;
+    constructor(_storageService: IStorageService);
+    get(profile: SessionVisibilityProfile): ISidePaneVisibilityState;
+    set(profile: SessionVisibilityProfile, state: ISidePaneVisibilityState): void;
+    private _load;
+    private _isVisibilityState;
+}

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

@@ -0,0 +1,77 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+
+var SessionVisibilityProfile;
+(function(SessionVisibilityProfile) {
+    SessionVisibilityProfile[SessionVisibilityProfile["New"] = 0] = "New";
+    SessionVisibilityProfile[SessionVisibilityProfile["Existing"] = 1] = "Existing";
+})(SessionVisibilityProfile || (SessionVisibilityProfile = {}));
+const SINGLE_PANE_VISIBILITY_STATE_KEY = "sessions.singlePane.sidePaneVisibility";
+const DEFAULT_NEW_SESSION_VISIBILITY_STATE = {
+    editorVisible: false,
+    auxiliaryBarVisible: true
+};
+const DEFAULT_EXISTING_SESSION_VISIBILITY_STATE = {
+    editorVisible: true,
+    auxiliaryBarVisible: false
+};
+let SinglePaneVisibilityProfileStore = class SinglePaneVisibilityProfileStore {
+    constructor(_storageService) {
+        this._storageService = _storageService;
+        this._profiles = {
+            newSession: DEFAULT_NEW_SESSION_VISIBILITY_STATE,
+            existingSession: DEFAULT_EXISTING_SESSION_VISIBILITY_STATE
+        };
+        this._load();
+    }
+    get(profile) {
+        return profile === SessionVisibilityProfile.New ? this._profiles.newSession : this._profiles.existingSession;
+    }
+    set(profile, state) {
+        this._profiles = profile === SessionVisibilityProfile.New ? {
+            ...this._profiles,
+            newSession: state
+        } : {
+            ...this._profiles,
+            existingSession: state
+        };
+        this._storageService.store(
+            SINGLE_PANE_VISIBILITY_STATE_KEY,
+            JSON.stringify(this._profiles),
+            StorageScope.WORKSPACE,
+            StorageTarget.MACHINE
+        );
+    }
+    _load() {
+        const raw = this._storageService.get(SINGLE_PANE_VISIBILITY_STATE_KEY, StorageScope.WORKSPACE);
+        if (!raw) {
+            return;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (this._isVisibilityState(parsed?.newSession) && this._isVisibilityState(parsed?.existingSession)) {
+                this._profiles = {
+                    newSession: parsed.newSession,
+                    existingSession: parsed.existingSession
+                };
+            } else if (this._isVisibilityState(parsed)) {
+                this._profiles = {
+                    ...this._profiles,
+                    existingSession: parsed
+                };
+            } else {
+                this._storageService.remove(SINGLE_PANE_VISIBILITY_STATE_KEY, StorageScope.WORKSPACE);
+            }
+        } catch {
+            this._storageService.remove(SINGLE_PANE_VISIBILITY_STATE_KEY, StorageScope.WORKSPACE);
+        }
+    }
+    _isVisibilityState(value) {
+        return typeof value?.editorVisible === "boolean" && typeof value.auxiliaryBarVisible === "boolean";
+    }
+};
+SinglePaneVisibilityProfileStore = ( __decorate([( __param(0, IStorageService))], SinglePaneVisibilityProfileStore));
+
+export { SessionVisibilityProfile, SinglePaneVisibilityProfileStore };