@codingame/monaco-vscode-api 1.81.8-next.2 → 1.82.0-next.0

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

@@ -16,6 +16,7 @@ import { TestResultItem, getMarkId } from './testTypes.js';
     onDidWriteData: Event.None,
     endPromise: Promise.resolve(),
     getRange: () => VSBuffer.alloc(0),
+    getRangeIter: () => [],
 });
 class TaskRawOutput {
     constructor() {
@@ -32,6 +33,14 @@ class TaskRawOutput {
     getRange(start, length) {
         const buf = VSBuffer.alloc(length);
         let bufLastWrite = 0;
+        for (const chunk of this.getRangeIter(start, length)) {
+            buf.buffer.set(chunk.buffer, bufLastWrite);
+            bufLastWrite += chunk.byteLength;
+        }
+        return bufLastWrite < length ? buf.slice(0, bufLastWrite) : buf;
+    }
+    *getRangeIter(start, length) {
+        let soFar = 0;
         let internalLastRead = 0;
         for (const b of this.buffers) {
             if (internalLastRead + b.byteLength <= start) {
@@ -39,28 +48,45 @@ class TaskRawOutput {
                 continue;
             }
             const bstart = Math.max(0, start - internalLastRead);
-            const bend = Math.min(b.byteLength, bstart + length - bufLastWrite);
-            buf.buffer.set(b.buffer.subarray(bstart, bend), bufLastWrite);
-            bufLastWrite += bend - bstart;
+            const bend = Math.min(b.byteLength, bstart + length - soFar);
+            yield b.slice(bstart, bend);
+            soFar += bend - bstart;
             internalLastRead += b.byteLength;
-            if (bufLastWrite === buf.byteLength) {
+            if (soFar === length) {
                 break;
             }
         }
-        return bufLastWrite < length ? buf.slice(0, bufLastWrite) : buf;
     }
     append(data, marker) {
-        let startOffset = this.offset;
-        if (marker !== undefined) {
-            const start = VSBuffer.fromString(getMarkCode(marker, true));
-            const end = VSBuffer.fromString(getMarkCode(marker, false));
-            startOffset += start.byteLength;
-            data = VSBuffer.concat([start, data, end]);
+        const offset = this.offset;
+        let length = data.byteLength;
+        if (marker === undefined) {
+            this.push(data);
+            return { offset, length };
+        }
+        const start = VSBuffer.fromString(getMarkCode(marker, true));
+        const end = VSBuffer.fromString(getMarkCode(marker, false));
+        length += start.byteLength + end.byteLength;
+        this.push(start);
+        let trimLen = data.byteLength;
+        for (; trimLen > 0; trimLen--) {
+            const last = data.buffer[trimLen - 1];
+            if (last !== 13  && last !== 10 ) {
+                break;
+            }
+        }
+        this.push(data.slice(0, trimLen));
+        this.push(end);
+        this.push(data.slice(trimLen));
+        return { offset, length };
+    }
+    push(data) {
+        if (data.byteLength === 0) {
+            return;
         }
         this.buffers.push(data);
         this.writeDataEmitter.fire(data);
         this.offset += data.byteLength;
-        return startOffset;
     }
     end() {
         this.endDeferred.complete();
@@ -93,6 +119,7 @@ class LiveTestResult {
         this.changeEmitter = ( new Emitter());
         this.testById = ( new Map());
         this.testMarkerCounter = 0;
+        this.startedAt = Date.now();
         this.onChange = this.changeEmitter.event;
         this.onComplete = this.completeEmitter.event;
         this.onNewTask = this.newTaskEmitter.event;
@@ -145,19 +172,19 @@ class LiveTestResult {
         }
         const index = this.mustGetTaskIndex(taskId);
         const task = this.tasks[index];
-        const offset = task.output.append(output, marker);
+        const { offset, length } = task.output.append(output, marker);
         const message = {
             location,
             message: removeAnsiEscapeCodes(preview),
             offset,
-            length: output.byteLength,
-            marker: marker,
+            length,
+            marker,
             type: 1 ,
         };
         const test = testId && this.testById.get(testId);
         if (test) {
             test.tasks[index].messages.push(message);
-            this.changeEmitter.fire({ item: test, result: this, reason: 2  });
+            this.changeEmitter.fire({ item: test, result: this, reason: 2 , message });
         }
         else {
             task.otherMessages.push(message);
@@ -200,7 +227,7 @@ class LiveTestResult {
             return;
         }
         entry.tasks[this.mustGetTaskIndex(taskId)].messages.push(message);
-        this.changeEmitter.fire({ item: entry, result: this, reason: 2  });
+        this.changeEmitter.fire({ item: entry, result: this, reason: 2 , message });
     }
     markTaskComplete(taskId) {
         const index = this.mustGetTaskIndex(taskId);

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

@@ -20,6 +20,7 @@ var ITestErrorMessage;
         type: 0 ,
         expected: message.expected,
         actual: message.actual,
+        contextValue: message.contextValue,
         location: message.location && IRichLocation.serialize(message.location),
     });
     ITestErrorMessage.deserialize = (message) => ({
@@ -27,6 +28,7 @@ var ITestErrorMessage;
         type: 0 ,
         expected: message.expected,
         actual: message.actual,
+        contextValue: message.contextValue,
         location: message.location && IRichLocation.deserialize(message.location),
     });
 })(ITestErrorMessage || (ITestErrorMessage = {})));

package/vscode/src/vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution.js

@@ -15,6 +15,7 @@ import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiati
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
 import { TypeHierarchyTreePeekWidget } from './typeHierarchyPeek.js';
 import { TypeHierarchyProviderRegistry, TypeHierarchyModel } from '../common/typeHierarchy.js';
+var TypeHierarchyController_1;
 const _ctxHasTypeHierarchyProvider = ( new RawContextKey('editorHasTypeHierarchyProvider', false, ( localize(
     'editorHasTypeHierarchyProvider',
     'Whether a type hierarchy provider is available'
@@ -34,9 +35,10 @@ function sanitizedDirection(candidate) {
         : "subtypes" ;
 }
 let TypeHierarchyController = class TypeHierarchyController {
+    static { TypeHierarchyController_1 = this; }
     static { this.Id = 'typeHierarchy'; }
     static get(editor) {
-        return editor.getContribution(TypeHierarchyController.Id);
+        return editor.getContribution(TypeHierarchyController_1.Id);
     }
     static { this._storageDirectionKey = 'typeHierarchy/defaultDirection'; }
     constructor(_editor, _contextKeyService, _storageService, _editorService, _instantiationService) {
@@ -70,7 +72,7 @@ let TypeHierarchyController = class TypeHierarchyController {
         }
         const cts = ( new CancellationTokenSource());
         const model = TypeHierarchyModel.create(document, position, cts.token);
-        const direction = sanitizedDirection(this._storageService.get(TypeHierarchyController._storageDirectionKey, 0 , "subtypes" ));
+        const direction = sanitizedDirection(this._storageService.get(TypeHierarchyController_1._storageDirectionKey, 0 , "subtypes" ));
         this._showTypeHierarchyWidget(position, direction, model, cts);
     }
     _showTypeHierarchyWidget(position, direction, model, cts) {
@@ -81,7 +83,7 @@ let TypeHierarchyController = class TypeHierarchyController {
         this._widget.showLoading();
         this._sessionDisposables.add(this._widget.onDidClose(() => {
             this.endTypeHierarchy();
-            this._storageService.store(TypeHierarchyController._storageDirectionKey, this._widget.direction, 0 , 0 );
+            this._storageService.store(TypeHierarchyController_1._storageDirectionKey, this._widget.direction, 0 , 0 );
         }));
         this._sessionDisposables.add({ dispose() { cts.dispose(true); } });
         this._sessionDisposables.add(this._widget);
@@ -119,7 +121,7 @@ let TypeHierarchyController = class TypeHierarchyController {
         }
         const newModel = model.fork(typeItem.item);
         this._sessionDisposables.clear();
-        TypeHierarchyController.get(newEditor)?._showTypeHierarchyWidget(Range.lift(newModel.root.selectionRange).getStartPosition(), this._widget.direction, Promise.resolve(newModel), ( new CancellationTokenSource()));
+        TypeHierarchyController_1.get(newEditor)?._showTypeHierarchyWidget(Range.lift(newModel.root.selectionRange).getStartPosition(), this._widget.direction, Promise.resolve(newModel), ( new CancellationTokenSource()));
     }
     showSupertypes() {
         this._widget?.updateDirection("supertypes" );
@@ -135,14 +137,14 @@ let TypeHierarchyController = class TypeHierarchyController {
         this._editor.focus();
     }
 };
-TypeHierarchyController = ( __decorate([
+TypeHierarchyController = TypeHierarchyController_1 = ( __decorate([
     ( __param(1, IContextKeyService)),
     ( __param(2, IStorageService)),
     ( __param(3, ICodeEditorService)),
     ( __param(4, IInstantiationService))
 ], TypeHierarchyController));
 registerEditorContribution(TypeHierarchyController.Id, TypeHierarchyController, 0 );
-registerAction2(class extends EditorAction2 {
+registerAction2(class PeekTypeHierarchyAction extends EditorAction2 {
     constructor() {
         super({
             id: 'editor.showTypeHierarchy',
@@ -153,7 +155,8 @@ registerAction2(class extends EditorAction2 {
                 order: 1000,
                 when: ( ContextKeyExpr.and(_ctxHasTypeHierarchyProvider, PeekContext.notInPeekEditor)),
             },
-            precondition: ( ContextKeyExpr.and(_ctxHasTypeHierarchyProvider, PeekContext.notInPeekEditor))
+            precondition: ( ContextKeyExpr.and(_ctxHasTypeHierarchyProvider, PeekContext.notInPeekEditor)),
+            f1: true
         });
     }
     async runEditorCommand(_accessor, editor) {

package/vscode/src/vs/workbench/contrib/typeHierarchy/browser/typeHierarchyPeek.js

@@ -21,6 +21,7 @@ import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/st
 import { themeColorFromId, IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
 import { VirtualDelegate, TypeRenderer, DataSource, Sorter, AccessibilityProvider, IdentityProvider } from './typeHierarchyTree.js';
 import { IEditorService } from '../../../services/editor/common/editorService.js';
+var TypeHierarchyTreePeekWidget_1;
 class LayoutInfo {
     static store(info, storageService) {
         storageService.store('typeHierarchyPeekLayout', JSON.stringify(info), 0 , 1 );
@@ -43,6 +44,7 @@ class LayoutInfo {
 class TypeHierarchyTree extends WorkbenchAsyncDataTree {
 }
 let TypeHierarchyTreePeekWidget = class TypeHierarchyTreePeekWidget extends peekView.PeekViewWidget {
+    static { TypeHierarchyTreePeekWidget_1 = this; }
     static { this.TitleMenu = ( new MenuId('typehierarchy/title')); }
     constructor(editor, _where, _direction, themeService, _peekViewService, _editorService, _textModelService, _storageService, _menuService, _contextKeyService, _instantiationService) {
         super(editor, { showFrame: true, showArrow: true, isResizeable: true, isAccessible: true }, _instantiationService);
@@ -85,7 +87,7 @@ let TypeHierarchyTreePeekWidget = class TypeHierarchyTreePeekWidget extends peek
     }
     _fillHead(container) {
         super._fillHead(container, true);
-        const menu = this._menuService.createMenu(TypeHierarchyTreePeekWidget.TitleMenu, this._contextKeyService);
+        const menu = this._menuService.createMenu(TypeHierarchyTreePeekWidget_1.TitleMenu, this._contextKeyService);
         const updateToolbar = () => {
             const actions = [];
             createAndFillInActionBarActions(menu, undefined, actions);
@@ -319,7 +321,7 @@ let TypeHierarchyTreePeekWidget = class TypeHierarchyTreePeekWidget extends peek
         }
     }
 };
-TypeHierarchyTreePeekWidget = ( __decorate([
+TypeHierarchyTreePeekWidget = TypeHierarchyTreePeekWidget_1 = ( __decorate([
     ( __param(3, IThemeService)),
     ( __param(4, peekView.IPeekViewService)),
     ( __param(5, IEditorService)),

package/vscode/src/vs/workbench/contrib/webview/browser/webviewFindWidget.js

@@ -9,7 +9,11 @@ let WebviewFindWidget = class WebviewFindWidget extends SimpleFindWidget {
         return undefined;
     }
     constructor(_delegate, contextViewService, contextKeyService, keybindingService) {
-        super({ showCommonFindToggles: false, checkImeCompletionState: _delegate.checkImeCompletionState }, contextViewService, contextKeyService, keybindingService);
+        super({
+            showCommonFindToggles: false,
+            checkImeCompletionState: _delegate.checkImeCompletionState,
+            enableSash: true,
+        }, contextViewService, contextKeyService, keybindingService);
         this._delegate = _delegate;
         this._findWidgetFocused = KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED.bindTo(contextKeyService);
         this._register(_delegate.hasFindResult(hasResult => {

package/vscode/src/vs/workbench/contrib/webviewPanel/browser/webviewEditor.js

@@ -17,6 +17,7 @@ import { IEditorGroupsService } from '../../../services/editor/common/editorGrou
 import { IEditorService } from '../../../services/editor/common/editorService.js';
 import { IHostService } from '../../../services/host/browser/host.js';
 import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+var WebviewEditor_1;
 const CONTEXT_ACTIVE_WEBVIEW_PANEL_ID = ( new RawContextKey('activeWebviewPanelId', '', {
     type: 'string',
     description: ( nls.localize(
@@ -25,10 +26,11 @@ const CONTEXT_ACTIVE_WEBVIEW_PANEL_ID = ( new RawContextKey('activeWebviewPanelI
     )),
 }));
 let WebviewEditor = class WebviewEditor extends EditorPane {
+    static { WebviewEditor_1 = this; }
     static { this.ID = 'WebviewEditor'; }
     get onDidFocus() { return this._onDidFocusWebview.event; }
     constructor(telemetryService, themeService, storageService, editorGroupsService, _editorService, _workbenchLayoutService, _editorDropService, _hostService, _contextKeyService) {
-        super(WebviewEditor.ID, telemetryService, themeService, storageService);
+        super(WebviewEditor_1.ID, telemetryService, themeService, storageService);
         this._editorService = _editorService;
         this._workbenchLayoutService = _workbenchLayoutService;
         this._editorDropService = _editorDropService;
@@ -156,7 +158,7 @@ let WebviewEditor = class WebviewEditor extends EditorPane {
         return store;
     }
 };
-WebviewEditor = ( __decorate([
+WebviewEditor = WebviewEditor_1 = ( __decorate([
     ( __param(0, ITelemetryService)),
     ( __param(1, IThemeService)),
     ( __param(2, IStorageService)),

package/vscode/src/vs/workbench/contrib/webviewView/browser/webviewViewPane.js

@@ -3,7 +3,6 @@ import { Dimension, EventType, addDisposableListener, findParentWithClass } from
 import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { MutableDisposable, DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
 import { MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.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';
@@ -23,10 +22,12 @@ import { WebviewWindowDragMonitor } from '../../webview/browser/webviewWindowDra
 import { IWebviewViewService } from './webviewViewService.js';
 import { IActivityService, NumberBadge } from '../../../services/activity/common/activity.js';
 import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+var WebviewViewPane_1;
 const storageKeys = {
     webviewState: 'webviewState',
 };
 let WebviewViewPane = class WebviewViewPane extends ViewPane {
+    static { WebviewViewPane_1 = this; }
     static getOriginStore(storageService) {
         this._originStore ??= ( new ExtensionKeyedWebviewOriginStore('webviewViews.origins', storageService));
         return this._originStore;
@@ -109,7 +110,7 @@ let WebviewViewPane = class WebviewViewPane extends ViewPane {
             return;
         }
         this._activated = true;
-        const origin = this.extensionId ? WebviewViewPane.getOriginStore(this.storageService).getOrigin(this.id, this.extensionId) : undefined;
+        const origin = this.extensionId ? WebviewViewPane_1.getOriginStore(this.storageService).getOrigin(this.id, this.extensionId) : undefined;
         const webview = this.webviewService.createWebviewOverlay({
             origin,
             providedViewType: this.id,
@@ -207,10 +208,10 @@ let WebviewViewPane = class WebviewViewPane extends ViewPane {
         this._repositionTimeout = setTimeout(() => this.doLayoutWebview(dimension), 200);
     }
     findRootContainer(container) {
-        return withNullAsUndefined(findParentWithClass(container, 'monaco-scrollable-element'));
+        return findParentWithClass(container, 'monaco-scrollable-element') ?? undefined;
     }
 };
-WebviewViewPane = ( __decorate([
+WebviewViewPane = WebviewViewPane_1 = ( __decorate([
     ( __param(1, IConfigurationService)),
     ( __param(2, IContextKeyService)),
     ( __param(3, IContextMenuService)),

package/vscode/src/vs/workbench/services/actions/common/menusExtensionPoint.js

@@ -153,6 +153,18 @@ const apiMenus = [
         )),
         supportsSubmenus: false
     },
+    {
+        key: 'terminal/context',
+        id: MenuId.TerminalInstanceContext,
+        description: ( localize('menus.terminalContext', "The terminal context menu")),
+        proposed: 'terminalContextMenu'
+    },
+    {
+        key: 'terminal/title/context',
+        id: MenuId.TerminalTabContext,
+        description: ( localize('menus.terminalTabContext', "The terminal tabs context menu")),
+        proposed: 'terminalContextMenu'
+    },
     {
         key: 'view/title',
         id: MenuId.ViewTitle,
@@ -269,6 +281,22 @@ const apiMenus = [
             "The menu for a gutter decoration for a test item"
         )),
     },
+    {
+        key: 'testing/message/context',
+        id: MenuId.TestMessageContext,
+        description: ( localize(
+            'testing.message.context.title',
+            "A prominent button overlaying editor content where the message is displayed"
+        )),
+    },
+    {
+        key: 'testing/message/content',
+        id: MenuId.TestMessageContent,
+        description: ( localize(
+            'testing.message.content.title',
+            "Context menu for the message in the results tree"
+        )),
+    },
     {
         key: 'extension/context',
         id: MenuId.ExtensionContext,

package/vscode/src/vs/workbench/services/activity/common/activity.d.ts

@@ -30,4 +30,4 @@ interface IBadge {
     getDescription(): string;
 }
 
-export { IActivity, IActivityService, IBadge };
+export { type IActivity, IActivityService, type IBadge };

package/vscode/src/vs/workbench/services/{semanticSimilarity/common/semanticSimilarityService.js → aiEmbeddingVector/common/aiEmbeddingVectorService.js}

@@ -3,8 +3,10 @@ import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/com
 import { timeout, createCancelablePromise, raceCancellablePromises } from 'monaco-editor/esm/vs/base/common/async.js';
 import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-const ISemanticSimilarityService = ( createDecorator('ISemanticSimilarityService'));
-let SemanticSimilarityService = class SemanticSimilarityService {
+var AiEmbeddingVectorService_1;
+const IAiEmbeddingVectorService = ( createDecorator('IAiEmbeddingVectorService'));
+let AiEmbeddingVectorService = class AiEmbeddingVectorService {
+    static { AiEmbeddingVectorService_1 = this; }
     static { this.DEFAULT_TIMEOUT = 1000 * 10; }
     constructor(logService) {
         this.logService = logService;
@@ -13,7 +15,7 @@ let SemanticSimilarityService = class SemanticSimilarityService {
     isEnabled() {
         return this._providers.length > 0;
     }
-    registerSemanticSimilarityProvider(provider) {
+    registerAiEmbeddingVectorProvider(model, provider) {
         this._providers.push(provider);
         return {
             dispose: () => {
@@ -24,13 +26,13 @@ let SemanticSimilarityService = class SemanticSimilarityService {
             }
         };
     }
-    async getSimilarityScore(string1, comparisons, token) {
+    async getEmbeddingVector(strings, token) {
         if (this._providers.length === 0) {
-            throw new Error('No semantic similarity providers registered');
+            throw new Error('No embedding vector providers registered');
         }
         const stopwatch = StopWatch.create();
         const cancellablePromises = [];
-        const timer = timeout(SemanticSimilarityService.DEFAULT_TIMEOUT);
+        const timer = timeout(AiEmbeddingVectorService_1.DEFAULT_TIMEOUT);
         const disposable = token.onCancellationRequested(() => {
             disposable.dispose();
             timer.cancel();
@@ -38,12 +40,12 @@ let SemanticSimilarityService = class SemanticSimilarityService {
         for (const provider of this._providers) {
             cancellablePromises.push(createCancelablePromise(async (t) => {
                 try {
-                    return await provider.provideSimilarityScore(string1, comparisons, t);
+                    return await provider.provideAiEmbeddingVector(Array.isArray(strings) ? strings : [strings], t);
                 }
                 catch (e) {
                 }
                 await timer;
-                throw new Error('Semantic similarity provider timed out');
+                throw new Error('Embedding vector provider timed out');
             }));
         }
         cancellablePromises.push(createCancelablePromise(async (t) => {
@@ -52,19 +54,22 @@ let SemanticSimilarityService = class SemanticSimilarityService {
                 disposable.dispose();
             });
             await timer;
-            throw new Error('Semantic similarity provider timed out');
+            throw new Error('Embedding vector provider timed out');
         }));
         try {
             const result = await raceCancellablePromises(cancellablePromises);
+            if (result.length === 1) {
+                return result[0];
+            }
             return result;
         }
         finally {
             stopwatch.stop();
-            this.logService.trace(`[SemanticSimilarityService]: getSimilarityScore took ${stopwatch.elapsed()}ms`);
+            this.logService.trace(`[AiEmbeddingVectorService]: getEmbeddingVector took ${stopwatch.elapsed()}ms`);
         }
     }
 };
-SemanticSimilarityService = ( __decorate([
+AiEmbeddingVectorService = AiEmbeddingVectorService_1 = ( __decorate([
     ( __param(0, ILogService))
-], SemanticSimilarityService));
-export { ISemanticSimilarityService, SemanticSimilarityService };
+], AiEmbeddingVectorService));
+export { AiEmbeddingVectorService, IAiEmbeddingVectorService };

package/vscode/src/vs/workbench/services/aiRelatedInformation/common/aiRelatedInformation.js

@@ -0,0 +1,10 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IAiRelatedInformationService = ( createDecorator('IAiRelatedInformationService'));
+var RelatedInformationType;
+( (function(RelatedInformationType) {
+    RelatedInformationType[RelatedInformationType["SymbolInformation"] = 1] = "SymbolInformation";
+    RelatedInformationType[RelatedInformationType["CommandInformation"] = 2] = "CommandInformation";
+    RelatedInformationType[RelatedInformationType["SearchInformation"] = 3] = "SearchInformation";
+    RelatedInformationType[RelatedInformationType["SettingInformation"] = 4] = "SettingInformation";
+})(RelatedInformationType || (RelatedInformationType = {})));
+export { IAiRelatedInformationService, RelatedInformationType };

package/vscode/src/vs/workbench/services/configuration/browser/configuration.js

@@ -202,8 +202,10 @@ class FileServiceBasedConfiguration extends Disposable {
         const resolveContents = async (resources) => {
             return Promise.all(( (resources.map(async (resource) => {
                 try {
-                    const content = ( ((await this.fileService.readFile(resource)).value.toString()));
-                    return content;
+                    const content = await this.fileService.readFile(resource, { atomic: true });
+                    return (
+                         (content.value.toString())
+                    );
                 }
                 catch (error) {
                     this.logService.trace(`Error while resolving configuration file '${( ( resource.toString()))}': ${errors.getErrorMessage(error)}`);
@@ -396,7 +398,7 @@ class FileServiceBasedRemoteUserConfiguration extends Disposable {
         return this.reload();
     }
     async resolveContent() {
-        const content = await this.fileService.readFile(this.configurationResource);
+        const content = await this.fileService.readFile(this.configurationResource, { atomic: true });
         return (
              (content.value.toString())
         );
@@ -612,7 +614,7 @@ class FileServiceBasedWorkspaceConfiguration extends Disposable {
         return this._workspaceIdentifier;
     }
     async resolveContent(workspaceIdentifier) {
-        const content = await this.fileService.readFile(workspaceIdentifier.configPath);
+        const content = await this.fileService.readFile(workspaceIdentifier.configPath, { atomic: true });
         return (
              (content.value.toString())
         );

package/vscode/src/vs/workbench/services/configuration/browser/configurationService.js

@@ -32,7 +32,7 @@ import { NullPolicyService } from 'monaco-editor/esm/vs/platform/policy/common/p
 import { IJSONEditingService } from '../common/jsonEditing.js';
 import { workbenchConfigurationNodeBase } from '../../../common/configuration.js';
 function getLocalUserConfigurationScopes(userDataProfile, hasRemote) {
-    return userDataProfile.isDefault
+    return (userDataProfile.isDefault || userDataProfile.useDefaultFlags?.settings)
         ? hasRemote ? LOCAL_MACHINE_SCOPES : undefined
         : hasRemote ? LOCAL_MACHINE_PROFILE_SCOPES : PROFILE_SCOPES;
 }

package/vscode/src/vs/workbench/services/configuration/common/configurationEditing.js

@@ -13,7 +13,6 @@ import { Extensions, OVERRIDE_PROPERTY_REGEX, keyFromOverrideIdentifiers } from
 import { IEditorService } from '../../editor/common/editorService.js';
 import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
 import { IPreferencesService } from '../../preferences/common/preferences.js';
-import { withNullAsUndefined, withUndefinedAsNull } from 'monaco-editor/esm/vs/base/common/types.js';
 import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
 import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
 import { EditOperation } from 'monaco-editor/esm/vs/editor/common/core/editOperation.js';
@@ -510,12 +509,12 @@ let ConfigurationEditing = class ConfigurationEditing {
                 const resource = this.getConfigurationFileResource(target, key, standaloneConfigurationMap[key], overrides.resource, undefined);
                 if (config.key === key) {
                     const jsonPath = this.isWorkspaceConfigurationResource(resource) ? [key] : [];
-                    return { key: jsonPath[jsonPath.length - 1], jsonPath, value: config.value, resource: withNullAsUndefined(resource), workspaceStandAloneConfigurationKey: key, target };
+                    return { key: jsonPath[jsonPath.length - 1], jsonPath, value: config.value, resource: resource ?? undefined, workspaceStandAloneConfigurationKey: key, target };
                 }
                 const keyPrefix = `${key}.`;
                 if (config.key.indexOf(keyPrefix) === 0) {
                     const jsonPath = this.isWorkspaceConfigurationResource(resource) ? [key, config.key.substr(keyPrefix.length)] : [config.key.substr(keyPrefix.length)];
-                    return { key: jsonPath[jsonPath.length - 1], jsonPath, value: config.value, resource: withNullAsUndefined(resource), workspaceStandAloneConfigurationKey: key, target };
+                    return { key: jsonPath[jsonPath.length - 1], jsonPath, value: config.value, resource: resource ?? undefined, workspaceStandAloneConfigurationKey: key, target };
                 }
             }
         }
@@ -524,13 +523,13 @@ let ConfigurationEditing = class ConfigurationEditing {
         const configurationScope = configurationProperties[key]?.scope;
         let jsonPath = overrides.overrideIdentifiers?.length ? [keyFromOverrideIdentifiers(overrides.overrideIdentifiers), key] : [key];
         if (target === 1  || target === 2 ) {
-            return { key, jsonPath, value: config.value, resource: withNullAsUndefined(this.getConfigurationFileResource(target, key, '', null, configurationScope)), target };
+            return { key, jsonPath, value: config.value, resource: this.getConfigurationFileResource(target, key, '', null, configurationScope) ?? undefined, target };
         }
         const resource = this.getConfigurationFileResource(target, key, FOLDER_SETTINGS_PATH, overrides.resource, configurationScope);
         if (this.isWorkspaceConfigurationResource(resource)) {
             jsonPath = ['settings', ...jsonPath];
         }
-        return { key, jsonPath, value: config.value, resource: withNullAsUndefined(resource), target };
+        return { key, jsonPath, value: config.value, resource: resource ?? undefined, target };
     }
     isWorkspaceConfigurationResource(resource) {
         const workspace = this.contextService.getWorkspace();
@@ -556,7 +555,7 @@ let ConfigurationEditing = class ConfigurationEditing {
             const workspace = this.contextService.getWorkspace();
             if (target === 3 ) {
                 if (workbenchState === 3 ) {
-                    return withUndefinedAsNull(workspace.configuration);
+                    return workspace.configuration ?? null;
                 }
                 if (workbenchState === 2 ) {
                     return workspace.folders[0].toResource(relativePath);

package/vscode/src/vs/workbench/services/editor/browser/codeEditorService.js

@@ -11,8 +11,8 @@ let CodeEditorService = class CodeEditorService extends AbstractCodeEditorServic
         super(themeService);
         this.editorService = editorService;
         this.configurationService = configurationService;
-        this.registerCodeEditorOpenHandler(this.doOpenCodeEditor.bind(this));
-        this.registerCodeEditorOpenHandler(this.doOpenCodeEditorFromDiff.bind(this));
+        this._register(this.registerCodeEditorOpenHandler(this.doOpenCodeEditor.bind(this)));
+        this._register(this.registerCodeEditorOpenHandler(this.doOpenCodeEditorFromDiff.bind(this)));
     }
     getActiveCodeEditor() {
         const activeTextEditorControl = this.editorService.activeTextEditorControl;