@theia/debug 1.70.0-next.81 → 1.71.0-next.0

package/src/browser/editor/debug-editor-model.ts

@@ -58,13 +58,24 @@ export class DebugEditorModel implements Disposable {
     protected uri: URI;
 
     protected breakpointDecorations: string[] = [];
-    protected breakpointRanges = new Map<string, [monaco.Range, SourceBreakpoint]>();
+    protected breakpointRanges = new Map<string, [monaco.Range, DebugSourceBreakpoint]>();
 
     protected currentBreakpointDecorations: string[] = [];
 
     protected editorDecorations: string[] = [];
 
-    protected updatingDecorations = false;
+    /**
+     * Set during `render()` to prevent `onDidChangeDecorations` → `updateBreakpoints()`
+     * from reading back the decoration positions we just wrote, which would produce
+     * a spurious or circular `setBreakpoints` call.
+     */
+    protected ignoreDecorationsChangedEvent = false;
+
+    /**
+     * Set during `updateBreakpoints()` to prevent the resulting
+     * `onDidChangeBreakpoints` from re-entering `render()`.
+     */
+    protected ignoreBreakpointsChangeEvent = false;
     protected toDisposeOnModelChange = new DisposableCollection();
 
     @inject(DebugHoverWidget)
@@ -111,12 +122,12 @@ export class DebugEditorModel implements Disposable {
             this.sessions.onDidChange(() => this.update()),
             this.toDisposeOnUpdate,
             Disposable.create(() => this.toDisposeOnModelChange.dispose()),
-            this.sessionManager.onDidChangeBreakpoints(({ session, uri }) => {
-                if ((!session || session === this.sessionManager.currentSession) && uri.isEqual(this.uri)) {
+            this.breakpoints.onDidChangeBreakpoints(event => {
+                if (!this.ignoreBreakpointsChangeEvent) {
                     this.render();
                 }
+                this.closeBreakpointIfAffected(event);
             }),
-            this.breakpoints.onDidChangeBreakpoints(event => this.closeBreakpointIfAffected(event)),
         ]);
         this.updateModel();
     }
@@ -237,8 +248,13 @@ export class DebugEditorModel implements Disposable {
     }
 
     render(): void {
-        this.renderBreakpoints();
-        this.renderCurrentBreakpoints();
+        this.ignoreDecorationsChangedEvent = true;
+        try {
+            this.renderBreakpoints();
+            this.renderCurrentBreakpoints();
+        } finally {
+            this.ignoreDecorationsChangedEvent = false;
+        }
     }
     protected renderBreakpoints(): void {
         const breakpoints = this.breakpoints.getBreakpoints(this.uri);
@@ -246,12 +262,12 @@ export class DebugEditorModel implements Disposable {
         this.breakpointDecorations = this.deltaDecorations(this.breakpointDecorations, decorations);
         this.updateBreakpointRanges(breakpoints);
     }
-    protected createBreakpointDecorations(breakpoints: SourceBreakpoint[]): monaco.editor.IModelDeltaDecoration[] {
+    protected createBreakpointDecorations(breakpoints: readonly DebugSourceBreakpoint[]): monaco.editor.IModelDeltaDecoration[] {
         return breakpoints.map(breakpoint => this.createBreakpointDecoration(breakpoint));
     }
-    protected createBreakpointDecoration(breakpoint: SourceBreakpoint): monaco.editor.IModelDeltaDecoration {
-        const lineNumber = breakpoint.raw.line;
-        const column = breakpoint.raw.column || this.editor.getControl().getModel()?.getLineFirstNonWhitespaceColumn(lineNumber) || 1;
+    protected createBreakpointDecoration(breakpoint: DebugSourceBreakpoint): monaco.editor.IModelDeltaDecoration {
+        const lineNumber = breakpoint.line;
+        const column = breakpoint.column || this.editor.getControl().getModel()?.getLineFirstNonWhitespaceColumn(lineNumber) || 1;
         const range = new monaco.Range(lineNumber, column, lineNumber, column + 1);
         return {
             range,
@@ -261,7 +277,7 @@ export class DebugEditorModel implements Disposable {
         };
     }
 
-    protected updateBreakpointRanges(breakpoints: SourceBreakpoint[]): void {
+    protected updateBreakpointRanges(breakpoints: readonly DebugSourceBreakpoint[]): void {
         this.breakpointRanges.clear();
         for (let i = 0; i < this.breakpointDecorations.length; i++) {
             const decoration = this.breakpointDecorations[i];
@@ -278,8 +294,19 @@ export class DebugEditorModel implements Disposable {
         this.currentBreakpointDecorations = this.deltaDecorations(this.currentBreakpointDecorations, decorations);
     }
     protected createCurrentBreakpointDecorations(): monaco.editor.IModelDeltaDecoration[] {
-        const breakpoints = this.sessions.getBreakpoints(this.uri);
-        return breakpoints.map(breakpoint => this.createCurrentBreakpointDecoration(breakpoint));
+        const breakpoints = this.breakpoints.getBreakpoints(this.uri);
+        // Deduplicate by rendered position: when multiple breakpoints resolve
+        // to the same (line, column) — e.g. via source-map collapsing — only
+        // create one decoration to avoid double dots in the editor.
+        const seen = new Set<string>();
+        const result: monaco.editor.IModelDeltaDecoration[] = [];
+        for (const bp of breakpoints) {
+            const key = `${bp.line}:${bp.column ?? 0}`;
+            if (seen.has(key)) { continue; }
+            seen.add(key);
+            result.push(this.createCurrentBreakpointDecoration(bp));
+        }
+        return result;
     }
     protected createCurrentBreakpointDecoration(breakpoint: DebugSourceBreakpoint): monaco.editor.IModelDeltaDecoration {
         const lineNumber = breakpoint.line;
@@ -301,11 +328,16 @@ export class DebugEditorModel implements Disposable {
     protected updateBreakpoints(): void {
         if (this.areBreakpointsAffected()) {
             const breakpoints = this.createBreakpoints();
-            this.breakpoints.setBreakpoints(this.uri, breakpoints);
+            this.ignoreBreakpointsChangeEvent = true;
+            try {
+                this.breakpoints.setBreakpoints(this.uri, breakpoints);
+            } finally {
+                this.ignoreBreakpointsChangeEvent = false;
+            }
         }
     }
     protected areBreakpointsAffected(): boolean {
-        if (this.updatingDecorations || !this.editor.getControl().getModel()) {
+        if (this.ignoreDecorationsChangedEvent || !this.editor.getControl().getModel()) {
             return false;
         }
         for (const decoration of this.breakpointDecorations) {
@@ -328,11 +360,11 @@ export class DebugEditorModel implements Disposable {
                 const column = range.startColumn;
                 const oldBreakpoint = this.breakpointRanges.get(decoration)?.[1];
                 if (oldBreakpoint) {
-                    const isLineBreakpoint = oldBreakpoint.raw.line !== undefined && oldBreakpoint.raw.column === undefined;
+                    const isLineBreakpoint = oldBreakpoint.origin.raw.line !== undefined && oldBreakpoint.origin.raw.column === undefined;
                     const position = isLineBreakpoint ? `${line}` : `${line}:${column}`;
                     if (!positions.has(position)) {
                         const change = isLineBreakpoint ? { line } : { line, column };
-                        const breakpoint = SourceBreakpoint.create(uri, change, oldBreakpoint);
+                        const breakpoint = SourceBreakpoint.create(uri, change, oldBreakpoint.origin);
                         breakpoints.push(breakpoint);
                         positions.add(position);
                     }
@@ -345,16 +377,17 @@ export class DebugEditorModel implements Disposable {
     get position(): monaco.Position {
         return this.editor.getControl().getPosition()!;
     }
+
     getBreakpoint(position: monaco.Position = this.position): DebugSourceBreakpoint | undefined {
         return this.getInlineBreakpoint(position) || this.getLineBreakpoints(position)[0];
     }
 
     getInlineBreakpoint(position: monaco.Position = this.position): DebugSourceBreakpoint | undefined {
-        return this.sessions.getInlineBreakpoint(this.uri, position.lineNumber, position.column);
+        return this.breakpoints.getBreakpoints(this.uri).find(candidate => candidate.line === position.lineNumber && candidate.column === position.column);
     }
 
     protected getLineBreakpoints(position: monaco.Position = this.position): DebugSourceBreakpoint[] {
-        return this.sessions.getLineBreakpoints(this.uri, position.lineNumber);
+        return this.breakpoints.getBreakpoints(this.uri).filter(candidate => candidate.line === position.lineNumber);
     }
 
     protected addBreakpoint(raw: DebugProtocol.SourceBreakpoint): void {
@@ -374,13 +407,8 @@ export class DebugEditorModel implements Disposable {
     }
 
     addInlineBreakpoint(): void {
-        const { position } = this;
-        const { lineNumber, column } = position;
-        const breakpoint = this.getInlineBreakpoint(position);
-        if (breakpoint) {
-            return;
-        }
-        this.addBreakpoint({ line: lineNumber, column });
+        const { position: { lineNumber: line, column } } = this;
+        this.addBreakpoint({ line, column });
     }
 
     acceptBreakpoint(): void {
@@ -388,7 +416,7 @@ export class DebugEditorModel implements Disposable {
         if (position && values) {
             const breakpoint = position.column > 0 ? this.getInlineBreakpoint(position) : this.getLineBreakpoints(position)[0];
             if (breakpoint) {
-                breakpoint.updateOrigins(values);
+                this.breakpoints.updateBreakpoint(breakpoint, values);
             } else {
                 const { lineNumber } = position;
                 const column = position.column > 0 ? position.column : undefined;
@@ -446,7 +474,7 @@ export class DebugEditorModel implements Disposable {
             return;
         }
         for (const breakpoint of removed) {
-            if (breakpoint.raw.line === position.lineNumber) {
+            if (breakpoint.line === position.lineNumber) {
                 this.breakpointWidget.hide();
                 break;
             }
@@ -479,12 +507,7 @@ export class DebugEditorModel implements Disposable {
     }
 
     protected deltaDecorations(oldDecorations: string[], newDecorations: monaco.editor.IModelDeltaDecoration[]): string[] {
-        this.updatingDecorations = true;
-        try {
-            return this.editor.getControl().deltaDecorations(oldDecorations, newDecorations);
-        } finally {
-            this.updatingDecorations = false;
-        }
+        return this.editor.getControl().deltaDecorations(oldDecorations, newDecorations);
     }
 
     static STICKINESS = monaco.editor.TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges;

package/src/browser/model/debug-breakpoint-opener.ts

@@ -0,0 +1,51 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { MaybePromise, URI } from '@theia/core';
+import { OpenHandler, OpenerOptions } from '@theia/core/lib/browser';
+import { EditorManager } from '@theia/editor/lib/browser';
+import { BreakpointManager } from '../breakpoint/breakpoint-manager';
+import { DebugSessionManager } from '../debug-session-manager';
+import { DEBUG_BREAKPOINT_SCHEME } from '../breakpoint/breakpoint-marker';
+
+@injectable()
+export class DebugBreakpointOpener implements OpenHandler {
+    @inject(BreakpointManager) protected readonly breakpointManager: BreakpointManager;
+    @inject(DebugSessionManager) protected readonly sessionManager: DebugSessionManager;
+    @inject(EditorManager) protected readonly editorManager: EditorManager;
+
+    readonly id = 'debug-breakpoint-opener';
+
+    canHandle(uri: URI, options?: OpenerOptions | undefined): MaybePromise<number> {
+        return uri.scheme === DEBUG_BREAKPOINT_SCHEME ? 150 : -1;
+    }
+
+    open(uri: URI, options?: OpenerOptions | undefined): MaybePromise<object | undefined> {
+        if (uri.scheme !== DEBUG_BREAKPOINT_SCHEME) { throw new Error(`Unexpected scheme. Expected '${DEBUG_BREAKPOINT_SCHEME}' but got '${uri.scheme}'.`); }
+        const bpId = uri.authority;
+        const bp = this.breakpointManager.getBreakpointById(bpId);
+        if (!bp) { return; }
+        if (bp.raw?.source) {
+            const session = this.sessionManager.getSession(bp.raw.sessionId);
+            const source = session?.getSource(bp.raw.source);
+            if (source) {
+                return source.open(options);
+            }
+        }
+        return this.editorManager.open(bp.uri, options);
+    }
+}

package/src/browser/model/debug-breakpoint.tsx

@@ -17,24 +17,19 @@
 import * as React from '@theia/core/shared/react';
 import { DebugProtocol } from '@vscode/debugprotocol/lib/debugProtocol';
 import URI from '@theia/core/lib/common/uri';
-import { EditorManager } from '@theia/editor/lib/browser';
-import { LabelProvider, DISABLED_CLASS, TreeWidget } from '@theia/core/lib/browser';
+import { CommandService } from '@theia/core/lib/common';
+import { LabelProvider, DISABLED_CLASS, OpenerService, TreeWidget } from '@theia/core/lib/browser';
 import { TreeElement } from '@theia/core/lib/browser/source-tree';
 import { SelectableTreeNode } from '@theia/core/lib/browser/tree/tree-selection';
-import { DebugSession } from '../debug-session';
 import { BaseBreakpoint } from '../breakpoint/breakpoint-marker';
 import { BreakpointManager } from '../breakpoint/breakpoint-manager';
 import { nls } from '@theia/core';
 
-export class DebugBreakpointData {
-    readonly raw?: DebugProtocol.Breakpoint;
-}
-
-export class DebugBreakpointOptions {
+export interface DebugBreakpointOptions {
     readonly labelProvider: LabelProvider;
     readonly breakpoints: BreakpointManager;
-    readonly editorManager: EditorManager;
-    readonly session?: DebugSession;
+    readonly openerService: OpenerService;
+    readonly commandService: CommandService;
 }
 
 export class DebugBreakpointDecoration {
@@ -42,27 +37,102 @@ export class DebugBreakpointDecoration {
     readonly message: string[];
 }
 
-export abstract class DebugBreakpoint<T extends BaseBreakpoint = BaseBreakpoint> extends DebugBreakpointOptions implements TreeElement {
+export type BPCapabilities = Required<Pick<
+    DebugProtocol.Capabilities,
+    | 'supportsConditionalBreakpoints'
+    | 'supportsHitConditionalBreakpoints'
+    | 'supportsLogPoints'
+    | 'supportsFunctionBreakpoints'
+    | 'supportsDataBreakpoints'
+    | 'supportsInstructionBreakpoints'
+>>;
+
+export interface BPSessionData extends BPCapabilities, DebugProtocol.Breakpoint {
+    sessionId: string;
+}
+
+export abstract class DebugBreakpoint<T extends BaseBreakpoint = BaseBreakpoint> implements TreeElement {
 
-    readonly raw?: DebugProtocol.Breakpoint;
+    readonly labelProvider: LabelProvider;
+    readonly breakpoints: BreakpointManager;
+    readonly openerService: OpenerService;
+    readonly commandService: CommandService;
+
+    protected _raw?: BPSessionData;
+    protected readonly sessionData = new Map<string, BPSessionData>();
     protected treeWidget?: TreeWidget;
 
     constructor(
         readonly uri: URI,
         options: DebugBreakpointOptions
     ) {
-        super();
-        Object.assign(this, options);
+        this.labelProvider = options.labelProvider;
+        this.breakpoints = options.breakpoints;
+        this.openerService = options.openerService;
+        this.commandService = options.commandService;
     }
 
     abstract get origin(): T;
 
-    update(data: DebugBreakpointData): void {
-        Object.assign(this, data);
+    get raw(): BPSessionData | undefined {
+        return this._raw;
     }
 
-    get idFromAdapter(): number | undefined {
-        return this.raw && this.raw.id;
+    update(sessionId: string, data?: Omit<BPSessionData, 'sessionId'>): boolean {
+        if (!data) {
+            if (!this.sessionData.has(sessionId)) {
+                return false;
+            }
+            this.sessionData.delete(sessionId);
+        } else {
+            const toSet = { ...data, sessionId };
+            this.sessionData.set(sessionId, toSet);
+        }
+        const verifiedLocations = new Map<string, BPSessionData>();
+        this.sessionData.forEach(bp => bp.verified && verifiedLocations.set(`${bp.line}:${bp.column}:${bp.instructionReference}`, bp));
+        if (verifiedLocations.size === 1) {
+            // Exactly one verified location across all sessions — use it.
+            this._raw = verifiedLocations.values().next().value;
+        } else if (verifiedLocations.size === 0) {
+            // No session has verified; pick the first session's data (if any) so
+            // that capability flags and unverified messages are still available.
+            this._raw = this.sessionData.values().next().value;
+        } else {
+            // Multiple sessions verified at different locations. Following
+            // VSCode, we set _raw to undefined so that the breakpoint falls
+            // back to its user-set position and shows as verified (the
+            // default when no resolved data exists). Callers that need a
+            // specific session's view can use getDebugProtocolBreakpoint().
+            this._raw = undefined;
+        }
+        return true;
+    }
+
+    getIdForSession(sessionId: string): number | undefined {
+        return this.sessionData.get(sessionId)?.id;
+    }
+
+    /** Copied from https://github.com/microsoft/vscode/blob/8934b59d4aa696b6f51ac9bf2eeae8bbac5dac03/src/vs/workbench/contrib/debug/common/debugModel.ts#L953-L971 */
+    getDebugProtocolBreakpoint(
+        sessionId: string,
+    ): DebugProtocol.Breakpoint | undefined {
+        const data = this.sessionData.get(sessionId);
+        if (data) {
+            const bp: DebugProtocol.Breakpoint = {
+                id: data.id,
+                verified: data.verified,
+                message: data.message,
+                source: data.source,
+                line: data.line,
+                column: data.column,
+                endLine: data.endLine,
+                endColumn: data.endColumn,
+                instructionReference: data.instructionReference,
+                offset: data.offset,
+            };
+            return bp;
+        }
+        return undefined;
     }
 
     get id(): string {
@@ -73,12 +143,23 @@ export abstract class DebugBreakpoint<T extends BaseBreakpoint = BaseBreakpoint>
         return this.breakpoints.breakpointsEnabled && this.origin.enabled;
     }
 
+    /**
+     * True when at least one session has sent data for this breakpoint
+     * (regardless of whether it was verified).
+     */
     get installed(): boolean {
-        return !!this.raw;
+        return this.sessionData.size > 0;
     }
 
+    /**
+     * When resolved session data exists, reflects the adapter's answer.
+     * Otherwise returns `true`: either no session has weighed in yet (we
+     * haven't been told otherwise) or multiple sessions verified at
+     * different locations (`_raw` was cleared to fall back to the user-set
+     * position). Matches VSCode's default-true semantics.
+     */
     get verified(): boolean {
-        return !!this.raw ? this.raw.verified : false;
+        return this._raw ? this._raw.verified : true;
     }
 
     get message(): string {

package/src/browser/model/debug-data-breakpoint.tsx

@@ -22,14 +22,17 @@ import { DataBreakpoint } from '../breakpoint/breakpoint-marker';
 import { DebugBreakpoint, DebugBreakpointDecoration, DebugBreakpointOptions } from './debug-breakpoint';
 
 export class DebugDataBreakpoint extends DebugBreakpoint<DataBreakpoint> {
+
+    static create(origin: DataBreakpoint, options: DebugBreakpointOptions): DebugDataBreakpoint {
+        return new this(origin, options);
+    }
+
     constructor(readonly origin: DataBreakpoint, options: DebugBreakpointOptions) {
         super(BreakpointManager.DATA_URI, options);
     }
 
     setEnabled(enabled: boolean): void {
-        if (enabled !== this.origin.enabled) {
-            this.breakpoints.updateDataBreakpoint(this.origin.id, { enabled });
-        }
+        this.breakpoints.enableBreakpoint(this, enabled);
     }
 
     protected override isEnabled(): boolean {
@@ -37,11 +40,11 @@ export class DebugDataBreakpoint extends DebugBreakpoint<DataBreakpoint> {
     }
 
     protected isSupported(): boolean {
-        return Boolean(this.session?.capabilities.supportsDataBreakpoints);
+        return this.raw ? !!this.raw.supportsDataBreakpoints : true;
     }
 
     remove(): void {
-        this.breakpoints.removeDataBreakpoint(this.origin.id);
+        this.breakpoints.removeDataBreakpoint(this);
     }
 
     protected doRender(): React.ReactNode {

package/src/browser/model/debug-function-breakpoint.tsx

@@ -25,17 +25,16 @@ import { codicon } from '@theia/core/lib/browser';
 
 export class DebugFunctionBreakpoint extends DebugBreakpoint<FunctionBreakpoint> implements TreeElement {
 
-    constructor(readonly origin: FunctionBreakpoint, options: DebugBreakpointOptions) {
+    static create(origin: FunctionBreakpoint, options: DebugBreakpointOptions): DebugFunctionBreakpoint {
+        return new this(origin, options);
+    }
+
+    private constructor(readonly origin: FunctionBreakpoint, options: DebugBreakpointOptions) {
         super(BreakpointManager.FUNCTION_URI, options);
     }
 
     setEnabled(enabled: boolean): void {
-        const breakpoints = this.breakpoints.getFunctionBreakpoints();
-        const breakpoint = breakpoints.find(b => b.id === this.id);
-        if (breakpoint && breakpoint.enabled !== enabled) {
-            breakpoint.enabled = enabled;
-            this.breakpoints.setFunctionBreakpoints(breakpoints);
-        }
+        this.breakpoints.enableBreakpoint(this, enabled);
     }
 
     protected override isEnabled(): boolean {
@@ -43,16 +42,11 @@ export class DebugFunctionBreakpoint extends DebugBreakpoint<FunctionBreakpoint>
     }
 
     protected isSupported(): boolean {
-        const { session } = this;
-        return !session || !!session.capabilities.supportsFunctionBreakpoints;
+        return this.raw ? !!this.raw.supportsFunctionBreakpoints : true;
     }
 
     remove(): void {
-        const breakpoints = this.breakpoints.getFunctionBreakpoints();
-        const newBreakpoints = breakpoints.filter(b => b.id !== this.id);
-        if (breakpoints.length !== newBreakpoints.length) {
-            this.breakpoints.setFunctionBreakpoints(newBreakpoints);
-        }
+        this.breakpoints.removeFunctionBreakpoint(this);
     }
 
     get name(): string {
@@ -97,26 +91,21 @@ export class DebugFunctionBreakpoint extends DebugBreakpoint<FunctionBreakpoint>
         };
     }
 
-    async open(): Promise<void> {
+    static async editOrCreate(breakpoints: BreakpointManager, existing?: DebugFunctionBreakpoint): Promise<void> {
         const input = new SingleTextInputDialog({
             title: nls.localizeByDefault('Add Function Breakpoint'),
-            initialValue: this.name
+            initialValue: existing?.name ?? ''
         });
         const newValue = await input.open();
-        if (newValue !== undefined && newValue !== this.name) {
-            const breakpoints = this.breakpoints.getFunctionBreakpoints();
-            const breakpoint = breakpoints.find(b => b.id === this.id);
-            if (breakpoint) {
-                if (breakpoint.raw.name !== newValue) {
-                    breakpoint.raw.name = newValue;
-                    this.breakpoints.setFunctionBreakpoints(breakpoints);
-                }
-            } else {
-                this.origin.raw.name = newValue;
-                breakpoints.push(this.origin);
-                this.breakpoints.setFunctionBreakpoints(breakpoints);
-            }
+        if (!newValue) { return; }
+        if (existing) {
+            breakpoints.updateFunctionBreakpoint(existing, { name: newValue });
+        } else {
+            breakpoints.addFunctionBreakpoint(FunctionBreakpoint.create({ name: newValue }));
         }
     }
 
+    async open(): Promise<void> {
+        DebugFunctionBreakpoint.editOrCreate(this.breakpoints, this);
+    }
 }

package/src/browser/model/debug-instruction-breakpoint.tsx

@@ -22,14 +22,16 @@ import { InstructionBreakpoint } from '../breakpoint/breakpoint-marker';
 import { DebugBreakpoint, DebugBreakpointDecoration, DebugBreakpointOptions } from './debug-breakpoint';
 
 export class DebugInstructionBreakpoint extends DebugBreakpoint<InstructionBreakpoint> {
-    constructor(readonly origin: InstructionBreakpoint, options: DebugBreakpointOptions) {
+    static create(origin: InstructionBreakpoint, options: DebugBreakpointOptions): DebugInstructionBreakpoint {
+        return new this(origin, options);
+    }
+
+    private constructor(readonly origin: InstructionBreakpoint, options: DebugBreakpointOptions) {
         super(BreakpointManager.INSTRUCTION_URI, options);
     }
 
     setEnabled(enabled: boolean): void {
-        if (enabled !== this.origin.enabled) {
-            this.breakpoints.updateInstructionBreakpoint(this.origin.id, { enabled });
-        }
+        this.breakpoints.enableBreakpoint(this, enabled);
     }
 
     protected override isEnabled(): boolean {
@@ -37,16 +39,16 @@ export class DebugInstructionBreakpoint extends DebugBreakpoint<InstructionBreak
     }
 
     protected isSupported(): boolean {
-        return Boolean(this.session?.capabilities.supportsInstructionBreakpoints);
+        return this.raw ? !!this.raw.supportsInstructionBreakpoints : true;
     }
 
     remove(): void {
-        this.breakpoints.removeInstructionBreakpoint(this.origin.instructionReference);
+        this.breakpoints.removeInstructionBreakpoint(this);
     }
 
     protected doRender(): React.ReactNode {
         return <React.Fragment>
-            <span className="line-info">{this.origin.instructionReference}</span>;
+            <span className="line-info">{this.origin.raw.instructionReference}</span>
             {this.renderActions()}
         </React.Fragment>;
     }
@@ -69,7 +71,7 @@ export class DebugInstructionBreakpoint extends DebugBreakpoint<InstructionBreak
                 message: message ?? [nls.localize('theia/debug/instruction-breakpoint', 'Instruction Breakpoint')],
             };
         }
-        if (this.origin.condition || this.origin.hitCondition) {
+        if (this.origin.raw.condition || this.origin.raw.hitCondition) {
             return {
                 className: 'codicon-debug-breakpoint-conditional',
                 message: message || [nls.localize('theia/debug/conditionalBreakpoint', 'Conditional Breakpoint')]