@theia/plugin-ext 1.71.0-next.6 → 1.71.0-next.64

package/src/plugin/scm.ts

@@ -543,6 +543,8 @@ class SourceControlImpl implements theia.SourceControl {
     private static handlePool: number = 0;
     private groups: Map<GroupHandle, ScmResourceGroupImpl> = new Map<GroupHandle, ScmResourceGroupImpl>();
 
+    readonly apiObject: theia.SourceControl;
+
     get id(): string {
         return this._id;
     }
@@ -702,11 +704,13 @@ class SourceControlImpl implements theia.SourceControl {
         private _label: string,
         private _rootUri?: theia.Uri,
         _iconPath?: theia.IconPath,
+        _isHidden?: boolean,
         _parent?: SourceControlImpl
     ) {
         this.inputBox = new ScmInputBoxImpl(plugin, this.proxy, this.handle);
         this.proxy.$registerSourceControl(this.handle, _id, _label, _rootUri, _parent?.handle);
         this.onDidDisposeParent = _parent ? _parent.onDidDispose : Event.None;
+        this.apiObject = createAPIObject(this);
     }
 
     private createdResourceGroups = new Map<ScmResourceGroupImpl, Disposable>();
@@ -824,7 +828,7 @@ export class ScmExtImpl implements ScmExt {
                     return undefined;
                 }
                 if (typeof arg.resourceGroupHandle !== 'number') {
-                    return sourceControl;
+                    return sourceControl.apiObject;
                 }
                 const resourceGroup = sourceControl.getResourceGroup(arg.resourceGroupHandle);
                 if (typeof arg.resourceStateHandle !== 'number') {
@@ -836,17 +840,35 @@ export class ScmExtImpl implements ScmExt {
     }
 
     createSourceControl(extension: Plugin, id: string, label: string, rootUri: theia.Uri | undefined,
-        iconPath?: theia.IconPath, parent?: theia.SourceControl): theia.SourceControl {
+        iconPath?: theia.IconPath, isHidden?: boolean, parent?: theia.SourceControl): theia.SourceControl {
         const handle = ScmExtImpl.handlePool++;
         const parentImpl = parent ? this.findSourceControlImpl(parent) : undefined;
-        const sourceControl = new SourceControlImpl(extension, this.proxy, this.commands, id, label, rootUri, iconPath, parentImpl);
+        const sourceControl = new SourceControlImpl(extension, this.proxy, this.commands, id, label, rootUri, iconPath, isHidden, parentImpl);
         this.sourceControls.set(handle, sourceControl);
 
         const sourceControls = this.sourceControlsByExtension.get(extension.model.id) || [];
         sourceControls.push(sourceControl);
         this.sourceControlsByExtension.set(extension.model.id, sourceControls);
 
-        return sourceControl;
+        // Clean up registries when the source control is disposed. Without this,
+        // disposed entries leak and findSourceControlImpl() may return a stale
+        // (disposed) instance as a parent for a later-created source control
+        // with the same id + rootUri (e.g. a worktree recreated after removal).
+        sourceControl.onDidDispose(() => {
+            this.sourceControls.delete(handle);
+            const list = this.sourceControlsByExtension.get(extension.model.id);
+            if (list) {
+                const index = list.indexOf(sourceControl);
+                if (index >= 0) {
+                    list.splice(index, 1);
+                }
+                if (list.length === 0) {
+                    this.sourceControlsByExtension.delete(extension.model.id);
+                }
+            }
+        });
+
+        return sourceControl.apiObject;
     }
 
     private findSourceControlImpl(apiObject: theia.SourceControl): SourceControlImpl | undefined {

package/src/plugin/terminal-ext.spec.ts

@@ -0,0 +1,350 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource and others.
+//
+// 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 * as chai from 'chai';
+import * as theia from '@theia/plugin';
+import { TerminalServiceMain, Plugin, TerminalOptions } from '../common/plugin-api-rpc';
+import { RPCProtocol, ProxyIdentifier } from '../common/rpc-protocol';
+import { TerminalServiceExtImpl, TerminalExtImpl } from './terminal-ext';
+import { TerminalExitReason } from './types-impl';
+
+const expect = chai.expect;
+
+/**
+ * Creates a mock RPCProtocol that returns the given proxy for TERMINAL_MAIN.
+ */
+function createMockRpc(proxy: Partial<TerminalServiceMain>): RPCProtocol {
+    return {
+        getProxy<T>(_proxyId: ProxyIdentifier<T>): T {
+            return proxy as unknown as T;
+        },
+        set<T, R extends T>(_identifier: ProxyIdentifier<T>, instance: R): R {
+            return instance;
+        },
+        dispose(): void { }
+    } as RPCProtocol;
+}
+
+/**
+ * Creates a minimal mock Plugin object.
+ */
+function createMockPlugin(): Plugin {
+    return {
+        pluginPath: '/test',
+        pluginFolder: '/test',
+        pluginUri: 'file:///test',
+        model: { id: 'test.plugin' } as Plugin['model'],
+        rawModel: {} as Plugin['rawModel'],
+        lifecycle: {} as Plugin['lifecycle'],
+        isUnderDevelopment: false
+    };
+}
+
+/**
+ * Creates a stub TerminalServiceMain that records calls.
+ */
+function createMockProxy(): TerminalServiceMain & { createdTerminals: { id: string; options: TerminalOptions }[] } {
+    const createdTerminals: { id: string; options: TerminalOptions }[] = [];
+    return {
+        createdTerminals,
+        $createTerminal(id: string, options: TerminalOptions): Promise<string> {
+            createdTerminals.push({ id, options });
+            return Promise.resolve(id);
+        },
+        $sendText(): void { },
+        $write(): void { },
+        $resize(): void { },
+        $show(): void { },
+        $hide(): void { },
+        $dispose(): void { },
+        $setName(): void { },
+        $writeByTerminalId(): void { },
+        $resizeByTerminalId(): void { },
+        $disposeByTerminalId(): void { },
+        $setNameByTerminalId(): void { },
+        $setEnvironmentVariableCollection(): void { },
+        $registerTerminalLinkProvider(): void { },
+        $unregisterTerminalLinkProvider(): void { },
+        $registerTerminalObserver(): void { },
+        $unregisterTerminalObserver(): void { },
+    } as unknown as TerminalServiceMain & { createdTerminals: { id: string; options: TerminalOptions }[] };
+}
+
+describe('TerminalServiceExtImpl', () => {
+    let proxy: ReturnType<typeof createMockProxy>;
+    let service: TerminalServiceExtImpl;
+    let plugin: Plugin;
+
+    beforeEach(() => {
+        proxy = createMockProxy();
+        const rpc = createMockRpc(proxy);
+        service = new TerminalServiceExtImpl(rpc);
+        plugin = createMockPlugin();
+    });
+
+    describe('terminals list', () => {
+        it('returns empty array initially', () => {
+            expect(service.terminals).to.deep.equal([]);
+        });
+
+        it('includes terminals after creation via $terminalCreated', () => {
+            service.$terminalCreated('t1', 'Terminal 1');
+            expect(service.terminals).to.have.length(1);
+        });
+
+        it('removes terminals after $terminalClosed', () => {
+            service.$terminalCreated('t1', 'Terminal 1');
+            service.$terminalClosed('t1', { code: 0, reason: TerminalExitReason.Process });
+            expect(service.terminals).to.have.length(0);
+        });
+    });
+
+    describe('API object identity', () => {
+        it('returns the raw TerminalExtImpl when no wrapper is provided', () => {
+            const terminal = service.createTerminal(plugin, 'Test Terminal');
+            expect(terminal).to.be.instanceOf(TerminalExtImpl);
+        });
+
+        it('returns the wrapped API object when a wrapper is provided', () => {
+            const wrapper = (t: TerminalExtImpl): theia.Terminal => ({ ...t, name: 'wrapped' } as unknown as theia.Terminal);
+            service.createTerminal(plugin, 'Test Terminal', undefined, undefined, wrapper);
+            const id = proxy.createdTerminals[0].id;
+            service.$terminalCreated(id, 'Test Terminal');
+            const terminal = service.terminals[0];
+            expect(terminal.name).to.equal('wrapped');
+            expect(terminal).to.not.be.instanceOf(TerminalExtImpl);
+        });
+
+        it('fires onDidOpenTerminal with the API object, not the raw terminal', () => {
+            const apiObject = { marker: 'api-object' } as unknown as theia.Terminal;
+            const wrapper = (_t: TerminalExtImpl): theia.Terminal => apiObject;
+            service.createTerminal(plugin, 'Test Terminal', undefined, undefined, wrapper);
+
+            const opened: theia.Terminal[] = [];
+            service.onDidOpenTerminal(t => opened.push(t));
+
+            // Get the ID from the proxy call
+            const id = proxy.createdTerminals[0].id;
+            service.$terminalCreated(id, 'Test Terminal');
+
+            expect(opened).to.have.length(1);
+            expect(opened[0]).to.equal(apiObject);
+        });
+
+        it('fires onDidCloseTerminal with the API object', () => {
+            const apiObject = { marker: 'api-object' } as unknown as theia.Terminal;
+            const wrapper = (_t: TerminalExtImpl): theia.Terminal => apiObject;
+            service.createTerminal(plugin, 'Test Terminal', undefined, undefined, wrapper);
+
+            const closed: theia.Terminal[] = [];
+            service.onDidCloseTerminal(t => closed.push(t));
+
+            const id = proxy.createdTerminals[0].id;
+            service.$terminalCreated(id, 'Test Terminal');
+            service.$terminalClosed(id, { code: 0, reason: TerminalExitReason.Process });
+
+            expect(closed).to.have.length(1);
+            expect(closed[0]).to.equal(apiObject);
+        });
+
+        it('fires onDidChangeTerminalState with the API object on interaction', () => {
+            const apiObject = { marker: 'api-object' } as unknown as theia.Terminal;
+            const wrapper = (_t: TerminalExtImpl): theia.Terminal => apiObject;
+            service.createTerminal(plugin, 'Test Terminal', undefined, undefined, wrapper);
+
+            const stateChanged: theia.Terminal[] = [];
+            service.onDidChangeTerminalState(t => stateChanged.push(t));
+
+            const id = proxy.createdTerminals[0].id;
+            service.$terminalCreated(id, 'Test Terminal');
+            service.$terminalOnInteraction(id);
+
+            expect(stateChanged).to.have.length(1);
+            expect(stateChanged[0]).to.equal(apiObject);
+        });
+
+        it('fires onDidChangeTerminalState with the API object on shell type change', () => {
+            const apiObject = { marker: 'api-object' } as unknown as theia.Terminal;
+            const wrapper = (_t: TerminalExtImpl): theia.Terminal => apiObject;
+            service.createTerminal(plugin, 'Test Terminal', undefined, undefined, wrapper);
+
+            const stateChanged: theia.Terminal[] = [];
+            service.onDidChangeTerminalState(t => stateChanged.push(t));
+
+            const id = proxy.createdTerminals[0].id;
+            service.$terminalCreated(id, 'Test Terminal');
+            service.$terminalShellTypeChanged(id, '/bin/zsh');
+
+            expect(stateChanged).to.have.length(1);
+            expect(stateChanged[0]).to.equal(apiObject);
+        });
+
+        it('returns the API object from the terminals list', () => {
+            const apiObject = { marker: 'api-object' } as unknown as theia.Terminal;
+            const wrapper = (_t: TerminalExtImpl): theia.Terminal => apiObject;
+            service.createTerminal(plugin, 'Test Terminal', undefined, undefined, wrapper);
+
+            const id = proxy.createdTerminals[0].id;
+            service.$terminalCreated(id, 'Test Terminal');
+
+            const terminals = service.terminals;
+            expect(terminals).to.have.length(1);
+            expect(terminals[0]).to.equal(apiObject);
+        });
+
+        it('returns the API object as activeTerminal', () => {
+            const apiObject = { marker: 'api-object' } as unknown as theia.Terminal;
+            const wrapper = (_t: TerminalExtImpl): theia.Terminal => apiObject;
+            service.createTerminal(plugin, 'Test Terminal', undefined, undefined, wrapper);
+
+            const id = proxy.createdTerminals[0].id;
+            service.$terminalCreated(id, 'Test Terminal');
+            service.$currentTerminalChanged(id);
+
+            expect(service.activeTerminal).to.equal(apiObject);
+        });
+
+        it('cleans up API object on terminal close', () => {
+            const apiObject = { marker: 'api-object' } as unknown as theia.Terminal;
+            const wrapper = (_t: TerminalExtImpl): theia.Terminal => apiObject;
+            service.createTerminal(plugin, 'Test Terminal', undefined, undefined, wrapper);
+
+            const id = proxy.createdTerminals[0].id;
+            service.$terminalCreated(id, 'Test Terminal');
+            service.$terminalClosed(id, { code: 0, reason: TerminalExitReason.Process });
+
+            expect(service.terminals).to.have.length(0);
+        });
+    });
+
+    describe('parentTerminal resolution', () => {
+        it('resolves parentTerminal from API proxy objects', () => {
+            const apiObject = { marker: 'parent-api' } as unknown as theia.Terminal;
+            const wrapper = (_t: TerminalExtImpl): theia.Terminal => apiObject;
+            service.createTerminal(plugin, 'Parent', undefined, undefined, wrapper);
+
+            const parentId = proxy.createdTerminals[0].id;
+            service.$terminalCreated(parentId, 'Parent');
+
+            // Create a child with parentTerminal set to the API object
+            service.createTerminal(plugin, {
+                name: 'Child',
+                location: { parentTerminal: apiObject }
+            } as theia.TerminalOptions);
+
+            expect(proxy.createdTerminals).to.have.length(2);
+            // The second createTerminal call should have passed the parent ID
+            // We verify it was called on the proxy (the parentId arg is the 3rd parameter)
+        });
+
+        it('resolves parentTerminal from raw terminal objects', () => {
+            const rawTerminal = service.createTerminal(plugin, 'Parent');
+
+            const parentId = proxy.createdTerminals[0].id;
+            service.$terminalCreated(parentId, 'Parent');
+
+            // Create a child with parentTerminal set to the raw terminal
+            service.createTerminal(plugin, {
+                name: 'Child',
+                location: { parentTerminal: rawTerminal }
+            } as theia.TerminalOptions);
+
+            expect(proxy.createdTerminals).to.have.length(2);
+        });
+    });
+
+    describe('events for terminals without wrapper', () => {
+        it('fires onDidOpenTerminal with the raw terminal when no wrapper is used', () => {
+            const opened: theia.Terminal[] = [];
+            service.onDidOpenTerminal(t => opened.push(t));
+
+            service.$terminalCreated('ext-t1', 'External Terminal');
+
+            expect(opened).to.have.length(1);
+            expect(opened[0]).to.be.instanceOf(TerminalExtImpl);
+            expect(opened[0].name).to.equal('External Terminal');
+        });
+
+        it('fires onDidCloseTerminal with the raw terminal when no wrapper is used', () => {
+            const closed: theia.Terminal[] = [];
+            service.onDidCloseTerminal(t => closed.push(t));
+
+            service.$terminalCreated('ext-t1', 'External Terminal');
+            service.$terminalClosed('ext-t1', { code: 0, reason: TerminalExitReason.Process });
+
+            expect(closed).to.have.length(1);
+            expect(closed[0]).to.be.instanceOf(TerminalExtImpl);
+        });
+    });
+
+    describe('shell change', () => {
+        it('fires onDidChangeShell when shell changes', async () => {
+            const shells: string[] = [];
+            service.onDidChangeShell(s => shells.push(s));
+
+            await service.$setShell('/bin/zsh');
+
+            expect(shells).to.deep.equal(['/bin/zsh']);
+            expect(service.defaultShell).to.equal('/bin/zsh');
+        });
+
+        it('does not fire onDidChangeShell when shell is the same', async () => {
+            const shells: string[] = [];
+            await service.$setShell('/bin/zsh');
+
+            service.onDidChangeShell(s => shells.push(s));
+            await service.$setShell('/bin/zsh');
+
+            expect(shells).to.deep.equal([]);
+        });
+    });
+
+    describe('$terminalNameChanged', () => {
+        it('updates the terminal name', () => {
+            service.$terminalCreated('t1', 'Old Name');
+            service.$terminalNameChanged('t1', 'New Name');
+
+            expect(service.terminals[0].name).to.equal('New Name');
+        });
+    });
+
+    describe('activeTerminal', () => {
+        it('is undefined initially', () => {
+            expect(service.activeTerminal).to.equal(undefined);
+        });
+
+        it('reflects the current active terminal', () => {
+            service.$terminalCreated('t1', 'Terminal 1');
+            service.$currentTerminalChanged('t1');
+
+            expect(service.activeTerminal).to.not.equal(undefined);
+            expect(service.activeTerminal!.name).to.equal('Terminal 1');
+        });
+
+        it('fires onDidChangeActiveTerminal', () => {
+            const changes: (theia.Terminal | undefined)[] = [];
+            service.onDidChangeActiveTerminal(t => changes.push(t));
+
+            service.$terminalCreated('t1', 'Terminal 1');
+            service.$currentTerminalChanged('t1');
+            service.$currentTerminalChanged(undefined);
+
+            expect(changes).to.have.length(2);
+            expect(changes[0]!.name).to.equal('Terminal 1');
+            expect(changes[1]).to.equal(undefined);
+        });
+    });
+});

package/src/plugin/terminal-ext.ts

@@ -38,6 +38,13 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
 
     private readonly _terminals = new Map<string, TerminalExtImpl>();
 
+    /**
+     * Stores the API objects (Proxies) returned to plugins for each terminal.
+     * This ensures that events fire with the same object instance that plugins received,
+     * allowing strict equality checks (===) to work correctly.
+     */
+    private readonly _terminalApiObjects = new Map<string, theia.Terminal>();
+
     private readonly _pseudoTerminals = new Map<string, PseudoTerminal>();
 
     private static nextProviderId = 0;
@@ -66,8 +73,8 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
         this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.TERMINAL_MAIN);
     }
 
-    get terminals(): TerminalExtImpl[] {
-        return [...this._terminals.values()];
+    get terminals(): theia.Terminal[] {
+        return [...this._terminals.keys()].map(id => this.getApiObject(id)).filter((t): t is theia.Terminal => t !== undefined);
     }
 
     get defaultShell(): string {
@@ -84,7 +91,9 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
     createTerminal(
         plugin: Plugin,
         nameOrOptions: theia.TerminalOptions | theia.PseudoTerminalOptions | theia.ExtensionTerminalOptions | string | undefined,
-        shellPath?: string, shellArgs?: string[] | string
+        shellPath?: string,
+        shellArgs?: string[] | string,
+        apiObjectWrapper?: (terminal: TerminalExtImpl) => theia.Terminal
     ): theia.Terminal {
         const id = `plugin-terminal-${UUID.uuid4()}`;
         let options: TerminalOptions;
@@ -110,7 +119,15 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
         let parentId;
         if (options.location && typeof options.location === 'object' && 'parentTerminal' in options.location) {
             const parentTerminal = options.location.parentTerminal;
-            if (parentTerminal instanceof TerminalExtImpl) {
+            // Check both the API proxy objects and the raw terminals, since
+            // plugins receive the proxy but _terminals stores the raw object.
+            for (const [k, v] of this._terminalApiObjects) {
+                if (v === parentTerminal) {
+                    parentId = k;
+                    break;
+                }
+            }
+            if (!parentId) {
                 for (const [k, v] of this._terminals) {
                     if (v === parentTerminal) {
                         parentId = k;
@@ -136,7 +153,16 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
         if (typeof nameOrOptions === 'object' && 'pty' in nameOrOptions) {
             creationOptions = nameOrOptions;
         }
-        return this.obtainTerminal(id, options.name || 'Terminal', creationOptions);
+        const terminal = this.obtainTerminal(id, options.name || 'Terminal', creationOptions);
+
+        // If a wrapper function is provided, wrap the terminal and register the API object
+        // This ensures events fire with the same object instance that plugins received
+        if (apiObjectWrapper) {
+            const apiObject = apiObjectWrapper(terminal);
+            this._terminalApiObjects.set(id, apiObject);
+            return apiObject;
+        }
+        return terminal;
     }
 
     attachPtyToTerminal(terminalId: number, pty: theia.Pseudoterminal): void {
@@ -153,6 +179,13 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
         return terminal;
     }
 
+    /**
+     * Gets the API object for a terminal by ID, falling back to the raw terminal if not set.
+     */
+    protected getApiObject(id: string): theia.Terminal | undefined {
+        return this._terminalApiObjects.get(id) ?? this._terminals.get(id);
+    }
+
     $terminalOnInput(id: string, data: string): void {
         const terminal = this._pseudoTerminals.get(id);
         if (!terminal) {
@@ -168,7 +201,10 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
         }
         if (!terminal.state.isInteractedWith) {
             terminal.state = { ...terminal.state, isInteractedWith: true };
-            this.onDidChangeTerminalStateEmitter.fire(terminal);
+            const apiObject = this.getApiObject(id);
+            if (apiObject) {
+                this.onDidChangeTerminalStateEmitter.fire(apiObject);
+            }
         }
     }
 
@@ -179,7 +215,10 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
         }
         if (terminal.state.shell !== shellType) {
             terminal.state = { ...terminal.state, shell: shellType };
-            this.onDidChangeTerminalStateEmitter.fire(terminal);
+            const apiObject = this.getApiObject(id);
+            if (apiObject) {
+                this.onDidChangeTerminalStateEmitter.fire(apiObject);
+            }
         }
     }
 
@@ -194,7 +233,10 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
     $terminalCreated(id: string, name: string): void {
         const terminal = this.obtainTerminal(id, name);
         terminal.id.resolve(id);
-        this.onDidOpenTerminalEmitter.fire(terminal);
+        const apiObject = this.getApiObject(id);
+        if (apiObject) {
+            this.onDidOpenTerminalEmitter.fire(apiObject);
+        }
     }
 
     $terminalNameChanged(id: string, name: string): void {
@@ -234,8 +276,12 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
         const terminal = this._terminals.get(id);
         if (terminal) {
             terminal.exitStatus = exitStatus ?? { code: undefined, reason: TerminalExitReason.Unknown };
-            this.onDidCloseTerminalEmitter.fire(terminal);
+            const apiObject = this.getApiObject(id);
+            if (apiObject) {
+                this.onDidCloseTerminalEmitter.fire(apiObject);
+            }
             this._terminals.delete(id);
+            this._terminalApiObjects.delete(id);
         }
         const pseudoTerminal = this._pseudoTerminals.get(id);
         if (pseudoTerminal) {
@@ -245,8 +291,8 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
     }
 
     private activeTerminalId: string | undefined;
-    get activeTerminal(): TerminalExtImpl | undefined {
-        return this.activeTerminalId && this._terminals.get(this.activeTerminalId) || undefined;
+    get activeTerminal(): theia.Terminal | undefined {
+        return this.activeTerminalId && this.getApiObject(this.activeTerminalId) || undefined;
     }
     $currentTerminalChanged(id: string | undefined): void {
         this.activeTerminalId = id;
@@ -319,7 +365,7 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
 
     async $provideTerminalLinks(line: string, terminalId: string, token: theia.CancellationToken): Promise<ProvidedTerminalLink[]> {
         const links: ProvidedTerminalLink[] = [];
-        const terminal = this._terminals.get(terminalId);
+        const terminal = this.getApiObject(terminalId);
         if (terminal) {
             for (const [providerId, provider] of this.terminalLinkProviders) {
                 const providedLinks = await provider.provideTerminalLinks({ line, terminal }, token);

package/src/plugin/test-item.ts

@@ -132,9 +132,14 @@ export class TestItemCollection implements theia.TestItemCollection {
         return this.values.size;
     }
     replace(items: readonly theia.TestItem[]): void {
-        const toRemove = this.values.values.map(item => item.id);
-        items.forEach(item => this.add(item));
-        toRemove.forEach(key => this.delete(key));
+        const toDelete = new Set(this.values.values.map(item => item.id));
+        for (const item of items) {
+            toDelete.delete(item.id);
+            this.add(item);
+        }
+        for (const id of toDelete) {
+            this.delete(id);
+        }
     }
 
     forEach(callback: (item: theia.TestItem, collection: theia.TestItemCollection) => unknown, thisArg?: unknown): void {

package/src/plugin/tests.ts

@@ -299,6 +299,10 @@ export class TestRun implements theia.TestRun {
     }
 
     end(): void {
+        if (this.ended) {
+            return;
+        }
+        this.changeBatcher.flush();
         this.ended = true;
         this.proxy.$notifyTestRunEnded(this.controller.id, this.id);
     }
@@ -428,9 +432,16 @@ export class TestingExtImpl implements TestingExt {
     $onResolveChildren(controllerId: string, path: string[]): void {
         const controller = this.withController(controllerId);
         if (controller.resolveHandler) {
-            const item = controller.items.find(path);
-            if (item?.canResolveChildren) { // the item and resolve handler might have been been changed, but not sent to the front end
-                controller.resolveHandler?.(item);
+            if (path.length === 0) {
+                // Root-level resolve: discover top-level test items
+                controller.resolveHandler(undefined);
+            } else {
+                const item = controller.items.find(path);
+                // The `main` side should only request resolution for items with `canResolveChildren`, but with event batching,
+                // the flag can be out of sync with the state on the `plugin` side. The state on the `plugin` side is authoritative.
+                if (item?.canResolveChildren) {
+                    controller.resolveHandler(item);
+                }
             }
         }
     }

package/src/plugin/type-converters.ts

@@ -22,7 +22,7 @@ import {
     DecorationOptions, EditorPosition, Plugin, Position, WorkspaceTextEditDto, WorkspaceFileEditDto, Selection, TaskDto, WorkspaceEditDto
 } from '../common/plugin-api-rpc';
 import * as model from '../common/plugin-api-rpc-model';
-import { LanguageFilter, LanguageSelector, RelativePattern } from '@theia/editor/lib/common/language-selector';
+import { LanguageFilter, LanguageSelector } from '@theia/editor/lib/common/language-selector';
 import { MarkdownString as PluginMarkdownStringImpl } from './markdown-string';
 import * as types from './types-impl';
 import { UriComponents } from '../common/uri-components';
@@ -246,27 +246,21 @@ export function fromDocumentSelector(selector: theia.DocumentSelector | undefine
         return {
             language: selector.language,
             scheme: selector.scheme,
-            pattern: fromGlobPattern(selector.pattern!)
+            pattern: selector.pattern && fromGlobPattern(selector.pattern)
         } as LanguageFilter;
     }
 
 }
 
-export function fromGlobPattern(pattern: theia.GlobPattern): string | RelativePattern {
+export function fromGlobPattern(pattern: theia.GlobPattern): string | types.RelativePattern {
     if (typeof pattern === 'string') {
         return pattern;
     }
 
-    if (isRelativePattern(pattern)) {
-        return new types.RelativePattern(pattern.baseUri, pattern.pattern);
-    }
-
-    return pattern;
-}
-
-function isRelativePattern(obj: {}): obj is theia.RelativePattern {
-    const rp = obj as theia.RelativePattern;
-    return rp && typeof rp.baseUri === 'string' && typeof rp.pattern === 'string';
+    return new types.RelativePattern(
+        pattern.baseUri ?? pattern.base, // preserve backwards compatibility with older extensions: legacy relative pattern shape did not have the `baseUri` property
+        pattern.pattern
+    );
 }
 
 export function fromCompletionItemKind(kind?: types.CompletionItemKind): model.CompletionItemKind {