@codingame/monaco-vscode-api 37.3.11 → 37.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "37.3.11",
+  "version": "37.4.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
@@ -15,13 +15,13 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-base-service-override": "37.3.11",
-    "@codingame/monaco-vscode-environment-service-override": "37.3.11",
-    "@codingame/monaco-vscode-extensions-service-override": "37.3.11",
-    "@codingame/monaco-vscode-files-service-override": "37.3.11",
-    "@codingame/monaco-vscode-host-service-override": "37.3.11",
-    "@codingame/monaco-vscode-layout-service-override": "37.3.11",
-    "@codingame/monaco-vscode-quickaccess-service-override": "37.3.11",
+    "@codingame/monaco-vscode-base-service-override": "37.4.0",
+    "@codingame/monaco-vscode-environment-service-override": "37.4.0",
+    "@codingame/monaco-vscode-extensions-service-override": "37.4.0",
+    "@codingame/monaco-vscode-files-service-override": "37.4.0",
+    "@codingame/monaco-vscode-host-service-override": "37.4.0",
+    "@codingame/monaco-vscode-layout-service-override": "37.4.0",
+    "@codingame/monaco-vscode-quickaccess-service-override": "37.4.0",
     "@vscode/diff": "0.0.2-7",
     "@vscode/iconv-lite-umd": "0.7.1",
     "dompurify": "3.4.15",

package/services.js

@@ -540,10 +540,10 @@ export { IAutomationService } from './vscode/src/vs/workbench/contrib/chat/commo
 export { IAgentWorkbenchLayoutService } from './vscode/src/vs/sessions/browser/workbench.service.js';
 export { IAICustomizationItemsModel } from './vscode/src/vs/workbench/contrib/chat/browser/aiCustomization/aiCustomizationItemsModel.service.js';
 
-if (window.monacoVscodeApiBuildId != null && window.monacoVscodeApiBuildId !== "1.138.0-b83863cc-62ac-4280-864f-e513ebc4eb19") {
-    throw new Error(`Another version of monaco-vscode-api has already been loaded. Trying to load ${"1.138.0-b83863cc-62ac-4280-864f-e513ebc4eb19"}, ${window.monacoVscodeApiBuildId} is already loaded`);
+if (window.monacoVscodeApiBuildId != null && window.monacoVscodeApiBuildId !== "1.138.0-897b3e9f-e995-4307-a1f6-75656b0559fe") {
+    throw new Error(`Another version of monaco-vscode-api has already been loaded. Trying to load ${"1.138.0-897b3e9f-e995-4307-a1f6-75656b0559fe"}, ${window.monacoVscodeApiBuildId} is already loaded`);
 }
-window.monacoVscodeApiBuildId = "1.138.0-b83863cc-62ac-4280-864f-e513ebc4eb19";
+window.monacoVscodeApiBuildId = "1.138.0-897b3e9f-e995-4307-a1f6-75656b0559fe";
 function registerCommands(options) {
     function asMenuId(menu) {
         switch (menu) {

package/vscode/src/vs/platform/agentHost/common/agentHostFileSystemProvider.d.ts

@@ -121,6 +121,7 @@ export declare abstract class AHPFileSystemProvider extends Disposable implement
      * Tests can override this via the constructor parameter.
      */
     private static readonly _DEFAULT_CONNECTION_GRACE_MS;
+    private static readonly _DEFAULT_CONNECTION_REGISTRATION_MS;
     constructor(_connectionGraceMs?: number);
     /**
      * Register a mapping from a URI authority to a connection.
@@ -174,6 +175,7 @@ export declare abstract class AHPFileSystemProvider extends Disposable implement
         readonly read?: boolean;
         readonly write?: boolean;
     }): Promise<void>;
+    private _waitForAuthority;
     private _getConnection;
     /**
      * Translate a thrown error from a {@link IRemoteFilesystemConnection}

package/vscode/src/vs/platform/agentHost/common/agentHostFileSystemProvider.js

@@ -59,6 +59,9 @@ class AHPFileSystemProvider extends Disposable {
     static {
         this._DEFAULT_CONNECTION_GRACE_MS = 5000;
     }
+    static {
+        this._DEFAULT_CONNECTION_REGISTRATION_MS = 30000;
+    }
     constructor(_connectionGraceMs = AHPFileSystemProvider._DEFAULT_CONNECTION_GRACE_MS) {
         super();
         this._connectionGraceMs = _connectionGraceMs;
@@ -371,17 +374,39 @@ class AHPFileSystemProvider extends Disposable {
             throw this._mapError(err, FileSystemProviderErrorCode.NoPermissions);
         }
     }
-    _getConnection(authority) {
+    async _waitForAuthority(authority) {
         const entry = this._authorities.get(authority);
-        if (!entry) {
-            return Promise.reject(createFileSystemProviderError(
-                `No connection for authority: ${authority}`,
-                FileSystemProviderErrorCode.Unavailable
-            ));
+        if (entry) {
+            return entry;
         }
+        const store = ( new DisposableStore());
+        try {
+            return await ( new Promise((resolve, reject) => {
+                const unavailable = () => reject(createFileSystemProviderError(
+                    `No connection for authority: ${authority}`,
+                    FileSystemProviderErrorCode.Unavailable
+                ));
+                store.add(this._onDidChangeConnection.event(changedAuthority => {
+                    if (changedAuthority === authority) {
+                        const registered = this._authorities.get(authority);
+                        if (registered) {
+                            resolve(registered);
+                        }
+                    }
+                }));
+                store.add(
+                    disposableTimeout(unavailable, AHPFileSystemProvider._DEFAULT_CONNECTION_REGISTRATION_MS)
+                );
+            }));
+        } finally {
+            store.dispose();
+        }
+    }
+    async _getConnection(authority) {
+        const entry = await this._waitForAuthority(authority);
         const active = entry.connections.at(-1);
         if (active) {
-            return Promise.resolve(active);
+            return active;
         }
         return ( new Promise((resolve, reject) => {
             const settle = () => {

package/vscode/src/vs/platform/product/common/product.js

@@ -6,7 +6,7 @@ var product = {
   quality: 'stable',
   version: '1.138.0',
   commit: '7debcd0e2acdea1c52de81bf9ee1620444407dda',
-  date: '2026-10-09T18:04:32.478Z',
+  date: '2026-10-12T16:44:04.262Z',
   ...(globalThis._VSCODE_PRODUCT_JSON ?? {})
 };
 

package/vscode/src/vs/sessions/browser/workbench.d.ts

@@ -1,4 +1,4 @@
-import { Disposable, DisposableStore, IDisposable } from "../../base/common/lifecycle.js";
+import { DisposableStore, IDisposable } from "../../base/common/lifecycle.js";
 import { Event } from "../../base/common/event.js";
 import { IDimension } from "../../base/browser/dom.js";
 import { Parts, Position, PanelAlignment, SINGLE_WINDOW_PARTS, MULTI_WINDOW_PARTS, IPartVisibilityChangeEvent } from "../../workbench/services/layout/browser/layoutService.js";
@@ -11,17 +11,22 @@ import { IInstantiationService, ServicesAccessor } from "../../platform/instanti
 import { CodeWindow } from "../../base/browser/window.js";
 import { ServiceCollection } from "../../platform/instantiation/common/serviceCollection.js";
 import { WillShutdownEvent } from "../../workbench/services/lifecycle/common/lifecycle.js";
-import { ILifecycleService } from "../../workbench/services/lifecycle/common/lifecycle.service.js";
 import { NotificationService } from "@codingame/monaco-vscode-notifications-service-override/vscode/vs/workbench/services/notification/common/notificationService";
 import { IEditorWillOpenEvent } from "../../workbench/common/editor.js";
 import { SessionsLayoutPolicy } from "./layoutPolicy.js";
 import { ISessionsService } from "../services/sessions/browser/sessionsService.service.js";
+import { AbstractLayout } from "../../workbench/browser/abstractlayout.js";
 import { IAgentWorkbenchLayoutService } from "./workbench.service.js";
 export interface IWorkbenchOptions {
     /**
      * Extra classes to be added to the workbench container.
      */
     extraClasses?: string[];
+    /**
+     * Whether to reset the workbench parts layout on startup.
+     */
+    resetLayout?: boolean;
+    customEditorRestore?: (accessor: ServicesAccessor, defaultLayout: boolean) => Promise<void>;
 }
 /** Visibility of each workbench part in the Agents window layout. */
 export interface IPartVisibilityState {
@@ -89,7 +94,7 @@ export interface IDockedEditorLayout {
     getPreferredEditorPartWidth(): number | undefined;
 }
 export declare const CLOSE_MOBILE_SIDEBAR_DRAWER_COMMAND_ID = "sessions.closeMobileSidebarDrawer";
-export declare class Workbench extends Disposable implements IAgentWorkbenchLayoutService {
+export declare class Workbench extends AbstractLayout implements IAgentWorkbenchLayoutService {
     protected readonly parent: HTMLElement;
     private readonly options;
     private readonly serviceCollection;
@@ -188,11 +193,13 @@ export declare class Workbench extends Disposable implements IAgentWorkbenchLayo
     private _sidePaneStateBeforeHide;
     private _restoreSidePaneEditorMaximizedOnShow;
     protected readonly _defaultSidePaneState: ISidePaneState;
+    private readonly whenReadyPromise;
+    protected readonly whenReady: Promise<void>;
     private readonly restoredPromise;
     readonly whenRestored: Promise<void>;
     private restored;
-    readonly openedDefaultEditors = false;
     protected _savedPartSizes: IPartSizesState;
+    private initializationState;
     private static readonly _PART_VISIBILITY_KEY;
     private static readonly _PART_SIZES_KEY;
     protected editorGroupService: IEditorGroupsService;
@@ -237,6 +244,7 @@ export declare class Workbench extends Disposable implements IAgentWorkbenchLayo
     protected createNotificationsHandlers(instantiationService: IInstantiationService, notificationService: NotificationService): void;
     protected registerNotificationRowHeight(): void;
     private createPartContainer;
+    protected willRestoreEditors(): boolean;
     private createEditorPart;
     private createSessionsPart;
     private _restoreSessionsPartOnActivation;
@@ -244,10 +252,11 @@ export declare class Workbench extends Disposable implements IAgentWorkbenchLayo
     private _restoreMinimizedPartOnActivation;
     protected _minimumPartWidthForActivation(view: ISerializableView): number;
     private createCustomViewGridPart;
-    protected restore(lifecycleService: ILifecycleService): void;
-    protected restoreParts(): void;
+    protected restore(accessor: ServicesAccessor): void;
+    protected restoreParts(accessor: ServicesAccessor): void;
     private registerEditorTabHeightClass;
     initLayout(accessor: ServicesAccessor): void;
+    private initLayoutState;
     private areAllGroupsInMainPartEmpty;
     protected revealEditorOnOpen(e: IEditorWillOpenEvent): void;
     private handleDidCloseEditor;

package/vscode/src/vs/sessions/browser/workbench.js

@@ -4,10 +4,10 @@ import '../../workbench/browser/style.js';
 import * as style from './media/style.css';
 import * as workbench from './media/workbench.css';
 import * as phoneLayout from './media/phoneLayout.css';
-import { Disposable, DisposableStore, toDisposable } from '../../base/common/lifecycle.js';
+import { DisposableStore, toDisposable } from '../../base/common/lifecycle.js';
 import { Emitter, setGlobalLeakWarningThreshold, Event } from '../../base/common/event.js';
 import { getActiveDocument, getWindows, getClientArea, createElement, addDisposableListener, EventType, addDisposableGenericMouseDownListener, runWhenWindowIdle, Dimension, getWindowId, getWindow, getFullscreenElement, size, getActiveElement, isAncestorUsingFlowTo } from '../../base/browser/dom.js';
-import { DeferredPromise, RunOnceScheduler } from '../../base/common/async.js';
+import { DeferredPromise, timeout, RunOnceScheduler, Promises } from '../../base/common/async.js';
 import { isFirefox, isChrome, isSafari, onDidChangeFullscreen, isFullscreen } from '../../base/browser/browser.js';
 import { mark } from '../../base/common/performance.js';
 import { onUnexpectedError, setUnexpectedErrorHandler } from '../../base/common/errors.js';
@@ -73,6 +73,7 @@ import { ISessionsSetUpService } from './sessionsSetUpService.service.js';
 import { AGENTS_FLOATING_PANEL_GAP } from '../common/layoutConstants.js';
 import { ITelemetryService } from '../../platform/telemetry/common/telemetry.service.js';
 import { setContainerElement } from '../../base/browser/domStylesheets.js';
+import { AbstractLayout } from '../../workbench/browser/abstractlayout.js';
 import { IAgentWorkbenchLayoutService } from './workbench.service.js';
 import { autorun } from '../../base/common/observableInternal/reactions/autorun.js';
 import { Orientation } from '../../base/browser/ui/sash/sash.js';
@@ -100,7 +101,7 @@ var LayoutClasses;
     LayoutClasses["PHONE_LAYOUT"] = "phone-layout";
 })(LayoutClasses || (LayoutClasses = {}));
 const CLOSE_MOBILE_SIDEBAR_DRAWER_COMMAND_ID = "sessions.closeMobileSidebarDrawer";
-class Workbench extends Disposable {
+class Workbench extends AbstractLayout {
     get activeContainer() {
         return this.getContainerFromDocument(getActiveDocument());
     }
@@ -164,7 +165,10 @@ class Workbench extends Disposable {
         this._PART_SIZES_KEY = "workbench.sessions.partSizes";
     }
     constructor(parent, options, serviceCollection, logService) {
-        super();
+        super({
+            resetLayout: options?.resetLayout,
+            customEditorRestore: options?.customEditorRestore
+        });
         this.parent = parent;
         this.options = options;
         this.serviceCollection = serviceCollection;
@@ -233,10 +237,11 @@ class Workbench extends Disposable {
             editor: true,
             auxiliaryBar: true
         };
+        this.whenReadyPromise = ( new DeferredPromise());
+        this.whenReady = this.whenReadyPromise.p;
         this.restoredPromise = ( new DeferredPromise());
         this.whenRestored = this.restoredPromise.p;
         this.restored = false;
-        this.openedDefaultEditors = false;
         this._savedPartSizes = {};
         this.previousUnexpectedError = {
             message: undefined,
@@ -328,7 +333,7 @@ class Workbench extends Disposable {
                 }
                 this.createWorkbenchManagement(instantiationService);
                 this.layout();
-                this.restore(lifecycleService);
+                this.restore(accessor);
             });
             return instantiationService;
         } catch (error) {
@@ -678,6 +683,9 @@ class Workbench extends Disposable {
         part.setAttribute("role", role);
         return part;
     }
+    willRestoreEditors() {
+        return this.initializationState.editor.restoreEditors;
+    }
     createEditorPart() {
         const editorPartContainer = createElement("div");
         editorPartContainer.classList.add("part", "editor");
@@ -694,7 +702,7 @@ class Workbench extends Disposable {
         this._editorPartContainer = editorPartContainer;
         mark("code/willCreatePart/workbench.parts.editor");
         this.getPart(Parts.EDITOR_PART).create(editorPartContainer, {
-            restorePreviousState: false
+            restorePreviousState: this.willRestoreEditors()
         });
         mark("code/didCreatePart/workbench.parts.editor");
         this.mainContainer.appendChild(editorPartContainer);
@@ -756,27 +764,45 @@ class Workbench extends Disposable {
         mark(`code/didCreatePart/${Parts.CUSTOM_VIEW_GRID_PART}`);
         this.mainContainer.appendChild(customViewGridPartContainer);
     }
-    restore(lifecycleService) {
-        mark("code/didStartWorkbench");
-        performance.measure(
-            "perf: workbench create & restore",
-            "code/didLoadWorkbenchMain",
-            "code/didStartWorkbench"
-        );
-        this.restoreParts();
+    restore(accessor) {
+        const lifecycleService = accessor.get(ILifecycleService);
+        try {
+            this.restoreParts(accessor);
+        } catch (error) {
+            onUnexpectedError(error);
+        }
         void this.sessionsService.restoreVisibleSessions().catch(e => {
             this.logService.error("[Workbench] restoreVisibleSessions failed", e);
         });
-        lifecycleService.phase = LifecyclePhase.Restored;
-        this.setRestored();
-        const eventuallyPhaseScheduler = this._register(( new RunOnceScheduler(() => {
-            this._register(
-                runWhenWindowIdle(mainWindow, () => lifecycleService.phase = LifecyclePhase.Eventually, 2500)
-            );
-        }, 2500)));
-        eventuallyPhaseScheduler.schedule();
+        this.whenReady.finally(() => Promise.race([this.whenRestored, timeout(2000)]).finally(() => {
+            function markDidStartWorkbench() {
+                mark("code/didStartWorkbench");
+                performance.measure(
+                    "perf: workbench create & restore",
+                    "code/didLoadWorkbenchMain",
+                    "code/didStartWorkbench"
+                );
+            }
+            if (this.isRestored()) {
+                markDidStartWorkbench();
+            } else {
+                this.whenRestored.finally(() => markDidStartWorkbench());
+            }
+            lifecycleService.phase = LifecyclePhase.Restored;
+            const eventuallyPhaseScheduler = this._register(( new RunOnceScheduler(() => {
+                this._register(
+                    runWhenWindowIdle(mainWindow, () => lifecycleService.phase = LifecyclePhase.Eventually, 2500)
+                );
+            }, 2500)));
+            eventuallyPhaseScheduler.schedule();
+        }));
     }
-    restoreParts() {
+    restoreParts(accessor) {
+        const layoutReadyPromises = [];
+        const layoutRestoredPromises = [];
+        layoutReadyPromises.push(
+            this.restoreLayout(accessor, this.initializationState, layoutRestoredPromises)
+        );
         const partsToRestore = [{
             location: ViewContainerLocation.Sidebar,
             visible: this.partVisibility.sidebar
@@ -798,6 +824,12 @@ class Workbench extends Disposable {
                 }
             }
         }
+        Promises.settled(layoutReadyPromises).finally(() => {
+            this.whenReadyPromise.complete();
+            Promises.settled(layoutRestoredPromises).finally(() => {
+                this.setRestored();
+            });
+        });
     }
     registerEditorTabHeightClass() {
         const updateCompactHeight = () => this.mainContainer.classList.toggle(
@@ -837,6 +869,10 @@ class Workbench extends Disposable {
         this.partVisibility.sessions = visDefaults.sessions;
         this.partVisibility.editor = visDefaults.editor;
         this._applyPersistedPartVisibility();
+        this.initLayoutState(accessor);
+    }
+    initLayoutState(accessor) {
+        this.initializationState = this.getInitLayoutState(accessor);
     }
     areAllGroupsInMainPartEmpty() {
         for (const group of this.editorGroupService.mainPart.groups) {

package/vscode/src/vs/workbench/browser/abstractlayout.d.ts

@@ -0,0 +1,146 @@
+import { IDimension } from "../../base/browser/dom.js";
+import { Direction, IViewSize } from "../../base/browser/ui/grid/grid.js";
+import { Event } from "../../base/common/event.js";
+import { Disposable, DisposableStore, IDisposable } from "../../base/common/lifecycle.js";
+import { ServicesAccessor } from "../../platform/instantiation/common/instantiation.js";
+import { ILayoutOffsetInfo } from "../../platform/layout/browser/layoutService.js";
+import { IPath } from "../../platform/window/common/window.js";
+import { IUntypedEditorInput } from "../common/editor.js";
+import { EditorGroupLayout } from "../services/editor/common/editorGroupsService.js";
+import { IPartVisibilityChangeEvent, MULTI_WINDOW_PARTS, PanelAlignment, Parts, Position, SINGLE_WINDOW_PARTS } from "../services/layout/browser/layoutService.js";
+import { IWorkbenchLayoutService } from "../services/layout/browser/layoutService.service.js";
+import { Part } from "./part.js";
+export declare enum WorkbenchLayoutSettings {
+    AUXILIARYBAR_DEFAULT_VISIBILITY = "workbench.secondarySideBar.defaultVisibility",
+    AUXILIARYBAR_FORCE_MAXIMIZED = "workbench.secondarySideBar.forceMaximized",
+    ACTIVITY_BAR_VISIBLE = "workbench.activityBar.visible",
+    PANEL_POSITION = "workbench.panel.defaultLocation",
+    PANEL_OPENS_MAXIMIZED = "workbench.panel.opensMaximized",
+    ZEN_MODE_CONFIG = "zenMode",
+    EDITOR_CENTERED_LAYOUT_AUTO_RESIZE = "workbench.editor.centeredLayoutAutoResize",
+    EDITOR_RESTORE_EDITORS = "workbench.editor.restoreEditors"
+}
+export interface IEditorToOpen {
+    readonly editor: IUntypedEditorInput;
+    readonly viewColumn?: number;
+}
+export interface ILayoutInitializationState {
+    readonly views: {
+        readonly defaults: string[] | undefined;
+        readonly containerToRestore: {
+            sideBar?: string;
+            panel?: string;
+            auxiliaryBar?: string;
+        };
+    };
+    readonly editor: {
+        readonly restoreEditors: boolean;
+        readonly editorsToOpen: Promise<IEditorToOpen[]>;
+    };
+    readonly layout?: {
+        readonly editors?: EditorGroupLayout;
+    };
+}
+export interface IPathToOpen extends IPath {
+    readonly viewColumn?: number;
+}
+export interface IInitialEditorsState {
+    readonly filesToOpenOrCreate?: IPathToOpen[];
+    readonly filesToDiff?: IPathToOpen[];
+    readonly filesToMerge?: IPathToOpen[];
+    readonly layout?: EditorGroupLayout;
+}
+export declare abstract class AbstractLayout extends Disposable implements IWorkbenchLayoutService {
+    protected readonly layoutOptions?: {
+        resetLayout?: boolean;
+        customEditorRestore?: (accessor: ServicesAccessor, defaultLayout: boolean) => Promise<void>;
+    } | undefined;
+    readonly _serviceBrand: undefined;
+    abstract onDidChangeZenMode: Event<boolean>;
+    abstract onDidChangeWindowMaximized: Event<{
+        readonly windowId: number;
+        readonly maximized: boolean;
+    }>;
+    abstract onDidChangeMainEditorCenteredLayout: Event<boolean>;
+    abstract onDidChangePanelPosition: Event<string>;
+    abstract onDidChangePanelAlignment: Event<PanelAlignment>;
+    abstract onDidChangePartVisibility: Event<IPartVisibilityChangeEvent>;
+    abstract onDidChangeNotificationsVisibility: Event<boolean>;
+    abstract onDidChangeAuxiliaryBarMaximized: Event<void>;
+    abstract layout(): void;
+    abstract isRestored(): boolean;
+    abstract whenRestored: Promise<void>;
+    abstract hasFocus(part: Parts): boolean;
+    abstract isFloatingPanelsEnabled(): boolean;
+    abstract isModernUICompact(): boolean;
+    abstract focusPart(part: SINGLE_WINDOW_PARTS): void;
+    abstract focusPart(part: MULTI_WINDOW_PARTS, targetWindow: Window): void;
+    abstract focusPart(part: Parts, targetWindow: Window): void;
+    abstract focusPart(part: unknown, targetWindow?: unknown): void;
+    abstract getContainer(targetWindow: Window): HTMLElement;
+    abstract getContainer(targetWindow: Window, part: Parts): HTMLElement | undefined;
+    abstract getContainer(targetWindow: unknown, part?: unknown): HTMLElement | undefined;
+    abstract isVisible(part: SINGLE_WINDOW_PARTS): boolean;
+    abstract isVisible(part: MULTI_WINDOW_PARTS, targetWindow: Window): boolean;
+    abstract isVisible(part: Parts, targetWindow: Window): boolean;
+    abstract isVisible(part: unknown, targetWindow?: unknown): boolean;
+    abstract setPartHidden(hidden: boolean, part: Parts): void;
+    abstract isSecondarySideBarVisible(): boolean;
+    abstract toggleSecondarySideBar(): void;
+    abstract toggleMaximizedPanel(): void;
+    abstract isPanelMaximized(): boolean;
+    abstract toggleMaximizedAuxiliaryBar(): void;
+    abstract setAuxiliaryBarMaximized(maximized: boolean): boolean;
+    abstract isAuxiliaryBarMaximized(): boolean;
+    abstract hasMainWindowBorder(): boolean;
+    abstract getMainWindowBorderRadius(): string | undefined;
+    abstract getSideBarPosition(): Position;
+    abstract toggleMenuBar(): void;
+    abstract getPanelPosition(): Position;
+    abstract setPanelPosition(position: Position): void;
+    abstract getPanelAlignment(): PanelAlignment;
+    abstract setPanelAlignment(alignment: PanelAlignment): void;
+    abstract getMaximumEditorDimensions(container: HTMLElement): IDimension;
+    abstract toggleZenMode(): void;
+    abstract isMainEditorLayoutCentered(): boolean;
+    abstract centerMainEditorLayout(active: boolean): void;
+    abstract getSize(part: Parts): IViewSize;
+    abstract setSize(part: Parts, size: IViewSize): void;
+    abstract resizePart(part: Parts, sizeChangeWidth: number, sizeChangeHeight: number): void;
+    abstract registerPart(part: Part): IDisposable;
+    abstract isWindowMaximized(targetWindow: Window): boolean;
+    abstract updateWindowMaximizedState(targetWindow: Window, maximized: boolean): void;
+    abstract getVisibleNeighborPart(part: Parts, direction: Direction): Parts | undefined;
+    abstract onDidLayoutMainContainer: Event<IDimension>;
+    abstract onDidLayoutContainer: Event<{
+        readonly container: HTMLElement;
+        readonly dimension: IDimension;
+    }>;
+    abstract onDidLayoutActiveContainer: Event<IDimension>;
+    abstract onDidAddContainer: Event<{
+        readonly container: HTMLElement;
+        readonly disposables: DisposableStore;
+    }>;
+    abstract onDidChangeActiveContainer: Event<void>;
+    abstract mainContainerDimension: IDimension;
+    abstract activeContainerDimension: IDimension;
+    abstract mainContainer: HTMLElement;
+    abstract activeContainer: HTMLElement;
+    abstract containers: Iterable<HTMLElement>;
+    abstract whenContainerStylesLoaded(window: Window): Promise<void> | undefined;
+    abstract mainContainerOffset: ILayoutOffsetInfo;
+    abstract activeContainerOffset: ILayoutOffsetInfo;
+    abstract focus(): void;
+    private _openedDefaultEditors;
+    get openedDefaultEditors(): boolean;
+    constructor(layoutOptions?: {
+        resetLayout?: boolean;
+        customEditorRestore?: (accessor: ServicesAccessor, defaultLayout: boolean) => Promise<void>;
+    } | undefined);
+    protected getInitialEditorsState(accessor: ServicesAccessor): IInitialEditorsState | undefined;
+    protected getInitLayoutState(accessor: ServicesAccessor): ILayoutInitializationState;
+    private getDefaultLayoutViews;
+    private shouldRestoreEditors;
+    private resolveEditorsToOpen;
+    protected restoreLayout(accessor: ServicesAccessor, initialization: ILayoutInitializationState, layoutRestoredPromises: Promise<unknown>[]): Promise<void>;
+}

package/vscode/src/vs/workbench/browser/abstractlayout.js

@@ -0,0 +1,247 @@
+
+import { coalesce } from '../../base/common/arrays.js';
+import { Disposable } from '../../base/common/lifecycle.js';
+import { mark } from '../../base/common/performance.js';
+import { URI } from '../../base/common/uri.js';
+import { IConfigurationService } from '../../platform/configuration/common/configuration.service.js';
+import { IFileService } from '../../platform/files/common/files.service.js';
+import { IInstantiationService } from '../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../platform/log/common/log.service.js';
+import { StorageScope } from '../../platform/storage/common/storage.js';
+import { IStorageService } from '../../platform/storage/common/storage.service.js';
+import { isTemporaryWorkspace, WorkbenchState } from '../../platform/workspace/common/workspace.js';
+import { IWorkspaceContextService } from '../../platform/workspace/common/workspace.service.js';
+import { pathsToEditors, isResourceEditorInput } from '../common/editor.js';
+import { GroupsOrder } from '../services/editor/common/editorGroupsService.js';
+import { IEditorGroupsService } from '../services/editor/common/editorGroupsService.service.js';
+import { IEditorService } from '../services/editor/common/editorService.service.js';
+import { IBrowserWorkbenchEnvironmentService } from '../services/environment/browser/environmentService.service.js';
+
+var WorkbenchLayoutSettings;
+(function(WorkbenchLayoutSettings) {
+    WorkbenchLayoutSettings["AUXILIARYBAR_DEFAULT_VISIBILITY"] = "workbench.secondarySideBar.defaultVisibility";
+    WorkbenchLayoutSettings["AUXILIARYBAR_FORCE_MAXIMIZED"] = "workbench.secondarySideBar.forceMaximized";
+    WorkbenchLayoutSettings["ACTIVITY_BAR_VISIBLE"] = "workbench.activityBar.visible";
+    WorkbenchLayoutSettings["PANEL_POSITION"] = "workbench.panel.defaultLocation";
+    WorkbenchLayoutSettings["PANEL_OPENS_MAXIMIZED"] = "workbench.panel.opensMaximized";
+    WorkbenchLayoutSettings["ZEN_MODE_CONFIG"] = "zenMode";
+    WorkbenchLayoutSettings["EDITOR_CENTERED_LAYOUT_AUTO_RESIZE"] = "workbench.editor.centeredLayoutAutoResize";
+    WorkbenchLayoutSettings["EDITOR_RESTORE_EDITORS"] = "workbench.editor.restoreEditors";
+})(WorkbenchLayoutSettings || (WorkbenchLayoutSettings = {}));
+class AbstractLayout extends Disposable {
+    get openedDefaultEditors() {
+        return this._openedDefaultEditors;
+    }
+    constructor(layoutOptions) {
+        super();
+        this.layoutOptions = layoutOptions;
+        this._openedDefaultEditors = false;
+    }
+    getInitialEditorsState(accessor) {
+        const environmentService = accessor.get(IBrowserWorkbenchEnvironmentService);
+        const storageService = accessor.get(IStorageService);
+        const defaultLayout = environmentService.options?.defaultLayout;
+        if ((defaultLayout?.editors?.length || defaultLayout?.layout?.editors) && (defaultLayout.force || storageService.isNew(StorageScope.WORKSPACE))) {
+            this._openedDefaultEditors = true;
+            return {
+                layout: defaultLayout.layout?.editors,
+                filesToOpenOrCreate: defaultLayout?.editors?.map(editor => {
+                    return {
+                        viewColumn: editor.viewColumn,
+                        fileUri: URI.revive(editor.uri),
+                        openOnlyIfExists: editor.openOnlyIfExists,
+                        options: editor.options
+                    };
+                })
+            };
+        }
+        const {
+            filesToOpenOrCreate,
+            filesToDiff,
+            filesToMerge
+        } = environmentService;
+        if (filesToOpenOrCreate || filesToDiff || filesToMerge) {
+            return {
+                filesToOpenOrCreate,
+                filesToDiff,
+                filesToMerge
+            };
+        }
+        return undefined;
+    }
+    getInitLayoutState(accessor) {
+        const logService = accessor.get(ILogService);
+        const environmentService = accessor.get(IBrowserWorkbenchEnvironmentService);
+        const storageService = accessor.get(IStorageService);
+        const initialEditorsState = this.getInitialEditorsState(accessor);
+        if (initialEditorsState) {
+            logService.trace("Initial editor state", initialEditorsState);
+        }
+        const initialLayoutState = {
+            layout: {
+                editors: initialEditorsState?.layout
+            },
+            editor: {
+                restoreEditors: this.shouldRestoreEditors(accessor, initialEditorsState),
+                editorsToOpen: this.resolveEditorsToOpen(accessor, initialEditorsState)
+            },
+            views: {
+                defaults: this.getDefaultLayoutViews(environmentService, storageService),
+                containerToRestore: {}
+            }
+        };
+        return initialLayoutState;
+    }
+    getDefaultLayoutViews(environmentService, storageService) {
+        const defaultLayout = environmentService.options?.defaultLayout;
+        if (!defaultLayout) {
+            return undefined;
+        }
+        if (!defaultLayout.force && !storageService.isNew(StorageScope.WORKSPACE)) {
+            return undefined;
+        }
+        const {
+            views
+        } = defaultLayout;
+        if (views?.length) {
+            return views.map(view => view.id);
+        }
+        return undefined;
+    }
+    shouldRestoreEditors(accessor, initialEditorsState) {
+        const contextService = accessor.get(IWorkspaceContextService);
+        const configurationService = accessor.get(IConfigurationService);
+        if (isTemporaryWorkspace(contextService.getWorkspace())) {
+            return false;
+        }
+        if (configurationService.getValue(WorkbenchLayoutSettings.EDITOR_RESTORE_EDITORS) === false) {
+            return false;
+        }
+        const forceRestoreEditors = configurationService.getValue("window.restoreWindows") === "preserve";
+        return !!forceRestoreEditors || initialEditorsState === undefined;
+    }
+    async resolveEditorsToOpen(accessor, initialEditorsState) {
+        const fileService = accessor.get(IFileService);
+        const logService = accessor.get(ILogService);
+        const contextService = accessor.get(IWorkspaceContextService);
+        const configurationService = accessor.get(IConfigurationService);
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        if (initialEditorsState) {
+            const filesToMerge = coalesce(
+                await pathsToEditors(initialEditorsState.filesToMerge, fileService, logService)
+            );
+            if (filesToMerge.length === 4 && isResourceEditorInput(filesToMerge[0]) && isResourceEditorInput(filesToMerge[1]) && isResourceEditorInput(filesToMerge[2]) && isResourceEditorInput(filesToMerge[3])) {
+                return [{
+                    editor: {
+                        input1: {
+                            resource: filesToMerge[0].resource
+                        },
+                        input2: {
+                            resource: filesToMerge[1].resource
+                        },
+                        base: {
+                            resource: filesToMerge[2].resource
+                        },
+                        result: {
+                            resource: filesToMerge[3].resource
+                        },
+                        options: {
+                            pinned: true
+                        }
+                    }
+                }];
+            }
+            const filesToDiff = coalesce(
+                await pathsToEditors(initialEditorsState.filesToDiff, fileService, logService)
+            );
+            if (filesToDiff.length === 2) {
+                return [{
+                    editor: {
+                        original: {
+                            resource: filesToDiff[0].resource
+                        },
+                        modified: {
+                            resource: filesToDiff[1].resource
+                        },
+                        options: {
+                            pinned: true
+                        }
+                    }
+                }];
+            }
+            const filesToOpenOrCreate = [];
+            const resolvedFilesToOpenOrCreate = await pathsToEditors(initialEditorsState.filesToOpenOrCreate, fileService, logService);
+            for (let i = 0; i < resolvedFilesToOpenOrCreate.length; i++) {
+                const resolvedFileToOpenOrCreate = resolvedFilesToOpenOrCreate[i];
+                if (resolvedFileToOpenOrCreate) {
+                    filesToOpenOrCreate.push({
+                        editor: resolvedFileToOpenOrCreate,
+                        viewColumn: initialEditorsState.filesToOpenOrCreate?.[i].viewColumn
+                    });
+                }
+            }
+            return filesToOpenOrCreate;
+        }
+        else if (contextService.getWorkbenchState() === WorkbenchState.EMPTY && configurationService.getValue("workbench.startupEditor") === "newUntitledFile") {
+            if (editorGroupService.hasRestorableState) {
+                return [];
+            }
+            return [{
+                editor: {
+                    resource: undefined
+                }
+            }];
+        }
+        return [];
+    }
+    async restoreLayout(accessor, initialization, layoutRestoredPromises) {
+        const instantiationService = accessor.get(IInstantiationService);
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        const editorService = accessor.get(IEditorService);
+        const logService = accessor.get(ILogService);
+        mark("code/willRestoreEditors");
+        await editorGroupService.whenReady;
+        mark("code/restoreEditors/editorGroupsReady");
+        if (initialization.layout?.editors) {
+            editorGroupService.mainPart.applyLayout(initialization.layout.editors);
+        }
+        const editors = await initialization.editor.editorsToOpen;
+        mark("code/restoreEditors/editorsToOpenResolved");
+        let openEditorsPromise = undefined;
+        if (editors.length) {
+            const editorGroupsInVisualOrder = editorGroupService.mainPart.getGroups(GroupsOrder.GRID_APPEARANCE);
+            const mapEditorsToGroup = ( new Map());
+            for (const editor of editors) {
+                const group = editorGroupsInVisualOrder[(editor.viewColumn ?? 1) - 1];
+                let editorsByGroup = mapEditorsToGroup.get(group.id);
+                if (!editorsByGroup) {
+                    editorsByGroup = ( new Set());
+                    mapEditorsToGroup.set(group.id, editorsByGroup);
+                }
+                editorsByGroup.add(editor.editor);
+            }
+            openEditorsPromise = Promise.all(Array.from(mapEditorsToGroup).map(async ([groupId, editors]) => {
+                try {
+                    await editorService.openEditors(Array.from(editors), groupId, {
+                        validateTrust: true
+                    });
+                } catch (error) {
+                    logService.error(error);
+                }
+            }));
+        }
+        const customEditorRestorePromise = instantiationService.invokeFunction(
+            this.layoutOptions?.customEditorRestore ?? (async () => {}),
+            !!initialization.layout?.editors
+        );
+        layoutRestoredPromises.push(Promise.all([
+            openEditorsPromise?.finally(() => mark("code/restoreEditors/editorsOpened")),
+            customEditorRestorePromise?.finally(() => mark("code/restoreEditors/customEditorsOpened")),
+            editorGroupService.whenRestored.finally(() => mark("code/restoreEditors/editorGroupsRestored"))
+        ]).finally(() => {
+            mark("code/didRestoreEditors");
+        }));
+    }
+}
+
+export { AbstractLayout, WorkbenchLayoutSettings };

package/vscode/src/vs/workbench/browser/workbench.contribution.js

@@ -606,9 +606,8 @@ const registry = ( Registry.as(Extensions.Configuration));
                     "Controls whether editors are restored on startup. When disabled, only dirty editors will be restored from the previous session."
                 )),
                 "default": true,
-                agentsWindow: {
-                    default: false,
-                    readOnly: true
+                "agentsWindow": {
+                    "default": false
                 }
             },
             "workbench.editor.splitInGroupLayout": {