@codingame/monaco-vscode-api 34.1.2 → 35.0.0

package/vscode/src/vs/base/common/defaultAccount.d.ts

@@ -1,6 +1,7 @@
-import { IExtraKnownMarketplaceEntry } from "./managedSettings.js";
+import type { ManagedSettingsData } from "./policy.js";
 export interface IQuotaSnapshotData {
     readonly overage_count: number;
+    readonly overage_entitlement: number;
     readonly overage_permitted: boolean;
     readonly percent_remaining: number;
     readonly unlimited: boolean;
@@ -48,26 +49,14 @@ export interface IPolicyData {
     readonly mcpRegistryUrl?: string;
     readonly mcpAccess?: "allow_all" | "registry_only";
     /**
-     * Enterprise-managed plugin enablement, delivered via the Copilot
-     * `managed_settings` API. Keys are plugin IDs in `<plugin>@<marketplace>`
-     * form; values are explicit enable/disable. Consumers that read
-     * `chat.pluginLocations` should merge these with user-supplied path-keyed
-     * entries via `IConfigurationService.inspect()`.
+     * Normalized enterprise-managed settings, keyed by dot-separated managed-settings
+     * paths such as `permissions.disableBypassPermissionsMode`. This is the single
+     * channel for enterprise-managed configuration: server-delivered settings and
+     * native MDM settings both project into this bag, so policy `value()` callbacks
+     * behave identically regardless of source. Structured settings (e.g.
+     * `enabledPlugins`, `extraKnownMarketplaces`) are carried as canonical JSON strings.
      */
-    readonly enabledPlugins?: Readonly<Record<string, boolean>>;
-    /**
-     * Enterprise-managed marketplace references, delivered via the Copilot
-     * `managed_settings` API. Each entry preserves the marketplace `name`
-     * (used as `displayLabel` so that `enabledPlugins["plugin@<name>"]` keys
-     * resolve) plus the original `source` discriminator. Legacy string entries
-     * are still accepted for forward/backward compatibility.
-     */
-    readonly extraKnownMarketplaces?: readonly (string | IExtraKnownMarketplaceEntry)[];
-    /**
-     * Enterprise-managed strict-marketplace flag. When true, only marketplaces
-     * listed in `extraKnownMarketplaces` (plus the user's own) are trusted.
-     */
-    readonly strictKnownMarketplaces?: boolean;
+    readonly managedSettings?: ManagedSettingsData;
 }
 export interface ICopilotTokenInfo {
     readonly sn?: string;

package/vscode/src/vs/base/common/managedSettings.d.ts

@@ -17,3 +17,35 @@ export type IExtraKnownMarketplaceEntry = {
         readonly ref?: string;
     };
 };
+/**
+ * A single entry in the enterprise-managed `strictKnownMarketplaces` allowlist
+ * (the `chat.plugins.strictMarketplaces` setting), a discriminated union on
+ * `source`. Delivered as JSON via managed settings (the server endpoint or
+ * native MDM) and validated at match time, so the optional fields are only
+ * meaningful for their corresponding `source`.
+ */
+export interface IStrictMarketplaceSource {
+    readonly source: "github" | "git" | "url" | "npm" | "file" | "directory" | "hostPattern" | "pathPattern";
+    readonly repo?: string;
+    readonly url?: string;
+    readonly ref?: string;
+    readonly path?: string;
+    readonly package?: string;
+    readonly hostPattern?: string;
+    readonly pathPattern?: string;
+    readonly headers?: Readonly<Record<string, string>>;
+}
+/**
+ * Converts an {@link IExtraKnownMarketplaceEntry} array into the
+ * `{ [name]: url-or-shorthand }` dict stored on the `chat.plugins.extraMarketplaces`
+ * setting (and carried as the canonical JSON value of the `extraKnownMarketplaces`
+ * managed setting across both the server endpoint and native MDM delivery).
+ *
+ * Plain-string entries (allowed by the policy schema but unnamed) are stored with
+ * the value used as both key and value so they survive the round-trip intact.
+ *
+ * Marketplace names come from managed settings (untrusted input) and are written as object keys,
+ * so `__proto__` / `constructor` / `prototype` keys are skipped to avoid prototype pollution
+ * (mirroring the guard in the managed-settings normalizer's string-map encoder).
+ */
+export declare function extraKnownMarketplacesToConfigDict(entries: readonly (string | IExtraKnownMarketplaceEntry)[] | undefined): Record<string, string> | undefined;

package/vscode/src/vs/base/common/managedSettings.js

@@ -0,0 +1,30 @@
+
+
+function extraKnownMarketplacesToConfigDict(entries) {
+    if (!entries?.length) {
+        return undefined;
+    }
+    const obj = {};
+    for (const entry of entries) {
+        if (typeof entry === 'string') {
+            if (isUnsafeMarketplaceKey(entry)) {
+                continue;
+            }
+            obj[entry] = entry;
+        }
+        else {
+            if (isUnsafeMarketplaceKey(entry.name)) {
+                continue;
+            }
+            const s = entry.source;
+            const base = s.source === 'github' ? s.repo : s.url;
+            obj[entry.name] = s.ref ? `${base}#${s.ref}` : base;
+        }
+    }
+    return obj;
+}
+function isUnsafeMarketplaceKey(key) {
+    return key === '__proto__' || key === 'constructor' || key === 'prototype';
+}
+
+export { extraKnownMarketplacesToConfigDict };

package/vscode/src/vs/base/common/map.d.ts

@@ -195,8 +195,14 @@ export declare class NKeyMap<TValue, TKeys extends (string | boolean | number)[]
     get(...keys: [
         ...TKeys
     ]): TValue | undefined;
+    delete(...keys: [
+        ...TKeys
+    ]): boolean;
+    deleteAll(...keys: Partial<TKeys>): boolean;
     clear(): void;
+    getAll(...keys: Partial<TKeys>): IterableIterator<TValue>;
     values(): IterableIterator<TValue>;
+    private _values;
     /**
      * Get a textual representation of the map for debugging purposes.
      */

package/vscode/src/vs/base/common/map.js

@@ -715,20 +715,74 @@ class NKeyMap {
         }
         return currentMap.get(keys[keys.length - 1]);
     }
+    delete(...keys) {
+        const maps = [this._data];
+        let currentMap = this._data;
+        for (let i = 0; i < keys.length - 1; i++) {
+            const nextMap = currentMap.get(keys[i]);
+            if (nextMap === undefined) {
+                return false;
+            }
+            currentMap = nextMap;
+            maps.push(currentMap);
+        }
+        const deleted = currentMap.delete(keys[keys.length - 1]);
+        for (let i = keys.length - 2; deleted && i >= 0; i--) {
+            if (maps[i + 1].size === 0) {
+                maps[i].delete(keys[i]);
+            }
+        }
+        return deleted;
+    }
+    deleteAll(...keys) {
+        if (keys.length === 0) {
+            const hadData = this._data.size > 0;
+            this._data.clear();
+            return hadData;
+        }
+        const maps = [this._data];
+        let currentMap = this._data;
+        for (let i = 0; i < keys.length - 1; i++) {
+            const nextMap = currentMap.get(keys[i]);
+            if (nextMap === undefined) {
+                return false;
+            }
+            currentMap = nextMap;
+            maps.push(currentMap);
+        }
+        const deleted = currentMap.delete(keys[keys.length - 1]);
+        for (let i = keys.length - 2; deleted && i >= 0; i--) {
+            if (maps[i + 1].size === 0) {
+                maps[i].delete(keys[i]);
+            }
+        }
+        return deleted;
+    }
     clear() {
         this._data.clear();
     }
+    *getAll(...keys) {
+        let currentMap = this._data;
+        for (const key of keys) {
+            const nextMap = currentMap.get(key);
+            if (nextMap === undefined) {
+                return;
+            }
+            currentMap = nextMap;
+        }
+        yield* this._values(currentMap);
+    }
     *values() {
-        function* iterate(map) {
-            for (const value of ( map.values())) {
-                if (value instanceof Map) {
-                    yield* iterate(value);
-                } else {
-                    yield value;
-                }
+        yield* this._values(this._data);
+    }
+    *_values(map) {
+        for (const value of ( map.values())) {
+            if (value instanceof Map) {
+                yield* this._values(value);
+            } else {
+                yield value;
             }
         }
-        yield* iterate(this._data);
     }
     toString() {
         const printMap = (map, depth) => {

package/vscode/src/vs/base/common/numbers.d.ts

@@ -1,4 +1,8 @@
 export declare function clamp(value: number, min: number, max: number): number;
+/**
+ * Formats a token count for compact display (e.g. `128K`, `1M`, `1.5M`).
+ */
+export declare function formatTokenCount(count: number): string;
 export declare function rot(index: number, modulo: number): number;
 export declare class Counter {
     private _next;

package/vscode/src/vs/base/common/numbers.js

@@ -4,6 +4,18 @@ import { assert } from './assert.js';
 function clamp(value, min, max) {
     return Math.min(Math.max(value, min), max);
 }
+function formatTokenCount(count) {
+    if (count >= 1_000_000) {
+        const value = count / 1_000_000;
+        const floored = Math.floor(value * 10) / 10;
+        return floored % 1 === 0 ? `${floored.toFixed(0)}M` : `${floored.toFixed(1)}M`;
+    } else if (count > 900_000) {
+        return "1M";
+    } else if (count >= 1000) {
+        return `${Math.round(count / 1000)}K`;
+    }
+    return ( count.toString());
+}
 function rot(index, modulo) {
     return (modulo + (index % modulo)) % modulo;
 }
@@ -77,4 +89,4 @@ function randomChance(p) {
     return Math.random() < p;
 }
 
-export { Counter, MovingAverage, SlidingWindowAverage, clamp, isPointWithinTriangle, randomChance, rot };
+export { Counter, MovingAverage, SlidingWindowAverage, clamp, formatTokenCount, isPointWithinTriangle, randomChance, rot };

package/vscode/src/vs/base/common/policy.d.ts

@@ -8,6 +8,13 @@ export type LocalizedValue = {
     key: string;
     value: string;
 };
+export type PolicyValue = string | number | boolean;
+export type ManagedSettingValue = PolicyValue;
+export type ManagedSettingsData = Readonly<Record<string, ManagedSettingValue>>;
+export interface IManagedSettingPolicyDefinition {
+    readonly type: "string" | "number" | "boolean";
+}
+export type IManagedSettingsPolicyDefinitions = Readonly<Record<string, IManagedSettingPolicyDefinition>>;
 export declare enum PolicyCategory {
     Extensions = "Extensions",
     IntegratedTerminal = "IntegratedTerminal",
@@ -57,6 +64,12 @@ export interface IPolicy {
      * If `undefined`, the feature's setting is not locked and can be overridden by other means.
      */
     readonly value?: (policyData: IPolicyData) => string | number | boolean | undefined;
+    /**
+     * Declares Copilot managed-settings keys this policy's value callback reads.
+     * Keys are dot-separated managed-settings paths, for example
+     * `permissions.disableBypassPermissionsMode`.
+     */
+    readonly managedSettings?: IManagedSettingsPolicyDefinitions;
     /**
      * The most-restrictive value that should be applied when the user is subject to the
      * "Require Approved Account" gate but the gate is not yet satisfied (i.e. no approved
@@ -69,3 +82,31 @@ export interface IPolicy {
      */
     readonly restrictedValue?: string | number | boolean;
 }
+/**
+ * A subordinate attachment to an existing {@link IPolicy} (the "owner"). A setting may declare a
+ * `policyReference` instead of a full `policy` to be governed by a policy owned by another setting,
+ * letting a single enterprise policy lock more than one setting (e.g. gating an agent in both the
+ * editor window and the Agents window).
+ *
+ * A reference is a pure pointer: it carries no policy semantics of its own. The owner is the single
+ * source of truth for the policy's catalog metadata *and* its runtime behaviour (type, value
+ * callback, etc.); a reference only contributes the policy name so the setting is gated and the OS
+ * policy watcher observes the name in processes where the owner is not loaded.
+ */
+export interface IPolicyReference {
+    /** The name of the owning {@link IPolicy} this setting attaches to. */
+    readonly name: PolicyName;
+}
+/**
+ * A `product.json` `extensionConfigurationPolicy` entry that attaches its setting to a policy
+ * *owned* by an in-code setting, instead of declaring a full owner {@link IPolicy}. This mirrors the
+ * in-code `policyReference` configuration field, so the same indirection can be expressed from
+ * `product.json` — where the owner's runtime behaviour (notably its `value` callback) cannot live.
+ *
+ * An `extensionConfigurationPolicy` entry is therefore either a full {@link IPolicy} (the setting
+ * "parents"/owns the policy, the current syntax) or this reference wrapper.
+ */
+export interface IExtensionConfigurationPolicyReference {
+    /** Pointer to the owning {@link IPolicy} declared by an in-code setting. */
+    readonly policyReference: IPolicyReference;
+}

package/vscode/src/vs/base/common/product.d.ts

@@ -1,6 +1,6 @@
 import { IStringDictionary } from "./collections.js";
 import { PlatformName } from "./platform.js";
-import { IPolicy } from "./policy.js";
+import { IExtensionConfigurationPolicyReference, IPolicy } from "./policy.js";
 export interface IBuiltInExtension {
     readonly name: string;
     readonly version: string;
@@ -65,6 +65,24 @@ export type ExtensionVirtualWorkspaceSupport = {
     readonly default?: boolean;
     readonly override?: boolean;
 };
+/**
+ * Per-SDK configuration for downloading an agent SDK on demand. The
+ * runtime substitutes `{sdkTarget}` in `urlTemplate` against the host's
+ * `(platform, arch, libc)` triple via `resolveSdkTarget()` in the agent
+ * SDK downloader.
+ *
+ * `urlTemplate` uses `format2()`-style named placeholders. Today only
+ * `{sdkTarget}` is recognised; the build emits e.g.
+ * `https://main.vscode-cdn.net/agent-sdk/claude/0.3.168/{sdkTarget}.tgz`
+ * and the runtime substitutes `darwin-arm64`, `linux-x64-musl`, etc.
+ *
+ * See `src/vs/platform/agentHost/node/claude/roadmap.md` Phase 15 for
+ * the rationale (macOS Universal compatibility, trust model).
+ */
+export interface IAgentSdkProductConfig {
+    readonly version: string;
+    readonly urlTemplate: string;
+}
 export interface IProductConfiguration {
     readonly version: string;
     readonly date?: string;
@@ -114,6 +132,9 @@ export interface IProductConfiguration {
         readonly nlsBaseUrl: string;
         readonly accessSKUs?: string[];
     };
+    readonly agentSdks?: {
+        readonly [packageId: string]: IAgentSdkProductConfig;
+    };
     readonly mcpGallery?: {
         readonly serviceUrl: string;
         readonly itemWebUrl: string;
@@ -195,7 +216,6 @@ export interface IProductConfiguration {
     readonly extensionSyncedKeys?: {
         readonly [extensionId: string]: string[];
     };
-    readonly extensionsEnabledWithApiProposalVersion?: string[];
     readonly extensionEnabledApiProposals?: {
         readonly [extensionId: string]: string[];
     };
@@ -226,8 +246,16 @@ export interface IProductConfiguration {
     readonly chatParticipantRegistry?: string;
     readonly chatSessionRecommendations?: IChatSessionRecommendation[];
     readonly emergencyAlertUrl?: string;
+    readonly voiceWsUrl?: string;
     readonly remoteDefaultExtensionsIfInstalledLocally?: string[];
-    readonly extensionConfigurationPolicy?: IStringDictionary<IPolicy>;
+    /**
+     * Maps an extension-contributed setting key to either a full enterprise {@link IPolicy}
+     * (the setting owns/"parents" the policy — the original syntax) or an
+     * {@link IExtensionConfigurationPolicyReference} (`{ policyReference: { name } }`), attaching the
+     * setting to a policy owned by an in-code setting. References let a `product.json`-provided
+     * setting be governed by a policy whose `value` callback — which JSON cannot carry — lives in code.
+     */
+    readonly extensionConfigurationPolicy?: IStringDictionary<IPolicy | IExtensionConfigurationPolicyReference>;
     readonly onboardingKeymaps?: readonly IProductOnboardingKeymap[];
     readonly onboardingThemes?: readonly IProductOnboardingTheme[];
     /**
@@ -357,6 +385,7 @@ export interface IDefaultChatAgent {
     readonly chatExtensionOutputExtensionStateCommand: string;
     readonly documentationUrl: string;
     readonly skusDocumentationUrl: string;
+    readonly optimizeUsageDocumentationUrl: string;
     readonly publicCodeMatchesUrl: string;
     readonly managePlanUrl: string;
     readonly upgradePlanUrl: string;

package/vscode/src/vs/base/common/uriTemplate.js

@@ -260,7 +260,7 @@ function pctEncode(str) {
         (chr >= 0x30 && chr <= 0x39 || chr >= 0x41 && chr <= 0x5a || chr >= 0x61 && chr <= 0x7a) || (chr === 0x2d || chr === 0x2e || chr === 0x5f || chr === 0x7e)) {
             out += str[i];
         } else {
-            out += "%" + ( chr.toString(16)).toUpperCase();
+            out += "%" + ( chr.toString(16)).toUpperCase().padStart(2, "0");
         }
     }
     return out;

package/vscode/src/vs/base/common/uuid.d.ts

@@ -1,4 +1,4 @@
 export declare function isUUID(value: string): boolean;
 export declare const generateUuid: () => string;
-/** Namespace should be 3 letter. */
+/** Namespace should be 3 letters, e.g. `abc-<uuid>`. */
 export declare function prefixedUuid(namespace: string): string;

package/vscode/src/vs/base/common/yaml.d.ts

@@ -24,6 +24,7 @@ export declare class MarkdownNode {
     constructor(header: YamlNode | undefined, body: string);
     getStringValue(name: string): string | undefined;
     getStringArrayValue(name: string): string[] | undefined;
+    getBooleanValue(name: string): boolean | undefined;
 }
 /**
  * Parses a comma-separated list from a scalar node's value into an array of scalars.

package/vscode/src/vs/base/common/yaml.js

@@ -7,6 +7,85 @@ function parse(input, errors = [], options = {}) {
     const parser = ( new YamlParser(tokens, input, errors, options));
     return parser.parse();
 }
+function parseFrontMatter(input, errors = [], options = {}) {
+    const tokens = ( new YamlScanner(input)).scan();
+    if (tokens.length === 0 || tokens[0].type !== TokenType.DocumentStart) {
+        return ( new MarkdownNode(undefined, input));
+    }
+    const hasClosingFrontMatter = ( tokens.slice(1).some(token => token.type === TokenType.DocumentStart));
+    if (!hasClosingFrontMatter) {
+        return ( new MarkdownNode(undefined, input));
+    }
+    const header = ( new YamlParser(tokens, input, errors, options)).parse();
+    const lastToken = tokens[tokens.length - 1];
+    const body = lastToken.type === TokenType.EOF ? input.substring(lastToken.startOffset) : "";
+    return ( new MarkdownNode(header, body));
+}
+class MarkdownNode {
+    constructor(header, body) {
+        this.header = header;
+        this.body = body;
+    }
+    getStringValue(name) {
+        if (this.header && this.header.type === "map") {
+            const property = this.header.properties.find(p => p.key.value === name);
+            if (property && property.value.type === "scalar") {
+                return property.value.value;
+            }
+        }
+        return undefined;
+    }
+    getStringArrayValue(name) {
+        if (this.header && this.header.type === "map") {
+            const property = this.header.properties.find(p => p.key.value === name);
+            if (property && property.value.type === "sequence") {
+                return ( property.value.items.filter(item => item.type === "scalar").map(item => item.value));
+            } else if (property && property.value.type === "scalar") {
+                if (property.value.format === "none") {
+                    return ( parseCommaSeparatedList(property.value.value, 0).map(item => item.value));
+                } else {
+                    return [property.value.value];
+                }
+            }
+        }
+        return undefined;
+    }
+    getBooleanValue(name) {
+        const value = this.getStringValue(name);
+        if (value === "true") {
+            return true;
+        } else if (value === "false") {
+            return false;
+        }
+        return undefined;
+    }
+}
+function parseCommaSeparatedList(value, offset = 0) {
+    const parsed = parse(`[${value}]`);
+    const shift = offset - 1;
+    const items = [];
+    if (parsed && parsed.type === "sequence") {
+        for (const item of parsed.items) {
+            if (item.type === "scalar") {
+                items.push({
+                    ...item,
+                    startOffset: item.startOffset + shift,
+                    endOffset: item.endOffset + shift
+                });
+            }
+        }
+    } else {
+        items.push({
+            type: "scalar",
+            value,
+            rawValue: value,
+            startOffset: offset,
+            endOffset: value.length + offset,
+            format: "none"
+        });
+    }
+    return items;
+}
 var TokenType;
 (function(TokenType) {
     TokenType[TokenType["Scalar"] = 0] = "Scalar";
@@ -1238,4 +1317,4 @@ class YamlParser {
     }
 }
 
-export { parse };
+export { MarkdownNode, parse, parseCommaSeparatedList, parseFrontMatter };

package/vscode/src/vs/editor/browser/widget/multiDiffEditor/diffEditorItemTemplate.js

@@ -177,6 +177,7 @@ let DiffEditorItemTemplate = class DiffEditorItemTemplate extends Disposable {
                 actionRunner: this._register(( new ActionRunnerWithContext(
                     () => (this._viewModel.get()?.modifiedUri ?? this._viewModel.get()?.originalUri)
                 ))),
+                highlightToggledItems: true,
                 menuOptions: {
                     shouldForwardArgs: true
                 },

package/vscode/src/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorViewModel.d.ts

@@ -24,6 +24,8 @@ export declare class MultiDiffEditorViewModel extends Disposable {
     waitForDiffOr1s(): Promise<void>;
     collapseAll(): void;
     expandAll(): void;
+    collapse(item: DocumentDiffItemViewModel): void;
+    expand(item: DocumentDiffItemViewModel): void;
     get contextKeys(): Record<string, ContextKeyValue> | undefined;
     constructor(model: IMultiDiffEditorModel, _instantiationService: IInstantiationService);
 }

package/vscode/src/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorViewModel.js

@@ -39,6 +39,16 @@ class MultiDiffEditorViewModel extends Disposable {
             }
         });
     }
+    collapse(item) {
+        transaction(tx => {
+            item.collapsed.set(true, tx);
+        });
+    }
+    expand(item) {
+        transaction(tx => {
+            item.collapsed.set(false, tx);
+        });
+    }
     get contextKeys() {
         return this.model.contextKeys;
     }

package/vscode/src/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorWidget.d.ts

@@ -22,7 +22,9 @@ export declare class MultiDiffEditorWidget extends Disposable {
     constructor(_element: HTMLElement, _workbenchUIElementFactory: IWorkbenchUIElementFactory, _instantiationService: IInstantiationService);
     reveal(resource: IMultiDiffResourceId, options?: RevealOptions): void;
     createViewModel(model: IMultiDiffEditorModel): MultiDiffEditorViewModel;
-    setViewModel(viewModel: MultiDiffEditorViewModel | undefined): void;
+    setViewModel(viewModel: MultiDiffEditorViewModel | undefined, options?: {
+        readonly preserveFocus?: boolean;
+    }): void;
     layout(dimension: Dimension): void;
     private readonly _activeControl;
     getActiveControl(): DiffEditorWidget | undefined;

package/vscode/src/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorWidget.js

@@ -40,7 +40,8 @@ let MultiDiffEditorWidget = class MultiDiffEditorWidget extends Disposable {
     createViewModel(model) {
         return ( new MultiDiffEditorViewModel(model, this._instantiationService));
     }
-    setViewModel(viewModel) {
+    setViewModel(viewModel, options) {
+        this._widgetImpl.get().setPreserveFocusOnLoad(!!options?.preserveFocus);
         this._viewModel.set(viewModel, undefined);
     }
     layout(dimension) {

package/vscode/src/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorWidgetImpl.d.ts

@@ -35,11 +35,26 @@ export declare class MultiDiffEditorWidgetImpl extends Disposable {
     readonly activeControl: import("../../../../base/common/observable.js").IObservableWithChange<import("../diffEditor/diffEditorWidget.js").DiffEditorWidget | undefined, void>;
     private readonly _contextKeyService;
     private readonly _instantiationService;
+    /**
+     * When `true`, the automatic "select the first change" initialization that
+     * runs once the view model finishes loading does not move keyboard focus
+     * into the editor. Driven by {@link setPreserveFocusOnLoad} so a
+     * `preserveFocus` open (e.g. restored in the background or on a session
+     * switch) does not steal focus, while a normal user-initiated open does.
+     */
+    private _preserveFocusOnLoad;
     constructor(_element: HTMLElement, _dimension: IObservable<Dimension | undefined>, _viewModel: IObservable<MultiDiffEditorViewModel | undefined>, _workbenchUIElementFactory: IWorkbenchUIElementFactory, _parentContextKeyService: IContextKeyService, _parentInstantiationService: IInstantiationService);
     setScrollState(scrollState: {
         top?: number;
         left?: number;
     }): void;
+    /**
+     * Controls whether the automatic first-change selection that runs once the
+     * view model finishes loading preserves focus instead of moving it into the
+     * editor. Set to `true` for `preserveFocus` opens so focus is not stolen
+     * from elsewhere.
+     */
+    setPreserveFocusOnLoad(preserveFocus: boolean): void;
     getRootElement(): HTMLElement;
     getContextKeyService(): IContextKeyService;
     getScopedInstantiationService(): IInstantiationService;

package/vscode/src/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorWidgetImpl.js

@@ -43,6 +43,7 @@ let MultiDiffEditorWidgetImpl = class MultiDiffEditorWidgetImpl extends Disposab
         this._workbenchUIElementFactory = _workbenchUIElementFactory;
         this._parentContextKeyService = _parentContextKeyService;
         this._parentInstantiationService = _parentInstantiationService;
+        this._preserveFocusOnLoad = false;
         this._scrollableElements = h("div.scrollContent", [h("div@content", {
             style: {
                 overflow: "hidden"
@@ -210,7 +211,7 @@ let MultiDiffEditorWidgetImpl = class MultiDiffEditorWidgetImpl extends Disposab
                 if (activeDiffItem) {
                     return;
                 }
-                this.goToNextChange();
+                this._navigateToChange("next", !this._preserveFocusOnLoad);
             }
         }));
         this._register(this._register(autorun(reader => {
@@ -225,6 +226,9 @@ let MultiDiffEditorWidgetImpl = class MultiDiffEditorWidgetImpl extends Disposab
             scrollTop: scrollState.top
         });
     }
+    setPreserveFocusOnLoad(preserveFocus) {
+        this._preserveFocusOnLoad = preserveFocus;
+    }
     getRootElement() {
         return this._elements.root;
     }
@@ -309,7 +313,7 @@ let MultiDiffEditorWidgetImpl = class MultiDiffEditorWidgetImpl extends Disposab
     goToPreviousChange() {
         this._navigateToChange("previous");
     }
-    _navigateToChange(direction) {
+    _navigateToChange(direction, focusEditor = true) {
         const viewItems = this._viewItems.get();
         if (viewItems.length === 0) {
             return;
@@ -317,7 +321,7 @@ let MultiDiffEditorWidgetImpl = class MultiDiffEditorWidgetImpl extends Disposab
         const activeViewModel = this._viewModel.get()?.activeDiffItem.get();
         const currentIndex = activeViewModel ? viewItems.findIndex(v => v.viewModel === activeViewModel) : -1;
         if (currentIndex === -1) {
-            this._goToFile(0, "first");
+            this._goToFile(0, "first", focusEditor);
             return;
         }
         const currentItem = viewItems[currentIndex];
@@ -335,9 +339,9 @@ let MultiDiffEditorWidgetImpl = class MultiDiffEditorWidgetImpl extends Disposab
             }
         }
         const nextIndex = (currentIndex + (direction === "next" ? 1 : -1) + viewItems.length) % viewItems.length;
-        this._goToFile(nextIndex, direction === "next" ? "first" : "last");
+        this._goToFile(nextIndex, direction === "next" ? "first" : "last", focusEditor);
     }
-    _goToFile(index, position) {
+    _goToFile(index, position, focusEditor = true) {
         const item = this._viewItems.get()[index];
         if (item.viewModel.collapsed.get()) {
             item.viewModel.collapsed.set(false, undefined);
@@ -360,7 +364,9 @@ let MultiDiffEditorWidgetImpl = class MultiDiffEditorWidgetImpl extends Disposab
                 modifiedEditor.revealLineInCenter(lastChange.modified.startLineNumber);
             }
         }
-        editor?.focus();
+        if (focusEditor) {
+            editor?.focus();
+        }
     }
     render(reader) {
         const scrollTop = this.scrollTop.read(reader);

package/vscode/src/vs/editor/common/languages.js

@@ -92,7 +92,6 @@ var CompletionItemKinds;
     byKind.set(CompletionItemKind.Value, Codicon.symbolValue);
     byKind.set(CompletionItemKind.Enum, Codicon.symbolEnum);
     byKind.set(CompletionItemKind.Constant, Codicon.symbolConstant);
-    byKind.set(CompletionItemKind.Enum, Codicon.symbolEnum);
     byKind.set(CompletionItemKind.EnumMember, Codicon.symbolEnumMember);
     byKind.set(CompletionItemKind.Keyword, Codicon.symbolKeyword);
     byKind.set(CompletionItemKind.Snippet, Codicon.symbolSnippet);