@codingame/monaco-vscode-api 1.82.6 → 1.83.0-next.0

package/vscode/src/vs/editor/common/languages.d.ts

@@ -9,7 +9,7 @@ import { URI } from '../../base/common/uri.js';
 import { ISingleEditOperation } from './core/editOperation.js';
 import { Position, IPosition } from './core/position.js';
 import { Range, IRange } from './core/range.js';
-import { Selection, ISelection } from './core/selection.js';
+import { Selection } from './core/selection.js';
 import { LanguageId } from './encodedTokenAttributes.js';
 import { ITextModel, EndOfLineSequence } from './model.js';
 import { ExtensionIdentifier } from '../../platform/extensions/common/extensions.js';
@@ -865,10 +865,6 @@ interface FormattingOptions {
      * Prefer spaces over tabs.
      */
     insertSpaces: boolean;
-    /**
-     * The list of multiple ranges to format at once, if the provider supports it.
-     */
-    ranges?: Range[];
 }
 /**
  * The document formatting provider interface defines the contract between extensions and
@@ -1258,13 +1254,14 @@ interface DocumentOnDropEditProvider {
     readonly dropMimeTypes?: readonly string[];
     provideDocumentOnDropEdits(model: ITextModel, position: IPosition, dataTransfer: IReadonlyVSDataTransfer, token: CancellationToken): ProviderResult<DocumentOnDropEdit>;
 }
-interface RelatedContextItem {
+interface DocumentContextItem {
     readonly uri: URI;
-    readonly range: IRange;
+    readonly version: number;
+    readonly ranges: IRange[];
 }
 interface MappedEditsContext {
-    selections: ISelection[];
-    related: RelatedContextItem[];
+    /** The outer array is sorted by priority - from highest to lowest. The inner arrays contain elements of the same priority. */
+    documents: DocumentContextItem[][];
 }
 interface MappedEditsProvider {
     /**
@@ -1280,4 +1277,4 @@ interface MappedEditsProvider {
     provideMappedEdits(document: ITextModel, codeBlocks: string[], context: MappedEditsContext, token: CancellationToken): Promise<WorkspaceEdit | null>;
 }
 
-export { type CodeAction, type CodeActionContext, type CodeActionList, type CodeActionProvider, CodeActionTriggerType, type CodeLens, type CodeLensList, type CodeLensProvider, Command, type CompletionContext, type CompletionItem, CompletionItemInsertTextRule, CompletionItemKind, type CompletionItemLabel, type CompletionItemProvider, type CompletionItemRanges, CompletionItemTag, type CompletionList, CompletionTriggerKind, type DeclarationProvider, type Definition, type DefinitionProvider, type DocumentColorProvider, type DocumentFormattingEditProvider, type DocumentHighlight, DocumentHighlightKind, type DocumentHighlightProvider, type DocumentOnDropEdit, type DocumentOnDropEditProvider, type DocumentPasteEdit, type DocumentPasteEditProvider, type DocumentRangeFormattingEditProvider, type DocumentRangeSemanticTokensProvider, type DocumentSemanticTokensProvider, type DocumentSymbol, type DocumentSymbolProvider, type DropYieldTo, type EvaluatableExpression, type EvaluatableExpressionProvider, type FoldingContext, type FoldingRange, FoldingRangeKind, type FoldingRangeProvider, type FormattingOptions, type Hover, type HoverProvider, type IColor, type IColorInformation, type IColorPresentation, type IInplaceReplaceSupportResult, type ILanguageIdCodec, type ILink, type ILinksList, type IWorkspaceFileEdit, type IWorkspaceTextEdit, type ImplementationProvider, type InlayHint, InlayHintKind, type InlayHintLabelPart, type InlayHintList, type InlayHintsProvider, type InlineCompletion, type InlineCompletionContext, type InlineCompletionProviderGroupId, InlineCompletionTriggerKind, type InlineCompletions, type InlineCompletionsProvider, type InlineValue, type InlineValueContext, type InlineValueExpression, type InlineValueText, type InlineValueVariableLookup, type InlineValuesProvider, type LinkProvider, type LinkedEditingRangeProvider, type LinkedEditingRanges, type Location, type LocationLink, type MappedEditsContext, type MappedEditsProvider, type OnTypeFormattingEditProvider, type ParameterInformation, type ProviderResult, type ReferenceContext, type ReferenceProvider, type Rejection, type RelatedContextItem, type RenameLocation, type RenameProvider, SelectedSuggestionInfo, type SelectionRange, type SelectionRangeProvider, type SemanticTokens, type SemanticTokensEdit, type SemanticTokensEdits, type SemanticTokensLegend, type SignatureHelp, type SignatureHelpContext, type SignatureHelpProvider, type SignatureHelpResult, SignatureHelpTriggerKind, type SignatureInformation, SymbolKind, SymbolTag, TextEdit, type TypeDefinitionProvider, type WorkspaceEdit, type WorkspaceEditMetadata, type WorkspaceFileEditOptions };
+export { type CodeAction, type CodeActionContext, type CodeActionList, type CodeActionProvider, CodeActionTriggerType, type CodeLens, type CodeLensList, type CodeLensProvider, Command, type CompletionContext, type CompletionItem, CompletionItemInsertTextRule, CompletionItemKind, type CompletionItemLabel, type CompletionItemProvider, type CompletionItemRanges, CompletionItemTag, type CompletionList, CompletionTriggerKind, type DeclarationProvider, type Definition, type DefinitionProvider, type DocumentColorProvider, type DocumentContextItem, type DocumentFormattingEditProvider, type DocumentHighlight, DocumentHighlightKind, type DocumentHighlightProvider, type DocumentOnDropEdit, type DocumentOnDropEditProvider, type DocumentPasteEdit, type DocumentPasteEditProvider, type DocumentRangeFormattingEditProvider, type DocumentRangeSemanticTokensProvider, type DocumentSemanticTokensProvider, type DocumentSymbol, type DocumentSymbolProvider, type DropYieldTo, type EvaluatableExpression, type EvaluatableExpressionProvider, type FoldingContext, type FoldingRange, FoldingRangeKind, type FoldingRangeProvider, type FormattingOptions, type Hover, type HoverProvider, type IColor, type IColorInformation, type IColorPresentation, type IInplaceReplaceSupportResult, type ILanguageIdCodec, type ILink, type ILinksList, type IWorkspaceFileEdit, type IWorkspaceTextEdit, type ImplementationProvider, type InlayHint, InlayHintKind, type InlayHintLabelPart, type InlayHintList, type InlayHintsProvider, type InlineCompletion, type InlineCompletionContext, type InlineCompletionProviderGroupId, InlineCompletionTriggerKind, type InlineCompletions, type InlineCompletionsProvider, type InlineValue, type InlineValueContext, type InlineValueExpression, type InlineValueText, type InlineValueVariableLookup, type InlineValuesProvider, type LinkProvider, type LinkedEditingRangeProvider, type LinkedEditingRanges, type Location, type LocationLink, type MappedEditsContext, type MappedEditsProvider, type OnTypeFormattingEditProvider, type ParameterInformation, type ProviderResult, type ReferenceContext, type ReferenceProvider, type Rejection, type RenameLocation, type RenameProvider, SelectedSuggestionInfo, type SelectionRange, type SelectionRangeProvider, type SemanticTokens, type SemanticTokensEdit, type SemanticTokensEdits, type SemanticTokensLegend, type SignatureHelp, type SignatureHelpContext, type SignatureHelpProvider, type SignatureHelpResult, SignatureHelpTriggerKind, type SignatureInformation, SymbolKind, SymbolTag, TextEdit, type TypeDefinitionProvider, type WorkspaceEdit, type WorkspaceEditMetadata, type WorkspaceFileEditOptions };

package/vscode/src/vs/editor/common/model.d.ts

@@ -499,7 +499,7 @@ declare class SearchData {
 /**
  * @internal
  */
-interface ITextBuffer extends IReadonlyTextBuffer {
+interface ITextBuffer extends IReadonlyTextBuffer, IDisposable {
     setEOL(newEOL: '\r\n' | '\n'): void;
     applyEdits(rawOperations: ValidAnnotatedEditOperation[], recordTrimAutoWhitespace: boolean, computeUndoEdits: boolean): ApplyEditsResult;
 }

package/vscode/src/vs/platform/actions/common/actions.d.ts

@@ -53,6 +53,7 @@ declare class MenuId {
     static readonly ExtensionContext: MenuId;
     static readonly GlobalActivity: MenuId;
     static readonly CommandCenter: MenuId;
+    static readonly CommandCenterCenter: MenuId;
     static readonly LayoutControlMenuSubmenu: MenuId;
     static readonly LayoutControlMenu: MenuId;
     static readonly MenubarMainMenu: MenuId;

package/vscode/src/vs/platform/extensionManagement/common/extensionNls.js

@@ -1,15 +1,15 @@
 import { isString, isObject } from 'monaco-editor/esm/vs/base/common/types.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
-function localizeManifest(extensionManifest, translations, fallbackTranslations) {
+function localizeManifest(logger, extensionManifest, translations, fallbackTranslations) {
     try {
-        replaceNLStrings(extensionManifest, translations, fallbackTranslations);
+        replaceNLStrings(logger, extensionManifest, translations, fallbackTranslations);
     }
     catch (error) {
-        console.error(error?.message ?? error);
+        logger.error(error?.message ?? error);
     }
     return extensionManifest;
 }
-function replaceNLStrings(extensionManifest, messages, originalMessages) {
+function replaceNLStrings(logger, extensionManifest, messages, originalMessages) {
     const processEntry = (obj, key, command) => {
         const value = obj[key];
         if (isString(value)) {
@@ -26,7 +26,7 @@ function replaceNLStrings(extensionManifest, messages, originalMessages) {
                 const originalMessage = typeof original === 'string' ? original : original?.message;
                 if (!message) {
                     if (!originalMessage) {
-                        console.warn(`[${extensionManifest.name}]: ${( ( localize('missingNLSKey', "Couldn't find message for key {0}.", messageKey)))}`);
+                        logger.warn(`[${extensionManifest.name}]: ${( ( localize('missingNLSKey', "Couldn't find message for key {0}.", messageKey)))}`);
                     }
                     return;
                 }

package/vscode/src/vs/platform/files/common/fileService.js

@@ -10,10 +10,10 @@ import { Disposable, toDisposable, dispose, DisposableStore } from 'monaco-edito
 import { TernarySearchTree } from 'monaco-editor/esm/vs/base/common/ternarySearchTree.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { mark } from 'monaco-editor/esm/vs/base/common/performance.js';
-import { isAbsolutePath, joinPath, dirname, basename, extUri, extUriIgnorePathCase } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { isAbsolutePath, extUri, extUriIgnorePathCase } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { isReadableStream, peekStream, peekReadable, consumeStream, transform, newWriteableStream, isReadableBufferedStream, listenStream } from 'monaco-editor/esm/vs/base/common/stream.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { FileChangesEvent, FileOperationError, hasOpenReadWriteCloseCapability, hasReadWriteCapability, hasFileReadStreamCapability, toFileSystemProviderErrorCode, FileSystemProviderErrorCode, ensureFileSystemProviderError, FileType, FilePermission, etag, FileOperationEvent, toFileOperationResult, ETAG_DISABLED, hasFileAtomicReadCapability, NotModifiedSinceFileOperationError, TooLargeFileOperationError, hasFileFolderCopyCapability, hasFileCloneCapability } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { FileChangesEvent, FileOperationError, hasOpenReadWriteCloseCapability, hasReadWriteCapability, hasFileReadStreamCapability, toFileSystemProviderErrorCode, FileSystemProviderErrorCode, ensureFileSystemProviderError, FileType, FilePermission, etag, FileOperationEvent, hasFileAtomicWriteCapability, toFileOperationResult, ETAG_DISABLED, hasFileAtomicReadCapability, NotModifiedSinceFileOperationError, TooLargeFileOperationError, hasFileFolderCopyCapability, hasFileAtomicDeleteCapability, hasFileCloneCapability } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { readFileIntoStream } from './io.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { ErrorNoTelemetry } from 'monaco-editor/esm/vs/base/common/errors.js';
@@ -246,8 +246,15 @@ let FileService = class FileService extends Disposable {
     async writeFile(resource, bufferOrReadableOrStream, options) {
         const provider = this.throwIfFileSystemIsReadonly(await this.withWriteProvider(resource), resource);
         const { providerExtUri } = this.getExtUri(provider);
+        let writeFileOptions = options;
+        if (hasFileAtomicWriteCapability(provider) && !writeFileOptions?.atomic) {
+            const enforcedAtomicWrite = provider.enforceAtomicWriteFile?.(resource);
+            if (enforcedAtomicWrite) {
+                writeFileOptions = { ...options, atomic: enforcedAtomicWrite };
+            }
+        }
         try {
-            const stat = await this.validateWriteFile(provider, resource, options);
+            const stat = await this.validateWriteFile(provider, resource, writeFileOptions);
             if (!stat) {
                 await this.mkdirp(provider, providerExtUri.dirname(resource));
             }
@@ -269,22 +276,19 @@ let FileService = class FileService extends Disposable {
             else {
                 bufferOrReadableOrStreamOrBufferedStream = bufferOrReadableOrStream;
             }
-            if (!hasOpenReadWriteCloseCapability(provider) || (hasReadWriteCapability(provider) && bufferOrReadableOrStreamOrBufferedStream instanceof VSBuffer)) {
-                await this.doWriteUnbuffered(provider, resource, options, bufferOrReadableOrStreamOrBufferedStream);
+            if (!hasOpenReadWriteCloseCapability(provider) ||
+                (hasReadWriteCapability(provider) && bufferOrReadableOrStreamOrBufferedStream instanceof VSBuffer) ||
+                (hasReadWriteCapability(provider) && hasFileAtomicWriteCapability(provider) && writeFileOptions?.atomic)
+            ) {
+                await this.doWriteUnbuffered(provider, resource, writeFileOptions, bufferOrReadableOrStreamOrBufferedStream);
             }
             else {
-                const contents = bufferOrReadableOrStreamOrBufferedStream instanceof VSBuffer ? bufferToReadable(bufferOrReadableOrStreamOrBufferedStream) : bufferOrReadableOrStreamOrBufferedStream;
-                if (options?.atomic !== false && options?.atomic?.postfix) {
-                    await this.doWriteBufferedAtomic(provider, resource, joinPath(dirname(resource), `${basename(resource)}${options.atomic.postfix}`), options, contents);
-                }
-                else {
-                    await this.doWriteBuffered(provider, resource, options, contents);
-                }
+                await this.doWriteBuffered(provider, resource, writeFileOptions, bufferOrReadableOrStreamOrBufferedStream instanceof VSBuffer ? bufferToReadable(bufferOrReadableOrStreamOrBufferedStream) : bufferOrReadableOrStreamOrBufferedStream);
             }
             this._onDidRunOperation.fire(( new FileOperationEvent(resource, 4 )));
         }
         catch (error) {
-            throw new FileOperationError(localize('err.write', "Unable to write file '{0}' ({1})", this.resourceForError(resource), ensureFileSystemProviderError(error).toString()), toFileOperationResult(error), options);
+            throw new FileOperationError(localize('err.write', "Unable to write file '{0}' ({1})", this.resourceForError(resource), ensureFileSystemProviderError(error).toString()), toFileOperationResult(error), writeFileOptions);
         }
         return this.resolve(resource, { resolveMetadata: true });
     }
@@ -296,7 +300,10 @@ let FileService = class FileService extends Disposable {
         const atomic = !!options?.atomic;
         if (atomic) {
             if (!((provider.capabilities & 32768) )) {
-                throw new Error(localize('writeFailedAtomicUnsupported', "Unable to atomically write file '{0}' because provider does not support it.", this.resourceForError(resource)));
+                throw new Error(localize('writeFailedAtomicUnsupported1', "Unable to atomically write file '{0}' because provider does not support it.", this.resourceForError(resource)));
+            }
+            if (!((provider.capabilities & 2) )) {
+                throw new Error(localize('writeFailedAtomicUnsupported2', "Unable to atomically write file '{0}' because provider does not support unbuffered writes.", this.resourceForError(resource)));
             }
             if (unlock) {
                 throw new Error(localize('writeFailedAtomicUnlock', "Unable to unlock file '{0}' because atomic write is enabled.", this.resourceForError(resource)));
@@ -356,27 +363,33 @@ let FileService = class FileService extends Disposable {
     }
     async doReadFileStream(provider, resource, options, token) {
         const cancellableSource = ( new CancellationTokenSource(token));
-        const statPromise = this.validateReadFile(resource, options).then(stat => stat, error => {
-            cancellableSource.cancel();
+        let readFileOptions = options;
+        if (hasFileAtomicReadCapability(provider) && provider.enforceAtomicReadFile?.(resource)) {
+            readFileOptions = { ...options, atomic: true };
+        }
+        const statPromise = this.validateReadFile(resource, readFileOptions).then(stat => stat, error => {
+            cancellableSource.dispose(true);
             throw error;
         });
         let fileStream = undefined;
         try {
-            if (typeof options?.etag === 'string' && options.etag !== ETAG_DISABLED) {
+            if (typeof readFileOptions?.etag === 'string' && readFileOptions.etag !== ETAG_DISABLED) {
                 await statPromise;
             }
-            if ((options?.atomic && hasFileAtomicReadCapability(provider)) ||
+            if ((readFileOptions?.atomic && hasFileAtomicReadCapability(provider)) ||
                 !(hasOpenReadWriteCloseCapability(provider) || hasFileReadStreamCapability(provider)) ||
-                (hasReadWriteCapability(provider) && options?.preferUnbuffered)
+                (hasReadWriteCapability(provider) && readFileOptions?.preferUnbuffered)
             ) {
-                fileStream = this.readFileUnbuffered(provider, resource, options);
+                fileStream = this.readFileUnbuffered(provider, resource, readFileOptions);
             }
             else if (hasFileReadStreamCapability(provider)) {
-                fileStream = this.readFileStreamed(provider, resource, cancellableSource.token, options);
+                fileStream = this.readFileStreamed(provider, resource, cancellableSource.token, readFileOptions);
             }
             else {
-                fileStream = this.readFileBuffered(provider, resource, cancellableSource.token, options);
+                fileStream = this.readFileBuffered(provider, resource, cancellableSource.token, readFileOptions);
             }
+            fileStream.on('end', () => cancellableSource.dispose());
+            fileStream.on('error', () => cancellableSource.dispose());
             const fileStat = await statPromise;
             return {
                 ...fileStat,
@@ -387,7 +400,7 @@ let FileService = class FileService extends Disposable {
             if (fileStream) {
                 await consumeStream(fileStream);
             }
-            throw this.restoreReadError(error, resource, options);
+            throw this.restoreReadError(error, resource, readFileOptions);
         }
     }
     restoreReadError(error, resource, options) {
@@ -692,9 +705,16 @@ let FileService = class FileService extends Disposable {
     }
     async del(resource, options) {
         const provider = await this.doValidateDelete(resource, options);
-        const useTrash = !!options?.useTrash;
-        const recursive = !!options?.recursive;
-        const atomic = options?.atomic ?? false;
+        let deleteFileOptions = options;
+        if (hasFileAtomicDeleteCapability(provider) && !deleteFileOptions?.atomic) {
+            const enforcedAtomicDelete = provider.enforceAtomicDelete?.(resource);
+            if (enforcedAtomicDelete) {
+                deleteFileOptions = { ...options, atomic: enforcedAtomicDelete };
+            }
+        }
+        const useTrash = !!deleteFileOptions?.useTrash;
+        const recursive = !!deleteFileOptions?.recursive;
+        const atomic = deleteFileOptions?.atomic ?? false;
         await provider.delete(resource, { recursive, useTrash, atomic });
         this._onDidRunOperation.fire(( new FileOperationEvent(resource, 1 )));
     }
@@ -764,20 +784,6 @@ let FileService = class FileService extends Disposable {
         }
         this.activeWatchers.clear();
     }
-    async doWriteBufferedAtomic(provider, resource, tempResource, options, readableOrStreamOrBufferedStream) {
-        await this.doWriteBuffered(provider, tempResource, options, readableOrStreamOrBufferedStream);
-        try {
-            await provider.rename(tempResource, resource, { overwrite: true });
-        }
-        catch (error) {
-            try {
-                await provider.delete(tempResource, { recursive: false, useTrash: false, atomic: false });
-            }
-            catch (error) {
-            }
-            throw error;
-        }
-    }
     async doWriteBuffered(provider, resource, options, readableOrStreamOrBufferedStream) {
         return this.writeQueue.queueFor(resource, this.getExtUri(provider).providerExtUri).queue(async () => {
             const handle = await provider.open(resource, { create: true, unlock: options?.unlock ?? false });

package/vscode/src/vs/platform/files/common/files.d.ts

@@ -222,6 +222,24 @@ interface IFileUnlockOptions {
      */
     readonly unlock: boolean;
 }
+interface IFileAtomicReadOptions {
+    /**
+     * The optional `atomic` flag can be used to make sure
+     * the `readFile` method is not running in parallel with
+     * any `write` operations in the same process.
+     *
+     * Typically you should not need to use this flag but if
+     * for example you are quickly reading a file right after
+     * a file event occurred and the file changes a lot, there
+     * is a chance that a read returns an empty or partial file
+     * because a pending write has not finished yet.
+     *
+     * Note: this does not prevent the file from being written
+     * to from a different process. If you need such atomic
+     * operations, you better use a real database as storage.
+     */
+    readonly atomic: boolean;
+}
 interface IFileAtomicOptions {
     /**
      * The postfix is used to create a temporary file based
@@ -244,6 +262,15 @@ interface IFileAtomicWriteOptions {
      */
     readonly atomic: IFileAtomicOptions | false;
 }
+interface IFileAtomicDeleteOptions {
+    /**
+     * The optional `atomic` flag can be used to make sure
+     * the `delete` method deletes the target atomically by
+     * first renaming it to a temporary resource in the same
+     * folder and then deleting it.
+     */
+    readonly atomic: IFileAtomicOptions | false;
+}
 interface IFileReadLimits {
     /**
      * If the file exceeds the given size, an error of kind
@@ -473,9 +500,27 @@ interface IFileSystemProviderWithFileReadWriteCapability extends IFileSystemProv
     readFile(resource: URI): Promise<Uint8Array>;
     writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
 }
+interface IFileSystemProviderWithOpenReadWriteCloseCapability extends IFileSystemProvider {
+    open(resource: URI, opts: IFileOpenOptions): Promise<number>;
+    close(fd: number): Promise<void>;
+    read(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
+    write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
+}
 interface IFileSystemProviderWithFileReadStreamCapability extends IFileSystemProvider {
     readFileStream(resource: URI, opts: IFileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array>;
 }
+interface IFileSystemProviderWithFileAtomicReadCapability extends IFileSystemProvider {
+    readFile(resource: URI, opts?: IFileAtomicReadOptions): Promise<Uint8Array>;
+    enforceAtomicReadFile?(resource: URI): boolean;
+}
+interface IFileSystemProviderWithFileAtomicWriteCapability extends IFileSystemProvider {
+    writeFile(resource: URI, contents: Uint8Array, opts?: IFileAtomicWriteOptions): Promise<void>;
+    enforceAtomicWriteFile?(resource: URI): IFileAtomicOptions | false;
+}
+interface IFileSystemProviderWithFileAtomicDeleteCapability extends IFileSystemProvider {
+    delete(resource: URI, opts: IFileAtomicDeleteOptions): Promise<void>;
+    enforceAtomicDelete?(resource: URI): IFileAtomicOptions | false;
+}
 declare enum FileSystemProviderErrorCode {
     FileExists = "EntryExists",
     FileNotFound = "EntryNotFound",
@@ -789,4 +834,4 @@ interface ICreateFileOptions {
     readonly overwrite?: boolean;
 }
 
-export { FileChangeType, FileChangesEvent, FileOperation, FileOperationEvent, FilePermission, FileSystemProviderCapabilities, FileSystemProviderError, FileSystemProviderErrorCode, FileType, type IBaseFileStat, type IBaseFileStatWithMetadata, type IBaseReadFileOptions, type ICreateFileOptions, type IFileAtomicOptions, type IFileAtomicWriteOptions, type IFileChange, type IFileContent, type IFileDeleteOptions, type IFileOpenForReadOptions, type IFileOpenForWriteOptions, type IFileOpenOptions, type IFileOperationEvent, type IFileOperationEventWithMetadata, type IFileOverwriteOptions, type IFileReadLimits, type IFileReadStreamOptions, IFileService, type IFileStat, type IFileStatResult, type IFileStatWithMetadata, type IFileStatWithPartialMetadata, type IFileStreamContent, type IFileSystemProvider, type IFileSystemProviderActivationEvent, type IFileSystemProviderCapabilitiesChangeEvent, type IFileSystemProviderError, type IFileSystemProviderRegistrationEvent, type IFileSystemProviderWithFileReadStreamCapability, type IFileSystemProviderWithFileReadWriteCapability, type IFileUnlockOptions, type IFileWriteOptions, type IReadFileOptions, type IReadFileStreamOptions, type IResolveFileOptions, type IResolveMetadataFileOptions, type IStat, type IWatchOptions, type IWriteFileOptions };
+export { FileChangeType, FileChangesEvent, FileOperation, FileOperationEvent, FilePermission, FileSystemProviderCapabilities, FileSystemProviderError, FileSystemProviderErrorCode, FileType, type IBaseFileStat, type IBaseFileStatWithMetadata, type IBaseReadFileOptions, type ICreateFileOptions, type IFileAtomicDeleteOptions, type IFileAtomicOptions, type IFileAtomicReadOptions, type IFileAtomicWriteOptions, type IFileChange, type IFileContent, type IFileDeleteOptions, type IFileOpenForReadOptions, type IFileOpenForWriteOptions, type IFileOpenOptions, type IFileOperationEvent, type IFileOperationEventWithMetadata, type IFileOverwriteOptions, type IFileReadLimits, type IFileReadStreamOptions, IFileService, type IFileStat, type IFileStatResult, type IFileStatWithMetadata, type IFileStatWithPartialMetadata, type IFileStreamContent, type IFileSystemProvider, type IFileSystemProviderActivationEvent, type IFileSystemProviderCapabilitiesChangeEvent, type IFileSystemProviderError, type IFileSystemProviderRegistrationEvent, type IFileSystemProviderWithFileAtomicDeleteCapability, type IFileSystemProviderWithFileAtomicReadCapability, type IFileSystemProviderWithFileAtomicWriteCapability, type IFileSystemProviderWithFileReadStreamCapability, type IFileSystemProviderWithFileReadWriteCapability, type IFileSystemProviderWithOpenReadWriteCloseCapability, type IFileUnlockOptions, type IFileWriteOptions, type IReadFileOptions, type IReadFileStreamOptions, type IResolveFileOptions, type IResolveMetadataFileOptions, type IStat, type IWatchOptions, type IWriteFileOptions };

package/vscode/src/vs/platform/files/common/inMemoryFilesystemProvider.js

@@ -1,6 +1,8 @@
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+import { newWriteableStream } from 'monaco-editor/esm/vs/base/common/stream.js';
 import { createFileSystemProviderError, FileSystemProviderErrorCode, FileType } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 class File {
     constructor(name) {
@@ -24,6 +26,8 @@ class Directory {
 class InMemoryFileSystemProvider extends Disposable {
     constructor() {
         super(...arguments);
+        this.memoryFdCounter = 0;
+        this.fdMemory = ( new Map());
         this._onDidChangeCapabilities = this._register(( new Emitter()));
         this.onDidChangeCapabilities = this._onDidChangeCapabilities.event;
         this._capabilities = 2  | 1024 ;
@@ -57,6 +61,12 @@ class InMemoryFileSystemProvider extends Disposable {
         }
         throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
     }
+    readFileStream(resource) {
+        const data = this._lookupAsFile(resource, false).data;
+        const stream = newWriteableStream(data => VSBuffer.concat(( data.map(data => VSBuffer.wrap(data)))).buffer);
+        stream.end(data);
+        return stream;
+    }
     async writeFile(resource, content, opts) {
         const basename = resources.basename(resource);
         const parent = this._lookupParentDirectory(resource);
@@ -80,6 +90,37 @@ class InMemoryFileSystemProvider extends Disposable {
         entry.data = content;
         this._fireSoon({ type: 0 , resource });
     }
+    open(resource, opts) {
+        const data = this._lookupAsFile(resource, false).data;
+        if (data) {
+            const fd = this.memoryFdCounter++;
+            this.fdMemory.set(fd, data);
+            return Promise.resolve(fd);
+        }
+        throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+    }
+    close(fd) {
+        this.fdMemory.delete(fd);
+        return Promise.resolve();
+    }
+    read(fd, pos, data, offset, length) {
+        const memory = this.fdMemory.get(fd);
+        if (!memory) {
+            throw createFileSystemProviderError(`No file with that descriptor open`, FileSystemProviderErrorCode.Unavailable);
+        }
+        const toWrite = VSBuffer.wrap(memory).slice(pos, pos + length);
+        data.set(toWrite.buffer, offset);
+        return Promise.resolve(toWrite.byteLength);
+    }
+    write(fd, pos, data, offset, length) {
+        const memory = this.fdMemory.get(fd);
+        if (!memory) {
+            throw createFileSystemProviderError(`No file with that descriptor open`, FileSystemProviderErrorCode.Unavailable);
+        }
+        const toWrite = VSBuffer.wrap(data).slice(offset, offset + length);
+        memory.set(toWrite.buffer, pos);
+        return Promise.resolve(toWrite.byteLength);
+    }
     async rename(from, to, opts) {
         if (!opts.overwrite && this._lookup(to, true)) {
             throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
@@ -171,5 +212,9 @@ class InMemoryFileSystemProvider extends Disposable {
             this._bufferedChanges.length = 0;
         }, 5);
     }
+    dispose() {
+        super.dispose();
+        this.fdMemory.clear();
+    }
 }
 export { InMemoryFileSystemProvider };

package/vscode/src/vs/platform/storage/common/storage.d.ts

@@ -167,6 +167,10 @@ interface IStorageService {
      * existed before.
      */
     isNew(scope: StorageScope): boolean;
+    /**
+     * Attempts to reduce the DB size via optimization commands if supported.
+     */
+    optimize(scope: StorageScope): Promise<void>;
     /**
      * Allows to flush state, e.g. in cases where a shutdown is
      * imminent. This will send out the `onWillSaveState` to ask
@@ -284,6 +288,7 @@ declare abstract class AbstractStorageService extends Disposable implements ISto
     isNew(scope: StorageScope): boolean;
     flush(reason?: WillSaveStateReason): Promise<void>;
     log(): Promise<void>;
+    optimize(scope: StorageScope): Promise<void>;
     switch(to: IAnyWorkspaceIdentifier | IUserDataProfile, preserveData: boolean): Promise<void>;
     protected canSwitchProfile(from: IUserDataProfile, to: IUserDataProfile): boolean;
     protected switchData(oldStorage: Map<string, string>, newStorage: IStorage, scope: StorageScope): void;

package/vscode/src/vs/platform/storage/common/storage.js

@@ -239,6 +239,10 @@ class AbstractStorageService extends Disposable {
         const workspaceItems = this.getStorage(1 )?.items ?? ( new Map());
         return logStorage(applicationItems, profileItems, workspaceItems, this.getLogDetails(-1 ) ?? '', this.getLogDetails(0 ) ?? '', this.getLogDetails(1 ) ?? '');
     }
+    async optimize(scope) {
+        await this.flush();
+        return this.getStorage(scope)?.optimize();
+    }
     async switch(to, preserveData) {
         this.emitWillSaveState(WillSaveStateReason.NONE);
         if (isUserDataProfile(to)) {

package/vscode/src/vs/platform/telemetry/common/telemetryUtils.js

@@ -18,9 +18,12 @@ function supportsTelemetry(productService, environmentService) {
     if (!environmentService.isBuilt && !environmentService.disableTelemetry) {
         return true;
     }
-    return !(environmentService.disableTelemetry || !productService.enableTelemetry || environmentService.extensionTestsLocationURI);
+    return !(environmentService.disableTelemetry || !productService.enableTelemetry);
 }
 function isLoggingOnly(productService, environmentService) {
+    if (environmentService.extensionTestsLocationURI) {
+        return true;
+    }
     if (environmentService.isBuilt) {
         return false;
     }

package/vscode/src/vs/platform/terminal/common/terminal.js

@@ -1,7 +1,5 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-const terminalTabFocusModeContextKey = ( new RawContextKey('terminalTabFocusMode', false, true));
 var TitleEventSource;
 ( (function(TitleEventSource) {
     TitleEventSource[TitleEventSource["Api"] = 0] = "Api";
@@ -46,4 +44,4 @@ class TerminalBackendRegistry {
 }
 Registry.add(TerminalExtensions.Backend, ( new TerminalBackendRegistry()));
 const ITerminalLogService = ( createDecorator('terminalLogService'));
-export { ITerminalLogService, TerminalExitReason, TerminalExtensions, TerminalLocation, TitleEventSource, terminalTabFocusModeContextKey };
+export { ITerminalLogService, TerminalExitReason, TerminalExtensions, TerminalLocation, TitleEventSource };

package/vscode/src/vs/platform/tunnel/common/tunnel.d.ts

@@ -12,7 +12,7 @@ interface TunnelOptions {
     protocol?: string;
 }
 declare enum TunnelPrivacyId {
-    ConstantPrivate = "constantPrivate",
+    ConstantPrivate = "constantPrivate",// private, and changing is unsupported
     Private = "private",
     Public = "public"
 }

package/vscode/src/vs/platform/userDataProfile/common/userDataProfile.d.ts

@@ -19,6 +19,7 @@ interface IUserDataProfile {
     readonly isDefault: boolean;
     readonly name: string;
     readonly shortName?: string;
+    readonly icon?: string;
     readonly location: URI;
     readonly globalStorageHome: URI;
     readonly settingsResource: URI;

package/vscode/src/vs/workbench/api/browser/mainThreadChat.js

@@ -134,6 +134,17 @@ let MainThreadChat = class MainThreadChat extends Disposable {
         if (isCompleteInteractiveProgressTreeData(progress)) {
             return;
         }
+        if ('documents' in progress) {
+            const usedContext = {
+                documents: ( progress.documents.map(({ uri, version, ranges }) => ({
+                    uri: URI.revive(uri),
+                    version,
+                    ranges,
+                }))),
+            };
+            this._activeRequestProgressCallbacks.get(id)?.(usedContext);
+            return;
+        }
         this._activeRequestProgressCallbacks.get(id)?.(progress);
     }
     async $acceptChatState(sessionId, state) {

package/vscode/src/vs/workbench/api/browser/mainThreadChatAgents.js

@@ -0,0 +1,50 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { IChatAgentService } from '../../contrib/chat/common/chatAgents.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+let MainThreadChatAgents = class MainThreadChatAgents {
+    constructor(extHostContext, _chatAgentService) {
+        this._chatAgentService = _chatAgentService;
+        this._agents = ( new DisposableMap());
+        this._pendingProgress = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatAgents));
+    }
+    $unregisterAgent(handle) {
+        this._agents.deleteAndDispose(handle);
+    }
+    dispose() {
+        this._agents.clearAndDisposeAll();
+    }
+    $registerAgent(handle, name, metadata) {
+        if (!this._chatAgentService.hasAgent(name)) {
+            this._chatAgentService.registerAgentData({
+                id: name,
+                metadata: revive(metadata)
+            });
+        }
+        const d = this._chatAgentService.registerAgentCallback(name, async (prompt, progress, history, token) => {
+            const requestId = Math.random();
+            this._pendingProgress.set(requestId, progress);
+            try {
+                return await this._proxy.$invokeAgent(handle, requestId, prompt, { history }, token);
+            }
+            finally {
+                this._pendingProgress.delete(requestId);
+            }
+        });
+        this._agents.set(handle, d);
+    }
+    async $handleProgressChunk(requestId, chunk) {
+        this._pendingProgress.get(requestId)?.report(revive(chunk));
+    }
+    $unregisterCommand(handle) {
+        this._agents.deleteAndDispose(handle);
+    }
+};
+MainThreadChatAgents = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadChatAgents),
+    ( __param(1, IChatAgentService))
+], MainThreadChatAgents);
+export { MainThreadChatAgents };

package/vscode/src/vs/workbench/api/browser/mainThreadChatSlashCommands.js

@@ -1,5 +1,6 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
 import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
 import { IChatSlashCommandService } from '../../contrib/chat/common/chatSlashCommands.js';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
@@ -24,7 +25,7 @@ let MainThreadChatSlashCommands = class MainThreadChatSlashCommands {
             const requestId = Math.random();
             this._pendingProgress.set(requestId, progress);
             try {
-                await this._proxy.$executeCommand(handle, requestId, prompt, { history }, token);
+                return await this._proxy.$executeCommand(handle, requestId, prompt, { history }, token);
             }
             finally {
                 this._pendingProgress.delete(requestId);
@@ -33,7 +34,7 @@ let MainThreadChatSlashCommands = class MainThreadChatSlashCommands {
         this._commands.set(handle, d);
     }
     async $handleProgressChunk(requestId, chunk) {
-        this._pendingProgress.get(requestId)?.report(chunk);
+        this._pendingProgress.get(requestId)?.report(revive(chunk));
     }
     $unregisterCommand(handle) {
         this._commands.deleteAndDispose(handle);