@codingame/monaco-vscode-api 3.2.3 → 4.1.0

package/vscode/src/vs/workbench/contrib/debug/browser/debugSession.js

@@ -0,0 +1,1328 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { status } from '../../../../base/browser/ui/aria/aria.js';
+import { distinct } from '../../../../base/common/arrays.js';
+import { RunOnceScheduler, raceTimeout, Queue } from '../../../../base/common/async.js';
+import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
+import { canceled } from '../../../../base/common/errors.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { normalizeDriveLetter } from '../../../../base/common/labels.js';
+import { DisposableStore, MutableDisposable, dispose, Disposable, DisposableMap } from '../../../../base/common/lifecycle.js';
+import { mixin } from '../../../../base/common/objects.js';
+import { language } from '../../../../base/common/platform.js';
+import { basenameOrAuthority } from '../../../../base/common/resources.js';
+import Severity$1 from '../../../../base/common/severity.js';
+import { URI } from '../../../../base/common/uri.js';
+import { generateUuid } from '../../../../base/common/uuid.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.js';
+import { IProductService } from '../../../../platform/product/common/productService.js';
+import { ITelemetryService, ICustomEndpointTelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { RawDebugSession } from './rawDebugSession.js';
+import { IDebugService, VIEWLET_ID } from '../common/debug.js';
+import { MemoryRegion, ExpressionContainer, Thread } from '../common/debugModel.js';
+import { Source } from '../common/debugSource.js';
+import { filterExceptionsFromTelemetry } from '../common/debugUtils.js';
+import { ReplModel } from '../common/replModel.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+import { IHostService } from '../../../services/host/browser/host.js';
+import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
+import { IPaneCompositePartService } from '../../../services/panecomposite/browser/panecomposite.js';
+import { getActiveWindow } from '../../../../base/browser/dom.js';
+import { mainWindow } from '../../../../base/browser/window.js';
+import { isDefined } from '../../../../base/common/types.js';
+const TRIGGERED_BREAKPOINT_MAX_DELAY = 1500;
+let DebugSession = class DebugSession {
+    constructor(id, _configuration, root, model, options, debugService, telemetryService, hostService, configurationService, paneCompositeService, workspaceContextService, productService, notificationService, lifecycleService, uriIdentityService, instantiationService, customEndpointTelemetryService, workbenchEnvironmentService, logService) {
+        this.id = id;
+        this._configuration = _configuration;
+        this.root = root;
+        this.model = model;
+        this.debugService = debugService;
+        this.telemetryService = telemetryService;
+        this.hostService = hostService;
+        this.configurationService = configurationService;
+        this.paneCompositeService = paneCompositeService;
+        this.workspaceContextService = workspaceContextService;
+        this.productService = productService;
+        this.notificationService = notificationService;
+        this.uriIdentityService = uriIdentityService;
+        this.instantiationService = instantiationService;
+        this.customEndpointTelemetryService = customEndpointTelemetryService;
+        this.workbenchEnvironmentService = workbenchEnvironmentService;
+        this.logService = logService;
+        this.initialized = false;
+        this.sources = ( new Map());
+        this.threads = ( new Map());
+        this.threadIds = [];
+        this.cancellationMap = ( new Map());
+        this.rawListeners = ( new DisposableStore());
+        this.globalDisposables = ( new DisposableStore());
+        this.stoppedDetails = [];
+        this.statusQueue = this.rawListeners.add(( new ThreadStatusScheduler()));
+        this._onDidChangeState = ( new Emitter());
+        this._onDidEndAdapter = ( new Emitter());
+        this._onDidLoadedSource = ( new Emitter());
+        this._onDidCustomEvent = ( new Emitter());
+        this._onDidProgressStart = ( new Emitter());
+        this._onDidProgressUpdate = ( new Emitter());
+        this._onDidProgressEnd = ( new Emitter());
+        this._onDidInvalidMemory = ( new Emitter());
+        this._onDidChangeREPLElements = ( new Emitter());
+        this._onDidChangeName = ( new Emitter());
+        this._options = options || {};
+        this.parentSession = this._options.parentSession;
+        if (this.hasSeparateRepl()) {
+            this.repl = ( new ReplModel(this.configurationService));
+        }
+        else {
+            this.repl = this.parentSession.repl;
+        }
+        const toDispose = this.globalDisposables;
+        const replListener = toDispose.add(( new MutableDisposable()));
+        replListener.value = this.repl.onDidChangeElements(() => this._onDidChangeREPLElements.fire());
+        if (lifecycleService) {
+            toDispose.add(lifecycleService.onWillShutdown(() => {
+                this.shutdown();
+                dispose(toDispose);
+            }));
+        }
+        const compoundRoot = this._options.compoundRoot;
+        if (compoundRoot) {
+            toDispose.add(compoundRoot.onDidSessionStop(() => this.terminate()));
+        }
+        this.passFocusScheduler = ( new RunOnceScheduler(() => {
+            if (( this.debugService.getModel().getSessions().some(s => s.state === 2 )) || ( this.getAllThreads().some(t => t.stopped))) {
+                if (typeof this.lastContinuedThreadId === 'number') {
+                    const thread = this.debugService.getViewModel().focusedThread;
+                    if (thread && thread.threadId === this.lastContinuedThreadId && !thread.stopped) {
+                        const toFocusThreadId = this.getStoppedDetails()?.threadId;
+                        const toFocusThread = typeof toFocusThreadId === 'number' ? this.getThread(toFocusThreadId) : undefined;
+                        this.debugService.focusStackFrame(undefined, toFocusThread);
+                    }
+                }
+                else {
+                    const session = this.debugService.getViewModel().focusedSession;
+                    if (session && session.getId() === this.getId() && session.state !== 2 ) {
+                        this.debugService.focusStackFrame(undefined);
+                    }
+                }
+            }
+        }, 800));
+        const parent = this._options.parentSession;
+        if (parent) {
+            toDispose.add(parent.onDidEndAdapter(() => {
+                if (!this.hasSeparateRepl() && this.raw?.isInShutdown === false) {
+                    this.repl = this.repl.clone();
+                    replListener.value = this.repl.onDidChangeElements(() => this._onDidChangeREPLElements.fire());
+                    this.parentSession = undefined;
+                }
+            }));
+        }
+    }
+    getId() {
+        return this.id;
+    }
+    setSubId(subId) {
+        this._subId = subId;
+    }
+    getMemory(memoryReference) {
+        return ( new MemoryRegion(memoryReference, this));
+    }
+    get subId() {
+        return this._subId;
+    }
+    get configuration() {
+        return this._configuration.resolved;
+    }
+    get unresolvedConfiguration() {
+        return this._configuration.unresolved;
+    }
+    get lifecycleManagedByParent() {
+        return !!this._options.lifecycleManagedByParent;
+    }
+    get compact() {
+        return !!this._options.compact;
+    }
+    get saveBeforeRestart() {
+        return this._options.saveBeforeRestart ?? !this._options?.parentSession;
+    }
+    get compoundRoot() {
+        return this._options.compoundRoot;
+    }
+    get suppressDebugStatusbar() {
+        return this._options.suppressDebugStatusbar ?? false;
+    }
+    get suppressDebugToolbar() {
+        return this._options.suppressDebugToolbar ?? false;
+    }
+    get suppressDebugView() {
+        return this._options.suppressDebugView ?? false;
+    }
+    get autoExpandLazyVariables() {
+        return this.configurationService.getValue('debug').autoExpandLazyVariables;
+    }
+    setConfiguration(configuration) {
+        this._configuration = configuration;
+    }
+    getLabel() {
+        const includeRoot = this.workspaceContextService.getWorkspace().folders.length > 1;
+        return includeRoot && this.root ? `${this.name} (${basenameOrAuthority(this.root.uri)})` : this.name;
+    }
+    setName(name) {
+        this._name = name;
+        this._onDidChangeName.fire(name);
+    }
+    get name() {
+        return this._name || this.configuration.name;
+    }
+    get state() {
+        if (!this.initialized) {
+            return 1 ;
+        }
+        if (!this.raw) {
+            return 0 ;
+        }
+        const focusedThread = this.debugService.getViewModel().focusedThread;
+        if (focusedThread && focusedThread.session === this) {
+            return focusedThread.stopped ? 2  : 3 ;
+        }
+        if (( this.getAllThreads().some(t => t.stopped))) {
+            return 2 ;
+        }
+        return 3 ;
+    }
+    get capabilities() {
+        return this.raw ? this.raw.capabilities : Object.create(null);
+    }
+    get onDidChangeState() {
+        return this._onDidChangeState.event;
+    }
+    get onDidEndAdapter() {
+        return this._onDidEndAdapter.event;
+    }
+    get onDidChangeReplElements() {
+        return this._onDidChangeREPLElements.event;
+    }
+    get onDidChangeName() {
+        return this._onDidChangeName.event;
+    }
+    get onDidCustomEvent() {
+        return this._onDidCustomEvent.event;
+    }
+    get onDidLoadedSource() {
+        return this._onDidLoadedSource.event;
+    }
+    get onDidProgressStart() {
+        return this._onDidProgressStart.event;
+    }
+    get onDidProgressUpdate() {
+        return this._onDidProgressUpdate.event;
+    }
+    get onDidProgressEnd() {
+        return this._onDidProgressEnd.event;
+    }
+    get onDidInvalidateMemory() {
+        return this._onDidInvalidMemory.event;
+    }
+    async initialize(dbgr) {
+        if (this.raw) {
+            await this.shutdown();
+        }
+        try {
+            const debugAdapter = await dbgr.createDebugAdapter(this);
+            this.raw = this.instantiationService.createInstance(RawDebugSession, debugAdapter, dbgr, this.id, this.configuration.name);
+            await this.raw.start();
+            this.registerListeners();
+            await this.raw.initialize({
+                clientID: 'vscode',
+                clientName: this.productService.nameLong,
+                adapterID: this.configuration.type,
+                pathFormat: 'path',
+                linesStartAt1: true,
+                columnsStartAt1: true,
+                supportsVariableType: true,
+                supportsVariablePaging: true,
+                supportsRunInTerminalRequest: true,
+                locale: language,
+                supportsProgressReporting: true,
+                supportsInvalidatedEvent: true,
+                supportsMemoryReferences: true,
+                supportsArgsCanBeInterpretedByShell: true,
+                supportsMemoryEvent: true,
+                supportsStartDebuggingRequest: true
+            });
+            this.initialized = true;
+            this._onDidChangeState.fire();
+            this.debugService.setExceptionBreakpointsForSession(this, (this.raw && this.raw.capabilities.exceptionBreakpointFilters) || []);
+            this.debugService.getModel().registerBreakpointModes(this.configuration.type, this.raw.capabilities.breakpointModes || []);
+        }
+        catch (err) {
+            this.initialized = true;
+            this._onDidChangeState.fire();
+            await this.shutdown();
+            throw err;
+        }
+    }
+    async launchOrAttach(config) {
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'launch or attach'));
+        }
+        if (this.parentSession && this.parentSession.state === 0 ) {
+            throw canceled();
+        }
+        config.__sessionId = this.getId();
+        try {
+            await this.raw.launchOrAttach(config);
+        }
+        catch (err) {
+            this.shutdown();
+            throw err;
+        }
+    }
+    async terminate(restart = false) {
+        if (!this.raw) {
+            this.onDidExitAdapter();
+        }
+        this.cancelAllRequests();
+        if (this._options.lifecycleManagedByParent && this.parentSession) {
+            await this.parentSession.terminate(restart);
+        }
+        else if (this.raw) {
+            if (this.raw.capabilities.supportsTerminateRequest && this._configuration.resolved.request === 'launch') {
+                await this.raw.terminate(restart);
+            }
+            else {
+                await this.raw.disconnect({ restart, terminateDebuggee: true });
+            }
+        }
+        if (!restart) {
+            this._options.compoundRoot?.sessionStopped();
+        }
+    }
+    async disconnect(restart = false, suspend = false) {
+        if (!this.raw) {
+            this.onDidExitAdapter();
+        }
+        this.cancelAllRequests();
+        if (this._options.lifecycleManagedByParent && this.parentSession) {
+            await this.parentSession.disconnect(restart, suspend);
+        }
+        else if (this.raw) {
+            await this.raw.disconnect({ restart, terminateDebuggee: false, suspendDebuggee: suspend });
+        }
+        if (!restart) {
+            this._options.compoundRoot?.sessionStopped();
+        }
+    }
+    async restart() {
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'restart'));
+        }
+        this.cancelAllRequests();
+        if (this._options.lifecycleManagedByParent && this.parentSession) {
+            await this.parentSession.restart();
+        }
+        else {
+            await this.raw.restart({ arguments: this.configuration });
+        }
+    }
+    async sendBreakpoints(modelUri, breakpointsToSend, sourceModified) {
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'breakpoints'));
+        }
+        if (!this.raw.readyForBreakpoints) {
+            return Promise.resolve(undefined);
+        }
+        const rawSource = this.getRawSource(modelUri);
+        if (breakpointsToSend.length && !rawSource.adapterData) {
+            rawSource.adapterData = breakpointsToSend[0].adapterData;
+        }
+        if (rawSource.path) {
+            rawSource.path = normalizeDriveLetter(rawSource.path);
+        }
+        const response = await this.raw.setBreakpoints({
+            source: rawSource,
+            lines: ( breakpointsToSend.map(bp => bp.sessionAgnosticData.lineNumber)),
+            breakpoints: ( breakpointsToSend.map(bp => bp.toDAP())),
+            sourceModified
+        });
+        if (response?.body) {
+            const data = ( new Map());
+            for (let i = 0; i < breakpointsToSend.length; i++) {
+                data.set(breakpointsToSend[i].getId(), response.body.breakpoints[i]);
+            }
+            this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
+        }
+    }
+    async sendFunctionBreakpoints(fbpts) {
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'function breakpoints'));
+        }
+        if (this.raw.readyForBreakpoints) {
+            const response = await this.raw.setFunctionBreakpoints({ breakpoints: ( fbpts.map(bp => bp.toDAP())) });
+            if (response?.body) {
+                const data = ( new Map());
+                for (let i = 0; i < fbpts.length; i++) {
+                    data.set(fbpts[i].getId(), response.body.breakpoints[i]);
+                }
+                this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
+            }
+        }
+    }
+    async sendExceptionBreakpoints(exbpts) {
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'exception breakpoints'));
+        }
+        if (this.raw.readyForBreakpoints) {
+            const args = this.capabilities.supportsExceptionFilterOptions ? {
+                filters: [],
+                filterOptions: ( exbpts.map(exb => {
+                    if (exb.condition) {
+                        return { filterId: exb.filter, condition: exb.condition };
+                    }
+                    return { filterId: exb.filter };
+                }))
+            } : { filters: ( exbpts.map(exb => exb.filter)) };
+            const response = await this.raw.setExceptionBreakpoints(args);
+            if (response?.body && response.body.breakpoints) {
+                const data = ( new Map());
+                for (let i = 0; i < exbpts.length; i++) {
+                    data.set(exbpts[i].getId(), response.body.breakpoints[i]);
+                }
+                this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
+            }
+        }
+    }
+    dataBytesBreakpointInfo(address, bytes) {
+        if (this.raw?.capabilities.supportsDataBreakpointBytes === false) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'sessionDoesNotSupporBytesBreakpoints', "Session does not support breakpoints with bytes"));
+        }
+        return this._dataBreakpointInfo({ name: address, bytes, asAddress: true });
+    }
+    dataBreakpointInfo(name, variablesReference) {
+        return this._dataBreakpointInfo({ name, variablesReference });
+    }
+    async _dataBreakpointInfo(args) {
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'data breakpoints info'));
+        }
+        if (!this.raw.readyForBreakpoints) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'sessionNotReadyForBreakpoints', "Session is not ready for breakpoints"));
+        }
+        const response = await this.raw.dataBreakpointInfo(args);
+        return response?.body;
+    }
+    async sendDataBreakpoints(dataBreakpoints) {
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'data breakpoints'));
+        }
+        if (this.raw.readyForBreakpoints) {
+            const converted = await Promise.all(( dataBreakpoints.map(async (bp) => {
+                try {
+                    const dap = await bp.toDAP(this);
+                    return { dap, bp };
+                }
+                catch (e) {
+                    return { bp, message: e.message };
+                }
+            })));
+            const response = await this.raw.setDataBreakpoints({ breakpoints: ( converted.map(d => d.dap)).filter(isDefined) });
+            if (response?.body) {
+                const data = ( new Map());
+                let i = 0;
+                for (const dap of converted) {
+                    if (!dap.dap) {
+                        data.set(dap.bp.getId(), dap.message);
+                    }
+                    else if (i < response.body.breakpoints.length) {
+                        data.set(dap.bp.getId(), response.body.breakpoints[i++]);
+                    }
+                }
+                this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
+            }
+        }
+    }
+    async sendInstructionBreakpoints(instructionBreakpoints) {
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'instruction breakpoints'));
+        }
+        if (this.raw.readyForBreakpoints) {
+            const response = await this.raw.setInstructionBreakpoints({ breakpoints: ( instructionBreakpoints.map(ib => ib.toDAP())) });
+            if (response?.body) {
+                const data = ( new Map());
+                for (let i = 0; i < instructionBreakpoints.length; i++) {
+                    data.set(instructionBreakpoints[i].getId(), response.body.breakpoints[i]);
+                }
+                this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
+            }
+        }
+    }
+    async breakpointsLocations(uri, lineNumber) {
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'breakpoints locations'));
+        }
+        const source = this.getRawSource(uri);
+        const response = await this.raw.breakpointLocations({ source, line: lineNumber });
+        if (!response || !response.body || !response.body.breakpoints) {
+            return [];
+        }
+        const positions = ( response.body.breakpoints.map(bp => ({ lineNumber: bp.line, column: bp.column || 1 })));
+        return distinct(positions, p => `${p.lineNumber}:${p.column}`);
+    }
+    getDebugProtocolBreakpoint(breakpointId) {
+        return this.model.getDebugProtocolBreakpoint(breakpointId, this.getId());
+    }
+    customRequest(request, args) {
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", request));
+        }
+        return this.raw.custom(request, args);
+    }
+    stackTrace(threadId, startFrame, levels, token) {
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'stackTrace'));
+        }
+        const sessionToken = this.getNewCancellationToken(threadId, token);
+        return this.raw.stackTrace({ threadId, startFrame, levels }, sessionToken);
+    }
+    async exceptionInfo(threadId) {
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'exceptionInfo'));
+        }
+        const response = await this.raw.exceptionInfo({ threadId });
+        if (response) {
+            return {
+                id: response.body.exceptionId,
+                description: response.body.description,
+                breakMode: response.body.breakMode,
+                details: response.body.details
+            };
+        }
+        return undefined;
+    }
+    scopes(frameId, threadId) {
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'scopes'));
+        }
+        const token = this.getNewCancellationToken(threadId);
+        return this.raw.scopes({ frameId }, token);
+    }
+    variables(variablesReference, threadId, filter, start, count) {
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'variables'));
+        }
+        const token = threadId ? this.getNewCancellationToken(threadId) : undefined;
+        return this.raw.variables({ variablesReference, filter, start, count }, token);
+    }
+    evaluate(expression, frameId, context) {
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'evaluate'));
+        }
+        return this.raw.evaluate({ expression, frameId, context });
+    }
+    async restartFrame(frameId, threadId) {
+        await this.waitForTriggeredBreakpoints();
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'restartFrame'));
+        }
+        await this.raw.restartFrame({ frameId }, threadId);
+    }
+    setLastSteppingGranularity(threadId, granularity) {
+        const thread = this.getThread(threadId);
+        if (thread) {
+            thread.lastSteppingGranularity = granularity;
+        }
+    }
+    async next(threadId, granularity) {
+        await this.waitForTriggeredBreakpoints();
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'next'));
+        }
+        this.setLastSteppingGranularity(threadId, granularity);
+        await this.raw.next({ threadId, granularity });
+    }
+    async stepIn(threadId, targetId, granularity) {
+        await this.waitForTriggeredBreakpoints();
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'stepIn'));
+        }
+        this.setLastSteppingGranularity(threadId, granularity);
+        await this.raw.stepIn({ threadId, targetId, granularity });
+    }
+    async stepOut(threadId, granularity) {
+        await this.waitForTriggeredBreakpoints();
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'stepOut'));
+        }
+        this.setLastSteppingGranularity(threadId, granularity);
+        await this.raw.stepOut({ threadId, granularity });
+    }
+    async stepBack(threadId, granularity) {
+        await this.waitForTriggeredBreakpoints();
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'stepBack'));
+        }
+        this.setLastSteppingGranularity(threadId, granularity);
+        await this.raw.stepBack({ threadId, granularity });
+    }
+    async continue(threadId) {
+        await this.waitForTriggeredBreakpoints();
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'continue'));
+        }
+        await this.raw.continue({ threadId });
+    }
+    async reverseContinue(threadId) {
+        await this.waitForTriggeredBreakpoints();
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'reverse continue'));
+        }
+        await this.raw.reverseContinue({ threadId });
+    }
+    async pause(threadId) {
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'pause'));
+        }
+        await this.raw.pause({ threadId });
+    }
+    async terminateThreads(threadIds) {
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'terminateThreads'));
+        }
+        await this.raw.terminateThreads({ threadIds });
+    }
+    setVariable(variablesReference, name, value) {
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'setVariable'));
+        }
+        return this.raw.setVariable({ variablesReference, name, value });
+    }
+    setExpression(frameId, expression, value) {
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'setExpression'));
+        }
+        return this.raw.setExpression({ expression, value, frameId });
+    }
+    gotoTargets(source, line, column) {
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'gotoTargets'));
+        }
+        return this.raw.gotoTargets({ source, line, column });
+    }
+    goto(threadId, targetId) {
+        if (!this.raw) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'goto'));
+        }
+        return this.raw.goto({ threadId, targetId });
+    }
+    loadSource(resource) {
+        if (!this.raw) {
+            return Promise.reject(( new Error(( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/debugSession',
+                'noDebugAdapter',
+                "No debugger available, can not send '{0}'",
+                'loadSource'
+            )))));
+        }
+        const source = this.getSourceForUri(resource);
+        let rawSource;
+        if (source) {
+            rawSource = source.raw;
+        }
+        else {
+            const data = Source.getEncodedDebugData(resource);
+            rawSource = { path: data.path, sourceReference: data.sourceReference };
+        }
+        return this.raw.source({ sourceReference: rawSource.sourceReference || 0, source: rawSource });
+    }
+    async getLoadedSources() {
+        if (!this.raw) {
+            return Promise.reject(( new Error(( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/debugSession',
+                'noDebugAdapter',
+                "No debugger available, can not send '{0}'",
+                'getLoadedSources'
+            )))));
+        }
+        const response = await this.raw.loadedSources({});
+        if (response?.body && response.body.sources) {
+            return ( response.body.sources.map(src => this.getSource(src)));
+        }
+        else {
+            return [];
+        }
+    }
+    async completions(frameId, threadId, text, position, overwriteBefore, token) {
+        if (!this.raw) {
+            return Promise.reject(( new Error(( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/debugSession',
+                'noDebugAdapter',
+                "No debugger available, can not send '{0}'",
+                'completions'
+            )))));
+        }
+        const sessionCancelationToken = this.getNewCancellationToken(threadId, token);
+        return this.raw.completions({
+            frameId,
+            text,
+            column: position.column,
+            line: position.lineNumber,
+        }, sessionCancelationToken);
+    }
+    async stepInTargets(frameId) {
+        if (!this.raw) {
+            return Promise.reject(( new Error(( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/debugSession',
+                'noDebugAdapter',
+                "No debugger available, can not send '{0}'",
+                'stepInTargets'
+            )))));
+        }
+        const response = await this.raw.stepInTargets({ frameId });
+        return response?.body.targets;
+    }
+    async cancel(progressId) {
+        if (!this.raw) {
+            return Promise.reject(( new Error(( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/debugSession',
+                'noDebugAdapter',
+                "No debugger available, can not send '{0}'",
+                'cancel'
+            )))));
+        }
+        return this.raw.cancel({ progressId });
+    }
+    async disassemble(memoryReference, offset, instructionOffset, instructionCount) {
+        if (!this.raw) {
+            return Promise.reject(( new Error(( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/debugSession',
+                'noDebugAdapter',
+                "No debugger available, can not send '{0}'",
+                'disassemble'
+            )))));
+        }
+        const response = await this.raw.disassemble({ memoryReference, offset, instructionOffset, instructionCount, resolveSymbols: true });
+        return response?.body?.instructions;
+    }
+    readMemory(memoryReference, offset, count) {
+        if (!this.raw) {
+            return Promise.reject(( new Error(( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/debugSession',
+                'noDebugAdapter',
+                "No debugger available, can not send '{0}'",
+                'readMemory'
+            )))));
+        }
+        return this.raw.readMemory({ count, memoryReference, offset });
+    }
+    writeMemory(memoryReference, offset, data, allowPartial) {
+        if (!this.raw) {
+            return Promise.reject(( new Error(( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/debugSession',
+                'noDebugAdapter',
+                "No debugger available, can not send '{0}'",
+                'disassemble'
+            )))));
+        }
+        return this.raw.writeMemory({ memoryReference, offset, allowPartial, data });
+    }
+    getThread(threadId) {
+        return this.threads.get(threadId);
+    }
+    getAllThreads() {
+        const result = [];
+        this.threadIds.forEach((threadId) => {
+            const thread = this.threads.get(threadId);
+            if (thread) {
+                result.push(thread);
+            }
+        });
+        return result;
+    }
+    clearThreads(removeThreads, reference = undefined) {
+        if (reference !== undefined && reference !== null) {
+            const thread = this.threads.get(reference);
+            if (thread) {
+                thread.clearCallStack();
+                thread.stoppedDetails = undefined;
+                thread.stopped = false;
+                if (removeThreads) {
+                    this.threads.delete(reference);
+                }
+            }
+        }
+        else {
+            this.threads.forEach(thread => {
+                thread.clearCallStack();
+                thread.stoppedDetails = undefined;
+                thread.stopped = false;
+            });
+            if (removeThreads) {
+                this.threads.clear();
+                this.threadIds = [];
+                ExpressionContainer.allValues.clear();
+            }
+        }
+    }
+    getStoppedDetails() {
+        return this.stoppedDetails.length >= 1 ? this.stoppedDetails[0] : undefined;
+    }
+    rawUpdate(data) {
+        this.threadIds = [];
+        data.threads.forEach(thread => {
+            this.threadIds.push(thread.id);
+            if (!( this.threads.has(thread.id))) {
+                this.threads.set(thread.id, ( new Thread(this, thread.name, thread.id)));
+            }
+            else if (thread.name) {
+                const oldThread = this.threads.get(thread.id);
+                if (oldThread) {
+                    oldThread.name = thread.name;
+                }
+            }
+        });
+        this.threads.forEach(t => {
+            if (this.threadIds.indexOf(t.threadId) === -1) {
+                this.threads.delete(t.threadId);
+            }
+        });
+        const stoppedDetails = data.stoppedDetails;
+        if (stoppedDetails) {
+            if (stoppedDetails.allThreadsStopped) {
+                this.threads.forEach(thread => {
+                    thread.stoppedDetails = thread.threadId === stoppedDetails.threadId ? stoppedDetails : { reason: thread.stoppedDetails?.reason };
+                    thread.stopped = true;
+                    thread.clearCallStack();
+                });
+            }
+            else {
+                const thread = typeof stoppedDetails.threadId === 'number' ? this.threads.get(stoppedDetails.threadId) : undefined;
+                if (thread) {
+                    thread.stoppedDetails = stoppedDetails;
+                    thread.clearCallStack();
+                    thread.stopped = true;
+                }
+            }
+        }
+    }
+    waitForTriggeredBreakpoints() {
+        if (!this._waitToResume) {
+            return;
+        }
+        return raceTimeout(this._waitToResume, TRIGGERED_BREAKPOINT_MAX_DELAY);
+    }
+    async fetchThreads(stoppedDetails) {
+        if (this.raw) {
+            const response = await this.raw.threads();
+            if (response?.body && response.body.threads) {
+                this.model.rawUpdate({
+                    sessionId: this.getId(),
+                    threads: response.body.threads,
+                    stoppedDetails
+                });
+            }
+        }
+    }
+    initializeForTest(raw) {
+        this.raw = raw;
+        this.registerListeners();
+    }
+    registerListeners() {
+        if (!this.raw) {
+            return;
+        }
+        this.rawListeners.add(this.raw.onDidInitialize(async () => {
+            status(this.configuration.noDebug
+                ? ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/debugSession',
+                'debuggingStartedNoDebug',
+                "Started running without debugging."
+            ))
+                : ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/debugSession',
+                'debuggingStarted',
+                "Debugging started."
+            )));
+            const sendConfigurationDone = async () => {
+                if (this.raw && this.raw.capabilities.supportsConfigurationDoneRequest) {
+                    try {
+                        await this.raw.configurationDone();
+                    }
+                    catch (e) {
+                        this.notificationService.error(e);
+                        this.raw?.disconnect({});
+                    }
+                }
+                return undefined;
+            };
+            try {
+                await this.debugService.sendAllBreakpoints(this);
+            }
+            finally {
+                await sendConfigurationDone();
+                await this.fetchThreads();
+            }
+        }));
+        const statusQueue = this.statusQueue;
+        this.rawListeners.add(this.raw.onDidStop(event => this.handleStop(event.body)));
+        this.rawListeners.add(this.raw.onDidThread(event => {
+            statusQueue.cancel([event.body.threadId]);
+            if (event.body.reason === 'started') {
+                if (!this.fetchThreadsScheduler) {
+                    this.fetchThreadsScheduler = ( new RunOnceScheduler(() => {
+                        this.fetchThreads();
+                    }, 100));
+                    this.rawListeners.add(this.fetchThreadsScheduler);
+                }
+                if (!this.fetchThreadsScheduler.isScheduled()) {
+                    this.fetchThreadsScheduler.schedule();
+                }
+            }
+            else if (event.body.reason === 'exited') {
+                this.model.clearThreads(this.getId(), true, event.body.threadId);
+                const viewModel = this.debugService.getViewModel();
+                const focusedThread = viewModel.focusedThread;
+                this.passFocusScheduler.cancel();
+                if (focusedThread && event.body.threadId === focusedThread.threadId) {
+                    this.debugService.focusStackFrame(undefined, undefined, viewModel.focusedSession, { explicit: false });
+                }
+            }
+        }));
+        this.rawListeners.add(this.raw.onDidTerminateDebugee(async (event) => {
+            status(( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/debugSession',
+                'debuggingStopped',
+                "Debugging stopped."
+            )));
+            if (event.body && event.body.restart) {
+                await this.debugService.restartSession(this, event.body.restart);
+            }
+            else if (this.raw) {
+                await this.raw.disconnect({ terminateDebuggee: false });
+            }
+        }));
+        this.rawListeners.add(this.raw.onDidContinued(event => {
+            const allThreads = event.body.allThreadsContinued !== false;
+            statusQueue.cancel(allThreads ? undefined : [event.body.threadId]);
+            const threadId = allThreads ? undefined : event.body.threadId;
+            if (typeof threadId === 'number') {
+                this.stoppedDetails = this.stoppedDetails.filter(sd => sd.threadId !== threadId);
+                const tokens = this.cancellationMap.get(threadId);
+                this.cancellationMap.delete(threadId);
+                tokens?.forEach(t => t.dispose(true));
+            }
+            else {
+                this.stoppedDetails = [];
+                this.cancelAllRequests();
+            }
+            this.lastContinuedThreadId = threadId;
+            this.passFocusScheduler.schedule();
+            this.model.clearThreads(this.getId(), false, threadId);
+            this._onDidChangeState.fire();
+        }));
+        const outputQueue = ( new Queue());
+        this.rawListeners.add(this.raw.onDidOutput(async (event) => {
+            const outputSeverity = event.body.category === 'stderr' ? Severity$1.Error : event.body.category === 'console' ? Severity$1.Warning : Severity$1.Info;
+            if (event.body.variablesReference) {
+                const source = event.body.source && event.body.line ? {
+                    lineNumber: event.body.line,
+                    column: event.body.column ? event.body.column : 1,
+                    source: this.getSource(event.body.source)
+                } : undefined;
+                const container = ( new ExpressionContainer(this, undefined, event.body.variablesReference, generateUuid()));
+                const children = container.getChildren();
+                outputQueue.queue(async () => {
+                    const resolved = await children;
+                    if (resolved.length === 1) {
+                        this.appendToRepl({ output: event.body.output, expression: resolved[0], sev: outputSeverity, source }, event.body.category === 'important');
+                        return;
+                    }
+                    resolved.forEach((child) => {
+                        child.name = null;
+                        this.appendToRepl({ output: '', expression: child, sev: outputSeverity, source }, event.body.category === 'important');
+                    });
+                });
+                return;
+            }
+            outputQueue.queue(async () => {
+                if (!event.body || !this.raw) {
+                    return;
+                }
+                if (event.body.category === 'telemetry') {
+                    const telemetryEndpoint = this.raw.dbgr.getCustomTelemetryEndpoint();
+                    if (telemetryEndpoint && this.telemetryService.telemetryLevel !== 0 ) {
+                        let data = event.body.data;
+                        if (!telemetryEndpoint.sendErrorTelemetry && event.body.data) {
+                            data = filterExceptionsFromTelemetry(event.body.data);
+                        }
+                        this.customEndpointTelemetryService.publicLog(telemetryEndpoint, event.body.output, data);
+                    }
+                    return;
+                }
+                const source = event.body.source && event.body.line ? {
+                    lineNumber: event.body.line,
+                    column: event.body.column ? event.body.column : 1,
+                    source: this.getSource(event.body.source)
+                } : undefined;
+                if (event.body.group === 'start' || event.body.group === 'startCollapsed') {
+                    const expanded = event.body.group === 'start';
+                    this.repl.startGroup(event.body.output || '', expanded, source);
+                    return;
+                }
+                if (event.body.group === 'end') {
+                    this.repl.endGroup();
+                    if (!event.body.output) {
+                        return;
+                    }
+                }
+                if (typeof event.body.output === 'string') {
+                    this.appendToRepl({ output: event.body.output, sev: outputSeverity, source }, event.body.category === 'important');
+                }
+            });
+        }));
+        this.rawListeners.add(this.raw.onDidBreakpoint(event => {
+            const id = event.body && event.body.breakpoint ? event.body.breakpoint.id : undefined;
+            const breakpoint = this.model.getBreakpoints().find(bp => bp.getIdFromAdapter(this.getId()) === id);
+            const functionBreakpoint = this.model.getFunctionBreakpoints().find(bp => bp.getIdFromAdapter(this.getId()) === id);
+            const dataBreakpoint = this.model.getDataBreakpoints().find(dbp => dbp.getIdFromAdapter(this.getId()) === id);
+            const exceptionBreakpoint = this.model.getExceptionBreakpoints().find(excbp => excbp.getIdFromAdapter(this.getId()) === id);
+            if (event.body.reason === 'new' && event.body.breakpoint.source && event.body.breakpoint.line) {
+                const source = this.getSource(event.body.breakpoint.source);
+                const bps = this.model.addBreakpoints(source.uri, [{
+                        column: event.body.breakpoint.column,
+                        enabled: true,
+                        lineNumber: event.body.breakpoint.line,
+                    }], false);
+                if (bps.length === 1) {
+                    const data = ( new Map([[bps[0].getId(), event.body.breakpoint]]));
+                    this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
+                }
+            }
+            if (event.body.reason === 'removed') {
+                if (breakpoint) {
+                    this.model.removeBreakpoints([breakpoint]);
+                }
+                if (functionBreakpoint) {
+                    this.model.removeFunctionBreakpoints(functionBreakpoint.getId());
+                }
+                if (dataBreakpoint) {
+                    this.model.removeDataBreakpoints(dataBreakpoint.getId());
+                }
+            }
+            if (event.body.reason === 'changed') {
+                if (breakpoint) {
+                    if (!breakpoint.column) {
+                        event.body.breakpoint.column = undefined;
+                    }
+                    const data = ( new Map([[breakpoint.getId(), event.body.breakpoint]]));
+                    this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
+                }
+                if (functionBreakpoint) {
+                    const data = ( new Map([[functionBreakpoint.getId(), event.body.breakpoint]]));
+                    this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
+                }
+                if (dataBreakpoint) {
+                    const data = ( new Map([[dataBreakpoint.getId(), event.body.breakpoint]]));
+                    this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
+                }
+                if (exceptionBreakpoint) {
+                    const data = ( new Map([[exceptionBreakpoint.getId(), event.body.breakpoint]]));
+                    this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
+                }
+            }
+        }));
+        this.rawListeners.add(this.raw.onDidLoadedSource(event => {
+            this._onDidLoadedSource.fire({
+                reason: event.body.reason,
+                source: this.getSource(event.body.source)
+            });
+        }));
+        this.rawListeners.add(this.raw.onDidCustomEvent(event => {
+            this._onDidCustomEvent.fire(event);
+        }));
+        this.rawListeners.add(this.raw.onDidProgressStart(event => {
+            this._onDidProgressStart.fire(event);
+        }));
+        this.rawListeners.add(this.raw.onDidProgressUpdate(event => {
+            this._onDidProgressUpdate.fire(event);
+        }));
+        this.rawListeners.add(this.raw.onDidProgressEnd(event => {
+            this._onDidProgressEnd.fire(event);
+        }));
+        this.rawListeners.add(this.raw.onDidInvalidateMemory(event => {
+            this._onDidInvalidMemory.fire(event);
+        }));
+        this.rawListeners.add(this.raw.onDidInvalidated(async (event) => {
+            const areas = event.body.areas || ['all'];
+            if (areas.includes('threads') || areas.includes('stacks') || areas.includes('all')) {
+                this.cancelAllRequests();
+                this.model.clearThreads(this.getId(), true);
+                const details = this.stoppedDetails;
+                this.stoppedDetails.length = 1;
+                await Promise.all(( details.map(d => this.handleStop(d))));
+            }
+            const viewModel = this.debugService.getViewModel();
+            if (viewModel.focusedSession === this) {
+                viewModel.updateViews();
+            }
+        }));
+        this.rawListeners.add(this.raw.onDidExitAdapter(event => this.onDidExitAdapter(event)));
+    }
+    async handleStop(event) {
+        this.passFocusScheduler.cancel();
+        this.stoppedDetails.push(event);
+        if (event.hitBreakpointIds) {
+            this._waitToResume = this.enableDependentBreakpoints(event.hitBreakpointIds);
+        }
+        this.statusQueue.run(this.fetchThreads(event).then(() => event.threadId === undefined ? this.threadIds : [event.threadId]), async (threadId, token) => {
+            const hasLotsOfThreads = event.threadId === undefined && this.threadIds.length > 10;
+            const focusedThread = this.debugService.getViewModel().focusedThread;
+            const focusedThreadDoesNotExist = focusedThread !== undefined && focusedThread.session === this && !( this.threads.has(focusedThread.threadId));
+            if (focusedThreadDoesNotExist) {
+                this.debugService.focusStackFrame(undefined, undefined);
+            }
+            const thread = typeof threadId === 'number' ? this.getThread(threadId) : undefined;
+            if (thread) {
+                const promises = this.model.refreshTopOfCallstack(thread,  !hasLotsOfThreads);
+                const focus = async () => {
+                    if (focusedThreadDoesNotExist || (!event.preserveFocusHint && thread.getCallStack().length)) {
+                        const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
+                        if (!focusedStackFrame || focusedStackFrame.thread.session === this) {
+                            const preserveFocus = !this.configurationService.getValue('debug').focusEditorOnBreak;
+                            await this.debugService.focusStackFrame(undefined, thread, undefined, { preserveFocus });
+                        }
+                        if (thread.stoppedDetails && !token.isCancellationRequested) {
+                            if (thread.stoppedDetails.reason === 'breakpoint' && this.configurationService.getValue('debug').openDebug === 'openOnDebugBreak' && !this.suppressDebugView) {
+                                await this.paneCompositeService.openPaneComposite(VIEWLET_ID, 0 );
+                            }
+                            if (this.configurationService.getValue('debug').focusWindowOnBreak && !this.workbenchEnvironmentService.extensionTestsLocationURI) {
+                                const activeWindow = getActiveWindow();
+                                if (!activeWindow.document.hasFocus()) {
+                                    await this.hostService.focus(mainWindow, { force: true  });
+                                }
+                            }
+                        }
+                    }
+                };
+                await promises.topCallStack;
+                if (!event.hitBreakpointIds) {
+                    this._waitToResume = this.enableDependentBreakpoints(thread);
+                }
+                if (token.isCancellationRequested) {
+                    return;
+                }
+                focus();
+                await promises.wholeCallStack;
+                if (token.isCancellationRequested) {
+                    return;
+                }
+                const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
+                if (!focusedStackFrame || !focusedStackFrame.source || focusedStackFrame.source.presentationHint === 'deemphasize' || focusedStackFrame.presentationHint === 'deemphasize') {
+                    focus();
+                }
+            }
+            this._onDidChangeState.fire();
+        });
+    }
+    async enableDependentBreakpoints(hitBreakpointIdsOrThread) {
+        let breakpoints;
+        if (Array.isArray(hitBreakpointIdsOrThread)) {
+            breakpoints = this.model.getBreakpoints().filter(bp => hitBreakpointIdsOrThread.includes(bp.getIdFromAdapter(this.id)));
+        }
+        else {
+            const frame = hitBreakpointIdsOrThread.getTopStackFrame();
+            if (frame === undefined) {
+                return;
+            }
+            if (hitBreakpointIdsOrThread.stoppedDetails && hitBreakpointIdsOrThread.stoppedDetails.reason !== 'breakpoint') {
+                return;
+            }
+            breakpoints = this.getBreakpointsAtPosition(frame.source.uri, frame.range.startLineNumber, frame.range.endLineNumber, frame.range.startColumn, frame.range.endColumn);
+        }
+        const urisToResend = ( new Set());
+        this.model.getBreakpoints({ triggeredOnly: true, enabledOnly: true }).forEach(bp => {
+            breakpoints.forEach(cbp => {
+                if (bp.enabled && bp.triggeredBy === cbp.getId()) {
+                    bp.setSessionDidTrigger(this.getId());
+                    urisToResend.add(( bp.uri.toString()));
+                }
+            });
+        });
+        const results = [];
+        urisToResend.forEach((uri) => results.push(this.debugService.sendBreakpoints(( URI.parse(uri)), undefined, this)));
+        return Promise.all(results);
+    }
+    getBreakpointsAtPosition(uri, startLineNumber, endLineNumber, startColumn, endColumn) {
+        return this.model.getBreakpoints({ uri: uri }).filter(bp => {
+            if (bp.lineNumber < startLineNumber || bp.lineNumber > endLineNumber) {
+                return false;
+            }
+            if (bp.column && (bp.column < startColumn || bp.column > endColumn)) {
+                return false;
+            }
+            return true;
+        });
+    }
+    onDidExitAdapter(event) {
+        this.initialized = true;
+        this.model.setBreakpointSessionData(this.getId(), this.capabilities, undefined);
+        this.shutdown();
+        this._onDidEndAdapter.fire(event);
+    }
+    shutdown() {
+        this.rawListeners.clear();
+        if (this.raw) {
+            this.raw.disconnect({});
+            this.raw.dispose();
+            this.raw = undefined;
+        }
+        this.fetchThreadsScheduler?.dispose();
+        this.fetchThreadsScheduler = undefined;
+        this.passFocusScheduler.cancel();
+        this.passFocusScheduler.dispose();
+        this.model.clearThreads(this.getId(), true);
+        this._onDidChangeState.fire();
+    }
+    dispose() {
+        this.cancelAllRequests();
+        this.rawListeners.dispose();
+        this.globalDisposables.dispose();
+    }
+    getSourceForUri(uri) {
+        return this.sources.get(( this.uriIdentityService.asCanonicalUri(uri).toString()));
+    }
+    getSource(raw) {
+        let source = ( new Source(raw, this.getId(), this.uriIdentityService, this.logService));
+        const uriKey = ( source.uri.toString());
+        const found = this.sources.get(uriKey);
+        if (found) {
+            source = found;
+            source.raw = mixin(source.raw, raw);
+            if (source.raw && raw) {
+                source.raw.presentationHint = raw.presentationHint;
+            }
+        }
+        else {
+            this.sources.set(uriKey, source);
+        }
+        return source;
+    }
+    getRawSource(uri) {
+        const source = this.getSourceForUri(uri);
+        if (source) {
+            return source.raw;
+        }
+        else {
+            const data = Source.getEncodedDebugData(uri);
+            return { name: data.name, path: data.path, sourceReference: data.sourceReference };
+        }
+    }
+    getNewCancellationToken(threadId, token) {
+        const tokenSource = ( new CancellationTokenSource(token));
+        const tokens = this.cancellationMap.get(threadId) || [];
+        tokens.push(tokenSource);
+        this.cancellationMap.set(threadId, tokens);
+        return tokenSource.token;
+    }
+    cancelAllRequests() {
+        this.cancellationMap.forEach(tokens => tokens.forEach(t => t.dispose(true)));
+        this.cancellationMap.clear();
+    }
+    getReplElements() {
+        return this.repl.getReplElements();
+    }
+    hasSeparateRepl() {
+        return !this.parentSession || this._options.repl !== 'mergeWithParent';
+    }
+    removeReplExpressions() {
+        this.repl.removeReplExpressions();
+    }
+    async addReplExpression(stackFrame, name) {
+        await this.repl.addReplExpression(this, stackFrame, name);
+        this.debugService.getViewModel().updateViews();
+    }
+    appendToRepl(data, isImportant) {
+        this.repl.appendToRepl(this, data);
+        if (isImportant) {
+            this.notificationService.notify({ message: ( data.output.toString()), severity: data.sev, source: this.name });
+        }
+    }
+};
+DebugSession = ( __decorate([
+    ( __param(5, IDebugService)),
+    ( __param(6, ITelemetryService)),
+    ( __param(7, IHostService)),
+    ( __param(8, IConfigurationService)),
+    ( __param(9, IPaneCompositePartService)),
+    ( __param(10, IWorkspaceContextService)),
+    ( __param(11, IProductService)),
+    ( __param(12, INotificationService)),
+    ( __param(13, ILifecycleService)),
+    ( __param(14, IUriIdentityService)),
+    ( __param(15, IInstantiationService)),
+    ( __param(16, ICustomEndpointTelemetryService)),
+    ( __param(17, IWorkbenchEnvironmentService)),
+    ( __param(18, ILogService))
+], DebugSession));
+class ThreadStatusScheduler extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.pendingCancellations = [];
+        this.threadOps = this._register(( new DisposableMap()));
+    }
+    async run(threadIdsP, operation) {
+        const cancelledWhileLookingUpThreads = ( new Set());
+        this.pendingCancellations.push(cancelledWhileLookingUpThreads);
+        const threadIds = await threadIdsP;
+        for (let i = 0; i < this.pendingCancellations.length; i++) {
+            const s = this.pendingCancellations[i];
+            if (s === cancelledWhileLookingUpThreads) {
+                this.pendingCancellations.splice(i, 1);
+                break;
+            }
+            else {
+                for (const threadId of threadIds) {
+                    s.add(threadId);
+                }
+            }
+        }
+        if (( cancelledWhileLookingUpThreads.has(undefined))) {
+            return;
+        }
+        await Promise.all(( threadIds.map(threadId => {
+            if (( cancelledWhileLookingUpThreads.has(threadId))) {
+                return;
+            }
+            this.threadOps.get(threadId)?.cancel();
+            const cts = ( new CancellationTokenSource());
+            this.threadOps.set(threadId, cts);
+            return operation(threadId, cts.token);
+        })));
+    }
+    cancel(threadIds) {
+        if (!threadIds) {
+            for (const [_, op] of this.threadOps) {
+                op.cancel();
+            }
+            this.threadOps.clearAndDisposeAll();
+            for (const s of this.pendingCancellations) {
+                s.add(undefined);
+            }
+        }
+        else {
+            for (const threadId of threadIds) {
+                this.threadOps.get(threadId)?.cancel();
+                this.threadOps.deleteAndDispose(threadId);
+                for (const s of this.pendingCancellations) {
+                    s.add(threadId);
+                }
+            }
+        }
+    }
+}
+export { DebugSession, ThreadStatusScheduler };