@codingame/monaco-vscode-api 1.78.4 → 1.78.5

package/dist/vscode/vs/workbench/contrib/debug/browser/debugService.js

@@ -0,0 +1,1171 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as aria from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { raceTimeout, RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { isErrorWithActions } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import * as errors from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { deepClone, equals } from 'monaco-editor/esm/vs/base/common/objects.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { isCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IExtensionHostDebugService } from '../../../../platform/debug/common/extensionHostDebug.js';
+import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IWorkspaceTrustRequestService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
+import { IViewsService, IViewDescriptorService } from '../../../common/views.js';
+import { AdapterManager } from './debugAdapterManager.js';
+import { DEBUG_CONFIGURE_COMMAND_ID, DEBUG_CONFIGURE_LABEL } from './debugCommands.js';
+import { ConfigurationManager } from './debugConfigurationManager.js';
+import { DebugMemoryFileSystemProvider } from './debugMemory.js';
+import { DebugSession } from './debugSession.js';
+import { DebugTaskRunner } from './debugTaskRunner.js';
+import { CALLSTACK_VIEW_ID, DEBUG_MEMORY_SCHEME, CONTEXT_DEBUG_TYPE, CONTEXT_DEBUG_STATE, CONTEXT_HAS_DEBUGGED, CONTEXT_IN_DEBUG_MODE, CONTEXT_DEBUG_UX, CONTEXT_BREAKPOINTS_EXIST, CONTEXT_DISASSEMBLY_VIEW_FOCUS, getStateLabel, debuggerDisabledMessage, VIEWLET_ID, REPL_VIEW_ID } from '../common/debug.js';
+import { DebugCompoundRoot } from '../common/debugCompoundRoot.js';
+import { DebugModel, Breakpoint, FunctionBreakpoint, DataBreakpoint, InstructionBreakpoint } from '../common/debugModel.js';
+import { DebugStorage } from '../common/debugStorage.js';
+import { DebugTelemetry } from '../common/debugTelemetry.js';
+import { saveAllBeforeDebugStart, getExtensionHostDebugSession } from '../common/debugUtils.js';
+import { ViewModel } from '../common/debugViewModel.js';
+import { DisassemblyViewInput } from '../common/disassemblyViewInput.js';
+import { VIEWLET_ID as VIEWLET_ID$1 } from '../../files/common/files.js';
+import { NumberBadge, IActivityService } from '../../../services/activity/common/activity.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
+import { IPaneCompositePartService } from '../../../services/panecomposite/browser/panecomposite.js';
+let DebugService = class DebugService {
+    constructor(editorService, paneCompositeService, viewsService, viewDescriptorService, notificationService, dialogService, layoutService, contextService, contextKeyService, lifecycleService, instantiationService, extensionService, fileService, configurationService, extensionHostDebugService, activityService, commandService, quickInputService, workspaceTrustRequestService, uriIdentityService) {
+        this.editorService = editorService;
+        this.paneCompositeService = paneCompositeService;
+        this.viewsService = viewsService;
+        this.viewDescriptorService = viewDescriptorService;
+        this.notificationService = notificationService;
+        this.dialogService = dialogService;
+        this.layoutService = layoutService;
+        this.contextService = contextService;
+        this.contextKeyService = contextKeyService;
+        this.lifecycleService = lifecycleService;
+        this.instantiationService = instantiationService;
+        this.extensionService = extensionService;
+        this.fileService = fileService;
+        this.configurationService = configurationService;
+        this.extensionHostDebugService = extensionHostDebugService;
+        this.activityService = activityService;
+        this.commandService = commandService;
+        this.quickInputService = quickInputService;
+        this.workspaceTrustRequestService = workspaceTrustRequestService;
+        this.uriIdentityService = uriIdentityService;
+        this.disposables = ( new DisposableStore());
+        this.initializing = false;
+        this.sessionCancellationTokens = ( new Map());
+        this.haveDoneLazySetup = false;
+        this.breakpointsToSendOnResourceSaved = ( new Set());
+        this._onDidChangeState = ( new Emitter());
+        this._onDidNewSession = ( new Emitter());
+        this._onWillNewSession = ( new Emitter());
+        this._onDidEndSession = ( new Emitter());
+        this.adapterManager = this.instantiationService.createInstance(AdapterManager, { onDidNewSession: this.onDidNewSession });
+        this.disposables.add(this.adapterManager);
+        this.configurationManager = this.instantiationService.createInstance(ConfigurationManager, this.adapterManager);
+        this.disposables.add(this.configurationManager);
+        this.debugStorage = this.instantiationService.createInstance(DebugStorage);
+        this.chosenEnvironments = this.debugStorage.loadChosenEnvironments();
+        this.model = this.instantiationService.createInstance(DebugModel, this.debugStorage);
+        this.telemetry = this.instantiationService.createInstance(DebugTelemetry, this.model);
+        this.viewModel = ( new ViewModel(contextKeyService));
+        this.taskRunner = this.instantiationService.createInstance(DebugTaskRunner);
+        this.disposables.add(this.fileService.onDidFilesChange(e => this.onFileChanges(e)));
+        this.disposables.add(this.lifecycleService.onWillShutdown(this.dispose, this));
+        this.disposables.add(this.extensionHostDebugService.onAttachSession(event => {
+            const session = this.model.getSession(event.sessionId, true);
+            if (session) {
+                session.configuration.request = 'attach';
+                session.configuration.port = event.port;
+                session.setSubId(event.subId);
+                this.launchOrAttachToSession(session);
+            }
+        }));
+        this.disposables.add(this.extensionHostDebugService.onTerminateSession(event => {
+            const session = this.model.getSession(event.sessionId);
+            if (session && session.subId === event.subId) {
+                session.disconnect();
+            }
+        }));
+        this.disposables.add(this.viewModel.onDidFocusStackFrame(() => {
+            this.onStateChange();
+        }));
+        this.disposables.add(this.viewModel.onDidFocusSession((session) => {
+            this.onStateChange();
+            if (session) {
+                this.setExceptionBreakpointFallbackSession(session.getId());
+            }
+        }));
+        this.disposables.add(Event.any(this.adapterManager.onDidRegisterDebugger, this.configurationManager.onDidSelectConfiguration)(() => {
+            const debugUxValue = (this.state !== 0  || (this.configurationManager.getAllConfigurations().length > 0 && this.adapterManager.hasEnabledDebuggers())) ? 'default' : 'simple';
+            this.debugUx.set(debugUxValue);
+            this.debugStorage.storeDebugUxState(debugUxValue);
+        }));
+        this.disposables.add(this.model.onDidChangeCallStack(() => {
+            const numberOfSessions = this.model.getSessions().filter(s => !s.parentSession).length;
+            this.activity?.dispose();
+            if (numberOfSessions > 0) {
+                const viewContainer = this.viewDescriptorService.getViewContainerByViewId(CALLSTACK_VIEW_ID);
+                if (viewContainer) {
+                    this.activity = this.activityService.showViewContainerActivity(viewContainer.id, { badge: ( new NumberBadge(numberOfSessions, n => n === 1 ? ( nls.localize('1activeSession', "1 active session")) : ( nls.localize('nActiveSessions', "{0} active sessions", n)))) });
+                }
+            }
+        }));
+        this.disposables.add(editorService.onDidActiveEditorChange(() => {
+            this.contextKeyService.bufferChangeEvents(() => {
+                if (editorService.activeEditor === DisassemblyViewInput.instance) {
+                    this.disassemblyViewFocus.set(true);
+                }
+                else {
+                    this.disassemblyViewFocus?.reset();
+                }
+            });
+        }));
+        this.disposables.add(this.lifecycleService.onBeforeShutdown(() => {
+            for (const editor of editorService.editors) {
+                if (editor.resource?.scheme === DEBUG_MEMORY_SCHEME) {
+                    editor.dispose();
+                }
+            }
+        }));
+        this.initContextKeys(contextKeyService);
+    }
+    initContextKeys(contextKeyService) {
+        queueMicrotask(() => {
+            contextKeyService.bufferChangeEvents(() => {
+                this.debugType = CONTEXT_DEBUG_TYPE.bindTo(contextKeyService);
+                this.debugState = CONTEXT_DEBUG_STATE.bindTo(contextKeyService);
+                this.hasDebugged = CONTEXT_HAS_DEBUGGED.bindTo(contextKeyService);
+                this.inDebugMode = CONTEXT_IN_DEBUG_MODE.bindTo(contextKeyService);
+                this.debugUx = CONTEXT_DEBUG_UX.bindTo(contextKeyService);
+                this.debugUx.set(this.debugStorage.loadDebugUxState());
+                this.breakpointsExist = CONTEXT_BREAKPOINTS_EXIST.bindTo(contextKeyService);
+                this.disassemblyViewFocus = CONTEXT_DISASSEMBLY_VIEW_FOCUS.bindTo(contextKeyService);
+            });
+            const setBreakpointsExistContext = () => this.breakpointsExist.set(!!(this.model.getBreakpoints().length || this.model.getDataBreakpoints().length || this.model.getFunctionBreakpoints().length));
+            setBreakpointsExistContext();
+            this.disposables.add(this.model.onDidChangeBreakpoints(() => setBreakpointsExistContext()));
+        });
+    }
+    getModel() {
+        return this.model;
+    }
+    getViewModel() {
+        return this.viewModel;
+    }
+    getConfigurationManager() {
+        return this.configurationManager;
+    }
+    getAdapterManager() {
+        return this.adapterManager;
+    }
+    sourceIsNotAvailable(uri) {
+        this.model.sourceIsNotAvailable(uri);
+    }
+    dispose() {
+        this.disposables.dispose();
+    }
+    get state() {
+        const focusedSession = this.viewModel.focusedSession;
+        if (focusedSession) {
+            return focusedSession.state;
+        }
+        return this.initializing ? 1  : 0 ;
+    }
+    get initializingOptions() {
+        return this._initializingOptions;
+    }
+    startInitializingState(options) {
+        if (!this.initializing) {
+            this.initializing = true;
+            this._initializingOptions = options;
+            this.onStateChange();
+        }
+    }
+    endInitializingState() {
+        if (this.initializing) {
+            this.initializing = false;
+            this._initializingOptions = undefined;
+            this.onStateChange();
+        }
+    }
+    cancelTokens(id) {
+        if (id) {
+            const token = this.sessionCancellationTokens.get(id);
+            if (token) {
+                token.cancel();
+                this.sessionCancellationTokens.delete(id);
+            }
+        }
+        else {
+            this.sessionCancellationTokens.forEach(t => t.cancel());
+            this.sessionCancellationTokens.clear();
+        }
+    }
+    onStateChange() {
+        const state = this.state;
+        if (this.previousState !== state) {
+            this.contextKeyService.bufferChangeEvents(() => {
+                this.debugState.set(getStateLabel(state));
+                this.inDebugMode.set(state !== 0 );
+                const debugUxValue = (((state !== 0  && state !== 1) ) || (this.adapterManager.hasEnabledDebuggers() && this.configurationManager.selectedConfiguration.name)) ? 'default' : 'simple';
+                this.debugUx.set(debugUxValue);
+                this.debugStorage.storeDebugUxState(debugUxValue);
+            });
+            this.previousState = state;
+            this._onDidChangeState.fire(state);
+        }
+    }
+    get onDidChangeState() {
+        return this._onDidChangeState.event;
+    }
+    get onDidNewSession() {
+        return this._onDidNewSession.event;
+    }
+    get onWillNewSession() {
+        return this._onWillNewSession.event;
+    }
+    get onDidEndSession() {
+        return this._onDidEndSession.event;
+    }
+    lazySetup() {
+        if (!this.haveDoneLazySetup) {
+            this.disposables.add(this.fileService.registerProvider(DEBUG_MEMORY_SCHEME, ( new DebugMemoryFileSystemProvider(this))));
+            this.haveDoneLazySetup = true;
+        }
+    }
+    async startDebugging(launch, configOrName, options, saveBeforeStart = !options?.parentSession) {
+        const message = options && options.noDebug ? ( nls.localize(
+            'runTrust',
+            "Running executes build tasks and program code from your workspace."
+        )) : ( nls.localize(
+            'debugTrust',
+            "Debugging executes build tasks and program code from your workspace."
+        ));
+        const trust = await this.workspaceTrustRequestService.requestWorkspaceTrust({ message });
+        if (!trust) {
+            return false;
+        }
+        this.lazySetup();
+        this.startInitializingState(options);
+        this.hasDebugged.set(true);
+        try {
+            await this.extensionService.activateByEvent('onDebug');
+            if (saveBeforeStart) {
+                await saveAllBeforeDebugStart(this.configurationService, this.editorService);
+            }
+            await this.extensionService.whenInstalledExtensionsRegistered();
+            let config;
+            let compound;
+            if (!configOrName) {
+                configOrName = this.configurationManager.selectedConfiguration.name;
+            }
+            if (typeof configOrName === 'string' && launch) {
+                config = launch.getConfiguration(configOrName);
+                compound = launch.getCompound(configOrName);
+            }
+            else if (typeof configOrName !== 'string') {
+                config = configOrName;
+            }
+            if (compound) {
+                if (!compound.configurations) {
+                    throw new Error(nls.localize({ key: 'compoundMustHaveConfigurations', comment: ['compound indicates a "compounds" configuration item', '"configurations" is an attribute and should not be localized'] }, "Compound must have \"configurations\" attribute set in order to start multiple configurations."));
+                }
+                if (compound.preLaunchTask) {
+                    const taskResult = await this.taskRunner.runTaskAndCheckErrors(launch?.workspace || this.contextService.getWorkspace(), compound.preLaunchTask);
+                    if (taskResult === 0 ) {
+                        this.endInitializingState();
+                        return false;
+                    }
+                }
+                if (compound.stopAll) {
+                    options = { ...options, compoundRoot: ( new DebugCompoundRoot()) };
+                }
+                const values = await Promise.all(( compound.configurations.map(configData => {
+                    const name = typeof configData === 'string' ? configData : configData.name;
+                    if (name === compound.name) {
+                        return Promise.resolve(false);
+                    }
+                    let launchForName;
+                    if (typeof configData === 'string') {
+                        const launchesContainingName = this.configurationManager.getLaunches().filter(l => !!l.getConfiguration(name));
+                        if (launchesContainingName.length === 1) {
+                            launchForName = launchesContainingName[0];
+                        }
+                        else if (launch && launchesContainingName.length > 1 && launchesContainingName.indexOf(launch) >= 0) {
+                            launchForName = launch;
+                        }
+                        else {
+                            throw new Error(launchesContainingName.length === 0 ? nls.localize('noConfigurationNameInWorkspace', "Could not find launch configuration '{0}' in the workspace.", name)
+                                : nls.localize('multipleConfigurationNamesInWorkspace', "There are multiple launch configurations '{0}' in the workspace. Use folder name to qualify the configuration.", name));
+                        }
+                    }
+                    else if (configData.folder) {
+                        const launchesMatchingConfigData = this.configurationManager.getLaunches().filter(l => l.workspace && l.workspace.name === configData.folder && !!l.getConfiguration(configData.name));
+                        if (launchesMatchingConfigData.length === 1) {
+                            launchForName = launchesMatchingConfigData[0];
+                        }
+                        else {
+                            throw new Error(nls.localize('noFolderWithName', "Can not find folder with name '{0}' for configuration '{1}' in compound '{2}'.", configData.folder, configData.name, compound.name));
+                        }
+                    }
+                    return this.createSession(launchForName, launchForName.getConfiguration(name), options);
+                })));
+                const result = values.every(success => !!success);
+                this.endInitializingState();
+                return result;
+            }
+            if (configOrName && !config) {
+                const message = !!launch ? ( nls.localize(
+                    'configMissing',
+                    "Configuration '{0}' is missing in 'launch.json'.",
+                    typeof configOrName === 'string' ? configOrName : configOrName.name
+                )) :
+                    ( nls.localize(
+                        'launchJsonDoesNotExist',
+                        "'launch.json' does not exist for passed workspace folder."
+                    ));
+                throw new Error(message);
+            }
+            const result = await this.createSession(launch, config, options);
+            this.endInitializingState();
+            return result;
+        }
+        catch (err) {
+            this.notificationService.error(err);
+            this.endInitializingState();
+            return Promise.reject(err);
+        }
+    }
+    async createSession(launch, config, options) {
+        let type;
+        if (config) {
+            type = config.type;
+        }
+        else {
+            config = Object.create(null);
+        }
+        if (options && options.noDebug) {
+            config.noDebug = true;
+        }
+        else if (options && typeof options.noDebug === 'undefined' && options.parentSession && options.parentSession.configuration.noDebug) {
+            config.noDebug = true;
+        }
+        const unresolvedConfig = deepClone(config);
+        let guess;
+        let activeEditor;
+        if (!type) {
+            activeEditor = this.editorService.activeEditor;
+            if (activeEditor && activeEditor.resource) {
+                type = this.chosenEnvironments[( activeEditor.resource.toString())];
+            }
+            if (!type) {
+                guess = await this.adapterManager.guessDebugger(false);
+                if (guess) {
+                    type = guess.type;
+                }
+            }
+        }
+        const initCancellationToken = ( new CancellationTokenSource());
+        const sessionId = generateUuid();
+        this.sessionCancellationTokens.set(sessionId, initCancellationToken);
+        const configByProviders = await this.configurationManager.resolveConfigurationByProviders(launch && launch.workspace ? launch.workspace.uri : undefined, type, config, initCancellationToken.token);
+        if (configByProviders && configByProviders.type) {
+            try {
+                let resolvedConfig = await this.substituteVariables(launch, configByProviders);
+                if (!resolvedConfig) {
+                    return false;
+                }
+                if (initCancellationToken.token.isCancellationRequested) {
+                    return false;
+                }
+                const workspace = launch?.workspace || this.contextService.getWorkspace();
+                const taskResult = await this.taskRunner.runTaskAndCheckErrors(workspace, resolvedConfig.preLaunchTask);
+                if (taskResult === 0 ) {
+                    return false;
+                }
+                const cfg = await this.configurationManager.resolveDebugConfigurationWithSubstitutedVariables(launch && launch.workspace ? launch.workspace.uri : undefined, type, resolvedConfig, initCancellationToken.token);
+                if (!cfg) {
+                    if (launch && type && cfg === null && !initCancellationToken.token.isCancellationRequested) {
+                        await launch.openConfigFile({ preserveFocus: true, type }, initCancellationToken.token);
+                    }
+                    return false;
+                }
+                resolvedConfig = cfg;
+                const dbg = this.adapterManager.getDebugger(resolvedConfig.type);
+                if (!dbg || (configByProviders.request !== 'attach' && configByProviders.request !== 'launch')) {
+                    let message;
+                    if (configByProviders.request !== 'attach' && configByProviders.request !== 'launch') {
+                        message = configByProviders.request ? ( nls.localize(
+                            'debugRequestNotSupported',
+                            "Attribute '{0}' has an unsupported value '{1}' in the chosen debug configuration.",
+                            'request',
+                            configByProviders.request
+                        ))
+                            : ( nls.localize(
+                            'debugRequesMissing',
+                            "Attribute '{0}' is missing from the chosen debug configuration.",
+                            'request'
+                        ));
+                    }
+                    else {
+                        message = resolvedConfig.type ? ( nls.localize(
+                            'debugTypeNotSupported',
+                            "Configured debug type '{0}' is not supported.",
+                            resolvedConfig.type
+                        )) :
+                            ( nls.localize(
+                                'debugTypeMissing',
+                                "Missing property 'type' for the chosen launch configuration."
+                            ));
+                    }
+                    const actionList = [];
+                    actionList.push(( new Action('installAdditionalDebuggers', ( nls.localize(
+                        { key: 'installAdditionalDebuggers', comment: ['Placeholder is the debug type, so for example "node", "python"'] },
+                        "Install {0} Extension",
+                        resolvedConfig.type
+                    )), undefined, true, async () => this.commandService.executeCommand('debug.installAdditionalDebuggers', resolvedConfig?.type))));
+                    await this.showError(message, actionList);
+                    return false;
+                }
+                if (!dbg.enabled) {
+                    await this.showError(debuggerDisabledMessage(dbg.type), []);
+                    return false;
+                }
+                const result = await this.doCreateSession(sessionId, launch?.workspace, { resolved: resolvedConfig, unresolved: unresolvedConfig }, options);
+                if (result && guess && activeEditor && activeEditor.resource) {
+                    this.chosenEnvironments[( activeEditor.resource.toString())] = guess.type;
+                    this.debugStorage.storeChosenEnvironments(this.chosenEnvironments);
+                }
+                return result;
+            }
+            catch (err) {
+                if (err && err.message) {
+                    await this.showError(err.message);
+                }
+                else if (this.contextService.getWorkbenchState() === 1 ) {
+                    await this.showError(( nls.localize(
+                        'noFolderWorkspaceDebugError',
+                        "The active file can not be debugged. Make sure it is saved and that you have a debug extension installed for that file type."
+                    )));
+                }
+                if (launch && !initCancellationToken.token.isCancellationRequested) {
+                    await launch.openConfigFile({ preserveFocus: true }, initCancellationToken.token);
+                }
+                return false;
+            }
+        }
+        if (launch && type && configByProviders === null && !initCancellationToken.token.isCancellationRequested) {
+            await launch.openConfigFile({ preserveFocus: true, type }, initCancellationToken.token);
+        }
+        return false;
+    }
+    async doCreateSession(sessionId, root, configuration, options) {
+        const session = this.instantiationService.createInstance(DebugSession, sessionId, configuration, root, this.model, options);
+        if (options?.startedByUser && ( this.model.getSessions().some(s => s.getLabel() === session.getLabel())) && configuration.resolved.suppressMultipleSessionWarning !== true) {
+            const result = await this.dialogService.confirm({ message: ( nls.localize(
+                'multipleSession',
+                "'{0}' is already running. Do you want to start another instance?",
+                session.getLabel()
+            )) });
+            if (!result.confirmed) {
+                return false;
+            }
+        }
+        this.model.addSession(session);
+        this.registerSessionListeners(session);
+        this._onWillNewSession.fire(session);
+        const openDebug = this.configurationService.getValue('debug').openDebug;
+        if (!configuration.resolved.noDebug && (openDebug === 'openOnSessionStart' || (openDebug !== 'neverOpen' && this.viewModel.firstSessionStart)) && !session.suppressDebugView) {
+            await this.paneCompositeService.openPaneComposite(VIEWLET_ID, 0 );
+        }
+        try {
+            await this.launchOrAttachToSession(session);
+            const internalConsoleOptions = session.configuration.internalConsoleOptions || this.configurationService.getValue('debug').internalConsoleOptions;
+            if (internalConsoleOptions === 'openOnSessionStart' || (this.viewModel.firstSessionStart && internalConsoleOptions === 'openOnFirstSessionStart')) {
+                this.viewsService.openView(REPL_VIEW_ID, false);
+            }
+            this.viewModel.firstSessionStart = false;
+            const showSubSessions = this.configurationService.getValue('debug').showSubSessionsInToolBar;
+            const sessions = this.model.getSessions();
+            const shownSessions = showSubSessions ? sessions : sessions.filter(s => !s.parentSession);
+            if (shownSessions.length > 1) {
+                this.viewModel.setMultiSessionView(true);
+            }
+            this._onDidNewSession.fire(session);
+            return true;
+        }
+        catch (error) {
+            if (errors.isCancellationError(error)) {
+                return false;
+            }
+            if (session && session.getReplElements().length > 0) {
+                this.viewsService.openView(REPL_VIEW_ID, false);
+            }
+            if (session.configuration && session.configuration.request === 'attach' && session.configuration.__autoAttach) {
+                return false;
+            }
+            const errorMessage = error instanceof Error ? error.message : error;
+            if (error.showUser !== false) {
+                await this.showError(errorMessage, isErrorWithActions(error) ? error.actions : []);
+            }
+            return false;
+        }
+    }
+    async launchOrAttachToSession(session, forceFocus = false) {
+        const dbgr = this.adapterManager.getDebugger(session.configuration.type);
+        try {
+            await session.initialize(dbgr);
+            await session.launchOrAttach(session.configuration);
+            const launchJsonExists = !!session.root && !!this.configurationService.getValue('launch', { resource: session.root.uri });
+            await this.telemetry.logDebugSessionStart(dbgr, launchJsonExists);
+            if (forceFocus || !this.viewModel.focusedSession || (session.parentSession === this.viewModel.focusedSession && session.compact)) {
+                await this.focusStackFrame(undefined, undefined, session);
+            }
+        }
+        catch (err) {
+            if (this.viewModel.focusedSession === session) {
+                await this.focusStackFrame(undefined);
+            }
+            return Promise.reject(err);
+        }
+    }
+    registerSessionListeners(session) {
+        const sessionRunningScheduler = ( new RunOnceScheduler(() => {
+            if (session.state === 3  && this.viewModel.focusedSession === session) {
+                this.viewModel.setFocus(undefined, this.viewModel.focusedThread, session, false);
+            }
+        }, 200));
+        this.disposables.add(session.onDidChangeState(() => {
+            if (session.state === 3  && this.viewModel.focusedSession === session) {
+                sessionRunningScheduler.schedule();
+            }
+            if (session === this.viewModel.focusedSession) {
+                this.onStateChange();
+            }
+        }));
+        this.disposables.add(session.onDidEndAdapter(async (adapterExitEvent) => {
+            if (adapterExitEvent) {
+                if (adapterExitEvent.error) {
+                    this.notificationService.error(( nls.localize(
+                        'debugAdapterCrash',
+                        "Debug adapter process has terminated unexpectedly ({0})",
+                        adapterExitEvent.error.message || ( adapterExitEvent.error.toString())
+                    )));
+                }
+                this.telemetry.logDebugSessionStop(session, adapterExitEvent);
+            }
+            const extensionDebugSession = getExtensionHostDebugSession(session);
+            if (extensionDebugSession && extensionDebugSession.state === 3  && extensionDebugSession.configuration.noDebug) {
+                this.extensionHostDebugService.close(extensionDebugSession.getId());
+            }
+            if (session.configuration.postDebugTask) {
+                const root = session.root ?? this.contextService.getWorkspace();
+                try {
+                    await this.taskRunner.runTask(root, session.configuration.postDebugTask);
+                }
+                catch (err) {
+                    this.notificationService.error(err);
+                }
+            }
+            this.endInitializingState();
+            this.cancelTokens(session.getId());
+            this._onDidEndSession.fire(session);
+            const focusedSession = this.viewModel.focusedSession;
+            if (focusedSession && focusedSession.getId() === session.getId()) {
+                const { session, thread, stackFrame } = getStackFrameThreadAndSessionToFocus(this.model, undefined, undefined, undefined, focusedSession);
+                this.viewModel.setFocus(stackFrame, thread, session, false);
+            }
+            if (this.model.getSessions().length === 0) {
+                this.viewModel.setMultiSessionView(false);
+                if (this.layoutService.isVisible("workbench.parts.sidebar" ) && this.configurationService.getValue('debug').openExplorerOnEnd) {
+                    this.paneCompositeService.openPaneComposite(VIEWLET_ID$1, 0 );
+                }
+                const dataBreakpoints = this.model.getDataBreakpoints().filter(dbp => !dbp.canPersist);
+                dataBreakpoints.forEach(dbp => this.model.removeDataBreakpoints(dbp.getId()));
+                if (this.configurationService.getValue('debug').console.closeOnEnd) {
+                    const debugConsoleContainer = this.viewDescriptorService.getViewContainerByViewId(REPL_VIEW_ID);
+                    if (debugConsoleContainer && this.viewsService.isViewContainerVisible(debugConsoleContainer.id)) {
+                        this.viewsService.closeViewContainer(debugConsoleContainer.id);
+                    }
+                }
+            }
+            this.model.removeExceptionBreakpointsForSession(session.getId());
+        }));
+    }
+    async restartSession(session, restartData) {
+        if (session.saveBeforeRestart) {
+            await saveAllBeforeDebugStart(this.configurationService, this.editorService);
+        }
+        const isAutoRestart = !!restartData;
+        const runTasks = async () => {
+            if (isAutoRestart) {
+                return Promise.resolve(1 );
+            }
+            const root = session.root || this.contextService.getWorkspace();
+            await this.taskRunner.runTask(root, session.configuration.preRestartTask);
+            await this.taskRunner.runTask(root, session.configuration.postDebugTask);
+            const taskResult1 = await this.taskRunner.runTaskAndCheckErrors(root, session.configuration.preLaunchTask);
+            if (taskResult1 !== 1 ) {
+                return taskResult1;
+            }
+            return this.taskRunner.runTaskAndCheckErrors(root, session.configuration.postRestartTask);
+        };
+        const extensionDebugSession = getExtensionHostDebugSession(session);
+        if (extensionDebugSession) {
+            const taskResult = await runTasks();
+            if (taskResult === 1 ) {
+                this.extensionHostDebugService.reload(extensionDebugSession.getId());
+            }
+            return;
+        }
+        let needsToSubstitute = false;
+        let unresolved;
+        const launch = session.root ? this.configurationManager.getLaunch(session.root.uri) : undefined;
+        if (launch) {
+            unresolved = launch.getConfiguration(session.configuration.name);
+            if (unresolved && !equals(unresolved, session.unresolvedConfiguration)) {
+                unresolved.type = session.configuration.type;
+                unresolved.noDebug = session.configuration.noDebug;
+                needsToSubstitute = true;
+            }
+        }
+        let resolved = session.configuration;
+        if (launch && needsToSubstitute && unresolved) {
+            const initCancellationToken = ( new CancellationTokenSource());
+            this.sessionCancellationTokens.set(session.getId(), initCancellationToken);
+            const resolvedByProviders = await this.configurationManager.resolveConfigurationByProviders(launch.workspace ? launch.workspace.uri : undefined, unresolved.type, unresolved, initCancellationToken.token);
+            if (resolvedByProviders) {
+                resolved = await this.substituteVariables(launch, resolvedByProviders);
+                if (resolved && !initCancellationToken.token.isCancellationRequested) {
+                    resolved = await this.configurationManager.resolveDebugConfigurationWithSubstitutedVariables(launch && launch.workspace ? launch.workspace.uri : undefined, unresolved.type, resolved, initCancellationToken.token);
+                }
+            }
+            else {
+                resolved = resolvedByProviders;
+            }
+        }
+        if (resolved) {
+            session.setConfiguration({ resolved, unresolved });
+        }
+        session.configuration.__restart = restartData;
+        if (session.capabilities.supportsRestartRequest) {
+            const taskResult = await runTasks();
+            if (taskResult === 1 ) {
+                await session.restart();
+            }
+            return;
+        }
+        const shouldFocus = !!this.viewModel.focusedSession && session.getId() === this.viewModel.focusedSession.getId();
+        if (isAutoRestart) {
+            await session.disconnect(true);
+        }
+        else {
+            await session.terminate(true);
+        }
+        return ( new Promise((c, e) => {
+            setTimeout(async () => {
+                const taskResult = await runTasks();
+                if (taskResult !== 1 ) {
+                    return;
+                }
+                if (!resolved) {
+                    return c(undefined);
+                }
+                try {
+                    await this.launchOrAttachToSession(session, shouldFocus);
+                    this._onDidNewSession.fire(session);
+                    c(undefined);
+                }
+                catch (error) {
+                    e(error);
+                }
+            }, 300);
+        }));
+    }
+    async stopSession(session, disconnect = false, suspend = false) {
+        if (session) {
+            return disconnect ? session.disconnect(undefined, suspend) : session.terminate();
+        }
+        const sessions = this.model.getSessions();
+        if (sessions.length === 0) {
+            this.taskRunner.cancel();
+            await this.quickInputService.cancel();
+            this.endInitializingState();
+            this.cancelTokens(undefined);
+        }
+        return Promise.all(( sessions.map(s => disconnect ? s.disconnect(undefined, suspend) : s.terminate())));
+    }
+    async substituteVariables(launch, config) {
+        const dbg = this.adapterManager.getDebugger(config.type);
+        if (dbg) {
+            let folder = undefined;
+            if (launch && launch.workspace) {
+                folder = launch.workspace;
+            }
+            else {
+                const folders = this.contextService.getWorkspace().folders;
+                if (folders.length === 1) {
+                    folder = folders[0];
+                }
+            }
+            try {
+                return await dbg.substituteVariables(folder, config);
+            }
+            catch (err) {
+                this.showError(err.message, undefined, !!launch?.getConfiguration(config.name));
+                return undefined;
+            }
+        }
+        return Promise.resolve(config);
+    }
+    async showError(message, errorActions = [], promptLaunchJson = true) {
+        const configureAction = ( new Action(
+            DEBUG_CONFIGURE_COMMAND_ID,
+            DEBUG_CONFIGURE_LABEL,
+            undefined,
+            true,
+            () => this.commandService.executeCommand(DEBUG_CONFIGURE_COMMAND_ID)
+        ));
+        const actions = errorActions.filter((action) => action.id.endsWith('.command')).length > 0 ?
+            errorActions :
+            [...errorActions, ...(promptLaunchJson ? [configureAction] : [])];
+        await this.dialogService.prompt({
+            type: Severity.Error,
+            message,
+            buttons: ( actions.map(action => ({
+                label: action.label,
+                run: () => action.run()
+            }))),
+            cancelButton: true
+        });
+    }
+    async focusStackFrame(_stackFrame, _thread, _session, options) {
+        const { stackFrame, thread, session } = getStackFrameThreadAndSessionToFocus(this.model, _stackFrame, _thread, _session);
+        if (stackFrame) {
+            const editor = await stackFrame.openInEditor(this.editorService, options?.preserveFocus ?? true, options?.sideBySide, options?.pinned);
+            if (editor) {
+                if (editor.input === DisassemblyViewInput.instance) ;
+                else {
+                    const control = editor.getControl();
+                    if (stackFrame && isCodeEditor(control) && control.hasModel()) {
+                        const model = control.getModel();
+                        const lineNumber = stackFrame.range.startLineNumber;
+                        if (lineNumber >= 1 && lineNumber <= model.getLineCount()) {
+                            const lineContent = control.getModel().getLineContent(lineNumber);
+                            aria.alert(( nls.localize(
+                                { key: 'debuggingPaused', comment: ['First placeholder is the file line content, second placeholder is the reason why debugging is stopped, for example "breakpoint", third is the stack frame name, and last is the line number.'] },
+                                "{0}, debugging paused {1}, {2}:{3}",
+                                lineContent,
+                                thread && thread.stoppedDetails ? `, reason ${thread.stoppedDetails.reason}` : '',
+                                stackFrame.source ? stackFrame.source.name : '',
+                                stackFrame.range.startLineNumber
+                            )));
+                        }
+                    }
+                }
+            }
+        }
+        if (session) {
+            this.debugType.set(session.configuration.type);
+        }
+        else {
+            this.debugType.reset();
+        }
+        this.viewModel.setFocus(stackFrame, thread, session, !!options?.explicit);
+    }
+    addWatchExpression(name) {
+        const we = this.model.addWatchExpression(name);
+        if (!name) {
+            this.viewModel.setSelectedExpression(we, false);
+        }
+        this.debugStorage.storeWatchExpressions(this.model.getWatchExpressions());
+    }
+    renameWatchExpression(id, newName) {
+        this.model.renameWatchExpression(id, newName);
+        this.debugStorage.storeWatchExpressions(this.model.getWatchExpressions());
+    }
+    moveWatchExpression(id, position) {
+        this.model.moveWatchExpression(id, position);
+        this.debugStorage.storeWatchExpressions(this.model.getWatchExpressions());
+    }
+    removeWatchExpressions(id) {
+        this.model.removeWatchExpressions(id);
+        this.debugStorage.storeWatchExpressions(this.model.getWatchExpressions());
+    }
+    canSetBreakpointsIn(model) {
+        return this.adapterManager.canSetBreakpointsIn(model);
+    }
+    async enableOrDisableBreakpoints(enable, breakpoint) {
+        if (breakpoint) {
+            this.model.setEnablement(breakpoint, enable);
+            this.debugStorage.storeBreakpoints(this.model);
+            if (breakpoint instanceof Breakpoint) {
+                await this.sendBreakpoints(breakpoint.originalUri);
+            }
+            else if (breakpoint instanceof FunctionBreakpoint) {
+                await this.sendFunctionBreakpoints();
+            }
+            else if (breakpoint instanceof DataBreakpoint) {
+                await this.sendDataBreakpoints();
+            }
+            else if (breakpoint instanceof InstructionBreakpoint) {
+                await this.sendInstructionBreakpoints();
+            }
+            else {
+                await this.sendExceptionBreakpoints();
+            }
+        }
+        else {
+            this.model.enableOrDisableAllBreakpoints(enable);
+            this.debugStorage.storeBreakpoints(this.model);
+            await this.sendAllBreakpoints();
+        }
+        this.debugStorage.storeBreakpoints(this.model);
+    }
+    async addBreakpoints(uri, rawBreakpoints, ariaAnnounce = true) {
+        const breakpoints = this.model.addBreakpoints(uri, rawBreakpoints);
+        if (ariaAnnounce) {
+            breakpoints.forEach(bp => aria.status(( nls.localize(
+                'breakpointAdded',
+                "Added breakpoint, line {0}, file {1}",
+                bp.lineNumber,
+                uri.fsPath
+            ))));
+        }
+        this.debugStorage.storeBreakpoints(this.model);
+        await this.sendBreakpoints(uri);
+        this.debugStorage.storeBreakpoints(this.model);
+        return breakpoints;
+    }
+    async updateBreakpoints(uri, data, sendOnResourceSaved) {
+        this.model.updateBreakpoints(data);
+        this.debugStorage.storeBreakpoints(this.model);
+        if (sendOnResourceSaved) {
+            this.breakpointsToSendOnResourceSaved.add(uri);
+        }
+        else {
+            await this.sendBreakpoints(uri);
+            this.debugStorage.storeBreakpoints(this.model);
+        }
+    }
+    async removeBreakpoints(id) {
+        const toRemove = this.model.getBreakpoints().filter(bp => !id || bp.getId() === id);
+        toRemove.forEach(bp => aria.status(( nls.localize(
+            'breakpointRemoved',
+            "Removed breakpoint, line {0}, file {1}",
+            bp.lineNumber,
+            bp.uri.fsPath
+        ))));
+        const urisToClear = ( distinct(toRemove, bp => ( bp.originalUri.toString())).map(bp => bp.originalUri));
+        this.model.removeBreakpoints(toRemove);
+        this.debugStorage.storeBreakpoints(this.model);
+        await Promise.all(( urisToClear.map(uri => this.sendBreakpoints(uri))));
+    }
+    setBreakpointsActivated(activated) {
+        this.model.setBreakpointsActivated(activated);
+        return this.sendAllBreakpoints();
+    }
+    addFunctionBreakpoint(name, id) {
+        this.model.addFunctionBreakpoint(name || '', id);
+    }
+    async updateFunctionBreakpoint(id, update) {
+        this.model.updateFunctionBreakpoint(id, update);
+        this.debugStorage.storeBreakpoints(this.model);
+        await this.sendFunctionBreakpoints();
+    }
+    async removeFunctionBreakpoints(id) {
+        this.model.removeFunctionBreakpoints(id);
+        this.debugStorage.storeBreakpoints(this.model);
+        await this.sendFunctionBreakpoints();
+    }
+    async addDataBreakpoint(label, dataId, canPersist, accessTypes, accessType) {
+        this.model.addDataBreakpoint(label, dataId, canPersist, accessTypes, accessType);
+        this.debugStorage.storeBreakpoints(this.model);
+        await this.sendDataBreakpoints();
+        this.debugStorage.storeBreakpoints(this.model);
+    }
+    async removeDataBreakpoints(id) {
+        this.model.removeDataBreakpoints(id);
+        this.debugStorage.storeBreakpoints(this.model);
+        await this.sendDataBreakpoints();
+    }
+    async addInstructionBreakpoint(address, offset, condition, hitCondition) {
+        this.model.addInstructionBreakpoint(address, offset, condition, hitCondition);
+        this.debugStorage.storeBreakpoints(this.model);
+        await this.sendInstructionBreakpoints();
+        this.debugStorage.storeBreakpoints(this.model);
+    }
+    async removeInstructionBreakpoints(address) {
+        this.model.removeInstructionBreakpoints(address);
+        this.debugStorage.storeBreakpoints(this.model);
+        await this.sendInstructionBreakpoints();
+    }
+    setExceptionBreakpointFallbackSession(sessionId) {
+        this.model.setExceptionBreakpointFallbackSession(sessionId);
+        this.debugStorage.storeBreakpoints(this.model);
+    }
+    setExceptionBreakpointsForSession(session, data) {
+        this.model.setExceptionBreakpointsForSession(session.getId(), data);
+        this.debugStorage.storeBreakpoints(this.model);
+    }
+    async setExceptionBreakpointCondition(exceptionBreakpoint, condition) {
+        this.model.setExceptionBreakpointCondition(exceptionBreakpoint, condition);
+        this.debugStorage.storeBreakpoints(this.model);
+        await this.sendExceptionBreakpoints();
+    }
+    async sendAllBreakpoints(session) {
+        const setBreakpointsPromises = ( distinct(this.model.getBreakpoints(), bp => ( bp.originalUri.toString()))
+            .map(bp => this.sendBreakpoints(bp.originalUri, false, session)));
+        if (session?.capabilities.supportsConfigurationDoneRequest) {
+            await Promise.all([
+                ...setBreakpointsPromises,
+                this.sendFunctionBreakpoints(session),
+                this.sendDataBreakpoints(session),
+                this.sendInstructionBreakpoints(session),
+                this.sendExceptionBreakpoints(session),
+            ]);
+        }
+        else {
+            await Promise.all(setBreakpointsPromises);
+            await this.sendFunctionBreakpoints(session);
+            await this.sendDataBreakpoints(session);
+            await this.sendInstructionBreakpoints(session);
+            await this.sendExceptionBreakpoints(session);
+        }
+    }
+    async sendBreakpoints(modelUri, sourceModified = false, session) {
+        const breakpointsToSend = this.model.getBreakpoints({ originalUri: modelUri, enabledOnly: true });
+        await sendToOneOrAllSessions(this.model, session, async (s) => {
+            if (!s.configuration.noDebug) {
+                await s.sendBreakpoints(modelUri, breakpointsToSend, sourceModified);
+            }
+        });
+    }
+    async sendFunctionBreakpoints(session) {
+        const breakpointsToSend = this.model.getFunctionBreakpoints().filter(fbp => fbp.enabled && this.model.areBreakpointsActivated());
+        await sendToOneOrAllSessions(this.model, session, async (s) => {
+            if (s.capabilities.supportsFunctionBreakpoints && !s.configuration.noDebug) {
+                await s.sendFunctionBreakpoints(breakpointsToSend);
+            }
+        });
+    }
+    async sendDataBreakpoints(session) {
+        const breakpointsToSend = this.model.getDataBreakpoints().filter(fbp => fbp.enabled && this.model.areBreakpointsActivated());
+        await sendToOneOrAllSessions(this.model, session, async (s) => {
+            if (s.capabilities.supportsDataBreakpoints && !s.configuration.noDebug) {
+                await s.sendDataBreakpoints(breakpointsToSend);
+            }
+        });
+    }
+    async sendInstructionBreakpoints(session) {
+        const breakpointsToSend = this.model.getInstructionBreakpoints().filter(fbp => fbp.enabled && this.model.areBreakpointsActivated());
+        await sendToOneOrAllSessions(this.model, session, async (s) => {
+            if (s.capabilities.supportsInstructionBreakpoints && !s.configuration.noDebug) {
+                await s.sendInstructionBreakpoints(breakpointsToSend);
+            }
+        });
+    }
+    sendExceptionBreakpoints(session) {
+        return sendToOneOrAllSessions(this.model, session, async (s) => {
+            const enabledExceptionBps = this.model.getExceptionBreakpointsForSession(s.getId()).filter(exb => exb.enabled);
+            if (s.capabilities.supportsConfigurationDoneRequest && (!s.capabilities.exceptionBreakpointFilters || s.capabilities.exceptionBreakpointFilters.length === 0)) {
+                return;
+            }
+            if (!s.configuration.noDebug) {
+                await s.sendExceptionBreakpoints(enabledExceptionBps);
+            }
+        });
+    }
+    onFileChanges(fileChangesEvent) {
+        const toRemove = this.model.getBreakpoints().filter(bp => fileChangesEvent.contains(bp.originalUri, 2 ));
+        if (toRemove.length) {
+            this.model.removeBreakpoints(toRemove);
+        }
+        const toSend = [];
+        for (const uri of this.breakpointsToSendOnResourceSaved) {
+            if (fileChangesEvent.contains(uri, 0 )) {
+                toSend.push(uri);
+            }
+        }
+        for (const uri of toSend) {
+            this.breakpointsToSendOnResourceSaved.delete(uri);
+            this.sendBreakpoints(uri, true);
+        }
+    }
+    async runTo(uri, lineNumber, column) {
+        let breakpointToRemove;
+        let threadToContinue = this.getViewModel().focusedThread;
+        const addTempBreakPoint = async () => {
+            const bpExists = !!(this.getModel().getBreakpoints({ column, lineNumber, uri }).length);
+            if (!bpExists) {
+                const addResult = await this.addAndValidateBreakpoints(uri, lineNumber, column);
+                if (addResult.thread) {
+                    threadToContinue = addResult.thread;
+                }
+                if (addResult.breakpoint) {
+                    breakpointToRemove = addResult.breakpoint;
+                }
+            }
+            return { threadToContinue, breakpointToRemove };
+        };
+        const removeTempBreakPoint = (state) => {
+            if (state === 2  || state === 0 ) {
+                if (breakpointToRemove) {
+                    this.removeBreakpoints(breakpointToRemove.getId());
+                }
+                return true;
+            }
+            return false;
+        };
+        await addTempBreakPoint();
+        if (this.state === 0 ) {
+            const { launch, name, getConfig } = this.getConfigurationManager().selectedConfiguration;
+            const config = await getConfig();
+            const configOrName = config ? Object.assign(deepClone(config), {}) : name;
+            const listener = this.onDidChangeState(state => {
+                if (removeTempBreakPoint(state)) {
+                    listener.dispose();
+                }
+            });
+            await this.startDebugging(launch, configOrName, undefined, true);
+        }
+        if (this.state === 2 ) {
+            const focusedSession = this.getViewModel().focusedSession;
+            if (!focusedSession || !threadToContinue) {
+                return;
+            }
+            const listener = threadToContinue.session.onDidChangeState(() => {
+                if (removeTempBreakPoint(focusedSession.state)) {
+                    listener.dispose();
+                }
+            });
+            await threadToContinue.continue();
+        }
+    }
+    async addAndValidateBreakpoints(uri, lineNumber, column) {
+        const debugModel = this.getModel();
+        const viewModel = this.getViewModel();
+        const breakpoints = await this.addBreakpoints(uri, [{ lineNumber, column }], false);
+        const breakpoint = breakpoints?.[0];
+        if (!breakpoint) {
+            return { breakpoint: undefined, thread: viewModel.focusedThread };
+        }
+        if (!breakpoint.verified) {
+            let listener;
+            await raceTimeout(( new Promise(resolve => {
+                listener = debugModel.onDidChangeBreakpoints(() => {
+                    if (breakpoint.verified) {
+                        resolve();
+                    }
+                });
+            })), 2000);
+            listener.dispose();
+        }
+        let bestThread = viewModel.focusedThread;
+        let bestScore = 0 ;
+        for (const sessionId of breakpoint.sessionsThatVerified) {
+            const session = debugModel.getSession(sessionId);
+            if (!session) {
+                continue;
+            }
+            const threads = session.getAllThreads().filter(t => t.stopped);
+            if (bestScore < 3 ) {
+                if (viewModel.focusedThread && threads.includes(viewModel.focusedThread)) {
+                    bestThread = viewModel.focusedThread;
+                    bestScore = 3 ;
+                }
+            }
+            if (bestScore < 2 ) {
+                const pausedInThisFile = threads.find(t => {
+                    const top = t.getTopStackFrame();
+                    return top && this.uriIdentityService.extUri.isEqual(top.source.uri, uri);
+                });
+                if (pausedInThisFile) {
+                    bestThread = pausedInThisFile;
+                    bestScore = 2 ;
+                }
+            }
+            if (bestScore < 1 ) {
+                bestThread = threads[0];
+                bestScore = 2 ;
+            }
+        }
+        return { thread: bestThread, breakpoint };
+    }
+};
+DebugService = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IPaneCompositePartService)),
+    ( __param(2, IViewsService)),
+    ( __param(3, IViewDescriptorService)),
+    ( __param(4, INotificationService)),
+    ( __param(5, IDialogService)),
+    ( __param(6, IWorkbenchLayoutService)),
+    ( __param(7, IWorkspaceContextService)),
+    ( __param(8, IContextKeyService)),
+    ( __param(9, ILifecycleService)),
+    ( __param(10, IInstantiationService)),
+    ( __param(11, IExtensionService)),
+    ( __param(12, IFileService)),
+    ( __param(13, IConfigurationService)),
+    ( __param(14, IExtensionHostDebugService)),
+    ( __param(15, IActivityService)),
+    ( __param(16, ICommandService)),
+    ( __param(17, IQuickInputService)),
+    ( __param(18, IWorkspaceTrustRequestService)),
+    ( __param(19, IUriIdentityService))
+], DebugService));
+function getStackFrameThreadAndSessionToFocus(model, stackFrame, thread, session, avoidSession) {
+    if (!session) {
+        if (stackFrame || thread) {
+            session = stackFrame ? stackFrame.thread.session : thread.session;
+        }
+        else {
+            const sessions = model.getSessions();
+            const stoppedSession = sessions.find(s => s.state === 2 );
+            session = stoppedSession || sessions.find(s => s !== avoidSession && s !== avoidSession?.parentSession) || (sessions.length ? sessions[0] : undefined);
+        }
+    }
+    if (!thread) {
+        if (stackFrame) {
+            thread = stackFrame.thread;
+        }
+        else {
+            const threads = session ? session.getAllThreads() : undefined;
+            const stoppedThread = threads && threads.find(t => t.stopped);
+            thread = stoppedThread || (threads && threads.length ? threads[0] : undefined);
+        }
+    }
+    if (!stackFrame && thread) {
+        stackFrame = thread.getTopStackFrame();
+    }
+    return { session, thread, stackFrame };
+}
+async function sendToOneOrAllSessions(model, session, send) {
+    if (session) {
+        await send(session);
+    }
+    else {
+        await Promise.all(( model.getSessions().map(s => send(s))));
+    }
+}
+export { DebugService, getStackFrameThreadAndSessionToFocus };