workbench.ts

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

import '../../workbench/browser/style.js';
import './media/style.css';
import { Disposable, DisposableStore, IDisposable, toDisposable } from '../../base/common/lifecycle.js';
import { Emitter, Event, setGlobalLeakWarningThreshold } from '../../base/common/event.js';
import { getActiveDocument, getActiveElement, getClientArea, getWindowId, getWindows, IDimension, isAncestorUsingFlowTo, isHTMLElement, size, Dimension, runWhenWindowIdle } from '../../base/browser/dom.js';
import { DeferredPromise, RunOnceScheduler } from '../../base/common/async.js';
import { isFullscreen, onDidChangeFullscreen, isChrome, isFirefox, isSafari } from '../../base/browser/browser.js';
import { mark } from '../../base/common/performance.js';
import { onUnexpectedError, setUnexpectedErrorHandler } from '../../base/common/errors.js';
import { isWindows, isLinux, isWeb, isNative, isMacintosh } from '../../base/common/platform.js';
import { Parts, Position, PanelAlignment, IWorkbenchLayoutService, SINGLE_WINDOW_PARTS, MULTI_WINDOW_PARTS, IPartVisibilityChangeEvent, positionToString } from '../../workbench/services/layout/browser/layoutService.js';
import { ILayoutOffsetInfo } from '../../platform/layout/browser/layoutService.js';
import { Part } from '../../workbench/browser/part.js';
import { Direction, ISerializableView, ISerializedGrid, ISerializedLeafNode, ISerializedNode, IViewSize, Orientation, SerializableGrid } from '../../base/browser/ui/grid/grid.js';
import { IEditorGroupsService } from '../../workbench/services/editor/common/editorGroupsService.js';
import { IEditorService } from '../../workbench/services/editor/common/editorService.js';
import { IPaneCompositePartService } from '../../workbench/services/panecomposite/browser/panecomposite.js';
import { IViewDescriptorService, ViewContainerLocation } from '../../workbench/common/views.js';
import { ILogService } from '../../platform/log/common/log.js';
import { IInstantiationService, refineServiceDecorator, ServicesAccessor } from '../../platform/instantiation/common/instantiation.js';
import { ITitleService } from '../../workbench/services/title/browser/titleService.js';
import { mainWindow, CodeWindow } from '../../base/browser/window.js';
import { coalesce } from '../../base/common/arrays.js';
import { ServiceCollection } from '../../platform/instantiation/common/serviceCollection.js';
import { InstantiationService } from '../../platform/instantiation/common/instantiationService.js';
import { getSingletonServiceDescriptors } from '../../platform/instantiation/common/extensions.js';
import { ILifecycleService, LifecyclePhase, WillShutdownEvent } from '../../workbench/services/lifecycle/common/lifecycle.js';
import { IStorageService, WillSaveStateReason, StorageScope, StorageTarget } from '../../platform/storage/common/storage.js';
import { IConfigurationChangeEvent, IConfigurationService } from '../../platform/configuration/common/configuration.js';
import { IHostService } from '../../workbench/services/host/browser/host.js';
import { IDialogService } from '../../platform/dialogs/common/dialogs.js';
import { INotificationService } from '../../platform/notification/common/notification.js';
import { NotificationService } from '../../workbench/services/notification/common/notificationService.js';
import { IHoverService, WorkbenchHoverDelegate } from '../../platform/hover/browser/hover.js';
import { setHoverDelegateFactory } from '../../base/browser/ui/hover/hoverDelegateFactory.js';
import { setBaseLayerHoverDelegate } from '../../base/browser/ui/hover/hoverDelegate2.js';
import { Registry } from '../../platform/registry/common/platform.js';
import { IWorkbenchContributionsRegistry, Extensions as WorkbenchExtensions } from '../../workbench/common/contributions.js';
import { IEditorFactoryRegistry, EditorExtensions } from '../../workbench/common/editor.js';
import { setARIAContainer } from '../../base/browser/ui/aria/aria.js';
import { FontMeasurements } from '../../editor/browser/config/fontMeasurements.js';
import { createBareFontInfoFromRawSettings } from '../../editor/common/config/fontInfoFromSettings.js';
import { toErrorMessage } from '../../base/common/errorMessage.js';
import { WorkbenchContextKeysHandler } from '../../workbench/browser/contextkeys.js';
import { PixelRatio } from '../../base/browser/pixelRatio.js';
import { AccessibilityProgressSignalScheduler } from '../../platform/accessibilitySignal/browser/progressAccessibilitySignalScheduler.js';
import { setProgressAccessibilitySignalScheduler } from '../../base/browser/ui/progressbar/progressAccessibilitySignal.js';
import { AccessibleViewRegistry } from '../../platform/accessibility/browser/accessibleViewRegistry.js';
import { NotificationAccessibleView } from '../../workbench/browser/parts/notifications/notificationAccessibleView.js';
import { NotificationsCenter } from '../../workbench/browser/parts/notifications/notificationsCenter.js';
import { NotificationsAlerts } from '../../workbench/browser/parts/notifications/notificationsAlerts.js';
import { NotificationsStatus } from '../../workbench/browser/parts/notifications/notificationsStatus.js';
import { registerNotificationCommands } from '../../workbench/browser/parts/notifications/notificationsCommands.js';
import { NotificationsToasts } from '../../workbench/browser/parts/notifications/notificationsToasts.js';
import { IMarkdownRendererService } from '../../platform/markdown/browser/markdownRenderer.js';
import { EditorMarkdownCodeBlockRenderer } from '../../editor/browser/widget/markdownRenderer/browser/editorMarkdownCodeBlockRenderer.js';
import { SyncDescriptor } from '../../platform/instantiation/common/descriptors.js';
import { TitleService } from './parts/titlebarPart.js';
import { IContextKeyService } from '../../platform/contextkey/common/contextkey.js';
import { EditorMaximizedContext, IsPhoneLayoutContext, KeyboardVisibleContext } from '../common/contextkeys.js';
import {
	NotificationsPosition,
	NotificationsSettings,
	getNotificationsPosition
} from '../../workbench/common/notifications.js';
import { SessionsLayoutPolicy } from './layoutPolicy.js';
import { MobileNavigationStack } from './mobileNavigationStack.js';
import { MobileTitlebarPart } from './parts/mobile/mobileTitlebarPart.js';
import { autorun } from '../../base/common/observable.js';
import { ISessionsManagementService } from '../services/sessions/common/sessionsManagement.js';

//#region Workbench Options

export interface IWorkbenchOptions {
	/**
	 * Extra classes to be added to the workbench container.
	 */
	extraClasses?: string[];
}

//#endregion

//#region Layout Classes

enum LayoutClasses {
	SIDEBAR_HIDDEN = 'nosidebar',
	MAIN_EDITOR_AREA_HIDDEN = 'nomaineditorarea',
	PANEL_HIDDEN = 'nopanel',
	AUXILIARYBAR_HIDDEN = 'noauxiliarybar',
	CHATBAR_HIDDEN = 'nochatbar',
	STATUSBAR_HIDDEN = 'nostatusbar',
	SHELL_GRADIENT_BACKGROUND = 'shell-gradient-background',
	FULLSCREEN = 'fullscreen',
	MAXIMIZED = 'maximized',
	PHONE_LAYOUT = 'phone-layout'
}

//#endregion

//#region Part Visibility State

interface IPartVisibilityState {
	sidebar: boolean;
	auxiliaryBar: boolean;
	editor: boolean;
	panel: boolean;
	chatBar: boolean;
}

//#endregion

export interface IAgentWorkbenchLayoutService extends IWorkbenchLayoutService {
	isEditorMaximized(): boolean;
	setEditorMaximized(maximized: boolean): void;

	readonly onDidChangeEditorMaximized: Event<void>;
}

export const IAgentWorkbenchLayoutService = refineServiceDecorator<IWorkbenchLayoutService, IAgentWorkbenchLayoutService>(IWorkbenchLayoutService);

export class Workbench extends Disposable implements IAgentWorkbenchLayoutService {

	declare readonly _serviceBrand: undefined;

	//#region Lifecycle Events

	private readonly _onWillShutdown = this._register(new Emitter<WillShutdownEvent>());
	readonly onWillShutdown = this._onWillShutdown.event;

	private readonly _onDidShutdown = this._register(new Emitter<void>());
	readonly onDidShutdown = this._onDidShutdown.event;

	//#endregion

	//#region Events

	private readonly _onDidChangeZenMode = this._register(new Emitter<boolean>());
	readonly onDidChangeZenMode = this._onDidChangeZenMode.event;

	private readonly _onDidChangeMainEditorCenteredLayout = this._register(new Emitter<boolean>());
	readonly onDidChangeMainEditorCenteredLayout = this._onDidChangeMainEditorCenteredLayout.event;

	private readonly _onDidChangePanelAlignment = this._register(new Emitter<PanelAlignment>());
	readonly onDidChangePanelAlignment = this._onDidChangePanelAlignment.event;

	private readonly _onDidChangeWindowMaximized = this._register(new Emitter<{ windowId: number; maximized: boolean }>());
	readonly onDidChangeWindowMaximized = this._onDidChangeWindowMaximized.event;

	private readonly _onDidChangePanelPosition = this._register(new Emitter<string>());
	readonly onDidChangePanelPosition = this._onDidChangePanelPosition.event;

	private readonly _onDidChangePartVisibility = this._register(new Emitter<IPartVisibilityChangeEvent>());
	readonly onDidChangePartVisibility = this._onDidChangePartVisibility.event;

	private readonly _onDidChangeNotificationsVisibility = this._register(new Emitter<boolean>());
	readonly onDidChangeNotificationsVisibility = this._onDidChangeNotificationsVisibility.event;

	private readonly _onDidChangeAuxiliaryBarMaximized = this._register(new Emitter<void>());
	readonly onDidChangeAuxiliaryBarMaximized = this._onDidChangeAuxiliaryBarMaximized.event;

	private readonly _onDidChangeEditorMaximized = this._register(new Emitter<void>());
	readonly onDidChangeEditorMaximized = this._onDidChangeEditorMaximized.event;

	private readonly _onDidLayoutMainContainer = this._register(new Emitter<IDimension>());
	readonly onDidLayoutMainContainer = this._onDidLayoutMainContainer.event;

	private readonly _onDidLayoutActiveContainer = this._register(new Emitter<IDimension>());
	readonly onDidLayoutActiveContainer = this._onDidLayoutActiveContainer.event;

	private readonly _onDidLayoutContainer = this._register(new Emitter<{ container: HTMLElement; dimension: IDimension }>());
	readonly onDidLayoutContainer = this._onDidLayoutContainer.event;

	private readonly _onDidAddContainer = this._register(new Emitter<{ container: HTMLElement; disposables: DisposableStore }>());
	readonly onDidAddContainer = this._onDidAddContainer.event;

	private readonly _onDidChangeActiveContainer = this._register(new Emitter<void>());
	readonly onDidChangeActiveContainer = this._onDidChangeActiveContainer.event;

	//#endregion

	//#region Properties

	readonly mainContainer = document.createElement('div');

	get activeContainer(): HTMLElement {
		return this.getContainerFromDocument(getActiveDocument());
	}

	get containers(): Iterable<HTMLElement> {
		const containers: HTMLElement[] = [];
		for (const { window } of getWindows()) {
			containers.push(this.getContainerFromDocument(window.document));
		}
		return containers;
	}

	private getContainerFromDocument(targetDocument: Document): HTMLElement {
		if (targetDocument === this.mainContainer.ownerDocument) {
			return this.mainContainer;
		} else {
			// eslint-disable-next-line no-restricted-syntax
			return targetDocument.body.getElementsByClassName('monaco-workbench')[0] as HTMLElement;
		}
	}

	private _mainContainerDimension!: IDimension;
	get mainContainerDimension(): IDimension { return this._mainContainerDimension; }

	get activeContainerDimension(): IDimension {
		return this.getContainerDimension(this.activeContainer);
	}

	private getContainerDimension(container: HTMLElement): IDimension {
		if (container === this.mainContainer) {
			return this.mainContainerDimension;
		} else {
			return getClientArea(container);
		}
	}

	get mainContainerOffset(): ILayoutOffsetInfo {
		return this.computeContainerOffset();
	}

	get activeContainerOffset(): ILayoutOffsetInfo {
		return this.computeContainerOffset();
	}

	private computeContainerOffset(): ILayoutOffsetInfo {
		let top = 0;
		let quickPickTop = 0;

		if (this.isVisible(Parts.TITLEBAR_PART, mainWindow)) {
			top = this.getPart(Parts.TITLEBAR_PART).maximumHeight;
			quickPickTop = top;
		} else if (this.mobileTopBarElement) {
			// On phone layout the MobileTitlebarPart replaces the titlebar
			top = this.mobileTopBarElement.offsetHeight;
			quickPickTop = top;
		}

		return { top, quickPickTop };
	}

	//#endregion

	//#region State

	private readonly parts = new Map<string, Part>();
	private workbenchGrid!: SerializableGrid<ISerializableView>;

	private titleBarPartView!: ISerializableView;
	private sideBarPartView!: ISerializableView;
	private panelPartView!: ISerializableView;
	private auxiliaryBarPartView!: ISerializableView;
	private editorPartView!: ISerializableView;

	private chatBarPartView!: ISerializableView;

	private readonly partVisibility: IPartVisibilityState = {
		sidebar: true,
		auxiliaryBar: true,
		editor: false,
		panel: false,
		chatBar: true
	};

	private mainWindowFullscreen = false;
	private readonly maximized = new Set<number>();
	private readonly layoutPolicy = this._register(new SessionsLayoutPolicy());
	private readonly mobileNavStack = this._register(new MobileNavigationStack());
	private mobileTopBarElement: HTMLElement | undefined;
	private readonly mobileTopBarDisposables = this._register(new DisposableStore());

	private _editorMaximized = false;
	private _editorLastNonMaximizedVisibility: IPartVisibilityState | undefined;

	private readonly restoredPromise = new DeferredPromise<void>();
	readonly whenRestored = this.restoredPromise.p;
	private restored = false;

	readonly openedDefaultEditors = false;

	//#endregion

	//#region Services

	private editorGroupService!: IEditorGroupsService;
	private editorService!: IEditorService;
	private paneCompositeService!: IPaneCompositePartService;
	private viewDescriptorService!: IViewDescriptorService;
	private sessionsManagementService!: ISessionsManagementService;
	private instantiationService!: IInstantiationService;

	//#endregion

	constructor(
		protected readonly parent: HTMLElement,
		private readonly options: IWorkbenchOptions | undefined,
		private readonly serviceCollection: ServiceCollection,
		private readonly logService: ILogService
	) {
		super();

		// Sessions-scoped mobile viewport tweaks. These are applied here
		// (rather than in the shared workbench.html) so that the regular
		// code-web workbench — which does not handle safe-area insets — is
		// not affected on notched mobile devices.
		// The viewport `<meta>` tag is injected by the shared workbench.html,
		// so we cannot use dom.ts `h()` to create it. Look it up by tag name
		// and filter by the `name` attribute to avoid a selector query.
		// eslint-disable-next-line no-restricted-syntax
		const metaElements = mainWindow.document.head.getElementsByTagName('meta');
		let viewportMeta: HTMLMetaElement | undefined;
		for (let i = 0; i < metaElements.length; i++) {
			if (metaElements[i].name === 'viewport') {
				viewportMeta = metaElements[i];
				break;
			}
		}
		if (viewportMeta && !viewportMeta.content.includes('viewport-fit=')) {
			viewportMeta.content = `${viewportMeta.content}, viewport-fit=cover`;
		}

		// Perf: measure workbench startup time
		mark('code/willStartWorkbench');

		this.registerErrorHandler(logService);
	}

	//#region Error Handling

	private registerErrorHandler(logService: ILogService): void {
		// Increase stack trace limit for better errors stacks
		if (!isFirefox) {
			Error.stackTraceLimit = 100;
		}

		// Listen on unhandled rejection events
		// Note: intentionally not registered as disposable to handle
		//       errors that can occur during shutdown phase.
		mainWindow.addEventListener('unhandledrejection', (event) => {
			// See https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent
			onUnexpectedError(event.reason);

			// Prevent the printing of this event to the console
			event.preventDefault();
		});

		// Install handler for unexpected errors
		setUnexpectedErrorHandler(error => this.handleUnexpectedError(error, logService));
	}

	private previousUnexpectedError: { message: string | undefined; time: number } = { message: undefined, time: 0 };
	private handleUnexpectedError(error: unknown, logService: ILogService): void {
		const message = toErrorMessage(error, true);
		if (!message) {
			return;
		}

		const now = Date.now();
		if (message === this.previousUnexpectedError.message && now - this.previousUnexpectedError.time <= 1000) {
			return; // Return if error message identical to previous and shorter than 1 second
		}

		this.previousUnexpectedError.time = now;
		this.previousUnexpectedError.message = message;

		// Log it
		logService.error(message);
	}

	//#endregion

	//#region Startup

	startup(): IInstantiationService {
		try {
			// Configure emitter leak warning threshold
			this._register(setGlobalLeakWarningThreshold(175));

			// Services
			const instantiationService = this.initServices(this.serviceCollection);

			instantiationService.invokeFunction(accessor => {
				const lifecycleService = accessor.get(ILifecycleService);
				const storageService = accessor.get(IStorageService);
				const configurationService = accessor.get(IConfigurationService);
				const hostService = accessor.get(IHostService);
				const hoverService = accessor.get(IHoverService);
				const dialogService = accessor.get(IDialogService);
				const notificationService = accessor.get(INotificationService) as NotificationService;
				const markdownRendererService = accessor.get(IMarkdownRendererService);

				// On web, the configuration service needs access to the
				// instantiation service for dynamic configuration resolution.
				if (isWeb && typeof (configurationService as IConfigurationService & { acquireInstantiationService?(i: IInstantiationService): void }).acquireInstantiationService === 'function') {
					(configurationService as IConfigurationService & { acquireInstantiationService(i: IInstantiationService): void }).acquireInstantiationService(instantiationService);
				}

				// Set code block renderer for markdown rendering
				markdownRendererService.setDefaultCodeBlockRenderer(instantiationService.createInstance(EditorMarkdownCodeBlockRenderer));

				// Default Hover Delegate must be registered before creating any workbench/layout components
				setHoverDelegateFactory((placement, enableInstantHover) => instantiationService.createInstance(WorkbenchHoverDelegate, placement, { instantHover: enableInstantHover }, {}));
				setBaseLayerHoverDelegate(hoverService);

				// Layout
				this.initLayout(accessor);

				// Registries - this creates and registers all parts
				Registry.as<IWorkbenchContributionsRegistry>(WorkbenchExtensions.Workbench).start(accessor);
				Registry.as<IEditorFactoryRegistry>(EditorExtensions.EditorFactory).start(accessor);

				// Context Keys
				this._register(instantiationService.createInstance(WorkbenchContextKeysHandler));

				// Editor Maximized Context Key
				const editorMaximizedContext = EditorMaximizedContext.bindTo(accessor.get(IContextKeyService));
				this._register(this.onDidChangeEditorMaximized(() => {
					editorMaximizedContext.set(this.isEditorMaximized());
				}));

				// Phone Layout Context Key
				const contextKeyService = accessor.get(IContextKeyService);
				const isPhoneLayoutCtx = IsPhoneLayoutContext.bindTo(contextKeyService);
				this._register(autorun(reader => {
					isPhoneLayoutCtx.set(this.layoutPolicy.viewportClass.read(reader) === 'phone');
				}));

				// Virtual keyboard detection via visualViewport API.
				// Use `window.innerHeight` (layout viewport) as the baseline
				// rather than a captured initial height. Layout viewport
				// updates on orientation change and split-screen resizes, so
				// comparing against it avoids stale baselines on landscape
				// launches, Android split-screen, and iOS URL-bar collapse.
				if (mainWindow.visualViewport) {
					const keyboardVisibleCtx = KeyboardVisibleContext.bindTo(contextKeyService);
					const KEYBOARD_HEIGHT_THRESHOLD_PX = 100;

					const onViewportResize = () => {
						const vp = mainWindow.visualViewport;
						if (!vp) {
							return;
						}
						const heightDiff = mainWindow.innerHeight - vp.height;
						keyboardVisibleCtx.set(heightDiff > KEYBOARD_HEIGHT_THRESHOLD_PX);
					};

					mainWindow.visualViewport.addEventListener('resize', onViewportResize);
					this._register({ dispose: () => mainWindow.visualViewport?.removeEventListener('resize', onViewportResize) });
				}

				// Orientation changes produce a window `resize` event which
				// is already handled by `registerLayoutListeners()`. No
				// separate matchMedia listener is needed — the previous
				// implementation caused a redundant second layout.

				// Register Listeners
				this.registerListeners(lifecycleService, storageService, configurationService, hostService, dialogService);

				// Render Workbench
				this.renderWorkbench(instantiationService, notificationService, storageService, configurationService);

				// Workbench Layout
				this.createWorkbenchLayout();

				// Create mobile navigation after grid exists (so DOM order is correct)
				if (this.layoutPolicy.viewportClass.get() === 'phone') {
					this.createMobileTitlebar();
				}

				// Workbench Management
				this.createWorkbenchManagement(instantiationService);

				// Layout
				this.layout();

				// Restore
				this.restore(lifecycleService);
			});

			return instantiationService;
		} catch (error) {
			onUnexpectedError(error);

			throw error; // rethrow because this is a critical issue we cannot handle properly here
		}
	}

	private initServices(serviceCollection: ServiceCollection): IInstantiationService {
		// Layout Service
		serviceCollection.set(IAgentWorkbenchLayoutService, this);

		// Title Service - agent sessions titlebar with dedicated part overrides
		serviceCollection.set(ITitleService, new SyncDescriptor(TitleService, []));

		// All Contributed Services
		const contributedServices = getSingletonServiceDescriptors();
		for (const [id, descriptor] of contributedServices) {
			serviceCollection.set(id, descriptor);
		}

		const instantiationService = new InstantiationService(serviceCollection, true);

		// Wrap up
		instantiationService.invokeFunction(accessor => {
			const lifecycleService = accessor.get(ILifecycleService);
			lifecycleService.phase = LifecyclePhase.Ready;
		});

		return instantiationService;
	}

	private registerListeners(lifecycleService: ILifecycleService, storageService: IStorageService, configurationService: IConfigurationService, hostService: IHostService, dialogService: IDialogService): void {
		// Configuration changes
		this._register(configurationService.onDidChangeConfiguration(e => this.updateFontAliasing(e, configurationService)));

		// Font Info
		if (isNative) {
			this._register(storageService.onWillSaveState(e => {
				if (e.reason === WillSaveStateReason.SHUTDOWN) {
					this.storeFontInfo(storageService);
				}
			}));
		} else {
			this._register(lifecycleService.onWillShutdown(() => this.storeFontInfo(storageService)));
		}

		// Lifecycle
		this._register(lifecycleService.onWillShutdown(event => this._onWillShutdown.fire(event)));
		this._register(lifecycleService.onDidShutdown(() => {
			this._onDidShutdown.fire();
			this.dispose();
		}));

		// Flush storage on window focus loss
		this._register(hostService.onDidChangeFocus(focus => {
			if (!focus) {
				storageService.flush();
			}
		}));

		// Dialogs showing/hiding
		this._register(dialogService.onWillShowDialog(() => this.mainContainer.classList.add('modal-dialog-visible')));
		this._register(dialogService.onDidShowDialog(() => this.mainContainer.classList.remove('modal-dialog-visible')));
	}

	//#region Font Aliasing and Caching

	private fontAliasing: 'default' | 'antialiased' | 'none' | 'auto' | undefined;
	private updateFontAliasing(e: IConfigurationChangeEvent | undefined, configurationService: IConfigurationService) {
		if (!isMacintosh) {
			return; // macOS only
		}

		if (e && !e.affectsConfiguration('workbench.fontAliasing')) {
			return;
		}

		const aliasing = configurationService.getValue<'default' | 'antialiased' | 'none' | 'auto'>('workbench.fontAliasing');
		if (this.fontAliasing === aliasing) {
			return;
		}

		this.fontAliasing = aliasing;

		// Remove all
		const fontAliasingValues: (typeof aliasing)[] = ['antialiased', 'none', 'auto'];
		this.mainContainer.classList.remove(...fontAliasingValues.map(value => `monaco-font-aliasing-${value}`));

		// Add specific
		if (fontAliasingValues.some(option => option === aliasing)) {
			this.mainContainer.classList.add(`monaco-font-aliasing-${aliasing}`);
		}
	}

	private restoreFontInfo(storageService: IStorageService, configurationService: IConfigurationService): void {
		const storedFontInfoRaw = storageService.get('editorFontInfo', StorageScope.APPLICATION);
		if (storedFontInfoRaw) {
			try {
				const storedFontInfo = JSON.parse(storedFontInfoRaw);
				if (Array.isArray(storedFontInfo)) {
					FontMeasurements.restoreFontInfo(mainWindow, storedFontInfo);
				}
			} catch (err) {
				/* ignore */
			}
		}

		FontMeasurements.readFontInfo(mainWindow, createBareFontInfoFromRawSettings(configurationService.getValue('editor'), PixelRatio.getInstance(mainWindow).value));
	}

	private storeFontInfo(storageService: IStorageService): void {
		const serializedFontInfo = FontMeasurements.serializeFontInfo(mainWindow);
		if (serializedFontInfo) {
			storageService.store('editorFontInfo', JSON.stringify(serializedFontInfo), StorageScope.APPLICATION, StorageTarget.MACHINE);
		}
	}

	//#endregion

	private renderWorkbench(instantiationService: IInstantiationService, notificationService: NotificationService, storageService: IStorageService, configurationService: IConfigurationService): void {
		// ARIA & Signals
		setARIAContainer(this.mainContainer);
		setProgressAccessibilitySignalScheduler((msDelayTime: number, msLoopTime?: number) => instantiationService.createInstance(AccessibilityProgressSignalScheduler, msDelayTime, msLoopTime));

		// Initialize viewport classification before building layout classes
		const initialDimension = getClientArea(this.parent);
		this.layoutPolicy.update(initialDimension.width, initialDimension.height);

		// Apply initial part visibility from layout policy (phone hides sidebar, etc.)
		const visibilityDefaults = this.layoutPolicy.getPartVisibilityDefaults();
		this.partVisibility.sidebar = visibilityDefaults.sidebar;
		this.partVisibility.auxiliaryBar = visibilityDefaults.auxiliaryBar;
		this.partVisibility.panel = visibilityDefaults.panel;
		this.partVisibility.chatBar = visibilityDefaults.chatBar;
		this.partVisibility.editor = visibilityDefaults.editor;

		// State specific classes
		const platformClass = isWindows ? 'windows' : isLinux ? 'linux' : 'mac';
		const workbenchClasses = coalesce([
			'monaco-workbench',
			'agent-sessions-workbench',
			LayoutClasses.SHELL_GRADIENT_BACKGROUND,
			platformClass,
			isWeb ? 'web' : undefined,
			isChrome ? 'chromium' : isFirefox ? 'firefox' : isSafari ? 'safari' : undefined,
			...this.getLayoutClasses(),
			...(this.options?.extraClasses ? this.options.extraClasses : [])
		]);

		this.mainContainer.classList.add(...workbenchClasses);

		// Apply font aliasing
		this.updateFontAliasing(undefined, configurationService);

		// Warm up font cache information before building up too many dom elements
		this.restoreFontInfo(storageService, configurationService);

		// Create Parts (editor starts hidden and is shown when an editor opens)
		for (const { id, role, classes } of [
			{ id: Parts.TITLEBAR_PART, role: 'none', classes: ['titlebar'] },
			{ id: Parts.SIDEBAR_PART, role: 'none', classes: ['sidebar', 'left'] },
			{ id: Parts.AUXILIARYBAR_PART, role: 'none', classes: ['auxiliarybar', 'basepanel', 'right'] },
			{ id: Parts.CHATBAR_PART, role: 'main', classes: ['chatbar', 'basepanel', 'right'] },
			{ id: Parts.PANEL_PART, role: 'none', classes: ['panel', 'basepanel', positionToString(this.getPanelPosition())] },
		]) {
			const partContainer = this.createPartContainer(id, role, classes);

			mark(`code/willCreatePart/${id}`);
			this.getPart(id).create(partContainer);
			mark(`code/didCreatePart/${id}`);
		}

		// Create Editor Part (hidden by default)
		this.createEditorPart();

		// Notification Handlers
		this.createNotificationsHandlers(instantiationService, notificationService, configurationService);

		// Add Workbench to DOM
		this.parent.appendChild(this.mainContainer);
	}

	private createMobileTitlebar(): void {
		this.mobileTopBarDisposables.clear();
		const mobileTitlebar = this.mobileTopBarDisposables.add(this.instantiationService.createInstance(MobileTitlebarPart, this.mainContainer));
		this.mobileTopBarElement = mobileTitlebar.element;

		// Hamburger: toggle sidebar drawer overlay
		this.mobileTopBarDisposables.add(mobileTitlebar.onDidClickHamburger(() => {
			this.toggleMobileSidebarDrawer();
		}));

		// New session: open new chat view
		this.mobileTopBarDisposables.add(mobileTitlebar.onDidClickNewSession(() => {
			this.sessionsManagementService.openNewSessionView();
		}));
	}

	private toggleMobileSidebarDrawer(): void {
		const isOpen = this.partVisibility.sidebar;
		if (isOpen) {
			this.closeMobileSidebarDrawer();
		} else {
			this.openMobileSidebarDrawer();
		}
	}

	private openMobileSidebarDrawer(): void {
		// Push a history entry so the Android back button dismisses the drawer.
		// Must come before setSideBarHidden(false) so layoutMobileSidebar() sees
		// the drawer state.
		if (!this.mobileNavStack.has('sidebar')) {
			this.mobileNavStack.push('sidebar');
		}

		// Show sidebar in grid — the actual drawer dimensions are applied by
		// layoutMobileSidebar() from within layout(), which uses the full
		// viewport width below the mobile top bar on phone. The toggle button
		// in the top bar remains visible and is used to close the drawer.
		this.setSideBarHidden(false);
	}

	private closeMobileSidebarDrawer(): void {
		// Hide sidebar in grid
		this.setSideBarHidden(true);

		// Sync the navigation stack with the browser history: if there is a
		// pending 'sidebar' entry (UI-initiated close), rewind history without
		// firing onDidPop. If we're being called from the back-button path
		// (onDidPop already fired), this is a no-op.
		if (this.mobileNavStack.has('sidebar')) {
			this.mobileNavStack.popSilently('sidebar');
		}
	}

	private createNotificationsHandlers(
		instantiationService: IInstantiationService,
		notificationService: NotificationService,
		configurationService: IConfigurationService
	): void {
		// Instantiate Notification components
		const notificationsCenter = this._register(instantiationService.createInstance(NotificationsCenter, this.mainContainer, notificationService.model));
		const notificationsToasts = this._register(instantiationService.createInstance(NotificationsToasts, this.mainContainer, notificationService.model));
		this._register(instantiationService.createInstance(NotificationsAlerts, notificationService.model));
		const notificationsStatus = this._register(instantiationService.createInstance(NotificationsStatus, notificationService.model));

		// Visibility
		this._register(notificationsCenter.onDidChangeVisibility(() => {
			notificationsStatus.update(notificationsCenter.isVisible, notificationsToasts.isVisible);
			notificationsToasts.update(notificationsCenter.isVisible);
		}));

		this._register(notificationsToasts.onDidChangeVisibility(() => {
			notificationsStatus.update(notificationsCenter.isVisible, notificationsToasts.isVisible);
		}));

		// Register Commands
		registerNotificationCommands(notificationsCenter, notificationsToasts, notificationService.model);

		// Register notification accessible view
		AccessibleViewRegistry.register(new NotificationAccessibleView());

		// The shared notification controllers apply a top-right inline offset based on the
		// default workbench custom titlebar height. The sessions workbench has its own
		// fixed chrome, so re-apply the sessions-specific top-right offset after they run.
		this.registerSessionsNotificationOffsets(configurationService, notificationsCenter, notificationsToasts);

		// Register with Layout
		this.registerNotifications({
			onDidChangeNotificationsVisibility: Event.map(
				Event.any(notificationsToasts.onDidChangeVisibility, notificationsCenter.onDidChangeVisibility),
				() => notificationsToasts.isVisible || notificationsCenter.isVisible
			)
		});
	}

	private registerSessionsNotificationOffsets(
		configurationService: IConfigurationService,
		notificationsCenter: NotificationsCenter,
		notificationsToasts: NotificationsToasts
	): void {
		const applySessionsNotificationOffsets = () => {
			const position = getNotificationsPosition(configurationService);
			const notificationsCenterContainer = this.getWorkbenchChildByClassName('notifications-center');
			const notificationsToastsContainer = this.getWorkbenchChildByClassName('notifications-toasts');

			if (position === NotificationsPosition.TOP_RIGHT) {
				notificationsCenterContainer?.style.setProperty('top', '40px');
				notificationsToastsContainer?.style.setProperty('top', '40px');
			}
		};

		this._register(this.onDidLayoutMainContainer(() => applySessionsNotificationOffsets()));
		this._register(notificationsCenter.onDidChangeVisibility(() => applySessionsNotificationOffsets()));
		this._register(notificationsToasts.onDidChangeVisibility(() => applySessionsNotificationOffsets()));
		this._register(configurationService.onDidChangeConfiguration(e => {
			if (e.affectsConfiguration(NotificationsSettings.NOTIFICATIONS_POSITION)) {
				applySessionsNotificationOffsets();
			}
		}));
	}

	private getWorkbenchChildByClassName(className: string): HTMLElement | undefined {
		for (const child of this.mainContainer.children) {
			if (isHTMLElement(child) && child.classList.contains(className)) {
				return child;
			}
		}

		return undefined;
	}

	private createPartContainer(id: string, role: string, classes: string[]): HTMLElement {
		const part = document.createElement('div');
		part.classList.add('part', ...classes);
		part.id = id;
		part.setAttribute('role', role);
		return part;
	}

	private createEditorPart(): void {
		const editorPartContainer = document.createElement('div');
		editorPartContainer.classList.add('part', 'editor');
		editorPartContainer.id = Parts.EDITOR_PART;
		editorPartContainer.setAttribute('role', 'main');

		mark('code/willCreatePart/workbench.parts.editor');
		this.getPart(Parts.EDITOR_PART).create(editorPartContainer, { restorePreviousState: false });
		mark('code/didCreatePart/workbench.parts.editor');

		this.mainContainer.appendChild(editorPartContainer);
	}

	private restore(lifecycleService: ILifecycleService): void {
		// Update perf marks
		mark('code/didStartWorkbench');
		performance.measure('perf: workbench create & restore', 'code/didLoadWorkbenchMain', 'code/didStartWorkbench');

		// Restore parts (open default view containers)
		this.restoreParts();

		// Set lifecycle phase to `Restored`
		lifecycleService.phase = LifecyclePhase.Restored;

		// Mark as restored
		this.setRestored();

		// Set lifecycle phase to `Eventually` after a short delay and when idle (min 2.5sec, max 5sec)
		const eventuallyPhaseScheduler = this._register(new RunOnceScheduler(() => {
			this._register(runWhenWindowIdle(mainWindow, () => lifecycleService.phase = LifecyclePhase.Eventually, 2500));
		}, 2500));
		eventuallyPhaseScheduler.schedule();
	}

	private restoreParts(): void {
		// Open default view containers for each visible part
		const partsToRestore: { location: ViewContainerLocation; visible: boolean }[] = [
			{ location: ViewContainerLocation.Sidebar, visible: this.partVisibility.sidebar },
			{ location: ViewContainerLocation.Panel, visible: this.partVisibility.panel },
			{ location: ViewContainerLocation.AuxiliaryBar, visible: this.partVisibility.auxiliaryBar },
			{ location: ViewContainerLocation.ChatBar, visible: this.partVisibility.chatBar },
		];

		for (const { location, visible } of partsToRestore) {
			if (visible) {
				const defaultViewContainer = this.viewDescriptorService.getDefaultViewContainer(location);
				if (defaultViewContainer) {
					this.paneCompositeService.openPaneComposite(defaultViewContainer.id, location);
				}
			}
		}
	}

	//#endregion

	//#region Initialization

	initLayout(accessor: ServicesAccessor): void {
		// Services - accessing these triggers their instantiation
		// which creates and registers the parts
		this.editorGroupService = accessor.get(IEditorGroupsService);
		this.editorService = accessor.get(IEditorService);
		this.paneCompositeService = accessor.get(IPaneCompositePartService);
		this.viewDescriptorService = accessor.get(IViewDescriptorService);
		this.sessionsManagementService = accessor.get(ISessionsManagementService);
		this.instantiationService = accessor.get(IInstantiationService);
		accessor.get(ITitleService);

		// Register layout listeners
		this.registerLayoutListeners();

		// Editor opens should only affect the main editor part when
		// they actually target one of the main editor groups. Modal
		// opens stay neutral.
		this._register(this.editorService.onWillOpenEditor(e => {
			const targetsMainEditorPart = this.editorGroupService.mainPart.groups.some(group => group.id === e.groupId);
			if (!targetsMainEditorPart) {
				return;
			}

			if (!this.partVisibility.editor) {
				this.setEditorHidden(false);
			}
		}));

		// Hide editor part when last editor closes
		this._register(this.editorService.onDidCloseEditor(() => {
			if (this.partVisibility.editor && this.areAllGroupsEmpty()) {
				this.setEditorHidden(true);
			}
		}));

		// Initialize layout state (must be done before createWorkbenchLayout)
		this._mainContainerDimension = getClientArea(this.parent, new Dimension(800, 600));
		this.layoutPolicy.update(this._mainContainerDimension.width, this._mainContainerDimension.height);

		// Update part visibility based on final viewport classification
		const visDefaults = this.layoutPolicy.getPartVisibilityDefaults();
		this.partVisibility.sidebar = visDefaults.sidebar;
		this.partVisibility.auxiliaryBar = visDefaults.auxiliaryBar;
		this.partVisibility.panel = visDefaults.panel;
		this.partVisibility.chatBar = visDefaults.chatBar;
		this.partVisibility.editor = visDefaults.editor;
	}

	private areAllGroupsEmpty(): boolean {
		for (const group of this.editorGroupService.groups) {
			if (!group.isEmpty) {
				return false;
			}
		}
		return true;
	}

	private registerLayoutListeners(): void {
		// Fullscreen changes
		this._register(onDidChangeFullscreen(windowId => {
			if (windowId === getWindowId(mainWindow)) {
				this.mainWindowFullscreen = isFullscreen(mainWindow);
				this.updateFullscreenClass();
				this.layout();
			}
		}));

		// Window resize — needed for device emulation and mobile viewport changes
		const onWindowResize = () => this.layout();
		mainWindow.addEventListener('resize', onWindowResize);
		this._register({ dispose: () => mainWindow.removeEventListener('resize', onWindowResize) });
	}

	private updateFullscreenClass(): void {
		if (this.mainWindowFullscreen) {
			this.mainContainer.classList.add(LayoutClasses.FULLSCREEN);
		} else {
			this.mainContainer.classList.remove(LayoutClasses.FULLSCREEN);
		}
	}

	//#endregion

	//#region Workbench Layout Creation

	createWorkbenchLayout(): void {
		const titleBar = this.getPart(Parts.TITLEBAR_PART);
		const editorPart = this.getPart(Parts.EDITOR_PART);
		const panelPart = this.getPart(Parts.PANEL_PART);
		const auxiliaryBarPart = this.getPart(Parts.AUXILIARYBAR_PART);
		const sideBar = this.getPart(Parts.SIDEBAR_PART);
		const chatBarPart = this.getPart(Parts.CHATBAR_PART);

		// View references for parts in the grid
		this.titleBarPartView = titleBar;
		this.sideBarPartView = sideBar;
		this.panelPartView = panelPart;
		this.auxiliaryBarPartView = auxiliaryBarPart;
		this.chatBarPartView = chatBarPart;
		this.editorPartView = editorPart;

		const viewMap: { [key: string]: ISerializableView } = {
			[Parts.TITLEBAR_PART]: this.titleBarPartView,
			[Parts.PANEL_PART]: this.panelPartView,
			[Parts.SIDEBAR_PART]: this.sideBarPartView,
			[Parts.AUXILIARYBAR_PART]: this.auxiliaryBarPartView,
			[Parts.CHATBAR_PART]: this.chatBarPartView,
			[Parts.EDITOR_PART]: this.editorPartView
		};

		const fromJSON = ({ type }: { type: string }) => viewMap[type];
		const workbenchGrid = SerializableGrid.deserialize(
			this.createGridDescriptor(),
			{ fromJSON },
			{ proportionalLayout: false }
		);

		this.mainContainer.prepend(workbenchGrid.element);
		this.mainContainer.setAttribute('role', 'application');
		this.workbenchGrid = workbenchGrid;
		this.workbenchGrid.edgeSnapping = this.mainWindowFullscreen;

		// Listen for part visibility changes (for parts in grid)
		for (const part of [titleBar, panelPart, sideBar, auxiliaryBarPart, chatBarPart, editorPart]) {
			this._register(part.onDidVisibilityChange(visible => {
				if (part === sideBar) {
					this.setSideBarHidden(!visible);
				} else if (part === panelPart) {
					this.setPanelHidden(!visible);
				} else if (part === auxiliaryBarPart) {
					this.setAuxiliaryBarHidden(!visible);
				} else if (part === chatBarPart) {
					this.setChatBarHidden(!visible);
				} else if (part === editorPart) {
					this.setEditorHidden(!visible);
				}

				this._onDidChangePartVisibility.fire({ partId: part.getId(), visible });
				this.handleContainerDidLayout(this.mainContainer, this._mainContainerDimension);
			}));
		}

		// Wire up mobile nav stack: back-button pops close the corresponding part
		this._register(this.mobileNavStack.onDidPop(layer => {
			switch (layer) {
				case 'sidebar':
					this.closeMobileSidebarDrawer();
					break;
				case 'panel':
					this.setPanelHidden(true);
					break;
				case 'auxbar':
					this.setAuxiliaryBarHidden(true);
					break;
				case 'editor':
					// Editor modal close is handled by the editor service
					break;
			}
		}));
	}

	createWorkbenchManagement(_instantiationService: IInstantiationService): void {
		// No floating toolbars in this layout
	}

	/**
	 * Creates the grid descriptor for the Agent Sessions layout.
	 *
	 * Structure (horizontal orientation):
	 * - Sidebar (left, spans full height from top to bottom)
	 * - Right section (vertical):
	 *   - Titlebar (top of right section)
	 *   - Top right (horizontal): Chat Bar | Editor | Auxiliary Bar
	 *   - Panel (below chat, editor, and auxiliary bar)
	 */
	private createGridDescriptor(): ISerializedGrid {
		const { width, height } = this._mainContainerDimension;

		return this.createDesktopGridDescriptor(width, height);
	}

	/**
	 * Standard multi-part layout for all viewport classes.
	 * On phone, the titlebar is hidden via CSS and a MobileTitlebarPart
	 * is prepended before the grid. Sidebar/panel/auxbar are hidden
	 * in the grid via partVisibility defaults.
	 */
	private createDesktopGridDescriptor(width: number, height: number): ISerializedGrid {

		// Default sizes from layout policy
		const sizes = this.layoutPolicy.getPartSizes(width, height);
		// For hidden parts, still provide a reasonable cached size for when they're shown later
		const sideBarSize = this.partVisibility.sidebar ? sizes.sideBarSize : Math.max(sizes.sideBarSize, 250);
		const auxiliaryBarSize = this.partVisibility.auxiliaryBar ? sizes.auxiliaryBarSize : Math.max(sizes.auxiliaryBarSize, 300);
		const panelSize = this.partVisibility.panel ? sizes.panelSize : Math.max(sizes.panelSize, 250);
		const editorSize = 600;
		const titleBarHeight = this.titleBarPartView?.minimumHeight ?? 30;

		// Calculate right section width — when sidebar is hidden it takes no space
		const effectiveSideBarWidth = this.partVisibility.sidebar ? sideBarSize : 0;
		const rightSectionWidth = Math.max(0, width - effectiveSideBarWidth);
		const effectiveAuxBarWidth = this.partVisibility.auxiliaryBar ? auxiliaryBarSize : 0;
		const effectiveEditorWidth = this.partVisibility.editor ? editorSize : 0;
		const chatBarWidth = Math.max(0, rightSectionWidth - effectiveAuxBarWidth - effectiveEditorWidth);

		const contentHeight = Math.max(0, height - titleBarHeight);
		const topRightHeight = Math.max(0, contentHeight - panelSize);

		const isPhone = this.layoutPolicy.viewportClass.get() === 'phone';

		const titleBarNode: ISerializedLeafNode = {
			type: 'leaf',
			data: { type: Parts.TITLEBAR_PART },
			size: titleBarHeight,
			visible: !isPhone
		};

		const sideBarNode: ISerializedLeafNode = {
			type: 'leaf',
			data: { type: Parts.SIDEBAR_PART },
			size: sideBarSize,
			visible: this.partVisibility.sidebar
		};

		const auxiliaryBarNode: ISerializedLeafNode = {
			type: 'leaf',
			data: { type: Parts.AUXILIARYBAR_PART },
			size: auxiliaryBarSize,
			visible: this.partVisibility.auxiliaryBar
		};

		const chatBarNode: ISerializedLeafNode = {
			type: 'leaf',
			data: { type: Parts.CHATBAR_PART },
			size: chatBarWidth,
			visible: this.partVisibility.chatBar
		};

		const editorNode: ISerializedLeafNode = {
			type: 'leaf',
			data: { type: Parts.EDITOR_PART },
			size: editorSize,
			visible: this.partVisibility.editor
		};

		const panelNode: ISerializedLeafNode = {
			type: 'leaf',
			data: { type: Parts.PANEL_PART },
			size: panelSize,
			visible: this.partVisibility.panel
		};

		// Top right section: Chat Bar | Editor | Auxiliary Bar (horizontal)
		const topRightSection: ISerializedNode = {
			type: 'branch',
			data: [chatBarNode, editorNode, auxiliaryBarNode],
			size: topRightHeight
		};

		// Right section: Top Right | Panel (vertical)
		const rightSection: ISerializedNode = {
			type: 'branch',
			data: [topRightSection, panelNode],
			size: rightSectionWidth
		};

		// Content section: Sidebar | Right section (horizontal)
		const contentSection: ISerializedNode = {
			type: 'branch',
			data: [sideBarNode, rightSection],
			size: contentHeight
		};

		const result: ISerializedGrid = {
			root: {
				type: 'branch',
				size: width,
				data: [
					titleBarNode,
					contentSection
				]
			},
			orientation: Orientation.VERTICAL,
			width,
			height
		};

		return result;
	}

	//#endregion

	//#region Layout Methods

	private _previousViewportClass: string | undefined;

	layout(): void {
		this._mainContainerDimension = getClientArea(
			this.mainWindowFullscreen ? mainWindow.document.body : this.parent
		);

		// Update viewport classification and toggle mobile CSS classes
		const previousClass = this._previousViewportClass;
		this.layoutPolicy.update(this._mainContainerDimension.width, this._mainContainerDimension.height);
		const currentClass = this.layoutPolicy.viewportClass.get();
		this.mainContainer.classList.toggle(LayoutClasses.PHONE_LAYOUT, currentClass === 'phone');

		// When viewport class changes at runtime (e.g., device emulation toggle),
		// update part visibility and create/destroy mobile components
		if (previousClass !== undefined && previousClass !== currentClass) {
			if (currentClass === 'phone' && !this.mobileTopBarElement) {
				this.createMobileTitlebar();
				// Hide titlebar in grid on phone (replaced by MobileTitlebarPart)
				this.workbenchGrid.setViewVisible(this.titleBarPartView, false);
				// On phone, only chat is visible — hide everything else first
				const defaults = this.layoutPolicy.getPartVisibilityDefaults();
				if (this.partVisibility.sidebar !== defaults.sidebar) {
					this.setSideBarHidden(!defaults.sidebar);
				}
				if (this.partVisibility.auxiliaryBar !== defaults.auxiliaryBar) {
					this.setAuxiliaryBarHidden(!defaults.auxiliaryBar);
				}
				if (this.partVisibility.panel !== defaults.panel) {
					this.setPanelHidden(!defaults.panel);
				}
			} else if (currentClass !== 'phone' && this.mobileTopBarElement) {
				// Remove mobile components when leaving phone layout
				this.mobileTopBarDisposables.clear();
				this.mobileTopBarElement = undefined;
				// Restore titlebar in grid
				this.workbenchGrid.setViewVisible(this.titleBarPartView, true);
				// Restore desktop part visibility
				const defaults = this.layoutPolicy.getPartVisibilityDefaults();
				if (this.partVisibility.sidebar !== defaults.sidebar) {
					this.setSideBarHidden(!defaults.sidebar);
				}
				if (this.partVisibility.chatBar !== defaults.chatBar) {
					this.setChatBarHidden(!defaults.chatBar);
				}
				if (this.partVisibility.auxiliaryBar !== defaults.auxiliaryBar) {
					this.setAuxiliaryBarHidden(!defaults.auxiliaryBar);
				}
				if (this.partVisibility.panel !== defaults.panel) {
					this.setPanelHidden(!defaults.panel);
				}
			}

			// Re-run updateStyles() on pane composite parts so that
			// mobile Part subclasses can re-apply or clear card-chrome
			// inline styles based on the new `.phone-layout` class.
			for (const partId of [Parts.CHATBAR_PART, Parts.SIDEBAR_PART, Parts.AUXILIARYBAR_PART, Parts.PANEL_PART]) {
				this.parts.get(partId)?.updateStyles();
			}
		}
		this._previousViewportClass = currentClass;

		this.logService.trace(`Workbench#layout, height: ${this._mainContainerDimension.height}, width: ${this._mainContainerDimension.width}`);

		size(this.mainContainer, this._mainContainerDimension.width, this._mainContainerDimension.height);

		// On phone, subtract the mobile top bar height from the grid
		const mobileTopBarHeight = this.mobileTopBarElement?.offsetHeight ?? 0;
		const gridHeight = this._mainContainerDimension.height - mobileTopBarHeight;

		// Layout the grid widget
		this.workbenchGrid.layout(this._mainContainerDimension.width, gridHeight);
		this.layoutMobileSidebar();

		// Emit as event
		this.handleContainerDidLayout(this.mainContainer, this._mainContainerDimension);
	}

	private layoutMobileSidebar(): void {
		const sidebarContainer = this.getContainer(mainWindow, Parts.SIDEBAR_PART);
		const sidebarPart = this.getPart(Parts.SIDEBAR_PART);
		if (!sidebarContainer) {
			return;
		}

		// On phone the sidebar renders as a full-viewport overlay drawer.
		// Geometry is fully expressed in CSS — see
		// `mobileChatShell.css` (split-view-view fills the grid) and
		// `sidebarPart.css` (drawer animation, z-index). We avoid setting
		// inline position/size styles here because writing them after the
		// grid has already laid out and painted the sidebar causes a
		// visible one-frame snap on toggle.
		const isPhone = this.layoutPolicy.viewportClass.get() === 'phone';
		if (!isPhone || !this.partVisibility.sidebar) {
			sidebarContainer.classList.remove('mobile-overlay-sidebar');
			return;
		}

		sidebarContainer.classList.add('mobile-overlay-sidebar');

		// Re-layout the sidebar Part with the drawer's content dimensions
		// so its internal composite/list sizing matches the CSS-positioned
		// drawer (grid area minus the mobile top bar).
		const topBarHeight = this.mobileTopBarElement?.offsetHeight ?? 48;
		const drawerWidth = this._mainContainerDimension.width;
		const drawerHeight = Math.max(0, this._mainContainerDimension.height - topBarHeight);
		sidebarPart.layout(drawerWidth, drawerHeight, topBarHeight, 0);
	}

	private handleContainerDidLayout(container: HTMLElement, dimension: IDimension): void {
		this._onDidLayoutContainer.fire({ container, dimension });
		if (container === this.mainContainer) {
			this._onDidLayoutMainContainer.fire(dimension);
		}
		if (container === this.activeContainer) {
			this._onDidLayoutActiveContainer.fire(dimension);
		}
	}

	getLayoutClasses(): string[] {
		return coalesce([
			!this.partVisibility.sidebar ? LayoutClasses.SIDEBAR_HIDDEN : undefined,
			!this.partVisibility.editor ? LayoutClasses.MAIN_EDITOR_AREA_HIDDEN : undefined,
			!this.partVisibility.panel ? LayoutClasses.PANEL_HIDDEN : undefined,
			!this.partVisibility.auxiliaryBar ? LayoutClasses.AUXILIARYBAR_HIDDEN : undefined,
			!this.partVisibility.chatBar ? LayoutClasses.CHATBAR_HIDDEN : undefined,
			LayoutClasses.STATUSBAR_HIDDEN, // agents window never has a status bar
			this.mainWindowFullscreen ? LayoutClasses.FULLSCREEN : undefined,
			this.layoutPolicy.viewportClass.get() === 'phone' ? LayoutClasses.PHONE_LAYOUT : undefined,
		]);
	}

	//#endregion

	//#region Part Management

	registerPart(part: Part): IDisposable {
		const id = part.getId();
		this.parts.set(id, part);
		return toDisposable(() => this.parts.delete(id));
	}

	getPart(key: Parts): Part {
		const part = this.parts.get(key);
		if (!part) {
			throw new Error(`Unknown part ${key}`);
		}
		return part;
	}

	hasFocus(part: Parts): boolean {
		const container = this.getContainer(mainWindow, part);
		if (!container) {
			return false;
		}

		const activeElement = getActiveElement();
		if (!activeElement) {
			return false;
		}

		return isAncestorUsingFlowTo(activeElement, container);
	}

	focusPart(part: MULTI_WINDOW_PARTS, targetWindow: Window): void;
	focusPart(part: SINGLE_WINDOW_PARTS): void;
	focusPart(part: Parts, targetWindow: Window = mainWindow): void {
		switch (part) {
			case Parts.EDITOR_PART:
				this.editorGroupService.activeGroup.focus();
				break;
			case Parts.PANEL_PART:
				this.paneCompositeService.getActivePaneComposite(ViewContainerLocation.Panel)?.focus();
				break;
			case Parts.SIDEBAR_PART:
				this.paneCompositeService.getActivePaneComposite(ViewContainerLocation.Sidebar)?.focus();
				break;
			case Parts.AUXILIARYBAR_PART:
				this.paneCompositeService.getActivePaneComposite(ViewContainerLocation.AuxiliaryBar)?.focus();
				break;
			case Parts.CHATBAR_PART:
				this.paneCompositeService.getActivePaneComposite(ViewContainerLocation.ChatBar)?.focus();
				break;
			default: {
				const container = this.getContainer(targetWindow, part);
				container?.focus();
			}
		}
	}

	focus(): void {
		this.focusPart(Parts.CHATBAR_PART);
	}

	//#endregion

	//#region Container Methods

	getContainer(targetWindow: Window): HTMLElement;
	getContainer(targetWindow: Window, part: Parts): HTMLElement | undefined;
	getContainer(targetWindow: Window, part?: Parts): HTMLElement | undefined {
		if (typeof part === 'undefined') {
			return this.getContainerFromDocument(targetWindow.document);
		}

		if (targetWindow === mainWindow) {
			return this.parts.get(part)?.getContainer();
		}

		// For auxiliary windows, only editor part is supported
		if (part === Parts.EDITOR_PART) {
			const container = this.getContainerFromDocument(targetWindow.document);
			const partCandidate = this.editorGroupService.getPart(container);
			if (partCandidate instanceof Part) {
				return partCandidate.getContainer();
			}
		}

		return undefined;
	}

	whenContainerStylesLoaded(_window: CodeWindow): Promise<void> | undefined {
		return undefined;
	}

	//#endregion

	//#region Part Visibility

	isActivityBarHidden(): boolean {
		return true; // No activity bar in this layout
	}

	isVisible(part: SINGLE_WINDOW_PARTS): boolean;
	isVisible(part: MULTI_WINDOW_PARTS, targetWindow: Window): boolean;
	isVisible(part: Parts, targetWindow?: Window): boolean {
		switch (part) {
			case Parts.TITLEBAR_PART:
				// On phone layout the grid titlebar is hidden (replaced by MobileTitlebarPart)
				return this.layoutPolicy.viewportClass.get() !== 'phone';
			case Parts.SIDEBAR_PART:
				return this.partVisibility.sidebar;
			case Parts.AUXILIARYBAR_PART:
				return this.partVisibility.auxiliaryBar;
			case Parts.EDITOR_PART:
				return this.partVisibility.editor;
			case Parts.PANEL_PART:
				return this.partVisibility.panel;
			case Parts.CHATBAR_PART:
				return this.partVisibility.chatBar;
			case Parts.ACTIVITYBAR_PART:
			case Parts.STATUSBAR_PART:
			case Parts.BANNER_PART:
			default:
				return false;
		}
	}

	setPartHidden(hidden: boolean, part: Parts): void {
		switch (part) {
			case Parts.SIDEBAR_PART:
				this.setSideBarHidden(hidden);
				break;
			case Parts.AUXILIARYBAR_PART:
				this.setAuxiliaryBarHidden(hidden);
				break;
			case Parts.EDITOR_PART:
				this.setEditorHidden(hidden);
				break;
			case Parts.PANEL_PART:
				this.setPanelHidden(hidden);
				break;
			case Parts.CHATBAR_PART:
				this.setChatBarHidden(hidden);
				break;
		}
	}

	private setSideBarHidden(hidden: boolean): void {
		if (this.partVisibility.sidebar === !hidden) {
			return;
		}

		this.partVisibility.sidebar = !hidden;
		this.mainContainer.classList.toggle(LayoutClasses.SIDEBAR_HIDDEN, hidden);

		// Propagate to grid
		this.workbenchGrid.setViewVisible(
			this.sideBarPartView,
			!hidden,
		);

		// If sidebar becomes hidden, also hide the current active pane composite
		if (hidden && this.paneCompositeService.getActivePaneComposite(ViewContainerLocation.Sidebar)) {
			this.paneCompositeService.hideActivePaneComposite(ViewContainerLocation.Sidebar);
		}

		// If sidebar becomes visible, show last active Viewlet or default viewlet
		if (!hidden && !this.paneCompositeService.getActivePaneComposite(ViewContainerLocation.Sidebar)) {
			const viewletToOpen = this.paneCompositeService.getLastActivePaneCompositeId(ViewContainerLocation.Sidebar) ??
				this.viewDescriptorService.getDefaultViewContainer(ViewContainerLocation.Sidebar)?.id;
			if (viewletToOpen) {
				this.paneCompositeService.openPaneComposite(viewletToOpen, ViewContainerLocation.Sidebar);
			}
		}

		this.layoutMobileSidebar();
	}

	private setAuxiliaryBarHidden(hidden: boolean): void {
		if (this.partVisibility.auxiliaryBar === !hidden) {
			return;
		}

		this.partVisibility.auxiliaryBar = !hidden;
		this.mainContainer.classList.toggle(LayoutClasses.AUXILIARYBAR_HIDDEN, hidden);

		// Propagate to grid
		this.workbenchGrid.setViewVisible(
			this.auxiliaryBarPartView,
			!hidden,
		);

		// If auxiliary bar becomes hidden, also hide the current active pane composite
		if (hidden && this.paneCompositeService.getActivePaneComposite(ViewContainerLocation.AuxiliaryBar)) {
			this.paneCompositeService.hideActivePaneComposite(ViewContainerLocation.AuxiliaryBar);
		}

		// If auxiliary bar becomes visible, show last active pane composite or default
		if (!hidden && !this.paneCompositeService.getActivePaneComposite(ViewContainerLocation.AuxiliaryBar)) {
			const paneCompositeToOpen = this.paneCompositeService.getLastActivePaneCompositeId(ViewContainerLocation.AuxiliaryBar) ??
				this.viewDescriptorService.getDefaultViewContainer(ViewContainerLocation.AuxiliaryBar)?.id;
			if (paneCompositeToOpen) {
				this.paneCompositeService.openPaneComposite(paneCompositeToOpen, ViewContainerLocation.AuxiliaryBar);
			}
		}
	}

	private setEditorHidden(hidden: boolean): void {
		if (this.partVisibility.editor === !hidden) {
			return;
		}

		// If hiding the editor while maximized
		if (hidden && this._editorMaximized) {
			this.setEditorMaximized(false);
		}

		this.partVisibility.editor = !hidden;
		this.mainContainer.classList.toggle(LayoutClasses.MAIN_EDITOR_AREA_HIDDEN, hidden);

		if (this.editorPartView) {
			this.workbenchGrid.setViewVisible(this.editorPartView, !hidden);
		}
	}

	private setPanelHidden(hidden: boolean): void {
		if (this.partVisibility.panel === !hidden) {
			return;
		}

		// If hiding and the panel is maximized, exit maximized state first
		if (hidden && this.workbenchGrid.hasMaximizedView()) {
			this.workbenchGrid.exitMaximizedView();
		}

		const panelHadFocus = !hidden || this.hasFocus(Parts.PANEL_PART);

		this.partVisibility.panel = !hidden;
		this.mainContainer.classList.toggle(LayoutClasses.PANEL_HIDDEN, hidden);

		// Propagate to grid
		this.workbenchGrid.setViewVisible(
			this.panelPartView,
			!hidden,
		);

		// If panel becomes hidden, also hide the current active pane composite
		if (hidden && this.paneCompositeService.getActivePaneComposite(ViewContainerLocation.Panel)) {
			this.paneCompositeService.hideActivePaneComposite(ViewContainerLocation.Panel);

			// Focus the chat bar when hiding the panel if it had focus
			if (panelHadFocus) {
				this.focusPart(Parts.CHATBAR_PART);
			}
		}

		// If panel becomes visible, show last active panel or default and focus it
		if (!hidden) {
			if (!this.paneCompositeService.getActivePaneComposite(ViewContainerLocation.Panel)) {
				const panelToOpen = this.paneCompositeService.getLastActivePaneCompositeId(ViewContainerLocation.Panel) ??
					this.viewDescriptorService.getDefaultViewContainer(ViewContainerLocation.Panel)?.id;
				if (panelToOpen) {
					this.paneCompositeService.openPaneComposite(panelToOpen, ViewContainerLocation.Panel);
				}
			}

			this.focusPart(Parts.PANEL_PART);
		}
	}

	private setChatBarHidden(hidden: boolean): void {
		if (this.partVisibility.chatBar === !hidden) {
			return;
		}

		this.partVisibility.chatBar = !hidden;
		this.mainContainer.classList.toggle(LayoutClasses.CHATBAR_HIDDEN, hidden);

		// Propagate to grid
		this.workbenchGrid.setViewVisible(this.chatBarPartView, !hidden);

		// If chat bar becomes hidden, also hide the current active pane composite
		if (hidden && this.paneCompositeService.getActivePaneComposite(ViewContainerLocation.ChatBar)) {
			this.paneCompositeService.hideActivePaneComposite(ViewContainerLocation.ChatBar);
		}

		// If chat bar becomes visible, show last active pane composite or default
		if (!hidden && !this.paneCompositeService.getActivePaneComposite(ViewContainerLocation.ChatBar)) {
			const paneCompositeToOpen = this.paneCompositeService.getLastActivePaneCompositeId(ViewContainerLocation.ChatBar) ??
				this.viewDescriptorService.getDefaultViewContainer(ViewContainerLocation.ChatBar)?.id;
			if (paneCompositeToOpen) {
				this.paneCompositeService.openPaneComposite(paneCompositeToOpen, ViewContainerLocation.ChatBar);
			}
		}
	}

	//#endregion

	//#region Position Methods (Fixed - Not Configurable)

	getSideBarPosition(): Position {
		return Position.LEFT; // Always left in this layout
	}

	getPanelPosition(): Position {
		return Position.BOTTOM; // Always bottom in this layout
	}

	setPanelPosition(_position: Position): void {
		// No-op: Panel position is fixed in this layout
	}

	getPanelAlignment(): PanelAlignment {
		return 'justify'; // Full width panel
	}

	setPanelAlignment(_alignment: PanelAlignment): void {
		// No-op: Panel alignment is fixed in this layout
	}

	//#endregion

	//#region Size Methods

	getSize(part: Parts): IViewSize {
		const view = this.getPartView(part);
		if (!view) {
			return { width: 0, height: 0 };
		}
		return this.workbenchGrid.getViewSize(view);
	}

	setSize(part: Parts, size: IViewSize): void {
		const view = this.getPartView(part);
		if (view) {
			this.workbenchGrid.resizeView(view, size);
		}
	}

	resizePart(part: Parts, sizeChangeWidth: number, sizeChangeHeight: number): void {
		const view = this.getPartView(part);
		if (!view) {
			return;
		}

		const currentSize = this.workbenchGrid.getViewSize(view);
		this.workbenchGrid.resizeView(view, {
			width: currentSize.width + sizeChangeWidth,
			height: currentSize.height + sizeChangeHeight
		});
	}

	private getPartView(part: Parts): ISerializableView | undefined {
		switch (part) {
			case Parts.TITLEBAR_PART:
				return this.titleBarPartView;
			case Parts.SIDEBAR_PART:
				return this.sideBarPartView;
			case Parts.AUXILIARYBAR_PART:
				return this.auxiliaryBarPartView;
			case Parts.EDITOR_PART:
				return this.editorPartView;
			case Parts.PANEL_PART:
				return this.panelPartView;
			case Parts.CHATBAR_PART:
				return this.chatBarPartView;
			default:
				return undefined;
		}
	}

	getMaximumEditorDimensions(_container: HTMLElement): IDimension {
		// Return the available space for editor (excluding other parts)
		const sidebarWidth = this.partVisibility.sidebar ? this.workbenchGrid.getViewSize(this.sideBarPartView).width : 0;
		const auxiliaryBarWidth = this.partVisibility.auxiliaryBar ? this.workbenchGrid.getViewSize(this.auxiliaryBarPartView).width : 0;
		const panelHeight = this.partVisibility.panel ? this.workbenchGrid.getViewSize(this.panelPartView).height : 0;
		const titleBarHeight = this.workbenchGrid.getViewSize(this.titleBarPartView).height;

		return new Dimension(
			this._mainContainerDimension.width - sidebarWidth - auxiliaryBarWidth,
			this._mainContainerDimension.height - titleBarHeight - panelHeight
		);
	}

	//#endregion

	//#region Unsupported Features (No-ops)

	toggleMaximizedPanel(): void {
		if (!this.workbenchGrid) {
			return;
		}

		if (this.isPanelMaximized()) {
			this.workbenchGrid.exitMaximizedView();
		} else {
			this.workbenchGrid.maximizeView(this.panelPartView, [this.titleBarPartView, this.sideBarPartView]);
		}
	}

	isPanelMaximized(): boolean {
		if (!this.workbenchGrid) {
			return false;
		}

		return this.workbenchGrid.isViewMaximized(this.panelPartView);
	}

	toggleMaximizedAuxiliaryBar(): void {
		// No-op: Maximize not supported in this layout
	}

	setAuxiliaryBarMaximized(_maximized: boolean): boolean {
		return false; // Maximize not supported
	}

	isAuxiliaryBarMaximized(): boolean {
		return false; // Maximize not supported
	}

	isEditorMaximized(): boolean {
		return this._editorMaximized;
	}

	setEditorMaximized(maximized: boolean): void {
		if (maximized === this._editorMaximized) {
			return;
		}

		if (maximized) {
			// Save current visibility state
			this._editorLastNonMaximizedVisibility = {
				sidebar: this.partVisibility.sidebar,
				auxiliaryBar: this.partVisibility.auxiliaryBar,
				editor: this.partVisibility.editor,
				panel: this.partVisibility.panel,
				chatBar: this.partVisibility.chatBar,
			};

			// Ensure editor is visible
			if (!this.partVisibility.editor) {
				this.setEditorHidden(false);
			}

			// Hide all other content parts
			if (this.partVisibility.sidebar) {
				this.setSideBarHidden(true);
			}
			if (this.partVisibility.chatBar) {
				this.setChatBarHidden(true);
			}

			this._editorMaximized = true;
		} else {
			const state = this._editorLastNonMaximizedVisibility;

			// Restore previous visibility state
			this.setSideBarHidden(!state?.sidebar);
			this.setChatBarHidden(!state?.chatBar);

			this._editorMaximized = false;
		}

		this._onDidChangeEditorMaximized.fire();
	}

	toggleZenMode(): void {
		// No-op: Zen mode not supported in this layout
	}

	toggleMenuBar(): void {
		// No-op: Menu bar toggle not supported in this layout
	}

	isMainEditorLayoutCentered(): boolean {
		return false; // Centered layout not supported
	}

	centerMainEditorLayout(_active: boolean): void {
		// No-op: Centered layout not supported in this layout
	}

	hasMainWindowBorder(): boolean {
		return false;
	}

	getMainWindowBorderRadius(): string | undefined {
		return undefined;
	}

	//#endregion

	//#region Window Maximized State

	isWindowMaximized(targetWindow: Window): boolean {
		return this.maximized.has(getWindowId(targetWindow));
	}

	updateWindowMaximizedState(targetWindow: Window, maximized: boolean): void {
		const windowId = getWindowId(targetWindow);
		if (maximized) {
			this.maximized.add(windowId);
			if (targetWindow === mainWindow) {
				this.mainContainer.classList.add(LayoutClasses.MAXIMIZED);
			}
		} else {
			this.maximized.delete(windowId);
			if (targetWindow === mainWindow) {
				this.mainContainer.classList.remove(LayoutClasses.MAXIMIZED);
			}
		}

		this._onDidChangeWindowMaximized.fire({ windowId, maximized });
	}

	//#endregion

	//#region Neighbor Parts

	getVisibleNeighborPart(part: Parts, direction: Direction): Parts | undefined {
		if (!this.workbenchGrid) {
			return undefined;
		}

		const view = this.getPartView(part);
		if (!view) {
			return undefined;
		}

		const neighbor = this.workbenchGrid.getNeighborViews(view, direction, false);
		if (neighbor.length === 0) {
			return undefined;
		}

		const neighborView = neighbor[0];

		if (neighborView === this.titleBarPartView) {
			return Parts.TITLEBAR_PART;
		}
		if (neighborView === this.sideBarPartView) {
			return Parts.SIDEBAR_PART;
		}
		if (neighborView === this.auxiliaryBarPartView) {
			return Parts.AUXILIARYBAR_PART;
		}
		if (neighborView === this.editorPartView) {
			return Parts.EDITOR_PART;
		}
		if (neighborView === this.panelPartView) {
			return Parts.PANEL_PART;
		}
		if (neighborView === this.chatBarPartView) {
			return Parts.CHATBAR_PART;
		}

		return undefined;
	}

	//#endregion

	//#region Restore

	isRestored(): boolean {
		return this.restored;
	}

	setRestored(): void {
		this.restored = true;
		this.restoredPromise.complete();
	}

	//#endregion

	//#region Notifications Registration

	registerNotifications(delegate: { onDidChangeNotificationsVisibility: Event<boolean> }): void {
		this._register(delegate.onDidChangeNotificationsVisibility(visible => this._onDidChangeNotificationsVisibility.fire(visible)));
	}

	//#endregion
}