@codingame/monaco-vscode-api 3.2.3 → 4.0.0

package/vscode/src/vs/workbench/contrib/speech/common/speechService.js

@@ -1,6 +1,7 @@
 import { localizeWithPath } from '../../../../nls.js';
 import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
 import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+import { language } from '../../../../base/common/platform.js';
 const ISpeechService = ( createDecorator('speechService'));
 const HasSpeechProvider = ( new RawContextKey('hasSpeechProvider', false, { type: 'string', description: ( localizeWithPath(
     'vs/workbench/contrib/speech/common/speechService',
@@ -29,4 +30,205 @@ var KeywordRecognitionStatus;
     KeywordRecognitionStatus[KeywordRecognitionStatus["Stopped"] = 2] = "Stopped";
     KeywordRecognitionStatus[KeywordRecognitionStatus["Canceled"] = 3] = "Canceled";
 })(KeywordRecognitionStatus || (KeywordRecognitionStatus = {})));
-export { HasSpeechProvider, ISpeechService, KeywordRecognitionStatus, SpeechToTextInProgress, SpeechToTextStatus };
+const SPEECH_LANGUAGE_CONFIG = 'accessibility.voice.speechLanguage';
+const SPEECH_LANGUAGES = {
+    ['da-DK']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.da-DK',
+            "Danish (Denmark)"
+        ))
+    },
+    ['de-DE']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.de-DE',
+            "German (Germany)"
+        ))
+    },
+    ['en-AU']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.en-AU',
+            "English (Australia)"
+        ))
+    },
+    ['en-CA']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.en-CA',
+            "English (Canada)"
+        ))
+    },
+    ['en-GB']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.en-GB',
+            "English (United Kingdom)"
+        ))
+    },
+    ['en-IE']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.en-IE',
+            "English (Ireland)"
+        ))
+    },
+    ['en-IN']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.en-IN',
+            "English (India)"
+        ))
+    },
+    ['en-NZ']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.en-NZ',
+            "English (New Zealand)"
+        ))
+    },
+    ['en-US']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.en-US',
+            "English (United States)"
+        ))
+    },
+    ['es-ES']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.es-ES',
+            "Spanish (Spain)"
+        ))
+    },
+    ['es-MX']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.es-MX',
+            "Spanish (Mexico)"
+        ))
+    },
+    ['fr-CA']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.fr-CA',
+            "French (Canada)"
+        ))
+    },
+    ['fr-FR']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.fr-FR',
+            "French (France)"
+        ))
+    },
+    ['hi-IN']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.hi-IN',
+            "Hindi (India)"
+        ))
+    },
+    ['it-IT']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.it-IT',
+            "Italian (Italy)"
+        ))
+    },
+    ['ja-JP']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.ja-JP',
+            "Japanese (Japan)"
+        ))
+    },
+    ['ko-KR']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.ko-KR',
+            "Korean (South Korea)"
+        ))
+    },
+    ['nl-NL']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.nl-NL',
+            "Dutch (Netherlands)"
+        ))
+    },
+    ['pt-PT']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.pt-PT',
+            "Portuguese (Portugal)"
+        ))
+    },
+    ['pt-BR']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.pt-BR',
+            "Portuguese (Brazil)"
+        ))
+    },
+    ['ru-RU']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.ru-RU',
+            "Russian (Russia)"
+        ))
+    },
+    ['sv-SE']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.sv-SE',
+            "Swedish (Sweden)"
+        ))
+    },
+    ['tr-TR']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.tr-TR',
+            "Turkish (Türkiye)"
+        ))
+    },
+    ['zh-CN']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.zh-CN',
+            "Chinese (Simplified, China)"
+        ))
+    },
+    ['zh-HK']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.zh-HK',
+            "Chinese (Traditional, Hong Kong)"
+        ))
+    },
+    ['zh-TW']: {
+        name: ( localizeWithPath(
+            'vs/workbench/contrib/speech/common/speechService',
+            'speechLanguage.zh-TW',
+            "Chinese (Traditional, Taiwan)"
+        ))
+    }
+};
+function speechLanguageConfigToLanguage(config, lang = language) {
+    if (typeof config === 'string') {
+        if (config === 'auto') {
+            if (lang !== 'en') {
+                const langParts = lang.split('-');
+                return speechLanguageConfigToLanguage(`${langParts[0]}-${(langParts[1] ?? langParts[0]).toUpperCase()}`);
+            }
+        }
+        else {
+            if (SPEECH_LANGUAGES[config]) {
+                return config;
+            }
+        }
+    }
+    return 'en-US';
+}
+export { HasSpeechProvider, ISpeechService, KeywordRecognitionStatus, SPEECH_LANGUAGES, SPEECH_LANGUAGE_CONFIG, SpeechToTextInProgress, SpeechToTextStatus, speechLanguageConfigToLanguage };

package/vscode/src/vs/workbench/contrib/tags/browser/workspaceTagsService.js

@@ -1,3 +1,6 @@
+import '../../../../platform/instantiation/common/instantiation.js';
+import '../../../../base/common/path.js';
+import '../../../../base/common/platform.js';
 class NoOpWorkspaceTagsService {
     getTags() {
         return Promise.resolve({});

package/vscode/src/vs/workbench/contrib/tags/common/workspaceTags.js

@@ -1,3 +1,5 @@
 import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+import '../../../../base/common/path.js';
+import '../../../../base/common/platform.js';
 const IWorkspaceTagsService = ( createDecorator('workspaceTagsService'));
 export { IWorkspaceTagsService };

package/vscode/src/vs/workbench/contrib/terminal/browser/terminal.d.ts

@@ -17,9 +17,10 @@ import { ITerminalStatusList } from './terminalStatusList.js';
 import { XtermTerminal } from './xterm/xtermTerminal.js';
 import { IStartExtensionTerminalRequest, ITerminalProcessExtHostProxy, IRemoteTerminalAttachTarget, ITerminalConfiguration, ITerminalFont, ITerminalProcessInfo } from '../common/terminal.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
-import { IMarker, ITheme, Terminal } from '@xterm/xterm';
+import { IMarker, IBufferRange, ITheme, Terminal } from '@xterm/xterm';
 import { ScrollPosition } from './xterm/markNavigationAddon.js';
 import { SIDE_GROUP_TYPE, ACTIVE_GROUP_TYPE, AUX_WINDOW_GROUP_TYPE } from '../../../services/editor/common/editorService.js';
+import { ICurrentPartialCommand } from '../../../../platform/terminal/common/capabilities/commandDetection/terminalCommand.js';
 
 /**
  * A terminal contribution that gets created whenever a terminal is created. A contribution has
@@ -92,12 +93,15 @@ interface IMarkTracker {
     selectToNextMark(): void;
     selectToPreviousLine(): void;
     selectToNextLine(): void;
-    clearMarker(): void;
+    clear(): void;
     scrollToClosestMarker(startMarkerId: string, endMarkerId?: string, highlight?: boolean | undefined): void;
     scrollToLine(line: number, position: ScrollPosition): void;
-    revealCommand(command: ITerminalCommand, position?: ScrollPosition): void;
+    revealCommand(command: ITerminalCommand | ICurrentPartialCommand, position?: ScrollPosition): void;
+    revealRange(range: IBufferRange): void;
     registerTemporaryDecoration(marker: IMarker, endMarker: IMarker | undefined, showOutline: boolean): void;
     showCommandGuide(command: ITerminalCommand | undefined): void;
+    saveScrollState(): void;
+    restoreScrollState(): void;
 }
 interface ITerminalGroup {
     activeInstance: ITerminalInstance | undefined;
@@ -216,6 +220,10 @@ interface ITerminalService extends ITerminalInstanceHost {
     readonly onDidRegisterProcessSupport: Event<void>;
     readonly onDidChangeConnectionState: Event<void>;
     readonly onDidChangeActiveGroup: Event<ITerminalGroup | undefined>;
+    readonly onAnyInstanceData: Event<{
+        instance: ITerminalInstance;
+        data: string;
+    }>;
     readonly onAnyInstanceDataInput: Event<ITerminalInstance>;
     readonly onAnyInstanceIconChange: Event<{
         instance: ITerminalInstance;

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalEditorInput.js

@@ -1,6 +1,6 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { localizeWithPath } from '../../../../nls.js';
-import Severity from '../../../../base/common/severity.js';
+import Severity$1 from '../../../../base/common/severity.js';
 import { toDisposable, dispose } from '../../../../base/common/lifecycle.js';
 import { IThemeService } from '../../../../platform/theme/common/themeService.js';
 import { ThemeIcon } from '../../../../base/common/themables.js';
@@ -69,7 +69,7 @@ let TerminalEditorInput = class TerminalEditorInput extends EditorInput {
     }
     async confirm(terminals) {
         const { confirmed } = await this._dialogService.confirm({
-            type: Severity.Warning,
+            type: Severity$1.Warning,
             message: ( localizeWithPath(
                 'vs/workbench/contrib/terminal/browser/terminalEditorInput',
                 'confirmDirtyTerminal.message',

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm/markNavigationAddon.js

@@ -5,6 +5,7 @@ import { timeout } from '../../../../../base/common/async.js';
 import { IThemeService } from '../../../../../platform/theme/common/themeService.js';
 import { TERMINAL_OVERVIEW_RULER_CURSOR_FOREGROUND_COLOR } from '../../common/terminalColorRegistry.js';
 import { getWindow } from '../../../../../base/browser/dom.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
 var Boundary;
 ( (function(Boundary) {
     Boundary[Boundary["Top"] = 0] = "Top";
@@ -17,9 +18,10 @@ let MarkNavigationAddon = class MarkNavigationAddon extends Disposable {
             this._currentMarker = Boundary.Bottom;
         }));
     }
-    constructor(_capabilities, _themeService) {
+    constructor(_capabilities, _configurationService, _themeService) {
         super();
         this._capabilities = _capabilities;
+        this._configurationService = _configurationService;
         this._themeService = _themeService;
         this._currentMarker = Boundary.Bottom;
         this._selectionStart = null;
@@ -64,7 +66,7 @@ let MarkNavigationAddon = class MarkNavigationAddon extends Disposable {
         }
         return undefined;
     }
-    clearMarker() {
+    clear() {
         this._currentMarker = Boundary.Bottom;
         this._resetNavigationDecorations();
         this._selectionStart = null;
@@ -181,16 +183,21 @@ let MarkNavigationAddon = class MarkNavigationAddon extends Disposable {
             this._scrollToMarker(marker, position);
         }
     }
-    _scrollToMarker(start, position, end, hideDecoration) {
+    _scrollToMarker(start, position, end, options) {
         if (!this._terminal) {
             return;
         }
-        if (!this._isMarkerInViewport(this._terminal, start)) {
+        if (!this._isMarkerInViewport(this._terminal, start) || options?.forceScroll) {
             const line = this.getTargetScrollLine(toLineIndex(start), position);
             this._terminal.scrollToLine(line);
         }
-        if (!hideDecoration) {
-            this.registerTemporaryDecoration(start, end, true);
+        if (!options?.hideDecoration) {
+            if (options?.bufferRange) {
+                this._highlightBufferRange(options.bufferRange);
+            }
+            else {
+                this.registerTemporaryDecoration(start, end, true);
+            }
         }
     }
     _createMarkerForOffset(marker, offset) {
@@ -217,6 +224,12 @@ let MarkNavigationAddon = class MarkNavigationAddon extends Disposable {
         const commandRowCount = command.getCommandRowCount();
         this._scrollToMarker(line - (promptRowCount - 1), position, line + (commandRowCount - 1));
     }
+    revealRange(range) {
+        this._scrollToMarker(range.start.y - 1, 1 , range.end.y - 1, {
+            bufferRange: range,
+            forceScroll: !!this._configurationService.getValue("terminal.integrated.stickyScroll.enabled" )
+        });
+    }
     showCommandGuide(command) {
         if (!this._terminal) {
             return;
@@ -266,6 +279,42 @@ let MarkNavigationAddon = class MarkNavigationAddon extends Disposable {
             }
         }
     }
+    saveScrollState() {
+        this._scrollState = { viewportY: this._terminal?.buffer.active.viewportY ?? 0 };
+    }
+    restoreScrollState() {
+        if (this._scrollState && this._terminal) {
+            this._terminal.scrollToLine(this._scrollState.viewportY);
+            this._scrollState = undefined;
+        }
+    }
+    _highlightBufferRange(range) {
+        if (!this._terminal) {
+            return;
+        }
+        this._resetNavigationDecorations();
+        const startLine = range.start.y;
+        const decorationCount = range.end.y - range.start.y + 1;
+        for (let i = 0; i < decorationCount; i++) {
+            const decoration = this._terminal.registerDecoration({
+                marker: this._createMarkerForOffset(startLine - 1, i),
+                x: range.start.x - 1,
+                width: (range.end.x - 1) - (range.start.x - 1) + 1,
+                overviewRulerOptions: undefined
+            });
+            if (decoration) {
+                this._navigationDecorations?.push(decoration);
+                let renderedElement;
+                decoration.onRender(element => {
+                    if (!renderedElement) {
+                        renderedElement = element;
+                        element.classList.add('terminal-range-highlight');
+                    }
+                });
+                decoration.onDispose(() => { this._navigationDecorations = this._navigationDecorations?.filter(d => d !== decoration); });
+            }
+        }
+    }
     registerTemporaryDecoration(marker, endMarker, showOutline) {
         if (!this._terminal) {
             return;
@@ -341,7 +390,7 @@ let MarkNavigationAddon = class MarkNavigationAddon extends Disposable {
             return;
         }
         const endMarker = endMarkerId ? detectionCapability.getMark(endMarkerId) : startMarker;
-        this._scrollToMarker(startMarker, 0 , endMarker, !highlight);
+        this._scrollToMarker(startMarker, 0 , endMarker, { hideDecoration: !highlight });
     }
     selectToPreviousMark() {
         if (!this._terminal) {
@@ -487,7 +536,8 @@ let MarkNavigationAddon = class MarkNavigationAddon extends Disposable {
     }
 };
 MarkNavigationAddon = ( __decorate([
-    ( __param(1, IThemeService))
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IThemeService))
 ], MarkNavigationAddon));
 function getLine(xterm, marker) {
     if (marker === Boundary.Bottom) {

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm/xtermTerminal.js

@@ -135,7 +135,8 @@ let XtermTerminal = class XtermTerminal extends Disposable {
             scrollSensitivity: config.mouseWheelScrollSensitivity,
             wordSeparator: config.wordSeparators,
             overviewRulerWidth: 10,
-            ignoreBracketedPasteMode: config.ignoreBracketedPasteMode
+            ignoreBracketedPasteMode: config.ignoreBracketedPasteMode,
+            rescaleOverlappingGlyphs: config.rescaleOverlappingGlyphs,
         })));
         this._updateSmoothScrolling();
         this._core = this.raw._core;
@@ -276,6 +277,7 @@ let XtermTerminal = class XtermTerminal extends Disposable {
         this.raw.options.wordSeparator = config.wordSeparators;
         this.raw.options.customGlyphs = config.customGlyphs;
         this.raw.options.ignoreBracketedPasteMode = config.ignoreBracketedPasteMode;
+        this.raw.options.rescaleOverlappingGlyphs = config.rescaleOverlappingGlyphs;
         this._updateSmoothScrolling();
         if (this._attached?.options.enableGpu) {
             if (this._shouldLoadWebgl()) {

package/vscode/src/vs/workbench/contrib/terminal/common/terminal.d.ts

@@ -125,6 +125,7 @@ interface ITerminalConfiguration {
     enableImages: boolean;
     smoothScrolling: boolean;
     ignoreBracketedPasteMode: boolean;
+    rescaleOverlappingGlyphs: boolean;
 }
 interface ITerminalFont {
     fontFamily: string;

package/vscode/src/vs/workbench/contrib/terminal/common/terminal.js

@@ -156,7 +156,18 @@ const DEFAULT_COMMANDS_TO_SKIP_SHELL = [
     'workbench.action.quickOpenView',
     'workbench.action.toggleMaximizedPanel',
     'notification.acceptPrimaryAction',
-    'runCommands'
+    'runCommands',
+    'workbench.action.terminal.chat.start',
+    'workbench.action.terminal.chat.close',
+    'workbench.action.terminal.chat.discard',
+    'workbench.action.terminal.chat.makeRequest',
+    'workbench.action.terminal.chat.cancel',
+    'workbench.action.terminal.chat.feedbackHelpful',
+    'workbench.action.terminal.chat.feedbackUnhelpful',
+    'workbench.action.terminal.chat.feedbackReportIssue',
+    'workbench.action.terminal.chat.runCommand',
+    'workbench.action.terminal.chat.insertCommand',
+    'workbench.action.terminal.chat.viewInChat',
 ];
 const terminalContributionsDescriptor = {
     extensionPoint: 'terminal',

package/vscode/src/vs/workbench/contrib/terminal/common/terminalColorRegistry.js

@@ -1,5 +1,15 @@
 import { localizeWithPath } from '../../../../nls.js';
-import { registerColor, editorSelectionBackground, transparent, editorFindMatch, editorHoverHighlight, editorFindMatchHighlight, overviewRulerFindMatchForeground } from '../../../../platform/theme/common/colorRegistry.js';
+import { registerColor, transparent } from '../../../../platform/theme/common/colorUtils.js';
+import '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import { editorSelectionBackground, editorFindMatch, editorFindMatchHighlight, overviewRulerFindMatchForeground, editorHoverHighlight } from '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
 import { PANEL_BORDER, EDITOR_DRAG_AND_DROP_BACKGROUND, TAB_ACTIVE_BORDER } from '../../../common/theme.js';
 const ansiColorIdentifiers = [];
 const TERMINAL_BACKGROUND_COLOR = registerColor('terminal.background', null, ( localizeWithPath(

package/vscode/src/vs/workbench/contrib/testing/common/testCoverage.js

@@ -1,26 +1,61 @@
 import { CancellationToken } from '../../../../base/common/cancellation.js';
 import { ResourceMap } from '../../../../base/common/map.js';
+import { deepClone } from '../../../../base/common/objects.js';
+import '../../../../base/common/observableInternal/derived.js';
+import '../../../../base/common/observableInternal/autorun.js';
+import { observableSignal } from '../../../../base/common/observableInternal/utils.js';
 import { WellDefinedPrefixTree } from '../../../../base/common/prefixTree.js';
 import { URI } from '../../../../base/common/uri.js';
-import { ICoveredCount } from './testTypes.js';
+let incId = 0;
 class TestCoverage {
-    static async load(taskId, accessor, uriIdentityService, token) {
-        const files = await accessor.provideFileCoverage(token);
-        const map = ( new ResourceMap());
-        for (const [i, file] of files.entries()) {
-            map.set(file.uri, ( new FileCoverage(file, i, accessor)));
-        }
-        return ( new TestCoverage(taskId, map, uriIdentityService));
-    }
-    get tree() {
-        return this._tree ??= this.buildCoverageTree();
-    }
-    constructor(fromTaskId, fileCoverage, uriIdentityService) {
+    constructor(fromTaskId, uriIdentityService, accessor) {
         this.fromTaskId = fromTaskId;
-        this.fileCoverage = fileCoverage;
         this.uriIdentityService = uriIdentityService;
+        this.accessor = accessor;
+        this.fileCoverage = ( new ResourceMap());
+        this.didAddCoverage = observableSignal(this);
+        this.tree = ( new WellDefinedPrefixTree());
         this.associatedData = ( new Map());
     }
+    append(rawCoverage, tx) {
+        const coverage = ( new FileCoverage(rawCoverage, this.accessor));
+        const previous = this.getComputedForUri(coverage.uri);
+        const applyDelta = (kind, node) => {
+            if (!node[kind]) {
+                if (coverage[kind]) {
+                    node[kind] = { ...coverage[kind] };
+                }
+            }
+            else {
+                node[kind].covered += (coverage[kind]?.covered || 0) - (previous?.[kind]?.covered || 0);
+                node[kind].total += (coverage[kind]?.total || 0) - (previous?.[kind]?.total || 0);
+            }
+        };
+        const canonical = [...this.treePathForUri(coverage.uri,  true)];
+        const chain = [];
+        this.tree.insert(this.treePathForUri(coverage.uri,  false), coverage, node => {
+            chain.push(node);
+            if (chain.length === canonical.length) {
+                node.value = coverage;
+            }
+            else if (!node.value) {
+                const intermediate = deepClone(rawCoverage);
+                intermediate.id = String(incId++);
+                intermediate.uri = this.treePathToUri(canonical.slice(0, chain.length));
+                node.value = ( new ComputedFileCoverage(intermediate));
+            }
+            else {
+                applyDelta('statement', node.value);
+                applyDelta('branch', node.value);
+                applyDelta('declaration', node.value);
+                node.value.didChange.trigger(tx);
+            }
+        });
+        this.fileCoverage.set(coverage.uri, coverage);
+        if (chain) {
+            this.didAddCoverage.trigger(tx, chain);
+        }
+    }
     getAllFiles() {
         return this.fileCoverage;
     }
@@ -30,45 +65,6 @@ class TestCoverage {
     getComputedForUri(uri) {
         return this.tree.find(this.treePathForUri(uri,  false));
     }
-    buildCoverageTree() {
-        const tree = ( new WellDefinedPrefixTree());
-        const nodeCanonicalSegments = ( new Map());
-        for (const file of ( this.fileCoverage.values())) {
-            const keyPath = this.treePathForUri(file.uri,  false);
-            const canonicalPath = this.treePathForUri(file.uri,  true);
-            tree.insert(keyPath, file, node => {
-                nodeCanonicalSegments.set(node, canonicalPath.next().value);
-            });
-        }
-        const calculateComputed = (path, node) => {
-            if (node.value) {
-                return node.value;
-            }
-            const fileCoverage = {
-                uri: this.treePathToUri(path),
-                statement: ICoveredCount.empty(),
-            };
-            if (node.children) {
-                for (const [prefix, child] of node.children) {
-                    path.push(nodeCanonicalSegments.get(child) || prefix);
-                    const v = calculateComputed(path, child);
-                    path.pop();
-                    ICoveredCount.sum(fileCoverage.statement, v.statement);
-                    if (v.branch) {
-                        ICoveredCount.sum(fileCoverage.branch ??= ICoveredCount.empty(), v.branch);
-                    }
-                    if (v.declaration) {
-                        ICoveredCount.sum(fileCoverage.declaration ??= ICoveredCount.empty(), v.declaration);
-                    }
-                }
-            }
-            return node.value = ( new ComputedFileCoverage(fileCoverage));
-        };
-        for (const node of tree.nodes) {
-            calculateComputed([], node);
-        }
-        return tree;
-    }
     *treePathForUri(uri, canconicalPath) {
         yield uri.scheme;
         yield uri.authority;
@@ -97,6 +93,8 @@ class AbstractFileCoverage {
         return getTotalCoveragePercent(this.statement, this.branch, this.declaration);
     }
     constructor(coverage) {
+        this.didChange = observableSignal(this);
+        this.id = coverage.id;
         this.uri = coverage.uri;
         this.statement = coverage.statement;
         this.branch = coverage.branch;
@@ -109,14 +107,12 @@ class FileCoverage extends AbstractFileCoverage {
     get hasSynchronousDetails() {
         return this._details instanceof Array || this.resolved;
     }
-    constructor(coverage, index, accessor) {
+    constructor(coverage, accessor) {
         super(coverage);
-        this.index = index;
         this.accessor = accessor;
-        this._details = coverage.details;
     }
     async details(token = CancellationToken.None) {
-        this._details ??= this.accessor.resolveFileCoverage(this.index, token);
+        this._details ??= this.accessor.getCoverageDetails(this.id, token);
         try {
             const d = await this._details;
             this.resolved = true;