@theia/debug 1.77.0-next.6 → 1.77.0-next.63

package/src/browser/console/debug-console-contribution.tsx

@@ -92,23 +92,18 @@ export class DebugConsoleContribution extends AbstractViewContribution<ConsoleWi
             this.debugSessionManager.onDidCreateDebugSession(session => {
                 const consoleParent = session.findConsoleParent();
                 if (consoleParent) {
-                    const parentConsoleSession = this.consoleSessionManager.get(consoleParent.id);
-                    if (parentConsoleSession instanceof DebugConsoleSession) {
-                        session.on('output', event => parentConsoleSession.logOutput(parentConsoleSession.debugSession, event));
+                    const parentConsoleSession = this.findConsoleSession(consoleParent);
+                    if (parentConsoleSession) {
+                        // Log against the session the output came from, so that variable references resolve on its adapter.
+                        session.on('output', event => parentConsoleSession.logOutput(session, event));
                     }
                 } else {
-                    const consoleSession = this.debugConsoleSessionFactory(session);
-                    this.consoleSessionManager.add(consoleSession);
+                    const consoleSession = this.getOrCreateConsoleSession(session);
                     session.on('output', event => consoleSession.logOutput(session, event));
                 }
             }),
             this.debugSessionManager.onDidChangeActiveDebugSession(event => this.handleActiveDebugSessionChanged(event)),
-            this.debugSessionManager.onDidDestroyDebugSession(session => {
-                const consoleSession = this.consoleSessionManager.get(session.id);
-                if (consoleSession instanceof DebugConsoleSession) {
-                    consoleSession.markTerminated();
-                }
-            }),
+            this.debugSessionManager.onDidDestroyDebugSession(session => this.handleDebugSessionDestroyed(session)),
             this.consoleSessionManager.onDidChangeSelectedSession(() => {
                 const session = this.consoleSessionManager.selectedSession;
                 if (session && this.filterInputRef) {
@@ -121,12 +116,56 @@ export class DebugConsoleContribution extends AbstractViewContribution<ConsoleWi
         ]);
     }
 
+    /**
+     * Returns the console of the given session, if it still belongs to one.
+     *
+     * A console keeps the id it was created with even when it is reused by a restarted session, so it cannot be
+     * looked up by the session id.
+     */
+    protected findConsoleSession(debugSession: DebugSession): DebugConsoleSession | undefined {
+        return this.consoleSessionManager.all.find((candidate): candidate is DebugConsoleSession =>
+            candidate instanceof DebugConsoleSession && candidate.debugSession?.id === debugSession.id);
+    }
+
+    /**
+     * Returns the console for a newly created session.
+     *
+     * A session reuses the console of a terminated session started from the same configuration, so that restarting
+     * does not leave a stopped console behind on every run.
+     */
+    protected getOrCreateConsoleSession(debugSession: DebugSession): DebugConsoleSession {
+        const reusable = this.consoleSessionManager.all.find((candidate): candidate is DebugConsoleSession =>
+            candidate instanceof DebugConsoleSession && candidate.isReusableBy(debugSession));
+        if (reusable) {
+            reusable.startFor(debugSession);
+            return reusable;
+        }
+        const consoleSession = this.debugConsoleSessionFactory(debugSession);
+        this.consoleSessionManager.add(consoleSession);
+        return consoleSession;
+    }
+
+    /**
+     * Terminates the console of the given session once no session runs in it any more.
+     *
+     * A child session merged into its parent's console may outlive the parent if its lifecycle is not managed by the
+     * parent, and it still needs the console to evaluate expressions while it runs.
+     */
+    protected handleDebugSessionDestroyed(debugSession: DebugSession): void {
+        const consoleOwner = debugSession.findConsoleParent() ?? debugSession;
+        const consoleSession = this.findConsoleSession(consoleOwner);
+        if (consoleSession && !this.debugSessionManager.sessions.some(candidate =>
+            candidate.id === consoleOwner.id || candidate.findConsoleParent()?.id === consoleOwner.id)) {
+            consoleSession.markTerminated();
+        }
+    }
+
     protected handleActiveDebugSessionChanged(event: DidChangeActiveDebugSession): void {
         if (!event.current) {
             return;
         } else {
             const topSession = event.current.findConsoleParent() || event.current;
-            const consoleSession = topSession ? this.consoleSessionManager.get(topSession.id) : undefined;
+            const consoleSession = topSession ? this.findConsoleSession(topSession) : undefined;
             this.consoleSessionManager.selectedSession = consoleSession;
             const consoleSelector = document.getElementById('debugConsoleSelector');
             if (consoleSession && consoleSelector instanceof HTMLSelectElement) {
@@ -217,7 +256,7 @@ export class DebugConsoleContribution extends AbstractViewContribution<ConsoleWi
         bind(DebugConsoleSession).toSelf().inRequestScope();
         bind(DebugConsoleSessionFactory).toFactory(context => (session: DebugSession) => {
             const consoleSession = context.container.get(DebugConsoleSession);
-            consoleSession.debugSession = session;
+            consoleSession.startFor(session);
             return consoleSession;
         });
         bind(ConsoleSessionManager).toSelf().inSingletonScope();
@@ -271,7 +310,7 @@ export class DebugConsoleContribution extends AbstractViewContribution<ConsoleWi
             });
 
         sortedSessions.forEach(session => {
-            let label = session.debugSession.label;
+            let label = session.label;
             if (session.terminated) {
                 label = `${label} (${nls.localizeByDefault('Stopped')})`;
             }

package/src/browser/console/debug-console-items.tsx

@@ -92,12 +92,17 @@ export class ExpressionContainer implements CompositeConsoleItem {
 
     protected elements: Promise<ExpressionContainer[]> | undefined;
     async getElements(): Promise<IterableIterator<ExpressionContainer>> {
-        if (!this.hasElements || !this.session) {
+        if (!this.hasElements) {
             return [][Symbol.iterator]();
         }
         if (!this.elements) {
+            if (!this.session) {
+                // Nothing was resolved while the session ran, and there is no session left to resolve it with.
+                return [][Symbol.iterator]();
+            }
             this.elements = this.doResolve();
         }
+        // What was resolved while the session ran stays available after it has ended, as it does in VS Code.
         return (await this.elements)[Symbol.iterator]();
     }
     protected async doResolve(): Promise<ExpressionContainer[]> {
@@ -166,6 +171,19 @@ export class ExpressionContainer implements CompositeConsoleItem {
         }
     }
 
+    protected async evaluateForClipboard(expression: string, context: DebugProtocol.EvaluateArguments['context'], fallback: string): Promise<string> {
+        const { session } = this;
+        if (!session) {
+            return fallback;
+        }
+        try {
+            const evaluationContext = session.capabilities.supportsClipboardContext ? 'clipboard' : context;
+            return (await session.evaluate(expression, evaluationContext)).result;
+        } catch {
+            return fallback;
+        }
+    }
+
 }
 export namespace ExpressionContainer {
     export interface Options {
@@ -223,7 +241,7 @@ export class DebugVariable extends ExpressionContainer {
         return <div className={this.variableClassName}>
             <span title={type || name} className='name' ref={this.setNameRef}>{name}{(value || lazy) && ': '}</span>
             {lazy && <span title={nls.localizeByDefault('Click to expand')} className={codicon('eye') + ' lazy-button'} onClick={this.handleLazyButtonClick} />}
-            <span title={value} className='value' ref={this.setValueRef}>{value}</span>
+            <span title={value} className='value'>{value}</span>
         </div>;
     }
 
@@ -271,17 +289,13 @@ export class DebugVariable extends ExpressionContainer {
     }
 
     get supportCopyValue(): boolean {
-        return !!this.valueRef && document.queryCommandSupported('copy');
+        return !!this.value;
     }
-    copyValue(): void {
-        const selection = document.getSelection();
-        if (this.valueRef && selection) {
-            selection.selectAllChildren(this.valueRef);
-            document.execCommand('copy');
-        }
+    async getValueToCopy(): Promise<string> {
+        return this.evaluateName
+            ? await this.evaluateForClipboard(this.evaluateName, 'variables', this.value)
+            : this.value;
     }
-    protected valueRef: HTMLSpanElement | undefined;
-    protected setValueRef = (valueRef: HTMLSpanElement | null): void => { this.valueRef = valueRef || undefined; };
 
     get supportCopyAsExpression(): boolean {
         return !!this.nameRef && document.queryCommandSupported('copy');

package/src/browser/console/debug-console-session.spec.ts

@@ -0,0 +1,246 @@
+// *****************************************************************************
+// 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 { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+
+let disableJSDOM = enableJSDOM();
+
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+
+import 'reflect-metadata';
+
+import { expect } from 'chai';
+import { DebugProtocol } from '@vscode/debugprotocol/lib/debugProtocol';
+import { ExpressionContainer } from './debug-console-items';
+import { DebugConsoleSession } from './debug-console-session';
+import { DebugSession } from '../debug-session';
+
+disableJSDOM();
+
+/**
+ * The variables the fake adapter answers with, so that an output event with a variables reference resolves to an
+ * expandable item, as it does when a program logs an object rather than a string.
+ */
+const VARIABLES: Record<number, DebugProtocol.Variable[]> = {
+    1: [{ name: 'logged', value: 'Object', variablesReference: 2 }],
+    2: [{ name: 'answer', value: '42', variablesReference: 0 }]
+};
+
+class TestDebugSessionManager {
+
+    protected readonly sessions = new Map<string, DebugSession>();
+
+    currentSession: DebugSession | undefined;
+
+    getSession(id: string): DebugSession | undefined {
+        return this.sessions.get(id);
+    }
+
+    add(session: DebugSession): void {
+        this.sessions.set(session.id, session);
+        this.currentSession = session;
+    }
+
+    /** Mirrors `DebugSessionManager.cleanup`, which drops the session before announcing its destruction. */
+    remove(id: string): void {
+        this.sessions.delete(id);
+        if (this.currentSession?.id === id) {
+            this.currentSession = undefined;
+        }
+    }
+
+}
+
+describe('DebugConsoleSession', () => {
+
+    before(() => disableJSDOM = enableJSDOM());
+    after(() => disableJSDOM());
+
+    let manager: TestDebugSessionManager;
+    let consoleSession: DebugConsoleSession;
+    let maximumLines: number;
+
+    const createDebugSession = (id: string, configurationName: string, workspaceFolderUri?: string): DebugSession => ({
+        id,
+        label: configurationName,
+        configuration: { name: configurationName, type: 'node', request: 'launch' },
+        options: { workspaceFolderUri },
+        autoExpandLazyVariables: false,
+        sendRequest: async (_command: string, args: { variablesReference: number }) => ({
+            body: { variables: VARIABLES[args.variablesReference] ?? [] }
+        })
+    } as unknown as DebugSession);
+
+    const outputEvent = (body: Partial<DebugProtocol.OutputEvent['body']>): DebugProtocol.OutputEvent =>
+        ({ event: 'output', body: { category: 'stdout', ...body } } as DebugProtocol.OutputEvent);
+
+    const contentsOf = (session: DebugConsoleSession): string[] =>
+        Array.from(session.getElements(), item => (item as { content?: string }).content ?? '');
+
+    beforeEach(() => {
+        manager = new TestDebugSessionManager();
+        maximumLines = 10000;
+        consoleSession = new DebugConsoleSession();
+        // The class uses property injection, and `init()` only registers a Monaco completion provider.
+        Object.assign(consoleSession as unknown as Record<string, unknown>, {
+            sessionManager: manager,
+            logger: { debug: () => { } },
+            preferences: { get 'debug.console.maximumLines'(): number { return maximumLines; } }
+        });
+    });
+
+    describe('when the session terminates', () => {
+
+        it('releases the session but keeps its output', async () => {
+            const session = createDebugSession('session-1', 'Launch Program');
+            manager.add(session);
+            consoleSession.startFor(session);
+            await consoleSession.logOutput(session, outputEvent({ output: 'hello' }));
+
+            expect(consoleSession.debugSession).to.equal(session);
+
+            manager.remove(session.id);
+            consoleSession.markTerminated();
+
+            expect(consoleSession.terminated).to.be.true;
+            expect(consoleSession.debugSession).to.be.undefined;
+            expect(contentsOf(consoleSession)).to.deep.equal(['hello']);
+        });
+
+        it('keeps the label and the configuration of the released session', () => {
+            const session = createDebugSession('session-1', 'Launch Program');
+            manager.add(session);
+            consoleSession.startFor(session);
+
+            manager.remove(session.id);
+            consoleSession.markTerminated();
+
+            expect(consoleSession.label).to.equal('Launch Program');
+            expect(consoleSession.configurationName).to.equal('Launch Program');
+        });
+
+        it('keeps what was expanded while the session ran', async () => {
+            const session = createDebugSession('session-1', 'Launch Program');
+            manager.add(session);
+            consoleSession.startFor(session);
+            // An output event carrying a variables reference, as sent for a logged object, yields expandable items
+            // that resolve their children through the session.
+            await consoleSession.logOutput(session, outputEvent({ variablesReference: 1 }));
+
+            const [logged] = Array.from(consoleSession.getElements()) as ExpressionContainer[];
+            expect(Array.from(await logged.getElements())).to.have.lengthOf(1, 'expandable while the session runs');
+
+            manager.remove(session.id);
+            consoleSession.markTerminated();
+
+            expect(Array.from(consoleSession.getElements())).to.have.lengthOf(1, 'output is preserved');
+            expect(Array.from(await logged.getElements())).to.have.lengthOf(1, 'expanded children are preserved');
+        });
+
+        it('does not retain the session through the items it logged', async () => {
+            const session = createDebugSession('session-1', 'Launch Program');
+            manager.add(session);
+            consoleSession.startFor(session);
+            await consoleSession.logOutput(session, outputEvent({ variablesReference: 1 }));
+
+            const [logged] = Array.from(consoleSession.getElements()) as ExpressionContainer[];
+
+            manager.remove(session.id);
+            consoleSession.markTerminated();
+
+            // Nothing was expanded before the session ended, so there is nothing cached to fall back on. The item
+            // resolves its session by id through the manager, which has dropped it, rather than holding on to it,
+            // so it has nothing left to ask.
+            expect(Array.from(await logged.getElements())).to.be.empty;
+        });
+
+    });
+
+    describe('when a session reuses the console', () => {
+
+        it('drops the output of the previous run and runs the new session', async () => {
+            const first = createDebugSession('session-1', 'Launch Program');
+            manager.add(first);
+            consoleSession.startFor(first);
+            await consoleSession.logOutput(first, outputEvent({ output: 'first run' }));
+            manager.remove(first.id);
+            consoleSession.markTerminated();
+
+            const second = createDebugSession('session-2', 'Launch Program');
+            manager.add(second);
+            consoleSession.startFor(second);
+
+            expect(consoleSession.terminated).to.be.false;
+            expect(consoleSession.debugSession).to.equal(second);
+            expect(contentsOf(consoleSession)).to.be.empty;
+
+            await consoleSession.logOutput(second, outputEvent({ output: 'second run' }));
+            expect(contentsOf(consoleSession)).to.deep.equal(['second run']);
+        });
+
+        it('is reusable only by a session of the same configuration once terminated', () => {
+            consoleSession.startFor(createDebugSession('session-1', 'Launch Program'));
+            expect(consoleSession.isReusableBy(createDebugSession('session-2', 'Launch Program'))).to.be.false;
+
+            consoleSession.markTerminated();
+
+            expect(consoleSession.isReusableBy(createDebugSession('session-2', 'Launch Program'))).to.be.true;
+            expect(consoleSession.isReusableBy(createDebugSession('session-2', 'Attach'))).to.be.false;
+        });
+
+        it('is not reusable by a configuration of the same name from another workspace folder', () => {
+            consoleSession.startFor(createDebugSession('session-1', 'Launch Program', 'file:///a'));
+            consoleSession.markTerminated();
+
+            expect(consoleSession.isReusableBy(createDebugSession('session-2', 'Launch Program', 'file:///b'))).to.be.false;
+            expect(consoleSession.isReusableBy(createDebugSession('session-2', 'Launch Program'))).to.be.false;
+            expect(consoleSession.isReusableBy(createDebugSession('session-2', 'Launch Program', 'file:///a'))).to.be.true;
+        });
+
+        it('keeps the id it was created with, so that it is not the id of either session', () => {
+            const first = createDebugSession('session-1', 'Launch Program');
+            consoleSession.startFor(first);
+            const id = consoleSession.id;
+
+            consoleSession.markTerminated();
+            consoleSession.startFor(createDebugSession('session-2', 'Launch Program'));
+
+            expect(consoleSession.id).to.equal(id);
+            expect(consoleSession.id).to.not.equal('session-1');
+            expect(consoleSession.id).to.not.equal('session-2');
+        });
+
+    });
+
+    describe('output limit', () => {
+
+        it('drops the oldest lines beyond `debug.console.maximumLines`', async () => {
+            maximumLines = 3;
+            const session = createDebugSession('session-1', 'Launch Program');
+            manager.add(session);
+            consoleSession.startFor(session);
+
+            await consoleSession.logOutput(session, outputEvent({ output: 'one\ntwo\nthree\nfour' }));
+            expect(contentsOf(consoleSession)).to.deep.equal(['two', 'three', 'four']);
+
+            consoleSession.appendLine('five');
+            expect(contentsOf(consoleSession)).to.deep.equal(['three', 'four', 'five']);
+        });
+
+    });
+
+});

package/src/browser/console/debug-console-session.ts

@@ -20,10 +20,12 @@ import { ConsoleSession, ConsoleItem } from '@theia/console/lib/browser/console-
 import { AnsiConsoleItem } from '@theia/console/lib/browser/ansi-console-item';
 import { DebugSession } from '../debug-session';
 import URI from '@theia/core/lib/common/uri';
+import { generateUuid } from '@theia/core/lib/common/uuid';
 import { ExpressionContainer, ExpressionItem } from './debug-console-items';
 import { Severity } from '@theia/core/lib/common/severity';
 import { inject, injectable, postConstruct, named } from '@theia/core/shared/inversify';
 import { DebugSessionManager } from '../debug-session-manager';
+import { DebugPreferences } from '../../common/debug-preferences';
 import * as monaco from '@theia/monaco-editor-core';
 import { LanguageSelector } from '@theia/monaco-editor-core/esm/vs/editor/common/languageSelector';
 import { Disposable, ILogger } from '@theia/core';
@@ -42,24 +44,61 @@ export class DebugConsoleSession extends ConsoleSession {
     @inject(ILogger) @named('debug:DebugConsoleSession')
     protected readonly logger: ILogger;
 
+    @inject(DebugPreferences)
+    protected readonly preferences: DebugPreferences;
+
+    /**
+     * The console has an identity of its own, independent of the sessions that run in it: it outlives the session it
+     * was created for and is reused by a later one.
+     */
+    override id = generateUuid();
+
     protected items: ConsoleItem[] = [];
 
     protected _terminated = false;
 
-    protected _debugSession: DebugSession;
+    protected _debugSession: DebugSession | undefined;
+
+    protected _label = '';
+
+    protected _configurationName: string | undefined;
+
+    protected _workspaceFolderUri: string | undefined;
 
     // content buffer for [append](#append) method
     protected uncompletedItemContent: string | undefined;
 
     protected readonly completionKinds = new Map<DebugProtocol.CompletionItemType | undefined, monaco.languages.CompletionItemKind>();
 
-    get debugSession(): DebugSession {
+    /**
+     * The debug session this console currently belongs to, or `undefined` once that session has terminated.
+     *
+     * The reference is dropped on termination so that the console does not keep the whole session graph alive
+     * while it preserves the output of that session.
+     */
+    get debugSession(): DebugSession | undefined {
         return this._debugSession;
     }
 
-    set debugSession(value: DebugSession) {
-        this._debugSession = value;
-        this.id = value.id;
+    /**
+     * The label of the session this console belongs to, retained after that session has terminated.
+     */
+    get label(): string {
+        return this._label;
+    }
+
+    /**
+     * The name of the configuration this console was started for, used to match a restarted session to its console.
+     */
+    get configurationName(): string | undefined {
+        return this._configurationName;
+    }
+
+    /**
+     * The workspace folder of the configuration this console was started for, if any.
+     */
+    get workspaceFolderUri(): string | undefined {
+        return this._workspaceFolderUri;
     }
 
     get terminated(): boolean {
@@ -69,10 +108,41 @@ export class DebugConsoleSession extends ConsoleSession {
     markTerminated(): void {
         if (!this._terminated) {
             this._terminated = true;
+            // Release the session: from here on the console only holds the output it has already collected.
+            this._debugSession = undefined;
             this.fireDidChange();
         }
     }
 
+    /**
+     * Whether the given session can take over this console: its session must have terminated and been started from the
+     * same configuration, which in a multi-root workspace includes the folder the configuration comes from.
+     */
+    isReusableBy(session: DebugSession): boolean {
+        return this._terminated
+            && this._configurationName === session.configuration.name
+            && this._workspaceFolderUri === session.options.workspaceFolderUri;
+    }
+
+    /**
+     * Runs the given session in this console, whether it is the session the console was created for or a later one
+     * reusing it. Counterpart of {@link markTerminated}.
+     *
+     * The output of any previous session is dropped: it belongs to that run, and keeping it would merge two runs into
+     * one view with no boundary between them. The filter and severity stay, since they are the view the user has set
+     * up for this configuration.
+     */
+    startFor(session: DebugSession): void {
+        this.items = [];
+        this.uncompletedItemContent = undefined;
+        this._debugSession = session;
+        this._label = session.label;
+        this._configurationName = session.configuration.name;
+        this._workspaceFolderUri = session.options.workspaceFolderUri;
+        this._terminated = false;
+        this.fireDidChange();
+    }
+
     @postConstruct()
     init(): void {
         this.completionKinds.set('method', monaco.languages.CompletionItemKind.Method);
@@ -175,16 +245,17 @@ export class DebugConsoleSession extends ConsoleSession {
     }
 
     protected findCurrentSession(): DebugSession | undefined {
+        const debugSession = this._debugSession;
         const currentSession = this.sessionManager.currentSession;
-        if (!currentSession) {
+        if (!debugSession || !currentSession) {
             return undefined;
         }
-        if (currentSession.id === this.debugSession.id) {
+        if (currentSession.id === debugSession.id) {
             // perfect match
-            return this.debugSession;
+            return debugSession;
         }
         const parentSession = currentSession.findConsoleParent();
-        if (parentSession?.id === this.debugSession.id) {
+        if (parentSession?.id === debugSession.id) {
             // child of our session
             return currentSession;
         }
@@ -215,7 +286,7 @@ export class DebugConsoleSession extends ConsoleSession {
 
     async execute(value: string): Promise<void> {
         const expression = new ExpressionItem(value, () => this.findCurrentSession());
-        this.items.push(expression);
+        this.appendItems([expression]);
         await expression.evaluate();
         this.fireDidChange();
     }
@@ -238,15 +309,28 @@ export class DebugConsoleSession extends ConsoleSession {
             this.uncompletedItemContent = value;
         }
 
-        this.items.push(new AnsiConsoleItem(this.uncompletedItemContent, Severity.Info));
+        this.appendItems([new AnsiConsoleItem(this.uncompletedItemContent, Severity.Info)]);
         this.fireDidChange();
     }
 
     appendLine(value: string): void {
-        this.items.push(new AnsiConsoleItem(value, Severity.Info));
+        this.appendItems([new AnsiConsoleItem(value, Severity.Info)]);
         this.fireDidChange();
     }
 
+    /**
+     * Appends items, dropping the oldest ones so that the console stays within `debug.console.maximumLines`.
+     */
+    protected appendItems(items: ConsoleItem[]): void {
+        for (const item of items) {
+            this.items.push(item);
+        }
+        const maximumLines = this.preferences['debug.console.maximumLines'];
+        if (maximumLines > 0 && this.items.length > maximumLines) {
+            this.items.splice(0, this.items.length - maximumLines);
+        }
+    }
+
     async logOutput(session: DebugSession, event: DebugProtocol.OutputEvent): Promise<void> {
         const body = event.body;
         const { category, variablesReference } = body;
@@ -256,14 +340,13 @@ export class DebugConsoleSession extends ConsoleSession {
         }
         const severity = category === 'stderr' ? Severity.Error : event.body.category === 'console' ? Severity.Warning : Severity.Info;
         if (variablesReference) {
-            const items = await new ExpressionContainer({ session: () => session, variablesReference }).getElements();
-            for (const item of items) {
-                this.items.push(Object.assign(item, { severity }));
-            }
+            // Resolve the session by id rather than capturing it, so that the items do not keep it alive once it is gone.
+            const { id } = session;
+            const sessionProvider = () => this.sessionManager.getSession(id);
+            const items = await new ExpressionContainer({ session: sessionProvider, variablesReference }).getElements();
+            this.appendItems(Array.from(items, item => Object.assign(item, { severity })));
         } else if (typeof body.output === 'string') {
-            for (const line of body.output.split('\n')) {
-                this.items.push(new AnsiConsoleItem(line, severity));
-            }
+            this.appendItems(body.output.split('\n').map(line => new AnsiConsoleItem(line, severity)));
         }
         this.fireDidChange();
     }