@codingame/monaco-vscode-workbench-service-override 37.6.0 → 38.0.0

package/vscode/src/vs/sessions/contrib/layout/browser/baseSessionLayoutController.js

@@ -8,8 +8,8 @@ import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/even
 import { KeyMod, KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
-import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap, ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { Categories } from '@codingame/monaco-vscode-api/vscode/vs/platform/action/common/actionCommonCategories';
@@ -20,6 +20,7 @@ import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platf
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
 import { KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
 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';
@@ -37,49 +38,59 @@ import { IPaneCompositePartService } from '@codingame/monaco-vscode-api/vscode/v
 import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
 import { IAgentWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service';
 import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
-import { SessionsWelcomeVisibleContext, IsQuickChatSessionContext, SinglePaneLayoutEnabledContext, CustomViewVisibleContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { SessionsWelcomeVisibleContext, IsQuickChatSessionContext, DesktopLayoutContext, CustomViewVisibleContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
 import { logSidePanelToggle } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionsTelemetry';
+import { ChatLayoutContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/chatLayout';
 import '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesService';
 import { IChangesViewService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/changesViewService.service';
 import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
 import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
 import { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
-import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
-import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import { ChatLayoutOwnerKeyRegistry } from './chatLayoutOwnerKeys.js';
+import { ISessionEditorWorkingSetService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/layout/common/sessionEditorWorkingSet.service';
+import { runOnChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/runOnChange';
 import { derivedOpts, derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 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 { derivedObservableWithCache } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/utils';
-import { runOnChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/runOnChange';
 import { ISessionChangesService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/sessionChangesService.service';
 
+var BaseLayoutController_1;
 const secondarySidebarToggleClosedIcon = registerIcon(
     "agent-secondary-sidebar-toggle-closed",
     Codicon.layoutSidebarRightOff,
-    ( localize(4113, "Icon for the sessions secondary sidebar when closed."))
+    ( localize(4748, "Icon for the sessions secondary sidebar when closed."))
 );
 const secondarySidebarToggleOpenIcon = registerIcon(
     "agent-secondary-sidebar-toggle-open",
     Codicon.layoutSidebarRight,
-    ( localize(4114, "Icon for the sessions secondary sidebar when open."))
+    ( localize(4749, "Icon for the sessions secondary sidebar when open."))
 );
+const SESSION_LAYOUT_STATE_SCHEMA_VERSION = 1;
+function isValidEditorWorkingSet(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const workingSet = value;
+    return typeof workingSet.id === "string" && typeof workingSet.name === "string";
+}
+function isValidSessionViewState(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const viewState = value;
+    return typeof viewState.auxiliaryBarVisible === "boolean" && (viewState.auxiliaryBarActiveViewContainerId === undefined || typeof viewState.auxiliaryBarActiveViewContainerId === "string") && (viewState.auxiliaryBarHiddenByCollapse === undefined || typeof viewState.auxiliaryBarHiddenByCollapse === "boolean");
+}
+function isValidSessionLayoutEntry(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const entry = value;
+    return typeof entry.sessionResource === "string" && ( URI.parse(entry.sessionResource)).scheme.length > 0 && (entry.editorWorkingSet === undefined || isValidEditorWorkingSet(entry.editorWorkingSet)) && (entry.viewState === undefined || isValidSessionViewState(entry.viewState)) && (entry.editorPartHidden === undefined || typeof entry.editorPartHidden === "boolean") && (entry.panelViewContainerId === undefined || typeof entry.panelViewContainerId === "string") && (entry.panelVisible === undefined || typeof entry.panelVisible === "boolean");
+}
 const SESSION_LAYOUT_STATE_KEY = "sessions.layoutState";
 const WORKING_SETS_STORAGE_KEY = "sessions.workingSets";
-const EMPTY_WORKING_SET_SETTING = "sessions.layout.useEmptyWorkingSetForNewSession";
-( Registry.as(Extensions.Configuration)).registerConfiguration({
-    id: "sessions",
-    properties: {
-        [EMPTY_WORKING_SET_SETTING]: {
-            type: "boolean",
-            default: true,
-            description: ( localize(
-                4115,
-                "Use en empty working set for new session. If false, keep the current working set."
-            ))
-        }
-    }
-});
-let BaseLayoutController = class BaseLayoutController extends Disposable {
+let BaseLayoutController = BaseLayoutController_1 = class BaseLayoutController extends Disposable {
     get _isRestoringSessionLayout() {
         return this._restoringSessionLayoutDepth > 0;
     }
@@ -89,6 +100,9 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
     get _legacyWorkingSetsStorageKey() {
         return WORKING_SETS_STORAGE_KEY;
     }
+    get _legacyLayoutStateStorageKey() {
+        return undefined;
+    }
     get _isEditorPartVisibilityPerSession() {
         return true;
     }
@@ -98,6 +112,33 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
     get _isPanelVisibilityPerSession() {
         return true;
     }
+    get _isPanelViewPerSession() {
+        return !this._isPanelVisibilityPerSession;
+    }
+    get _isPanelVisibilityPersisted() {
+        return false;
+    }
+    get _isLayoutStateVersioned() {
+        return false;
+    }
+    get _chatLayoutEnabled() {
+        return this._layoutService.chatLayoutPresentation.enabled;
+    }
+    _chatLayoutActive(reader) {
+        if (!this._chatLayoutContext) {
+            return false;
+        }
+        return (reader ? this._chatLayoutContext.state.read(reader) : this._chatLayoutContext.state.get()).presentation.active;
+    }
+    _chatLayoutSuspended(reader) {
+        return this._chatLayoutEnabled && !this._chatLayoutActive(reader);
+    }
+    _panelVisibilityKeyFor(session, reader) {
+        return this._ownerKeyFor(session, reader);
+    }
+    _defaultPanelVisibility(_key) {
+        return false;
+    }
     constructor(
         _layoutService,
         _sessionManagementService,
@@ -114,7 +155,9 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
         _viewDescriptorService,
         _contextKeyService,
         _instantiationService,
-        _lifecycleService
+        _lifecycleService,
+        _logService,
+        _editorWorkingSetService
     ) {
         super();
         this._layoutService = _layoutService;
@@ -133,18 +176,43 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
         this._contextKeyService = _contextKeyService;
         this._instantiationService = _instantiationService;
         this._lifecycleService = _lifecycleService;
+        this._logService = _logService;
+        this._editorWorkingSetService = _editorWorkingSetService;
         this._panelVisibilityBySession = ( new ResourceMap());
         this._panelViewBySession = ( new ResourceMap());
         this._viewStateBySession = ( new ResourceMap());
         this._workingSets = ( new ResourceMap());
+        this._legacyReferencedWorkingSetIds = ( new Set());
         this._editorPartHiddenBySession = ( new ResourceMap());
         this._workingSetSequencer = ( new Sequencer());
+        this._chatLayoutOwnerKeys = ( new ChatLayoutOwnerKeyRegistry());
+        this._replacedSessionResources = ( new ResourceSet());
         this._restoringSessionLayoutDepth = 0;
         this._onDidEndSessionLayoutRestore = this._register(( new Emitter()));
         this.onDidEndSessionLayoutRestore = this._onDidEndSessionLayoutRestore.event;
         this._togglingSidePane = false;
+        this._chatLayoutContext = this._chatLayoutEnabled ? this._register(( new ChatLayoutContext(
+            this._layoutService.chatLayoutPresentation,
+            this._sessionsService.activeSession
+        ))) : undefined;
         this._loadState();
         this._register(this._storageService.onWillSaveState(() => this._saveState()));
+        if (this._chatLayoutContext) {
+            this._register(runOnChange(this._chatLayoutContext.state, (current, previous) => {
+                const session = this._sessionsService.activeSession.get();
+                if (previous.presentation.active && current.presentation.active && previous.owner && current.owner && session && isEqual(previous.owner.sessionResource, current.owner.sessionResource) && !isEqual(previous.owner.chatResource, current.owner.chatResource) && session.status.read(undefined) !== SessionStatus.Untitled && !this._isRestoringSessionLayout) {
+                    this._onActiveSessionSwitched(session, session);
+                    const key = this._ownerKeyForChat(
+                        previous.owner.sessionResource,
+                        previous.owner.chatResource,
+                        session.mainChat.get().resource
+                    );
+                    if (key) {
+                        this._saveWorkingSet(key);
+                    }
+                }
+            }));
+        }
         this.activeSessionResourceObs = derivedOpts({
             equalsFn: isEqual
         }, reader => {
@@ -156,18 +224,22 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
         });
         this._register(autorun(reader => {
             const visibleSessions = this._sessionsService.visibleSessions.read(reader);
-            if (visibleSessions.length <= 1) {
+            if (visibleSessions.length <= 1 || this._chatLayoutActive(reader)) {
                 return;
             }
             for (const session of visibleSessions) {
                 if (!session) {
                     continue;
                 }
+                const ownerKey = this._ownerKeyFor(session);
+                if (!ownerKey) {
+                    continue;
+                }
                 if (this._isViewStatePerSession) {
-                    this._viewStateBySession.delete(session.resource);
+                    this._viewStateBySession.delete(ownerKey);
                 }
                 if (this._isPanelVisibilityPerSession) {
-                    this._panelVisibilityBySession.delete(session.resource);
+                    this._panelVisibilityBySession.delete(ownerKey);
                 }
             }
         }));
@@ -175,54 +247,76 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
             if (!this._isPanelVisibilityPerSession) {
                 return;
             }
-            const activeSessionResource = this.activeSessionResourceObs.read(reader);
-            if (this.multipleSessionsVisibleObs.read(reader)) {
+            const activeSession = this._sessionsService.activeSession.read(reader);
+            if (this._chatLayoutEnabled) {
+                activeSession?.activeChat.read(reader);
+            }
+            const chatLayoutActive = this._chatLayoutActive(reader);
+            if (this.multipleSessionsVisibleObs.read(reader) && !chatLayoutActive) {
                 return;
             }
-            this._syncPanelVisibility(activeSessionResource);
+            if (activeSession && this._chatLayoutSuspended(reader)) {
+                return;
+            }
+            this._syncPanelVisibility(
+                activeSession ? this._panelVisibilityKeyFor(activeSession, reader) : undefined
+            );
         }));
         this._register(this._layoutService.onDidChangePartVisibility(e => {
             if (!this._isPanelVisibilityPerSession || e.partId !== Parts.PANEL_PART) {
                 return;
             }
-            if (this.multipleSessionsVisibleObs.get() || this._isCustomViewVisible()) {
+            if ((this.multipleSessionsVisibleObs.get() && !this._chatLayoutActive()) || this._isCustomViewVisible()) {
                 return;
             }
             const activeSession = this._sessionsService.activeSession.get();
-            if (activeSession) {
-                this._panelVisibilityBySession.set(activeSession.resource, e.visible);
+            const ownerKey = activeSession && this._panelVisibilityKeyFor(activeSession);
+            if (ownerKey) {
+                this._panelVisibilityBySession.set(ownerKey, e.visible);
             }
         }));
         this._register(this._paneCompositePartService.onDidPaneCompositeOpen(e => {
-            if (this._isPanelVisibilityPerSession || e.viewContainerLocation !== ViewContainerLocation.Panel) {
+            if (!this._isPanelViewPerSession || e.viewContainerLocation !== ViewContainerLocation.Panel) {
                 return;
             }
-            if (this.multipleSessionsVisibleObs.get() || this._isCustomViewVisible()) {
+            if ((this.multipleSessionsVisibleObs.get() && !this._chatLayoutActive()) || this._isCustomViewVisible()) {
                 return;
             }
             const activeSession = this._sessionsService.activeSession.get();
-            if (activeSession) {
-                this._panelViewBySession.set(activeSession.resource, e.composite.getId());
+            const ownerKey = activeSession && this._ownerKeyFor(activeSession);
+            if (ownerKey) {
+                this._panelViewBySession.set(ownerKey, e.composite.getId());
             }
         }));
         this._register(autorun(reader => {
-            if (this._isPanelVisibilityPerSession) {
+            if (!this._isPanelViewPerSession) {
                 return;
             }
-            const activeSessionResource = this.activeSessionResourceObs.read(reader);
-            if (this.multipleSessionsVisibleObs.read(reader)) {
+            const activeSession = this._sessionsService.activeSession.read(reader);
+            if (this._chatLayoutEnabled) {
+                activeSession?.activeChat.read(reader);
+            }
+            const chatLayoutActive = this._chatLayoutActive(reader);
+            if (this.multipleSessionsVisibleObs.read(reader) && !chatLayoutActive) {
                 return;
             }
-            this._syncPanelView(activeSessionResource);
+            if (activeSession && this._chatLayoutSuspended(reader)) {
+                return;
+            }
+            this._syncPanelView(activeSession ? this._ownerKeyFor(activeSession, reader) : undefined);
         }));
         this._register(this._layoutService.onDidChangePartVisibility(e => {
-            if (this._isPanelVisibilityPerSession || e.partId !== Parts.PANEL_PART || !e.visible) {
+            if (!this._isPanelViewPerSession || e.partId !== Parts.PANEL_PART || !e.visible) {
                 return;
             }
-            if (this.multipleSessionsVisibleObs.get() || this._isCustomViewVisible()) {
+            if ((this.multipleSessionsVisibleObs.get() && !this._chatLayoutActive()) || this._isCustomViewVisible()) {
+                return;
+            }
+            const activeSession = this._sessionsService.activeSession.get();
+            if (activeSession && this._chatLayoutSuspended()) {
                 return;
             }
-            this._syncPanelView(this._sessionsService.activeSession.get()?.resource);
+            this._syncPanelView(activeSession ? this._ownerKeyFor(activeSession) : undefined);
         }));
         this._register(this._layoutService.onDidChangePartVisibility(e => {
             if (!this._isEditorPartVisibilityPerSession || e.partId !== Parts.EDITOR_PART || this._isRestoringSessionLayout) {
@@ -232,8 +326,9 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
                 return;
             }
             const activeSession = this._sessionsService.activeSession.get();
-            if (activeSession) {
-                this._editorPartHiddenBySession.set(activeSession.resource, !e.visible);
+            const ownerKey = activeSession && this._ownerKeyFor(activeSession);
+            if (ownerKey) {
+                this._editorPartHiddenBySession.set(ownerKey, !e.visible);
             }
         }));
         this._useModalConfigObs = observableConfigValue("workbench.editor.useModal", "all", this._configurationService);
@@ -241,31 +336,117 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
             this._workspaceContextService.onDidChangeWorkspaceFolders,
             () => this._workspaceContextService.getWorkspace().folders
         );
+        const activeEditorWorkingSetTarget = derivedObservableWithCache(this, (reader, lastValue) => {
+            if (this._chatLayoutSuspended(reader)) {
+                return lastValue ?? {
+                    session: undefined,
+                    key: undefined,
+                    owner: undefined
+                };
+            }
+            const session = this._sessionsService.activeSession.read(reader);
+            const chat = session?.activeChat.read(reader);
+            const key = session && chat ? this._ownerKeyForChat(
+                session.resource,
+                chat.resource,
+                session.mainChat.read(reader).resource,
+                reader
+            ) : undefined;
+            if (isEqual(key, lastValue?.key)) {
+                return lastValue ?? {
+                    session,
+                    key,
+                    owner: this._editorWorkingSetOwnerFor(session, reader)
+                };
+            }
+            return {
+                session,
+                key,
+                owner: this._editorWorkingSetOwnerFor(session, reader)
+            };
+        });
         const activeSessionForWorkingSet = derivedObservableWithCache(this, (reader, lastValue) => {
             const workspaceFolders = workspaceFoldersObs.read(reader);
-            const activeSession = this._sessionsService.activeSession.read(reader);
-            const activeSessionWorkspaceUri = activeSession?.workspace.read(reader)?.folders[0]?.workingDirectory;
+            const target = activeEditorWorkingSetTarget.read(reader);
+            const activeSession = target.session;
+            const activeChat = activeSession?.activeChat.read(reader);
+            const activeSessionWorkspaceUri = activeChat?.workspace.read(reader)?.folders[0]?.workingDirectory;
             if (activeSessionWorkspaceUri && !( workspaceFolders.some(folder => isEqual(folder.uri, activeSessionWorkspaceUri)))) {
-                return lastValue;
+                return lastValue ?? {
+                    session: undefined,
+                    key: undefined,
+                    owner: undefined
+                };
             }
-            if (isEqual(activeSession?.resource, lastValue?.resource)) {
-                return lastValue;
+            if (isEqual(target.key, lastValue?.key)) {
+                return lastValue ?? target;
             }
-            return activeSession;
+            return target;
         });
+        let currentWorkingSetTarget = activeSessionForWorkingSet.get();
+        this._settledEditorWorkingSetKey = activeEditorWorkingSetTarget.get().key;
+        this._editorWorkingSetService.setCurrentOwner(activeEditorWorkingSetTarget.get().owner);
         this._register(
             runOnChange(this._sessionsService.activeSession, (session, previousSession) => {
-                if (previousSession && !isEqual(previousSession.resource, session?.resource) && previousSession.status.read(undefined) !== SessionStatus.Untitled && !this._isRestoringSessionLayout) {
-                    this._saveWorkingSet(previousSession.resource);
+                if (previousSession && !isEqual(previousSession.resource, session?.resource)) {
+                    this._onActiveSessionSwitched(previousSession, session);
+                    const wasReplaced = this._replacedSessionResources.delete(previousSession.resource);
+                    if (previousSession.status.read(undefined) !== SessionStatus.Untitled && !this._isRestoringSessionLayout && !wasReplaced) {
+                        const ownerKey = this._ownerKeyFor(previousSession);
+                        if (ownerKey) {
+                            this._saveWorkingSet(ownerKey);
+                        }
+                    }
                 }
             })
         );
-        this._register(runOnChange(activeSessionForWorkingSet, (session, previousSession) => {
-            if (previousSession || (session && ( this._workingSets.has(session.resource)))) {
-                this._withSessionLayoutRestore(() => this._applyWorkingSet(session?.resource, {
-                    isInitialRestore: !previousSession
-                }));
+        this._register(runOnChange(activeEditorWorkingSetTarget, (current, previous) => {
+            const shouldApply = !!previous.session || (!!current.key && ( this._workingSets.has(current.key)));
+            if (!shouldApply) {
+                const previousPending = this._pendingEditorWorkingSetRestore;
+                this._pendingEditorWorkingSetRestore = undefined;
+                previousPending?.restore.dispose();
+                this._editorWorkingSetService.setCurrentOwner(current.owner);
+                this._settledEditorWorkingSetKey = current.key;
+                return;
+            }
+            const pending = {
+                key: current.key,
+                owner: current.owner,
+                isInitialRestore: !previous.session,
+                restore: this._editorWorkingSetService.beginRestore(current.owner)
+            };
+            const previousPending = this._pendingEditorWorkingSetRestore;
+            this._pendingEditorWorkingSetRestore = pending;
+            previousPending?.restore.dispose();
+            if (previous.session && isEqual(current.key, currentWorkingSetTarget.key)) {
+                const immediate = this._takePendingEditorWorkingSetRestore(current.key);
+                if (immediate) {
+                    if (isEqual(current.key, this._settledEditorWorkingSetKey)) {
+                        this._applyPendingEditorWorkingSetRestore(immediate);
+                    } else {
+                        immediate.restore.dispose();
+                        this._editorWorkingSetService.setCurrentOwner(current.owner);
+                        this._settledEditorWorkingSetKey = current.key;
+                    }
+                }
+            }
+        }));
+        this._register(
+            toDisposable(() => this._pendingEditorWorkingSetRestore?.restore.dispose())
+        );
+        this._register(runOnChange(activeSessionForWorkingSet, (current, previous) => {
+            currentWorkingSetTarget = current;
+            const pending = this._takePendingEditorWorkingSetRestore(current.key);
+            if (!pending && !(current.key && ( this._workingSets.has(current.key)))) {
+                return;
             }
+            this._applyPendingEditorWorkingSetRestore(pending ?? {
+                key: current.key,
+                owner: current.owner,
+                isInitialRestore: !previous.session,
+                restore: this._editorWorkingSetService.beginRestore(current.owner)
+            });
         }));
         this._register(this._sessionManagementService.onDidChangeSessions(e => {
             const archivedSessions = e.changed.filter(session => session.isArchived.read(undefined));
@@ -274,6 +455,11 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
                 this._viewStateBySession.delete(session.resource);
                 this._editorPartHiddenBySession.delete(session.resource);
                 this._panelViewBySession.delete(session.resource);
+                this._panelVisibilityBySession.delete(session.resource);
+                this._onOwnerKeysForgotten([session.resource]);
+                if (this._chatLayoutEnabled) {
+                    this._forgetPeerChatState(this._chatLayoutOwnerKeys.forgetSession(session.resource));
+                }
             }
         }));
         this._register(this._sessionManagementService.onDidReplaceSession((
@@ -282,6 +468,31 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
                 to
             }
         ) => this._onSessionReplaced(from, to)));
+        this._register(this._sessionManagementService.onDidDeleteChat((
+            {
+                sessionResource,
+                chatResource,
+                session
+            }
+        ) => {
+            if (!this._chatLayoutEnabled) {
+                return;
+            }
+            const key = isEqual(chatResource, session.mainChat.get().resource) ? sessionResource : this._chatLayoutOwnerKeys.forgetChat(sessionResource, chatResource);
+            if (key) {
+                this._forgetPeerChatState([key]);
+            }
+        }));
+        this._register(this._sessionManagementService.onDidReplaceNewDraftSession((
+            {
+                from
+            }
+        ) => {
+            if (!this._chatLayoutEnabled) {
+                return;
+            }
+            this._forgetPeerChatState(this._chatLayoutOwnerKeys.forgetSession(from.resource));
+        }));
         this._register(this._layoutService.onWillToggleSidePane(() => {
             this._togglingSidePane = true;
         }));
@@ -299,20 +510,77 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
                 this._togglingSidePane = false;
             }
         }));
-        this._register(this._registerSidePaneToggleAction());
+        this._register(BaseLayoutController_1.registerSidePaneToggleAction());
         this._registerViewStateManagement();
         this._registerAuxiliaryControllers();
     }
+    _ownerKeyForChat(sessionResource, chatResource, mainChatResource, reader) {
+        if (!this._chatLayoutEnabled) {
+            return sessionResource;
+        }
+        if (!this._chatLayoutActive(reader)) {
+            return undefined;
+        }
+        return this._chatLayoutOwnerKeys.resolveKey({
+            sessionResource,
+            chatResource
+        }, mainChatResource);
+    }
+    _ownerKeyFor(session, reader) {
+        const activeChat = reader ? session.activeChat.read(reader) : session.activeChat.get();
+        const mainChat = reader ? session.mainChat.read(reader) : session.mainChat.get();
+        return this._ownerKeyForChat(session.resource, activeChat.resource, mainChat.resource, reader);
+    }
+    _editorWorkingSetOwnerFor(session, reader) {
+        return session && {
+            sessionResource: session.resource,
+            chatResource: this._chatLayoutActive(reader) ? session.activeChat.read(reader).resource : undefined
+        };
+    }
+    _takePendingEditorWorkingSetRestore(key) {
+        const pending = this._pendingEditorWorkingSetRestore;
+        if (!pending || !isEqual(pending.key, key)) {
+            return undefined;
+        }
+        this._pendingEditorWorkingSetRestore = undefined;
+        return pending;
+    }
+    _applyPendingEditorWorkingSetRestore(pending) {
+        this._withSessionLayoutRestore(async () => {
+            try {
+                await this._applyWorkingSet(pending.key, pending.owner, {
+                    isInitialRestore: pending.isInitialRestore
+                });
+            } finally {
+                pending.restore.dispose();
+                if (!this._editorWorkingSetService.restoreState.get().restoring) {
+                    this._settledEditorWorkingSetKey = pending.key;
+                }
+            }
+        });
+    }
+    _registerPersistedOwnerKeys(keys) {
+        if (!this._chatLayoutEnabled) {
+            return;
+        }
+        for (const key of keys) {
+            try {
+                this._chatLayoutOwnerKeys.registerPersistedKey(key);
+            } catch (error) {
+                this._logService.error(error);
+            }
+        }
+    }
     _registerAuxiliaryControllers() {}
     _isCustomViewVisible() {
         return this._layoutService.isVisible(Parts.CUSTOM_VIEW_GRID_PART);
     }
-    _registerSidePaneToggleAction() {
+    static registerSidePaneToggleAction() {
         return registerAction2(class extends Action2 {
             constructor() {
                 super({
                     id: "workbench.action.agentToggleSidePanel",
-                    title: ( localize2(4116, "Toggle Side Panel")),
+                    title: ( localize2(4750, "Toggle Side Panel")),
                     icon: secondarySidebarToggleClosedIcon,
                     toggled: {
                         condition: ( ContextKeyExpr.or(AuxiliaryBarVisibleContext, MainEditorAreaVisibleContext)),
@@ -320,13 +588,13 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
                     },
                     metadata: {
                         description: ( localize(
-                            4117,
+                            4751,
                             "Open/Show and Close/Hide the Side Panel (editor area and auxiliary bar)"
                         ))
                     },
                     category: Categories.View,
                     f1: true,
-                    precondition: ( ContextKeyExpr.and(( ContextKeyExpr.or(( IsQuickChatSessionContext.negate()), SinglePaneLayoutEnabledContext)), ( CustomViewVisibleContext.negate()))),
+                    precondition: ( ContextKeyExpr.and(( ContextKeyExpr.or(( IsQuickChatSessionContext.negate()), DesktopLayoutContext)), ( CustomViewVisibleContext.negate()))),
                     keybinding: {
                         weight: KeybindingWeight.SessionsContrib,
                         primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.KeyB
@@ -342,7 +610,7 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
             run(accessor) {
                 const nowVisible = accessor.get(IAgentWorkbenchLayoutService).toggleSidePane();
                 logSidePanelToggle(accessor.get(ITelemetryService), nowVisible);
-                alert(nowVisible ? ( localize(4118, "Side Panel shown")) : ( localize(4119, "Side Panel hidden")));
+                alert(nowVisible ? ( localize(4752, "Side Panel shown")) : ( localize(4753, "Side Panel hidden")));
             }
         });
     }
@@ -350,13 +618,16 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
     _onSessionReplaced(from, to) {
         const activeSession = this._sessionsService.activeSession.get();
         const replacedSessionIsActive = isEqual(activeSession?.resource, from.resource) || isEqual(activeSession?.resource, to.resource);
+        if (!isEqual(from.resource, to.resource)) {
+            this._replacedSessionResources.add(from.resource);
+        }
         if (this._isEditorPartVisibilityPerSession) {
             const editorPartHidden = this._editorPartHiddenBySession.get(from.resource) ?? (replacedSessionIsActive ? !this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow) : undefined);
             if (editorPartHidden !== undefined) {
                 this._editorPartHiddenBySession.set(to.resource, editorPartHidden);
             }
         }
-        if (!this._isPanelVisibilityPerSession) {
+        if (this._isPanelViewPerSession) {
             const panelView = this._panelViewBySession.get(from.resource);
             if (panelView !== undefined) {
                 this._panelViewBySession.set(to.resource, panelView);
@@ -365,12 +636,77 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
                 this._syncPanelView(to.resource);
             }
         }
+        if (this._isPanelVisibilityPerSession) {
+            const panelVisible = this._panelVisibilityBySession.get(from.resource);
+            if (panelVisible !== undefined) {
+                this._panelVisibilityBySession.set(to.resource, panelVisible);
+            }
+        }
+        if (this._chatLayoutEnabled) {
+            this._remapOwnerKeyState(from.resource, to.resource);
+            for (const {
+                oldKey,
+                newKey
+            } of this._chatLayoutOwnerKeys.remapSession({
+                from,
+                to
+            })) {
+                this._remapOwnerKeyState(oldKey, newKey);
+            }
+        }
+    }
+    _remapOwnerKeyState(oldKey, newKey) {
+        if (isEqual(oldKey, newKey)) {
+            return;
+        }
+        const workingSet = this._workingSets.get(oldKey);
+        if (workingSet) {
+            const previousAtNewKey = this._workingSets.get(newKey);
+            this._workingSets.set(newKey, workingSet);
+            this._workingSets.delete(oldKey);
+            if (previousAtNewKey && previousAtNewKey.id !== workingSet.id) {
+                this._releaseWorkingSetReference(previousAtNewKey);
+            }
+        }
+        const viewState = this._viewStateBySession.get(oldKey);
+        if (viewState) {
+            this._viewStateBySession.set(newKey, viewState);
+            this._viewStateBySession.delete(oldKey);
+        }
+        const editorPartHidden = this._editorPartHiddenBySession.get(oldKey);
+        if (editorPartHidden !== undefined) {
+            this._editorPartHiddenBySession.set(newKey, editorPartHidden);
+            this._editorPartHiddenBySession.delete(oldKey);
+        }
+        const panelView = this._panelViewBySession.get(oldKey);
+        if (panelView !== undefined) {
+            this._panelViewBySession.set(newKey, panelView);
+            this._panelViewBySession.delete(oldKey);
+        }
+        const panelVisible = this._panelVisibilityBySession.get(oldKey);
+        if (panelVisible !== undefined) {
+            this._panelVisibilityBySession.set(newKey, panelVisible);
+            this._panelVisibilityBySession.delete(oldKey);
+        }
+        this._onOwnerKeyRemapped(oldKey, newKey);
+    }
+    _forgetPeerChatState(keys) {
+        for (const key of keys) {
+            this._deleteWorkingSet(key);
+            this._viewStateBySession.delete(key);
+            this._editorPartHiddenBySession.delete(key);
+            this._panelViewBySession.delete(key);
+            this._panelVisibilityBySession.delete(key);
+        }
+        this._onOwnerKeysForgotten(keys);
     }
     _hasActiveAuxViewContainers() {
         return ( this._viewDescriptorService.getViewContainersByLocation(ViewContainerLocation.AuxiliaryBar).some(container => this._viewsService.isViewContainerActive(container.id)));
     }
     _onSidePaneToggled(_collapsed, _previousAuxiliaryBarVisible, _auxiliaryBarVisible) {}
     _captureActiveSessionViewState(_sessionResource) {}
+    _onOwnerKeyRemapped(_oldKey, _newKey) {}
+    _onOwnerKeysForgotten(_keys) {}
     _withSessionLayoutRestore(work) {
         this._restoringSessionLayoutDepth++;
         const suppression = this._suppressEditorVisibilityDuringRestore();
@@ -409,36 +745,92 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
         return false;
     }
     _onWillApplyWorkingSet(_workingSet) {}
+    _onActiveSessionSwitched(_previousSession, _session) {}
     _revealEditorPartForWorkingSet() {
         this._layoutService.setPartHidden(false, Parts.EDITOR_PART);
     }
     _hideEditorPartForWorkingSet() {
         this._layoutService.setPartHidden(true, Parts.EDITOR_PART);
     }
+    _applySessionLayoutEntries(entries) {
+        this._registerPersistedOwnerKeys(entries.map(entry => ( URI.parse(entry.sessionResource))));
+        for (const entry of entries) {
+            const resource = ( URI.parse(entry.sessionResource));
+            if (entry.editorWorkingSet) {
+                this._workingSets.set(resource, entry.editorWorkingSet);
+            }
+            if (this._isEditorPartVisibilityPerSession && entry.editorPartHidden !== undefined) {
+                this._editorPartHiddenBySession.set(resource, entry.editorPartHidden);
+            }
+            if (this._isViewStatePerSession && entry.viewState) {
+                this._viewStateBySession.set(resource, entry.viewState);
+            }
+            if (this._isPanelViewPerSession && entry.panelViewContainerId) {
+                this._panelViewBySession.set(resource, entry.panelViewContainerId);
+            }
+            if (this._isPanelVisibilityPersisted && typeof entry.panelVisible === "boolean") {
+                this._panelVisibilityBySession.set(resource, entry.panelVisible);
+            }
+        }
+    }
+    _parseVersionedSessionLayoutEntries(raw, storageKey) {
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== SESSION_LAYOUT_STATE_SCHEMA_VERSION || !Array.isArray(parsed.entries)) {
+            throw ( new Error(
+                `Unsupported ${storageKey} schema: expected version ${SESSION_LAYOUT_STATE_SCHEMA_VERSION}, got version ${String(parsed.version)}`
+            ));
+        }
+        const invalidIndex = parsed.entries.findIndex(entry => !isValidSessionLayoutEntry(entry));
+        if (invalidIndex !== -1) {
+            throw ( new Error(`Malformed ${storageKey} entry at index ${invalidIndex}`));
+        }
+        return parsed.entries;
+    }
+    _collectLegacyReferencedWorkingSetIds() {
+        const legacyPresentationKey = this._legacyLayoutStateStorageKey;
+        if (!legacyPresentationKey) {
+            return;
+        }
+        const legacyPresentationRaw = this._storageService.get(legacyPresentationKey, StorageScope.WORKSPACE);
+        if (!legacyPresentationRaw) {
+            return;
+        }
+        try {
+            const legacyEntries = JSON.parse(legacyPresentationRaw);
+            for (const entry of legacyEntries) {
+                if (entry.editorWorkingSet) {
+                    this._legacyReferencedWorkingSetIds.add(entry.editorWorkingSet.id);
+                }
+            }
+        } catch (error) {
+            this._logService.error(error);
+        }
+    }
     _loadState() {
+        this._collectLegacyReferencedWorkingSetIds();
         const raw = this._storageService.get(this._layoutStateStorageKey, StorageScope.WORKSPACE);
         if (raw) {
             try {
-                for (const entry of JSON.parse(raw)) {
-                    const resource = ( URI.parse(entry.sessionResource));
-                    if (entry.editorWorkingSet) {
-                        this._workingSets.set(resource, entry.editorWorkingSet);
-                    }
-                    if (this._isEditorPartVisibilityPerSession && entry.editorPartHidden !== undefined) {
-                        this._editorPartHiddenBySession.set(resource, entry.editorPartHidden);
-                    }
-                    if (this._isViewStatePerSession && entry.viewState) {
-                        this._viewStateBySession.set(resource, entry.viewState);
-                    }
-                    if (!this._isPanelVisibilityPerSession && entry.panelViewContainerId) {
-                        this._panelViewBySession.set(resource, entry.panelViewContainerId);
-                    }
-                }
+                const entries = this._isLayoutStateVersioned ? this._parseVersionedSessionLayoutEntries(raw, this._layoutStateStorageKey) : JSON.parse(raw);
+                this._applySessionLayoutEntries(entries);
                 return;
-            } catch {
+            } catch (error) {
+                if (this._isLayoutStateVersioned) {
+                    this._logService.error(error);
+                }
                 this._storageService.remove(this._layoutStateStorageKey, StorageScope.WORKSPACE);
             }
         }
+        const legacyPresentationKey = this._legacyLayoutStateStorageKey;
+        if (legacyPresentationKey) {
+            const legacyPresentationRaw = this._storageService.get(legacyPresentationKey, StorageScope.WORKSPACE);
+            if (legacyPresentationRaw) {
+                try {
+                    this._applySessionLayoutEntries(JSON.parse(legacyPresentationRaw));
+                    return;
+                } catch {}
+            }
+        }
         const legacyKey = this._legacyWorkingSetsStorageKey;
         if (!legacyKey) {
             return;
@@ -465,11 +857,12 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
     _saveState() {
         const activeSession = this._sessionsService.activeSession.get();
         const multipleVisible = this._sessionsService.visibleSessions.get().length > 1;
-        if (activeSession && !multipleVisible && activeSession.status.read(undefined) !== SessionStatus.Untitled) {
-            this._captureActiveSessionViewState(activeSession.resource);
+        const ownerKey = activeSession && this._ownerKeyFor(activeSession);
+        if (activeSession && ownerKey && !multipleVisible && activeSession.status.read(undefined) !== SessionStatus.Untitled) {
+            this._captureActiveSessionViewState(ownerKey);
         }
-        if (activeSession && activeSession.status.read(undefined) !== SessionStatus.Untitled) {
-            this._saveWorkingSet(activeSession.resource);
+        if (activeSession && ownerKey && activeSession.status.read(undefined) !== SessionStatus.Untitled) {
+            this._saveWorkingSet(ownerKey);
         }
         const allResources = ( new ResourceMap());
         this._workingSets.forEach((_, r) => allResources.set(r, true));
@@ -479,9 +872,12 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
         if (this._isEditorPartVisibilityPerSession) {
             this._editorPartHiddenBySession.forEach((_, r) => allResources.set(r, true));
         }
-        if (!this._isPanelVisibilityPerSession) {
+        if (this._isPanelViewPerSession) {
             this._panelViewBySession.forEach((_, r) => allResources.set(r, true));
         }
+        if (this._isPanelVisibilityPersisted) {
+            this._panelVisibilityBySession.forEach((_, r) => allResources.set(r, true));
+        }
         if (allResources.size === 0) {
             this._storageService.remove(this._layoutStateStorageKey, StorageScope.WORKSPACE);
             return;
@@ -493,12 +889,17 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
                 editorWorkingSet: this._workingSets.get(resource),
                 viewState: this._isViewStatePerSession ? this._viewStateBySession.get(resource) : undefined,
                 editorPartHidden: this._isEditorPartVisibilityPerSession ? this._editorPartHiddenBySession.get(resource) : undefined,
-                panelViewContainerId: !this._isPanelVisibilityPerSession ? this._panelViewBySession.get(resource) : undefined
+                panelViewContainerId: this._isPanelViewPerSession ? this._panelViewBySession.get(resource) : undefined,
+                panelVisible: this._isPanelVisibilityPersisted ? this._panelVisibilityBySession.get(resource) : undefined
             });
         });
+        const payload = this._isLayoutStateVersioned ? {
+            version: SESSION_LAYOUT_STATE_SCHEMA_VERSION,
+            entries
+        } : entries;
         this._storageService.store(
             this._layoutStateStorageKey,
-            JSON.stringify(entries),
+            JSON.stringify(payload),
             StorageScope.WORKSPACE,
             StorageTarget.MACHINE
         );
@@ -509,7 +910,10 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
             return;
         }
         const wasVisible = this._panelVisibilityBySession.get(sessionResource);
-        this._layoutService.setPartHidden(wasVisible !== true, Parts.PANEL_PART);
+        this._layoutService.setPartHidden(
+            !(wasVisible ?? this._defaultPanelVisibility(sessionResource)),
+            Parts.PANEL_PART
+        );
     }
     _syncPanelView(sessionResource) {
         if (!sessionResource || !this._layoutService.isVisible(Parts.PANEL_PART)) {
@@ -521,14 +925,16 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
         }
         this._paneCompositePartService.openPaneComposite(viewContainerId, ViewContainerLocation.Panel);
     }
-    async _applyWorkingSet(sessionResource, options) {
+    async _applyWorkingSet(sessionResource, owner, options) {
         const preserveFocus = true;
         const workingSet = sessionResource ? (this._workingSets.get(sessionResource) ?? "empty") : "empty";
-        if (workingSet === "empty" && !this._configurationService.getValue(EMPTY_WORKING_SET_SETTING)) {
-            return;
-        }
         this._onWillApplyWorkingSet(workingSet);
+        const chatLayoutSnapshot = this._chatLayoutContext?.state.get();
+        const isStaleChatOwner = () => !!chatLayoutSnapshot?.owner && !this._chatLayoutContext.isCurrent(chatLayoutSnapshot);
         return this._workingSetSequencer.queue(async () => {
+            if (isStaleChatOwner() || !this._editorWorkingSetService.beginApply(owner)) {
+                return;
+            }
             if (this._sessionsService.visibleSessions.get().length > 1) {
                 const suppression = this._layoutService.suppressEditorPartAutoVisibility();
                 try {
@@ -548,6 +954,9 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
                 await this._editorGroupsService.applyWorkingSet(workingSet, {
                     preserveFocus
                 });
+                if (isStaleChatOwner()) {
+                    return;
+                }
                 if (this._shouldRevealEditorPartForEmptyWorkingSet(revealEditorPart) && !this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
                     this._revealEditorPartForWorkingSet();
                 } else if (hideEditorPart && this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
@@ -564,6 +973,9 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
                 } finally {
                     suppression.dispose();
                 }
+                if (isStaleChatOwner()) {
+                    return;
+                }
                 if (this._shouldHideEditorPartOnApply(editorPartHidden) && this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
                     this._hideEditorPartForWorkingSet();
                 }
@@ -577,6 +989,9 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
             const result = await this._editorGroupsService.applyWorkingSet(workingSet, {
                 preserveFocus
             });
+            if (isStaleChatOwner()) {
+                return;
+            }
             if (revealEditorPart && result && !this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
                 this._revealEditorPartForWorkingSet();
             } else if (hideEditorPart && this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
@@ -597,10 +1012,26 @@ let BaseLayoutController = class BaseLayoutController extends Disposable {
         if (!existingWorkingSet) {
             return;
         }
-        this._editorGroupsService.deleteWorkingSet(existingWorkingSet);
         this._workingSets.delete(sessionResource);
+        this._releaseWorkingSetReference(existingWorkingSet);
+    }
+    _isWorkingSetStillReferenced(workingSet) {
+        if (( this._legacyReferencedWorkingSetIds.has(workingSet.id))) {
+            return true;
+        }
+        for (const tracked of ( this._workingSets.values())) {
+            if (tracked.id === workingSet.id) {
+                return true;
+            }
+        }
+        return false;
+    }
+    _releaseWorkingSetReference(workingSet) {
+        if (!this._isWorkingSetStillReferenced(workingSet)) {
+            this._editorGroupsService.deleteWorkingSet(workingSet);
+        }
     }
 };
-BaseLayoutController = ( __decorate([( __param(0, IAgentWorkbenchLayoutService)), ( __param(1, ISessionsManagementService)), ( __param(2, ISessionsService)), ( __param(3, IViewsService)), ( __param(4, IPaneCompositePartService)), ( __param(5, IStorageService)), ( __param(6, IConfigurationService)), ( __param(7, IEditorService)), ( __param(8, IEditorGroupsService)), ( __param(9, IWorkspaceContextService)), ( __param(10, ISessionChangesService)), ( __param(11, IChangesViewService)), ( __param(12, IViewDescriptorService)), ( __param(13, IContextKeyService)), ( __param(14, IInstantiationService)), ( __param(15, ILifecycleService))], BaseLayoutController));
+BaseLayoutController = BaseLayoutController_1 = ( __decorate([( __param(0, IAgentWorkbenchLayoutService)), ( __param(1, ISessionsManagementService)), ( __param(2, ISessionsService)), ( __param(3, IViewsService)), ( __param(4, IPaneCompositePartService)), ( __param(5, IStorageService)), ( __param(6, IConfigurationService)), ( __param(7, IEditorService)), ( __param(8, IEditorGroupsService)), ( __param(9, IWorkspaceContextService)), ( __param(10, ISessionChangesService)), ( __param(11, IChangesViewService)), ( __param(12, IViewDescriptorService)), ( __param(13, IContextKeyService)), ( __param(14, IInstantiationService)), ( __param(15, ILifecycleService)), ( __param(16, ILogService)), ( __param(17, ISessionEditorWorkingSetService))], BaseLayoutController));
 
 export { BaseLayoutController };