@theia/core 1.70.0-next.7 → 1.70.0-next.71

package/src/browser/about-dialog.tsx

@@ -21,7 +21,7 @@ import { ReactDialog } from './dialogs/react-dialog';
 import { ApplicationServer, ApplicationInfo, ExtensionInfo } from '../common/application-protocol';
 import { Message } from './widgets/widget';
 import { FrontendApplicationConfigProvider } from './frontend-application-config-provider';
-import { DEFAULT_SUPPORTED_API_VERSION } from '@theia/application-package/lib/api';
+import { DEFAULT_SUPPORTED_API_VERSION, DEFAULT_SUPPORTED_MONACO_VERSION } from '@theia/application-package/lib/api';
 import { WindowService } from './window/window-service';
 import { Key, KeyCode } from './keys';
 import { nls } from '../common/nls';
@@ -73,6 +73,7 @@ export class AboutDialog extends ReactDialog<void> {
         const versionLabel = nls.localizeByDefault('Version');
         const defaultApiLabel = nls.localize('theia/core/about/defaultApi', 'Default {0} API', 'VS Code');
         const compatibilityLabel = nls.localize('theia/core/about/compatibility', '{0} Compatibility', 'VS Code');
+        const monacoLabel = nls.localize('theia/core/about/monacoEditor', 'Monaco Editor Version');
 
         return <>
             <h3>{detailsLabel}</h3>
@@ -88,6 +89,7 @@ export class AboutDialog extends ReactDialog<void> {
                         {compatibilityLabel}
                     </a>
                 </p>
+                <p>{`${monacoLabel}: ${DEFAULT_SUPPORTED_MONACO_VERSION}`}</p>
             </div>
         </>;
     }

package/src/browser/common-frontend-contribution.ts

@@ -159,7 +159,6 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
     protected readonly undoRedoHandlerService: UndoRedoHandlerService;
 
     protected pinnedKey: ContextKey<boolean>;
-    protected inputFocus: ContextKey<boolean>;
 
     async configure(app: FrontendApplication): Promise<void> {
         // FIXME: This request blocks valuable startup time (~200ms).
@@ -174,9 +173,9 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
         this.contextKeyService.createKey<boolean>('isMac', OS.type() === OS.Type.OSX);
         this.contextKeyService.createKey<boolean>('isWindows', OS.type() === OS.Type.Windows);
         this.contextKeyService.createKey<boolean>('isWeb', !this.isElectron());
-        this.inputFocus = this.contextKeyService.createKey<boolean>('inputFocus', false);
-        this.updateInputFocus();
-        browser.onDomEvent(document, 'focusin', () => this.updateInputFocus());
+        // Note: the 'inputFocus' context key is tracked by Monaco's ContextKeyService
+        // which sets it for <input>, <textarea>, and elements with EditContext (Monaco editors).
+        // We no longer track it separately to avoid race conditions between two focusin listeners.
 
         this.pinnedKey = this.contextKeyService.createKey<boolean>('activeEditorIsPinned', false);
         this.updatePinnedKey();
@@ -234,15 +233,6 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
         }
     }
 
-    protected updateInputFocus(): void {
-        const activeElement = document.activeElement;
-        if (activeElement) {
-            const isInput = activeElement.tagName?.toLowerCase() === 'input'
-                || activeElement.tagName?.toLowerCase() === 'textarea';
-            this.inputFocus.set(isInput);
-        }
-    }
-
     protected updatePinnedKey(): void {
         const activeTab = this.shell.findTabBar();
         const pinningTarget = activeTab && this.shell.findTitle(activeTab);
@@ -498,7 +488,18 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
         commandRegistry.registerCommand(CommonCommands.CUT, {
             execute: () => {
                 if (supportCut) {
-                    document.execCommand('cut');
+                    const active = document.activeElement;
+                    if (environment.electron.is() && (active instanceof HTMLInputElement || active instanceof HTMLTextAreaElement)) {
+                        const start = active.selectionStart ?? 0;
+                        const end = active.selectionEnd ?? 0;
+                        const selectedText = active.value.substring(start, end);
+                        if (selectedText) {
+                            this.clipboardService.writeText(selectedText);
+                            document.execCommand('insertText', false, '');
+                        }
+                    } else {
+                        document.execCommand('cut');
+                    }
                 } else {
                     this.messageService.warn(nls.localize('theia/core/cutWarn', "Please use the browser's cut command or shortcut."));
                 }
@@ -507,16 +508,34 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
         commandRegistry.registerCommand(CommonCommands.COPY, {
             execute: () => {
                 if (supportCopy) {
-                    document.execCommand('copy');
+                    const active = document.activeElement;
+                    if (environment.electron.is() && (active instanceof HTMLInputElement || active instanceof HTMLTextAreaElement)) {
+                        const start = active.selectionStart ?? 0;
+                        const end = active.selectionEnd ?? 0;
+                        const selectedText = active.value.substring(start, end);
+                        if (selectedText) {
+                            this.clipboardService.writeText(selectedText);
+                        }
+                    } else {
+                        document.execCommand('copy');
+                    }
                 } else {
                     this.messageService.warn(nls.localize('theia/core/copyWarn', "Please use the browser's copy command or shortcut."));
                 }
             }
         });
         commandRegistry.registerCommand(CommonCommands.PASTE, {
-            execute: () => {
+            execute: async () => {
                 if (supportPaste) {
-                    document.execCommand('paste');
+                    const active = document.activeElement;
+                    if (environment.electron.is() && (active instanceof HTMLInputElement || active instanceof HTMLTextAreaElement)) {
+                        const text = await this.clipboardService.readText();
+                        if (text) {
+                            document.execCommand('insertText', false, text);
+                        }
+                    } else {
+                        document.execCommand('paste');
+                    }
                 } else {
                     this.messageService.warn(nls.localize('theia/core/pasteWarn', "Please use the browser's paste command or shortcut."));
                 }

package/src/browser/frontend-application-module.ts

@@ -123,7 +123,7 @@ import { DockPanel, RendererHost } from './widgets';
 import { TooltipService, TooltipServiceImpl } from './tooltip-service';
 import { BackendRequestService, RequestService, REQUEST_SERVICE_PATH } from '@theia/request';
 import { bindFrontendStopwatch, bindBackendStopwatch } from './performance';
-import { SaveableService } from './saveable-service';
+import { SaveableService, SaveErrorChecker } from './saveable-service';
 import { SecondaryWindowHandler } from './secondary-window-handler';
 import { UserWorkingDirectoryProvider } from './user-working-directory-provider';
 import { WindowTitleService } from './window/window-title-service';
@@ -461,6 +461,7 @@ export const frontendApplicationModule = new ContainerModule((bind, _unbind, _is
 
     bind(SaveableService).toSelf().inSingletonScope();
     bind(FrontendApplicationContribution).toService(SaveableService);
+    bindRootContributionProvider(bind, SaveErrorChecker);
 
     bind(UserWorkingDirectoryProvider).toSelf().inSingletonScope();
     bind(FrontendApplicationContribution).toService(UserWorkingDirectoryProvider);

package/src/browser/hover-service.ts

@@ -260,9 +260,11 @@ export class HoverService {
      * For interactive hovers, the hover remains visible to allow interaction with its elements.
      */
     protected listenForMouseClick(request: HoverRequest): void {
-        const handleMouseDown = (_e: MouseEvent) => {
-            const isInteractive = request.interactive;
-            if (!isInteractive) {
+        const handleMouseDown = (e: MouseEvent) => {
+            if (this.hoverHost.contains(e.target as Node)) {
+                return;
+            }
+            if (!request.interactive) {
                 this.cancelHover();
             }
         };

package/src/browser/markdown-rendering/markdown-renderer.ts

@@ -54,7 +54,7 @@ export interface MarkdownRenderOptions extends FormattedTextRenderOptions {
 /** Use this directly if you aren't worried about circular dependencies in the Shell */
 export const MarkdownRenderer = Symbol('MarkdownRenderer');
 export interface MarkdownRenderer {
-    render(markdown: MarkdownString | undefined, options?: MarkdownRenderOptions): MarkdownRenderResult;
+    render(markdown: MarkdownString, options?: MarkdownRenderOptions, outElement?: HTMLElement): MarkdownRenderResult;
 }
 
 /** Use this to avoid circular dependencies in the Shell */

package/src/browser/menu/browser-menu-plugin.ts

@@ -345,7 +345,15 @@ export class DynamicMenuWidget extends MenuWidget {
                     const enabled = node.isEnabled(nodePath, ...(this.args || []));
                     const toggled = node.isToggled ? !!node.isToggled(nodePath, ...(this.args || [])) : false;
                     phCommandRegistry.addCommand(id, {
-                        execute: () => { node.run(nodePath, ...(this.args || [])); },
+                        execute: () => {
+                            // Restore focus to the previously focused element before executing
+                            // the command so that focus-dependent commands like clipboard
+                            // operations target the correct element instead of the menu.
+                            if (this.previousFocusedElement) {
+                                this.previousFocusedElement.focus({ preventScroll: true });
+                            }
+                            node.run(nodePath, ...(this.args || []));
+                        },
                         isEnabled: () => enabled,
                         isToggled: () => toggled,
                         isVisible: () => true,

package/src/browser/quick-input/quick-input-service.spec.ts

@@ -23,11 +23,14 @@ describe('quick-input-service', () => {
 
     describe('#findMatches', () => {
 
-        it('should return the proper highlights when matches are found', () => {
+        it('should return a single contiguous range for substring matches', () => {
             expect(findMatches('abc', 'a')).deep.equal([{ start: 0, end: 1 }]);
-            expect(findMatches('abc', 'ab')).deep.equal([{ start: 0, end: 1 }, { start: 1, end: 2 }]);
+            expect(findMatches('abc', 'ab')).deep.equal([{ start: 0, end: 2 }]);
+            expect(findMatches('abc', 'abc')).deep.equal([{ start: 0, end: 3 }]);
+        });
+
+        it('should return per-character ranges for fuzzy-only matches', () => {
             expect(findMatches('abc', 'ac')).deep.equal([{ start: 0, end: 1 }, { start: 2, end: 3 }]);
-            expect(findMatches('abc', 'abc')).deep.equal([{ start: 0, end: 1 }, { start: 1, end: 2 }, { start: 2, end: 3 }]);
         });
 
         it('should fail when out of order', () => {
@@ -67,9 +70,7 @@ describe('quick-input-service', () => {
                 label: 'abc',
                 highlights: {
                     label: [
-                        { start: 0, end: 1 },
-                        { start: 1, end: 2 },
-                        { start: 2, end: 3 }
+                        { start: 0, end: 3 }
                     ]
                 }
             };
@@ -152,9 +153,7 @@ describe('quick-input-service', () => {
                 label: 'abc',
                 highlights: {
                     label: [
-                        { start: 0, end: 1 },
-                        { start: 1, end: 2 },
-                        { start: 2, end: 3 }
+                        { start: 0, end: 3 }
                     ]
                 }
             };
@@ -171,6 +170,56 @@ describe('quick-input-service', () => {
             expect(filterItems(items, 'yyy')).deep.equal([]);
         });
 
+        it('should rank substring matches before fuzzy-only matches', () => {
+            const testItems: QuickPickItem[] = [
+                { label: 'reformatting' },
+                { label: 'fontSize' },
+                { label: 'fontFamily' },
+            ];
+            const result = filterItems(testItems, 'font').filter(QuickPickItem.is);
+            expect(result).length(2);
+            expect(result[0].label).equal('fontSize');
+            expect(result[1].label).equal('fontFamily');
+        });
+
+        it('should rank prefix matches before other substring matches', () => {
+            const testItems: QuickPickItem[] = [
+                { label: 'setFont' },
+                { label: 'fontSize' },
+                { label: 'fontFamily' },
+            ];
+            const result = filterItems(testItems, 'font').filter(QuickPickItem.is);
+            expect(result).length(3);
+            expect(result[0].label).equal('fontSize');
+            expect(result[1].label).equal('fontFamily');
+            expect(result[2].label).equal('setFont');
+        });
+
+        it('should treat segmented prefix matches as prefix matches', () => {
+            const testItems: QuickPickItem[] = [
+                { label: 'backend-workspace-service.ts' },
+                { label: 'workspace-backend-service.ts' },
+            ];
+            const result = filterItems(testItems, 'works-ser').filter(QuickPickItem.is);
+            expect(result).length(2);
+            expect(result[0].label).equal('workspace-backend-service.ts');
+            expect(result[1].label).equal('backend-workspace-service.ts');
+        });
+
+        it('should drop separators when their group has no matches', () => {
+            const testItems = [
+                { type: 'separator' as const, label: 'Group A' },
+                { label: 'fontSize' },
+                { type: 'separator' as const, label: 'Group B' },
+                { label: 'xyz' },
+            ];
+            const result = filterItems(testItems, 'font');
+            // Group B's only item "xyz" doesn't match, so Group B separator is dropped
+            expect(result).length(2);
+            expect(result[0]).to.have.property('type', 'separator');
+            expect(result[1]).to.have.property('label', 'fontSize');
+        });
+
     });
 
 });

package/src/browser/saveable-service.ts

@@ -15,8 +15,8 @@
  ********************************************************************************/
 
 import type { ApplicationShell } from './shell';
-import { injectable } from 'inversify';
-import { UNTITLED_SCHEME, URI, Disposable, DisposableCollection, Emitter, Event } from '../common';
+import { inject, injectable, named } from 'inversify';
+import { ContributionProvider, UNTITLED_SCHEME, URI, Disposable, DisposableCollection, Emitter, Event } from '../common';
 import { Navigatable, NavigatableWidget } from './navigatable-types';
 import { AutoSaveMode, Saveable, SaveableSource, SaveableWidget, SaveOptions, SaveReason, setDirty, close, PostCreationSaveableWidget, ShouldSaveDialog } from './saveable';
 import { waitForClosed, Widget } from './widgets';
@@ -24,16 +24,40 @@ import { FrontendApplicationContribution } from './frontend-application-contribu
 import { FrontendApplication } from './frontend-application';
 import throttle = require('lodash.throttle');
 
+export const SaveErrorChecker = Symbol('SaveErrorChecker');
+
+/**
+ * Contribution point for checking whether a given URI has errors.
+ * When `files.autoSaveWhenNoErrors` is enabled, auto-save will be suppressed
+ * for files where any registered checker reports errors.
+ */
+export interface SaveErrorChecker {
+    /**
+     * Returns `true` if the given URI has errors that should prevent auto-save.
+     */
+    hasErrors(uri: URI): boolean;
+    /**
+     * Event fired when the error state may have changed (e.g. diagnostics updated).
+     * The SaveableService listens to this to re-evaluate auto-save for dirty widgets.
+     */
+    onDidErrorStateChange: Event<void>;
+}
+
 @injectable()
 export class SaveableService implements FrontendApplicationContribution {
 
+    @inject(ContributionProvider) @named(SaveErrorChecker)
+    protected readonly errorCheckers: ContributionProvider<SaveErrorChecker>;
+
     protected saveThrottles = new Map<Widget, AutoSaveThrottle>();
     protected saveMode: AutoSaveMode = 'off';
     protected saveDelay = 1000;
+    protected saveWhenNoErrors = false;
     protected shell: ApplicationShell;
 
     protected readonly onDidAutoSaveChangeEmitter = new Emitter<AutoSaveMode>();
     protected readonly onDidAutoSaveDelayChangeEmitter = new Emitter<number>();
+    protected readonly onDidAutoSaveConditionsChangeEmitter = new Emitter<void>();
 
     get onDidAutoSaveChange(): Event<AutoSaveMode> {
         return this.onDidAutoSaveChangeEmitter.event;
@@ -43,6 +67,10 @@ export class SaveableService implements FrontendApplicationContribution {
         return this.onDidAutoSaveDelayChangeEmitter.event;
     }
 
+    get onDidAutoSaveConditionsChange(): Event<void> {
+        return this.onDidAutoSaveConditionsChangeEmitter.event;
+    }
+
     get autoSave(): AutoSaveMode {
         return this.saveMode;
     }
@@ -59,8 +87,22 @@ export class SaveableService implements FrontendApplicationContribution {
         this.updateAutoSaveDelay(value);
     }
 
+    get autoSaveWhenNoErrors(): boolean {
+        return this.saveWhenNoErrors;
+    }
+
+    set autoSaveWhenNoErrors(value: boolean) {
+        this.saveWhenNoErrors = value;
+    }
+
     onDidInitializeLayout(app: FrontendApplication): void {
         this.shell = app.shell;
+        // Listen to error state changes from all registered error checkers
+        for (const checker of this.errorCheckers.getContributions()) {
+            checker.onDidErrorStateChange(() => {
+                this.onDidAutoSaveConditionsChangeEmitter.fire();
+            });
+        }
         // Register restored editors first
         for (const widget of this.shell.widgets) {
             const saveable = Saveable.get(widget);
@@ -165,9 +207,16 @@ export class SaveableService implements FrontendApplicationContribution {
         if (uri?.scheme === UNTITLED_SCHEME) {
             // Never auto-save untitled documents
             return false;
-        } else {
-            return saveable.autosaveable !== false && saveable.dirty;
         }
+        if (saveable.autosaveable === false || !saveable.dirty) {
+            return false;
+        }
+        if (this.saveWhenNoErrors && uri) {
+            if (this.errorCheckers.getContributions().some(checker => checker.hasErrors(uri))) {
+                return false;
+            }
+        }
+        return true;
     }
 
     protected applySaveableWidget(widget: Widget, saveable: Saveable): void {
@@ -314,6 +363,9 @@ export class AutoSaveThrottle implements Disposable {
             }),
             saveService.onDidAutoSaveDelayChange(() => {
                 this.throttledSave(true);
+            }),
+            saveService.onDidAutoSaveConditionsChange(() => {
+                this.throttledSave();
             })
         );
     }

package/src/browser/style/hover-service.css

@@ -29,6 +29,7 @@
   border: 1px solid var(--theia-editorHoverWidget-border);
   padding: var(--theia-ui-padding);
   max-width: var(--theia-hover-max-width);
+  user-select: text;
 }
 
 /* overwrite potentially different default user agent styles */

package/src/browser/style/index.css

@@ -78,13 +78,13 @@
 
 html,
 body {
+    overflow: hidden;
     height: 100vh;
 }
 
 body {
     margin: 0;
     padding: 0;
-    overflow: hidden;
     font-family: var(--theia-ui-font-family);
     background: var(--theia-editor-background);
     color: var(--theia-foreground);

package/src/browser/tree/fuzzy-search.ts

@@ -14,123 +14,5 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import * as fuzzy from 'fuzzy';
-import { injectable } from 'inversify';
-
-@injectable()
-export class FuzzySearch {
-
-    private static readonly PRE = '\x01';
-    private static readonly POST = '\x02';
-
-    /**
-     * Filters the input and returns with an array that contains all items that match the pattern.
-     */
-    async filter<T>(input: FuzzySearch.Input<T>): Promise<FuzzySearch.Match<T>[]> {
-        return fuzzy.filter(input.pattern, input.items.slice(), {
-            pre: FuzzySearch.PRE,
-            post: FuzzySearch.POST,
-            extract: input.transform
-        }).sort(this.sortResults.bind(this)).map(this.mapResult.bind(this));
-    }
-
-    protected sortResults<T>(left: fuzzy.FilterResult<T>, right: fuzzy.FilterResult<T>): number {
-        return left.index - right.index;
-    }
-
-    protected mapResult<T>(result: fuzzy.FilterResult<T>): FuzzySearch.Match<T> {
-        return {
-            item: result.original,
-            ranges: this.mapRanges(result.string)
-        };
-    }
-
-    protected mapRanges(input: string): ReadonlyArray<FuzzySearch.Range> {
-        const copy = input.split('').filter(s => s !== '');
-        const ranges: FuzzySearch.Range[] = [];
-        const validate = (pre: number, post: number) => {
-            if (preIndex > postIndex || (preIndex === -1) !== (postIndex === -1)) {
-                throw new Error(`Error when trying to map ranges. Escaped string was: '${input}. [${[...input].join('|')}]'`);
-            }
-        };
-        let preIndex = copy.indexOf(FuzzySearch.PRE);
-        let postIndex = copy.indexOf(FuzzySearch.POST);
-        validate(preIndex, postIndex);
-        while (preIndex !== -1 && postIndex !== -1) {
-            ranges.push({
-                offset: preIndex,
-                length: postIndex - preIndex - 1
-            });
-            copy.splice(postIndex, 1);
-            copy.splice(preIndex, 1);
-            preIndex = copy.indexOf(FuzzySearch.PRE);
-            postIndex = copy.indexOf(FuzzySearch.POST);
-        }
-        if (ranges.length === 0) {
-            throw new Error(`Unexpected zero ranges for match-string: ${input}.`);
-        }
-        return ranges;
-    }
-
-}
-
-/**
- * Fuzzy searcher.
- */
-export namespace FuzzySearch {
-
-    /**
-     * A range representing the match region.
-     */
-    export interface Range {
-
-        /**
-         * The zero based offset of the match region.
-         */
-        readonly offset: number;
-
-        /**
-         * The length of the match region.
-         */
-        readonly length: number;
-    }
-
-    /**
-     * A fuzzy search match.
-     */
-    export interface Match<T> {
-
-        /**
-         * The original item.
-         */
-        readonly item: T;
-
-        /**
-         * An array of ranges representing the match regions.
-         */
-        readonly ranges: ReadonlyArray<Range>;
-    }
-
-    /**
-     * The fuzzy search input.
-     */
-    export interface Input<T> {
-
-        /**
-         * The pattern to match.
-         */
-        readonly pattern: string;
-
-        /**
-         * The items to filter based on the `pattern`.
-         */
-        readonly items: ReadonlyArray<T>;
-
-        /**
-         * Function that extracts the string from the inputs which will be used to evaluate the fuzzy matching filter.
-         */
-        readonly transform: (item: T) => string;
-
-    }
-
-}
+// Re-export from common location for backward compatibility.
+export { FuzzySearch } from '../../common/fuzzy-search';

package/src/browser/tree/tree-view-welcome-widget.tsx

@@ -257,8 +257,7 @@ export class TreeViewWelcomeWidget extends TreeWidget {
         event.stopPropagation();
 
         if (value.startsWith('command:')) {
-            const command = value.replace('command:', '');
-            this.commands.executeCommand(command);
+            open(this.openerService, new URI(value));
         } else if (value.startsWith('file:')) {
             const uri = value.replace('file:', '');
             open(this.openerService, new URI(CodeUri.file(uri).toString()));

package/src/browser/widgets/select-component.tsx

@@ -60,6 +60,7 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
     protected mountedListeners: Map<string, EventListenerOrEventListenerObject> = new Map();
     protected optimalWidth = 0;
     protected optimalHeight = 0;
+    protected resizeObserver: ResizeObserver | undefined;
 
     constructor(props: SelectComponentProps) {
         super(props);
@@ -148,14 +149,16 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
         return optimal + 20; // Just to be safe, add another 20 pixels here
     }
 
-    protected attachListeners(): void {
-        const hide = (event: MouseEvent) => {
+   protected attachListeners(): void {
+        const hide = (event: Event) => {
             if (!this.dropdownRef.current?.contains(event.target as Node)) {
                 this.hide();
             }
         };
+        const hideOnResize = () => this.hide();
         this.mountedListeners.set('scroll', hide);
         this.mountedListeners.set('wheel', hide);
+        this.mountedListeners.set('resize', hideOnResize);
 
         let parent = this.fieldRef.current?.parentElement;
         while (parent) {
@@ -170,9 +173,43 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
         for (const [key, listener] of this.mountedListeners.entries()) {
             window.addEventListener(key, listener);
         }
+
+        // Catch Lumino sash drags globally - observe the closest lm-Widget panel
+        const fieldEl = this.fieldRef.current;
+        const resizablePanel = fieldEl?.closest('.lm-Widget') ?? fieldEl?.parentElement;
+
+        if (resizablePanel && typeof ResizeObserver !== 'undefined') {
+            let lastWidth = 0;
+            let lastHeight = 0;
+            let isFirstFire = true;
+
+            this.resizeObserver = new ResizeObserver(entries => {
+                for (const entry of entries) {
+                    const { width, height } = entry.contentRect;
+
+                    // Ignore the initial automatic fire when the observer attaches
+                    if (isFirstFire) {
+                        lastWidth = width;
+                        lastHeight = height;
+                        isFirstFire = false;
+                        continue;
+                    }
+
+                    // Only hide if the panel dimensions actually changed by more than 2 pixels
+                    if (this.state.dimensions && (Math.abs(width - lastWidth) > 2 || Math.abs(height - lastHeight) > 2)) {
+                        this.hide();
+                    }
+
+                    lastWidth = width;
+                    lastHeight = height;
+                }
+            });
+            this.resizeObserver.observe(resizablePanel);
+        }
     }
 
     override componentWillUnmount(): void {
+        this.resizeObserver?.disconnect();
         if (this.mountedListeners.size > 0) {
             const eventListener = this.mountedListeners.get('scroll')!;
             let parent = this.fieldRef.current?.parentElement;

package/src/browser/window/default-window-service.ts

@@ -53,8 +53,13 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
         return undefined;
     }
 
-    openNewDefaultWindow(): void {
+    async openNewDefaultWindow(): Promise<number> {
         this.openNewWindow(`#${DEFAULT_WINDOW_HASH}`);
+        return -1;
+    }
+
+    closeWindow(windowId: number): void {
+        // No-op in browser-only mode
     }
 
     focus(): void {

package/src/browser/window/test/mock-window-service.ts

@@ -20,7 +20,8 @@ import { WindowService } from '../window-service';
 @injectable()
 export class MockWindowService implements WindowService {
     openNewWindow(): undefined { return undefined; }
-    openNewDefaultWindow(): void { }
+    async openNewDefaultWindow(): Promise<number> { return -1; }
+    closeWindow(): void { }
     focus(): void { }
     reload(): void { }
     isSafeToShutDown(): Promise<boolean> { return Promise.resolve(true); }