@theia/core 1.75.0-next.3 → 1.75.0-next.34

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

@@ -101,5 +101,48 @@ export class MarkdownRendererImpl implements MarkdownRenderer {
                 return `<i class="${codicon(chunk.name)} ${chunk.animation ? `fa-${chunk.animation}` : ''} icon-inline"></i>`;
             }).join('');
         };
+
+        // Support VS Code's `![alt](src|width=W,height=H)` image sizing syntax, which markdown-it
+        // would otherwise fold into the `src` attribute, yielding a broken image.
+        const renderImage = this.markdownIt.renderer.rules.image;
+        this.markdownIt.renderer.rules.image = (tokens, idx, options, env, self) => {
+            const token = tokens[idx];
+            const srcIndex = token.attrIndex('src');
+            if (srcIndex >= 0 && token.attrs) {
+                const src = token.attrs[srcIndex][1];
+                // markdown-it percent-encodes the link destination, so the separator may have
+                // become `%7C` by the time the token reaches the renderer.
+                const separator = /(?:\||%7c)(?![\s\S]*(?:\||%7c))/i.exec(src);
+                if (separator) {
+                    const dimensions = this.parseImageDimensions(src.substring(separator.index + separator[0].length));
+                    if (dimensions) {
+                        token.attrs[srcIndex][1] = src.substring(0, separator.index);
+                        for (const [name, value] of Object.entries(dimensions)) {
+                            token.attrSet(name, value);
+                        }
+                    }
+                }
+            }
+            return renderImage ? renderImage(tokens, idx, options, env, self) : self.renderToken(tokens, idx, options);
+        };
+    }
+
+    /**
+     * Parses the `width=W,height=H` parameter list of an image's sizing suffix.
+     *
+     * @returns the recognized dimensions, or `undefined` if the suffix is not a well-formed
+     * parameter list — in which case it is left as part of the `src`, since it may be a literal
+     * `|` in the URL.
+     */
+    protected parseImageDimensions(params: string): { width?: string, height?: string } | undefined {
+        const dimensions: { width?: string, height?: string } = {};
+        for (const param of params.split(',')) {
+            const match = /^\s*(width|height)\s*=\s*(\d+)\s*$/.exec(param);
+            if (!match) {
+                return undefined;
+            }
+            dimensions[match[1] as 'width' | 'height'] = match[2];
+        }
+        return Object.keys(dimensions).length > 0 ? dimensions : undefined;
     }
 }

package/src/browser/open-with-service.ts

@@ -14,14 +14,14 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { inject, injectable } from 'inversify';
+import { inject, injectable, named } from 'inversify';
 import { Disposable } from '../common/disposable';
 import { nls } from '../common/nls';
 import { MaybePromise } from '../common/types';
 import { URI } from '../common/uri';
 import { QuickInputService, QuickPickItem, QuickPickItemOrSeparator } from './quick-input';
 import { getDefaultHandler } from './opener-service';
-import { PreferenceService, PreferenceScope } from '../common';
+import { PreferenceService, PreferenceScope, ILogger } from '../common';
 
 export interface OpenWithHandler {
     /**
@@ -74,11 +74,14 @@ export class OpenWithService {
     @inject(PreferenceService)
     protected readonly preferenceService: PreferenceService;
 
+    @inject(ILogger) @named('core:OpenWithService')
+    protected readonly logger: ILogger;
+
     protected readonly handlers: OpenWithHandler[] = [];
 
     registerHandler(handler: OpenWithHandler): Disposable {
         if (this.handlers.some(h => h.id === handler.id)) {
-            console.warn('Duplicate OpenWithHandler registration: ' + handler.id);
+            this.logger.warn('Duplicate OpenWithHandler registration: ' + handler.id);
             return Disposable.NULL;
         }
         this.handlers.push(handler);

package/src/browser/performance/frontend-stopwatch.ts

@@ -14,12 +14,15 @@
 * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 *******************************************************************************/
 
-import { injectable } from 'inversify';
-import { Measurement, MeasurementOptions, Stopwatch } from '../../common';
+import { injectable, inject, named } from 'inversify';
+import { Measurement, MeasurementOptions, Stopwatch, ILogger } from '../../common';
 
 @injectable()
 export class FrontendStopwatch extends Stopwatch {
 
+    @inject(ILogger) @named('core:FrontendStopwatch')
+    protected override readonly logger: ILogger;
+
     constructor() {
         super({
             owner: 'frontend page',
@@ -51,7 +54,7 @@ export class FrontendStopwatch extends Stopwatch {
                 duration = entries[0].duration ?? Number.NaN;
                 startTime = entries[0].startTime ?? Number.NaN;
             } catch (e) {
-                console.warn(e);
+                this.logger.warn(e);
                 duration = Number.NaN;
                 startTime = Number.NaN;
             }

package/src/browser/perspective-service.ts

@@ -196,7 +196,7 @@ export class PerspectiveServiceImpl implements FrontendApplicationContribution,
     @inject(QuickInputService) @optional()
     protected readonly quickInputService: QuickInputService | undefined;
 
-    @inject(ILogger) @named('core:PerspectiveService')
+    @inject(ILogger) @named('core:PerspectiveServiceImpl')
     protected readonly logger: ILogger;
 
     @inject(WidgetAreaResolver)

package/src/browser/preferences/preference-proxy.spec.ts

@@ -28,6 +28,8 @@ import { PreferenceScope } from '../../common/preferences/preference-scope';
 import { FrontendApplicationConfigProvider } from '../frontend-application-config-provider';
 import { PreferenceProxyOptions, PreferenceProxy, PreferenceChangeEvent, createPreferenceProxy } from '../../common/preferences/preference-proxy';
 import { PreferenceProxyFactory } from '../../common/preferences/injectable-preference-proxy';
+import { ILogger } from '../../common/logger';
+import { MockLogger } from '../../common/test/mock-logger';
 
 disableJSDOM();
 
@@ -47,6 +49,7 @@ function createTestContainer(): Container {
     const result = new Container();
     bindPreferenceService(result.bind.bind(result));
     bindMockPreferenceProviders(result.bind.bind(result), result.unbind.bind(result));
+    result.bind(ILogger).to(MockLogger);
     return result;
 }
 

package/src/browser/preferences/preference-service.spec.ts

@@ -28,6 +28,8 @@ import { FrontendApplicationConfigProvider } from '../frontend-application-confi
 import { bindMockPreferenceProviders, MockPreferenceProvider } from './test';
 import { PreferenceChangeEvent, createPreferenceProxy } from '../../common/preferences/preference-proxy';
 import { bindPreferenceService } from '../frontend-application-bindings';
+import { ILogger } from '../../common/logger';
+import { MockLogger } from '../../common/test/mock-logger';
 
 disableJSDOM();
 
@@ -43,6 +45,7 @@ function createTestContainer(): Container {
     const result = new Container();
     bindPreferenceService(result.bind.bind(result));
     bindMockPreferenceProviders(result.bind.bind(result), result.unbind.bind(result));
+    result.bind(ILogger).to(MockLogger);
     return result;
 }
 

package/src/browser/preferences/preference-validation-service.ts

@@ -175,7 +175,7 @@ export class PreferenceValidationService {
             const configuredDefault = this.getDefaultFromSchema(schema);
             return this.validateOneOf(key, configuredDefault, { ...schema, default: undefined });
         }
-        console.log(`While validating ${key}, failed to find a valid value or default value. Using configured value ${value}.`);
+        this.logger.info(`While validating ${key}, failed to find a valid value or default value. Using configured value ${value}.`);
         return value;
     }
 

package/src/browser/saveable-service.ts

@@ -16,7 +16,7 @@
 
 import type { ApplicationShell } from './shell';
 import { inject, injectable, named } from 'inversify';
-import { ContributionProvider, UNTITLED_SCHEME, URI, Disposable, DisposableCollection, Emitter, Event } from '../common';
+import { ContributionProvider, UNTITLED_SCHEME, URI, Disposable, DisposableCollection, Emitter, Event, ILogger } 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';
@@ -53,6 +53,9 @@ export class SaveableService implements FrontendApplicationContribution {
     @inject(WindowFocusService)
     protected readonly windowFocusService: WindowFocusService;
 
+    @inject(ILogger) @named('core:SaveableService')
+    protected readonly logger: ILogger;
+
     protected saveThrottles = new Map<Widget, AutoSaveThrottle>();
     protected saveMode: AutoSaveMode = 'off';
     protected saveDelay = 1000;
@@ -284,7 +287,7 @@ export class SaveableService implements FrontendApplicationContribution {
         }
         const saveable = Saveable.get(widget);
         if (!saveable) {
-            console.warn('Saveable.get returned undefined on a known saveable widget. This is unexpected.');
+            this.logger.warn('Saveable.get returned undefined on a known saveable widget. This is unexpected.');
         }
         // Enter branch if saveable absent since we cannot check autosaveability more definitely.
         if (this.autoSave !== 'off' && (!saveable || this.shouldAutoSave(widget, saveable))) {

package/src/browser/shell/application-shell.spec.ts

@@ -0,0 +1,62 @@
+// *****************************************************************************
+// Copyright (C) 2026 Alec Timison.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { enableJSDOM } from '../test/jsdom';
+const disableJSDOM = enableJSDOM();
+
+import { expect } from 'chai';
+import { Widget } from '@theia/core/shared/@lumino/widgets';
+import * as sinon from 'sinon';
+import { DisposableCollection } from '../../common/disposable';
+import { ApplicationShell } from './application-shell';
+disableJSDOM();
+
+describe('ApplicationShell', () => {
+    let toTearDown: () => void;
+
+    beforeEach(() => {
+        toTearDown = enableJSDOM();
+    });
+
+    afterEach(() => {
+        sinon.restore();
+        toTearDown();
+    });
+
+    it('cancels the previous activation check', () => {
+        const shell = Object.create(ApplicationShell.prototype) as ApplicationShell;
+        Object.assign(shell, {
+            toDisposeOnActivationCheck: new DisposableCollection(),
+            logger: { warn: sinon.stub() }
+        });
+        const assertActivated = (shell as unknown as { assertActivated(widget: Widget): void }).assertActivated.bind(shell);
+        const firstWidget = new Widget();
+        const secondWidget = new Widget();
+        const request = {} as ReturnType<typeof window.setTimeout>;
+        sinon.stub(globalThis, 'setTimeout').returns(request);
+        sinon.stub(window, 'setTimeout').returns(request);
+        const clearTimeout = sinon.stub(window, 'clearTimeout');
+        window.cancelAnimationFrame = sinon.stub();
+
+        assertActivated(firstWidget);
+        assertActivated(secondWidget);
+
+        expect(clearTimeout.callCount).to.equal(1);
+        expect(clearTimeout.firstCall.args[0]).to.equal(request);
+        firstWidget.dispose();
+        secondWidget.dispose();
+    });
+});

package/src/browser/shell/application-shell.ts

@@ -1438,7 +1438,7 @@ export class ApplicationShell extends Widget {
         this.toDisposeOnActivationCheck.push(Disposable.create(() => widget.disposed.disconnect(onDispose)));
 
         let start = 0;
-        const step: FrameRequestCallback = () => {
+        const step = (): void => {
             const activeElement = widget.node.ownerDocument.activeElement;
             if (activeElement && widget.node.contains(activeElement)) {
                 return;
@@ -1449,13 +1449,13 @@ export class ApplicationShell extends Widget {
             }
             const delta = now - start;
             if (delta < this.activationTimeout) {
-                request = setTimeout(step, 0);
+                request = window.setTimeout(step, 0);
             } else {
                 this.logger.warn(`Widget was activated, but did not accept focus after ${this.activationTimeout}ms: ${widget.id}`);
             }
         };
-        let request = setTimeout(step, 0);
-        this.toDisposeOnActivationCheck.push(Disposable.create(() => window.cancelAnimationFrame(request)));
+        let request = window.setTimeout(step, 0);
+        this.toDisposeOnActivationCheck.push(Disposable.create(() => window.clearTimeout(request)));
     }
 
     /**

package/src/browser/shell/shell-layout-restorer.ts

@@ -154,7 +154,8 @@ export class ShellLayoutRestorer implements CommandContribution {
 
     constructor(
         @inject(WidgetManager) protected widgetManager: WidgetManager,
-        @inject(ILogger) protected logger: ILogger,
+        @inject(ILogger) @named('core:ShellLayoutRestorer')
+        protected readonly logger: ILogger,
         @inject(StorageService) protected storageService: StorageService) { }
 
     registerCommands(commands: CommandRegistry): void {
@@ -374,18 +375,18 @@ export class ShellLayoutRestorer implements CommandContribution {
         }
         if (layoutVersion !== applicationShellLayoutVersion) {
             if (layoutVersion < applicationShellLayoutVersion) {
-                console.warn(`Layout version ${layoutVersion} is behind current layout version ${applicationShellLayoutVersion}, trying to migrate...`);
+                this.logger.warn(`Layout version ${layoutVersion} is behind current layout version ${applicationShellLayoutVersion}, trying to migrate...`);
             } else {
-                console.warn(`Layout version ${layoutVersion} is ahead current layout version ${applicationShellLayoutVersion}, trying to load anyway...`);
+                this.logger.warn(`Layout version ${layoutVersion} is ahead current layout version ${applicationShellLayoutVersion}, trying to load anyway...`);
             }
-            console.info(`Please use '${RESET_LAYOUT.label}' command if the layout looks bogus.`);
+            this.logger.info(`Please use '${RESET_LAYOUT.label}' command if the layout looks bogus.`);
         }
 
         const migrations = this.migrations.getContributions()
             .filter(m => m.layoutVersion > layoutVersion && m.layoutVersion <= applicationShellLayoutVersion)
             .sort((m, m2) => m.layoutVersion - m2.layoutVersion);
         if (migrations.length) {
-            console.info(`Found ${migrations.length} migrations from layout version ${layoutVersion} to version ${applicationShellLayoutVersion}, migrating...`);
+            this.logger.info(`Found ${migrations.length} migrations from layout version ${layoutVersion} to version ${applicationShellLayoutVersion}, migrating...`);
         }
 
         const context = { layout, layoutVersion, migrations };

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar-menu-adapters.tsx

@@ -96,8 +96,9 @@ abstract class AbstractToolbarMenuWrapper {
         const icon = this.icon || 'ellipsis';
         const contextMatcher: ContextMatcher = this.contextKeyService;
         const className = `${icon} ${ACTION_ITEM}`;
+        const itemClassName = TabBarToolbar.Styles.TAB_BAR_TOOLBAR_ITEM + ' enabled menu' + (this.isToggled(widget) ? ' toggled' : '');
         if (CompoundMenuNode.is(this.menuNode) && !this.menuNode.isEmpty(this.effectiveMenuPath, this.contextKeyService, widget.node, widget)) {
-            return <div key={this.id} className={TabBarToolbar.Styles.TAB_BAR_TOOLBAR_ITEM + ' enabled menu'}>
+            return <div key={this.id} className={itemClassName}>
                 <div id={this.id} className={className}
                     title={this.tooltip || this.text}
                     onClick={e => this.executeCommand(widget, e)}
@@ -107,7 +108,7 @@ abstract class AbstractToolbarMenuWrapper {
                 </div>
             </div>;
         } else {
-            return <div key={this.id} className={TabBarToolbar.Styles.TAB_BAR_TOOLBAR_ITEM + ' enabled menu'}>
+            return <div key={this.id} className={itemClassName}>
                 <div id={this.id} className={className}
                     title={this.tooltip || this.text}
                     onClick={e => this.executeCommand(widget, e)}

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar-registry.ts

@@ -17,7 +17,7 @@
 import debounce = require('lodash.debounce');
 import { inject, injectable, named } from 'inversify';
 // eslint-disable-next-line max-len
-import { CommandRegistry, ContributionProvider, Disposable, DisposableCollection, Emitter, Event, MenuModelRegistry, MenuPath } from '../../../common';
+import { CommandRegistry, ContributionProvider, Disposable, DisposableCollection, Emitter, Event, MenuModelRegistry, MenuPath, ILogger } from '../../../common';
 import { ContextKeyService } from '../../context-key-service';
 import { FrontendApplicationContribution } from '../../frontend-application-contribution';
 import { Widget } from '../../widgets';
@@ -68,6 +68,9 @@ export class TabBarToolbarRegistry implements FrontendApplicationContribution {
     @inject(ContributionProvider) @named(TabBarToolbarContribution)
     protected readonly contributionProvider: ContributionProvider<TabBarToolbarContribution>;
 
+    @inject(ILogger) @named('core:TabBarToolbarRegistry')
+    protected readonly logger: ILogger;
+
     protected readonly onDidChangeEmitter = new Emitter<void>();
     readonly onDidChange: Event<void> = this.onDidChangeEmitter.event;
     // debounce in order to avoid to fire more than once in the same tick
@@ -223,7 +226,7 @@ export class TabBarToolbarRegistry implements FrontendApplicationContribution {
             this.fireOnDidChange();
             return { dispose: () => this.unregisterMenuDelegate(menuPath) };
         }
-        console.warn('Unable to register menu delegate. Delegate has already been registered', menuPath);
+        this.logger.warn('Unable to register menu delegate. Delegate has already been registered', menuPath);
         return Disposable.NULL;
     }
 

package/src/browser/status-bar/status-bar-view-model.ts

@@ -14,8 +14,8 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable } from 'inversify';
-import { ArrayUtils, Emitter, Event } from '../../common';
+import { injectable, inject, named } from 'inversify';
+import { ArrayUtils, Emitter, Event, ILogger } from '../../common';
 import { StatusBarAlignment, StatusBarEntry, StatusBarViewEntry, StatusBarViewModelEntry } from './status-bar-types';
 
 interface EntryLocation {
@@ -30,6 +30,10 @@ export class StatusBarViewModel {
     protected rightTree = new Array<StatusBarViewModelEntry>();
     protected containerPointers = new Map<string, StatusBarViewModelEntry[]>();
     protected onDidChangeEmitter = new Emitter<void>();
+
+    @inject(ILogger) @named('core:StatusBarViewModel')
+    protected readonly logger: ILogger;
+
     get onDidChange(): Event<void> {
         return this.onDidChangeEmitter.event;
     }
@@ -53,7 +57,7 @@ export class StatusBarViewModel {
     *getChildren(list: StatusBarViewModelEntry[], alignment: StatusBarAlignment, compact?: boolean): IterableIterator<StatusBarViewEntry> {
         for (const item of list) {
             if (item.leftChildren.length || item.rightChildren.length) {
-                console.warn(`Found embedded entries with affinity to ${item.id}. They will inherit alignment and compactness of parent.`);
+                this.logger.warn(`Found embedded entries with affinity to ${item.id}. They will inherit alignment and compactness of parent.`);
             }
             yield* this.getChildren(item.leftChildren, alignment, item.head.affinity?.compact);
             yield { entry: item.head, id: item.id, alignment, compact: compact || item.head.affinity?.compact };

package/src/browser/storage-service.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { inject, injectable, postConstruct } from 'inversify';
+import { inject, injectable, postConstruct, named } from 'inversify';
 import { ILogger } from '../common/logger';
 import { MessageService } from '../common/message-service';
 import { WindowService } from './window/window-service';
@@ -47,7 +47,9 @@ interface LocalStorage {
 export class LocalStorageService implements StorageService {
     private storage: LocalStorage;
 
-    @inject(ILogger) protected logger: ILogger;
+    @inject(ILogger) @named('core:LocalStorageService')
+    protected readonly logger: ILogger;
+
     @inject(MessageService) protected readonly messageService: MessageService;
     @inject(WindowService) protected readonly windowService: WindowService;
 

package/src/browser/tree/tree-consistency.spec.ts

@@ -21,6 +21,10 @@ import { TreeImpl, CompositeTreeNode, TreeNode } from './tree';
 import { TreeModel } from './tree-model';
 import { ExpandableTreeNode } from './tree-expansion';
 import { TreeLabelProvider } from './tree-label-provider';
+import { MockTreeModel } from './test/mock-tree-model';
+import { MockLogger } from '../../common/test/mock-logger';
+import { ILogger } from '../../common';
+import { Deferred, timeout } from '../../common/promise-util';
 
 @injectable()
 class ConsistencyTestTree extends TreeImpl {
@@ -69,6 +73,48 @@ function createConsistencyTestRoot(rootName: string): CompositeTreeNode {
     return root;
 }
 
+/**
+ * A `TreeImpl` whose `resolveChildren` can be stalled or overridden per node id, to
+ * simulate slow child resolution (e.g. a file system request) in tests.
+ */
+@injectable()
+class StallingTestTree extends TreeImpl {
+
+    protected readonly stalled = new Map<string, Deferred<TreeNode[]>>();
+    protected readonly overrides = new Map<string, () => TreeNode[]>();
+
+    /**
+     * Stall the *next* `resolveChildren` for `id` on the returned deferred. Later
+     * resolutions for the same id proceed normally, so the stall cannot leak into
+     * unrelated refreshes (e.g. the cascade of a newly set root).
+     */
+    stallNextResolve(id: string): Deferred<TreeNode[]> {
+        const gate = new Deferred<TreeNode[]>();
+        this.stalled.set(id, gate);
+        return gate;
+    }
+
+    /** Make the *next* `resolveChildren` for `id` return `children()` instead of the current child nodes. */
+    overrideNextResolve(id: string, children: () => TreeNode[]): void {
+        this.overrides.set(id, children);
+    }
+
+    protected override resolveChildren(parent: CompositeTreeNode): Promise<TreeNode[]> {
+        const gate = this.stalled.get(parent.id);
+        if (gate) {
+            this.stalled.delete(parent.id);
+            return gate.promise;
+        }
+        const override = this.overrides.get(parent.id);
+        if (override) {
+            this.overrides.delete(parent.id);
+            return Promise.resolve(override());
+        }
+        return super.resolveChildren(parent);
+    }
+
+}
+
 describe('Tree Consistency', () => {
 
     it('setting different tree roots should finish', async () => {
@@ -102,4 +148,77 @@ describe('Tree Consistency', () => {
         assert.ok(false, 'Resolving does not stop, attempts: ' + tree.resolveCounter);
     });
 
+    describe('stale refreshes', () => {
+
+        let tree: StallingTestTree;
+        let model: TreeModel;
+        let loggedErrors: unknown[][];
+
+        beforeEach(async () => {
+            const container = createTreeTestContainer();
+            container.bind(StallingTestTree).toSelf();
+            container.rebind(TreeImpl).toService(StallingTestTree);
+            tree = container.get(StallingTestTree);
+            model = container.get<TreeModel>(TreeModel);
+            loggedErrors = [];
+            const logger = container.get<MockLogger>(ILogger);
+            logger.error = async (...args: unknown[]) => { loggedErrors.push(args); };
+            model.root = MockTreeModel.HIERARCHICAL_MOCK_ROOT();
+            // let the refresh cascade triggered by setting the root settle
+            await timeout(0);
+        });
+
+        it('drops an in-flight refresh when the root is replaced meanwhile', async () => {
+            const stale = model.getNode('1.2') as CompositeTreeNode;
+            const gate = tree.stallNextResolve('1.2');
+            const pendingRefresh = tree.refresh(stale);
+
+            model.root = MockTreeModel.HIERARCHICAL_MOCK_ROOT();
+            gate.resolve(Array.from(stale.children));
+
+            assert.strictEqual(await pendingRefresh, undefined);
+            assert.deepStrictEqual(loggedErrors, []);
+            const fresh = model.getNode('1.2');
+            assert.ok(fresh);
+            assert.notStrictEqual(fresh, stale);
+        });
+
+        it('does not resurrect a removed subtree when a stale refresh completes', async () => {
+            const target = model.getNode('1.2') as CompositeTreeNode;
+            const gate = tree.stallNextResolve('1.2');
+            const pendingRefresh = tree.refresh(target);
+
+            CompositeTreeNode.removeChild(target.parent as CompositeTreeNode, target, tree);
+            assert.strictEqual(model.getNode('1.2'), undefined);
+            gate.resolve(Array.from(target.children));
+
+            assert.strictEqual(await pendingRefresh, undefined);
+            assert.strictEqual(model.getNode('1.2'), undefined);
+            assert.strictEqual(model.getNode('1.2.1'), undefined);
+        });
+
+        it('does not re-index a node object that a concurrent ancestor refresh replaced', async () => {
+            const stale = model.getNode('1.2') as CompositeTreeNode;
+            const gate = tree.stallNextResolve('1.2');
+            const pendingRefresh = tree.refresh(stale);
+
+            // an ancestor refresh yields a *fresh* object for the same id, as trees whose
+            // `resolveChildren` builds new nodes do
+            const parent = model.getNode('1') as CompositeTreeNode;
+            const replacement: CompositeTreeNode = { id: '1.2', name: '1.2', parent, children: [] };
+            tree.overrideNextResolve('1', () => parent.children.map(child => child.id === '1.2' ? replacement : child));
+            await tree.refresh(parent);
+            assert.strictEqual(model.getNode('1.2'), replacement);
+
+            gate.resolve(Array.from(stale.children));
+
+            assert.strictEqual(await pendingRefresh, undefined);
+            assert.deepStrictEqual(loggedErrors, []);
+            // the stale object must not take the replacement's place in the index, nor bring its children back
+            assert.strictEqual(model.getNode('1.2'), replacement);
+            assert.strictEqual(model.getNode('1.2.1'), undefined);
+        });
+
+    });
+
 });

package/src/browser/tree/tree-model.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { inject, injectable, postConstruct } from 'inversify';
+import { inject, injectable, postConstruct, named } from 'inversify';
 import { Event, Emitter, WaitUntilEvent } from '../../common/event';
 import { DisposableCollection } from '../../common/disposable';
 import { CancellationToken } from '../../common/cancellation';
@@ -165,7 +165,9 @@ export interface TreeModel extends Tree, TreeSelectionService, TreeExpansionServ
 @injectable()
 export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray<Readonly<SelectableTreeNode>>> {
 
-    @inject(ILogger) protected readonly logger: ILogger;
+    @inject(ILogger) @named('core:TreeModelImpl')
+    protected readonly logger: ILogger;
+
     @inject(Tree) protected readonly tree: Tree;
     @inject(TreeSelectionService) protected readonly selectionService: TreeSelectionService;
     @inject(TreeExpansionService) protected readonly expansionService: TreeExpansionService;

package/src/browser/tree/tree.ts

@@ -354,6 +354,12 @@ export class TreeImpl implements Tree {
                 result = parent;
                 const children = await this.resolveChildren(parent);
                 if (cancellationToken?.isCancellationRequested) { return; }
+                if (this.validateNode(parent) !== parent) {
+                    // the tree changed while children were being resolved (e.g. a new root was
+                    // set or the node was removed): drop the stale refresh
+                    this.logger.debug(`Refresh of node '${parent.id}' dropped, it no longer belongs to the tree.`);
+                    return undefined;
+                }
                 result = await this.setChildren(parent, children);
                 if (cancellationToken?.isCancellationRequested) { return; }
             } finally {

package/src/browser/widget-manager.ts

@@ -119,7 +119,7 @@ export class WidgetManager {
     @inject(ContributionProvider) @named(WidgetFactory)
     protected readonly factoryProvider: ContributionProvider<WidgetFactory>;
 
-    @inject(ILogger)
+    @inject(ILogger) @named('core:WidgetManager')
     protected readonly logger: ILogger;
 
     protected readonly onWillCreateWidgetEmitter = new Emitter<WillCreateWidgetEvent>();