@codingame/monaco-vscode-extensions-service-override 11.1.1 → 12.0.0

package/vscode/src/vs/workbench/services/extensions/common/extHostCustomers.d.ts

@@ -0,0 +1,32 @@
+import { IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { BrandedService, IConstructorSignature } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { ExtensionHostKind } from "vscode/vscode/vs/workbench/services/extensions/common/extensionHostKind";
+import { IExtensionHostProxy } from "vscode/vscode/vs/workbench/services/extensions/common/extensionHostProxy";
+import { IInternalExtensionService } from "vscode/vscode/vs/workbench/services/extensions/common/extensions";
+import { IRPCProtocol, ProxyIdentifier } from "vscode/vscode/vs/workbench/services/extensions/common/proxyIdentifier";
+export interface IExtHostContext extends IRPCProtocol {
+    readonly remoteAuthority: string | null;
+    readonly extensionHostKind: ExtensionHostKind;
+}
+export interface IInternalExtHostContext extends IExtHostContext {
+    readonly internalExtensionService: IInternalExtensionService;
+    _setExtensionHostProxy(extensionHostProxy: IExtensionHostProxy): void;
+    _setAllMainProxyIdentifiers(mainProxyIdentifiers: ProxyIdentifier<any>[]): void;
+}
+export type IExtHostNamedCustomer<T extends IDisposable> = [
+    ProxyIdentifier<T>,
+    IExtHostCustomerCtor<T>
+];
+export type IExtHostCustomerCtor<T extends IDisposable> = IConstructorSignature<T, [
+    IExtHostContext
+]>;
+export declare function extHostNamedCustomer<T extends IDisposable>(id: ProxyIdentifier<T>): <Services extends BrandedService[]>(ctor: {
+    new (context: IExtHostContext, ...services: Services): T;
+}) => void;
+export declare function extHostCustomer<T extends IDisposable, Services extends BrandedService[]>(ctor: {
+    new (context: IExtHostContext, ...services: Services): T;
+}): void;
+export declare namespace ExtHostCustomersRegistry {
+    function getNamedCustomers(): IExtHostNamedCustomer<IDisposable>[];
+    function getCustomers(): IExtHostCustomerCtor<IDisposable>[];
+}

package/vscode/src/vs/workbench/services/extensions/common/extHostCustomers.js

@@ -1,3 +1,5 @@
+
+
 function extHostNamedCustomer(id) {
     return function (ctor) {
         ExtHostCustomersRegistryImpl.INSTANCE.registerNamedCustomer(id, ctor);
@@ -7,7 +9,7 @@ function extHostCustomer(ctor) {
     ExtHostCustomersRegistryImpl.INSTANCE.registerCustomer(ctor);
 }
 var ExtHostCustomersRegistry;
-( (function(ExtHostCustomersRegistry) {
+(function (ExtHostCustomersRegistry) {
     function getNamedCustomers() {
         return ExtHostCustomersRegistryImpl.INSTANCE.getNamedCustomers();
     }
@@ -16,7 +18,7 @@ var ExtHostCustomersRegistry;
         return ExtHostCustomersRegistryImpl.INSTANCE.getCustomers();
     }
     ExtHostCustomersRegistry.getCustomers = getCustomers;
-})(ExtHostCustomersRegistry || (ExtHostCustomersRegistry = {})));
+})(ExtHostCustomersRegistry || (ExtHostCustomersRegistry = {}));
 class ExtHostCustomersRegistryImpl {
     static { this.INSTANCE = ( new ExtHostCustomersRegistryImpl()); }
     constructor() {

package/vscode/src/vs/workbench/services/extensions/common/extensionDevOptions.d.ts

@@ -0,0 +1,8 @@
+import { IEnvironmentService } from "vscode/vscode/vs/platform/environment/common/environment.service";
+export interface IExtensionDevOptions {
+    readonly isExtensionDevHost: boolean;
+    readonly isExtensionDevDebug: boolean;
+    readonly isExtensionDevDebugBrk: boolean;
+    readonly isExtensionDevTestFromCli: boolean;
+}
+export declare function parseExtensionDevOptions(environmentService: IEnvironmentService): IExtensionDevOptions;

package/vscode/src/vs/workbench/services/extensions/common/extensionDevOptions.js

@@ -1,3 +1,4 @@
+
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
 
 function parseExtensionDevOptions(environmentService) {

package/vscode/src/vs/workbench/services/extensions/common/extensionHostManager.d.ts

@@ -0,0 +1,68 @@
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { ExtensionIdentifier, IExtensionDescription } from "vscode/vscode/vs/platform/extensions/common/extensions";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { ITelemetryService } from "vscode/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IWorkbenchEnvironmentService } from "vscode/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { ExtensionHostKind } from "vscode/vscode/vs/workbench/services/extensions/common/extensionHostKind";
+import { IExtensionHostManager } from "./extensionHostManagers.js";
+import { IExtensionDescriptionDelta } from "vscode/vscode/vs/workbench/services/extensions/common/extensionHostProtocol";
+import { IResolveAuthorityResult } from "vscode/vscode/vs/workbench/services/extensions/common/extensionHostProxy";
+import { ExtensionRunningLocation } from "@codingame/monaco-vscode-d7f659f5-da33-5ea8-a3b8-9b94f2cf5f33-common/vscode/vs/workbench/services/extensions/common/extensionRunningLocation";
+import { ActivationKind, ExtensionActivationReason, ExtensionHostStartup, IExtensionHost, IInternalExtensionService } from "vscode/vscode/vs/workbench/services/extensions/common/extensions";
+import { ResponsiveState } from "vscode/vscode/vs/workbench/services/extensions/common/rpcProtocol";
+export declare class ExtensionHostManager extends Disposable implements IExtensionHostManager {
+    private readonly _internalExtensionService;
+    private readonly _instantiationService;
+    private readonly _environmentService;
+    private readonly _telemetryService;
+    private readonly _logService;
+    readonly onDidExit: Event<[
+        number,
+        string | null
+    ]>;
+    private readonly _onDidChangeResponsiveState;
+    readonly onDidChangeResponsiveState: Event<ResponsiveState>;
+    private readonly _cachedActivationEvents;
+    private readonly _resolvedActivationEvents;
+    private _rpcProtocol;
+    private readonly _customers;
+    private readonly _extensionHost;
+    private _proxy;
+    private _hasStarted;
+    get pid(): number | null;
+    get kind(): ExtensionHostKind;
+    get startup(): ExtensionHostStartup;
+    get friendyName(): string;
+    constructor(extensionHost: IExtensionHost, initialActivationEvents: string[], _internalExtensionService: IInternalExtensionService, _instantiationService: IInstantiationService, _environmentService: IWorkbenchEnvironmentService, _telemetryService: ITelemetryService, _logService: ILogService);
+    disconnect(): Promise<void>;
+    dispose(): void;
+    private measure;
+    ready(): Promise<void>;
+    private _measureLatency;
+    private static _convert;
+    private _measureUp;
+    private _measureDown;
+    private _createExtensionHostCustomers;
+    activate(extension: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<boolean>;
+    activateByEvent(activationEvent: string, activationKind: ActivationKind): Promise<void>;
+    activationEventIsDone(activationEvent: string): boolean;
+    private _activateByEvent;
+    getInspectPort(tryEnableInspector: boolean): Promise<{
+        port: number;
+        host: string;
+    } | undefined>;
+    resolveAuthority(remoteAuthority: string, resolveAttempt: number): Promise<IResolveAuthorityResult>;
+    getCanonicalURI(remoteAuthority: string, uri: URI): Promise<URI | null>;
+    start(extensionRegistryVersionId: number, allExtensions: IExtensionDescription[], myExtensions: ExtensionIdentifier[]): Promise<void>;
+    extensionTestsExecute(): Promise<number>;
+    representsRunningLocation(runningLocation: ExtensionRunningLocation): boolean;
+    deltaExtensions(incomingExtensionsDelta: IExtensionDescriptionDelta): Promise<void>;
+    containsExtension(extensionId: ExtensionIdentifier): boolean;
+    setRemoteEnvironment(env: {
+        [key: string]: string | null;
+    }): Promise<void>;
+}
+export declare function friendlyExtHostName(kind: ExtensionHostKind, pid: number | null): string;

package/vscode/src/vs/workbench/services/extensions/common/extensionHostManager.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { IntervalTimer } from 'vscode/vscode/vs/base/common/async';
 import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
 import { onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
@@ -16,7 +17,8 @@ import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/commo
 import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
 import { ExtHostCustomersRegistry } from './extHostCustomers.js';
 import { extensionHostKindToString } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostKind';
-import { RPCProtocol } from 'vscode/vscode/vs/workbench/services/extensions/common/rpcProtocol';
+import { ActivationKind } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { RPCProtocol, RequestInitiator } from 'vscode/vscode/vs/workbench/services/extensions/common/rpcProtocol';
 
 var ExtensionHostManager_1;
 let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager extends Disposable {
@@ -39,11 +41,11 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
         this._environmentService = _environmentService;
         this._telemetryService = _telemetryService;
         this._logService = _logService;
-        this._onDidChangeResponsiveState = this._register(( (new Emitter())));
+        this._onDidChangeResponsiveState = this._register(( new Emitter()));
         this.onDidChangeResponsiveState = this._onDidChangeResponsiveState.event;
         this._hasStarted = false;
-        this._cachedActivationEvents = ( (new Map()));
-        this._resolvedActivationEvents = ( (new Set()));
+        this._cachedActivationEvents = ( new Map());
+        this._resolvedActivationEvents = ( new Set());
         this._rpcProtocol = null;
         this._customers = [];
         this._extensionHost = extensionHost;
@@ -84,7 +86,7 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
             return null;
         });
         this._proxy.then(() => {
-            initialActivationEvents.forEach((activationEvent) => this.activateByEvent(activationEvent, 0 ));
+            initialActivationEvents.forEach((activationEvent) => this.activateByEvent(activationEvent, ActivationKind.Normal));
             this._register(registerLatencyTestProvider({
                 measure: () => this.measure()
             }));
@@ -162,19 +164,19 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
     _createExtensionHostCustomers(kind, protocol) {
         let logger = null;
         if (this._environmentService.logExtensionHostCommunication) {
-            logger = ( (new RPCLogger(kind)));
+            logger = ( new RPCLogger(kind));
         }
         else if (TelemetryRPCLogger.isEnabled()) {
-            logger = ( (new TelemetryRPCLogger(this._telemetryService)));
+            logger = ( new TelemetryRPCLogger(this._telemetryService));
         }
-        this._rpcProtocol = ( (new RPCProtocol(protocol, logger)));
+        this._rpcProtocol = ( new RPCProtocol(protocol, logger));
         this._register(this._rpcProtocol.onDidChangeResponsiveState((responsiveState) => this._onDidChangeResponsiveState.fire(responsiveState)));
         let extensionHostProxy = null;
         let mainProxyIdentifiers = [];
         const extHostContext = {
             remoteAuthority: this._extensionHost.remoteAuthority,
             extensionHostKind: this.kind,
-            getProxy: (identifier) => ( (this._rpcProtocol.getProxy(identifier))),
+            getProxy: (identifier) => ( this._rpcProtocol.getProxy(identifier)),
             set: (identifier, instance) => this._rpcProtocol.set(identifier, instance),
             dispose: () => this._rpcProtocol.dispose(),
             assertRegistered: (identifiers) => this._rpcProtocol.assertRegistered(identifiers),
@@ -213,7 +215,7 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
             }
         }
         if (!extensionHostProxy) {
-            throw ( (new Error(`Missing IExtensionHostProxy!`)));
+            throw ( new Error(`Missing IExtensionHostProxy!`));
         }
         this._rpcProtocol.assertRegistered(mainProxyIdentifiers);
         return extensionHostProxy;
@@ -226,18 +228,16 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
         return proxy.activate(extension, reason);
     }
     activateByEvent(activationEvent, activationKind) {
-        if (activationKind === 1  && !this._hasStarted) {
+        if (activationKind === ActivationKind.Immediate && !this._hasStarted) {
             return Promise.resolve();
         }
-        if (!( (this._cachedActivationEvents.has(activationEvent)))) {
+        if (!( this._cachedActivationEvents.has(activationEvent))) {
             this._cachedActivationEvents.set(activationEvent, this._activateByEvent(activationEvent, activationKind));
         }
         return this._cachedActivationEvents.get(activationEvent);
     }
     activationEventIsDone(activationEvent) {
-        return (
-             (this._resolvedActivationEvents.has(activationEvent))
-        );
+        return ( this._resolvedActivationEvents.has(activationEvent));
     }
     async _activateByEvent(activationEvent, activationKind) {
         if (!this._proxy) {
@@ -285,7 +285,7 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
             };
         }
         logInfo(`invoking...`);
-        const intervalLogger = ( (new IntervalTimer()));
+        const intervalLogger = ( new IntervalTimer());
         try {
             intervalLogger.cancelAndSet(() => logInfo('waiting...'), 1000);
             const resolverResult = await proxy.resolveAuthority(remoteAuthority, resolveAttempt);
@@ -314,7 +314,7 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
     async getCanonicalURI(remoteAuthority, uri) {
         const proxy = await this._proxy;
         if (!proxy) {
-            throw ( (new Error(`Cannot resolve canonical URI`)));
+            throw ( new Error(`Cannot resolve canonical URI`));
         }
         return proxy.getCanonicalURI(remoteAuthority, uri);
     }
@@ -329,7 +329,7 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
     async extensionTestsExecute() {
         const proxy = await this._proxy;
         if (!proxy) {
-            throw ( (new Error('Could not obtain Extension Host Proxy')));
+            throw ( new Error('Could not obtain Extension Host Proxy'));
         }
         return proxy.extensionTestsExecute();
     }
@@ -358,12 +358,12 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
         return proxy.setRemoteEnvironment(env);
     }
 };
-ExtensionHostManager = ExtensionHostManager_1 = ( (__decorate([
-    ( (__param(3, IInstantiationService))),
-    ( (__param(4, IWorkbenchEnvironmentService))),
-    ( (__param(5, ITelemetryService))),
-    ( (__param(6, ILogService)))
-], ExtensionHostManager)));
+ExtensionHostManager = ExtensionHostManager_1 = ( __decorate([
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IWorkbenchEnvironmentService)),
+    ( __param(5, ITelemetryService)),
+    ( __param(6, ILogService))
+], ExtensionHostManager));
 function friendlyExtHostName(kind, pid) {
     if (pid) {
         return `${extensionHostKindToString(kind)} pid: ${pid}`;
@@ -379,7 +379,7 @@ function prettyWithoutArrays(data) {
         return data;
     }
     if (data && typeof data === 'object' && typeof data.toString === 'function') {
-        const result = ( (data.toString()));
+        const result = ( data.toString());
         if (result !== '[object Object]') {
             return result;
         }
@@ -388,9 +388,7 @@ function prettyWithoutArrays(data) {
 }
 function pretty(data) {
     if (Array.isArray(data)) {
-        return (
-             (data.map(prettyWithoutArrays))
-        );
+        return ( data.map(prettyWithoutArrays));
     }
     return prettyWithoutArrays(data);
 }
@@ -429,10 +427,10 @@ let TelemetryRPCLogger = class TelemetryRPCLogger {
     }
     constructor(_telemetryService) {
         this._telemetryService = _telemetryService;
-        this._pendingRequests = ( (new Map()));
+        this._pendingRequests = ( new Map());
     }
     logIncoming(msgLength, req, initiator, str) {
-        if (initiator === 0  && /^receiveReply(Err)?:/.test(str)) {
+        if (initiator === RequestInitiator.LocalSide && /^receiveReply(Err)?:/.test(str)) {
             const requestStr = this._pendingRequests.get(req) ?? 'unknown_reply';
             this._pendingRequests.delete(req);
             this._telemetryService.publicLog2('extensionhost.incoming', {
@@ -440,7 +438,7 @@ let TelemetryRPCLogger = class TelemetryRPCLogger {
                 length: msgLength
             });
         }
-        if (initiator === 1  && /^receiveRequest /.test(str)) {
+        if (initiator === RequestInitiator.OtherSide && /^receiveRequest /.test(str)) {
             this._telemetryService.publicLog2('extensionhost.incoming', {
                 type: `${str}`,
                 length: msgLength
@@ -448,7 +446,7 @@ let TelemetryRPCLogger = class TelemetryRPCLogger {
         }
     }
     logOutgoing(msgLength, req, initiator, str) {
-        if (initiator === 0  && str.startsWith('request: ')) {
+        if (initiator === RequestInitiator.LocalSide && str.startsWith('request: ')) {
             this._pendingRequests.set(req, str);
             this._telemetryService.publicLog2('extensionhost.outgoing', {
                 type: str,
@@ -457,9 +455,9 @@ let TelemetryRPCLogger = class TelemetryRPCLogger {
         }
     }
 };
-TelemetryRPCLogger = ( (__decorate([
-    ( (__param(0, ITelemetryService)))
-], TelemetryRPCLogger)));
+TelemetryRPCLogger = ( __decorate([
+    ( __param(0, ITelemetryService))
+], TelemetryRPCLogger));
 const providers = [];
 function registerLatencyTestProvider(provider) {
     providers.push(provider);
@@ -481,15 +479,15 @@ registerAction2(class MeasureExtHostLatencyAction extends Action2 {
     constructor() {
         super({
             id: 'editor.action.measureExtHostLatency',
-            title: ( localize2(4901, "Measure Extension Host Latency")),
+            title: ( localize2(11485, "Measure Extension Host Latency")),
             category: Categories.Developer,
             f1: true
         });
     }
     async run(accessor) {
         const editorService = accessor.get(IEditorService);
-        const measurements = await Promise.all(( (getLatencyTestProviders().map(provider => provider.measure()))));
-        editorService.openEditor({ resource: undefined, contents: ( (measurements.map(MeasureExtHostLatencyAction._print))).join('\n\n'), options: { pinned: true } });
+        const measurements = await Promise.all(( getLatencyTestProviders().map(provider => provider.measure())));
+        editorService.openEditor({ resource: undefined, contents: ( measurements.map(MeasureExtHostLatencyAction._print)).join('\n\n'), options: { pinned: true } });
     }
     static _print(m) {
         if (!m) {

package/vscode/src/vs/workbench/services/extensions/common/extensionHostManagers.d.ts

@@ -0,0 +1,40 @@
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { ExtensionIdentifier, IExtensionDescription } from "vscode/vscode/vs/platform/extensions/common/extensions";
+import { ExtensionHostKind } from "vscode/vscode/vs/workbench/services/extensions/common/extensionHostKind";
+import { IExtensionDescriptionDelta } from "vscode/vscode/vs/workbench/services/extensions/common/extensionHostProtocol";
+import { IResolveAuthorityResult } from "vscode/vscode/vs/workbench/services/extensions/common/extensionHostProxy";
+import { ExtensionRunningLocation } from "@codingame/monaco-vscode-d7f659f5-da33-5ea8-a3b8-9b94f2cf5f33-common/vscode/vs/workbench/services/extensions/common/extensionRunningLocation";
+import { ActivationKind, ExtensionActivationReason, ExtensionHostStartup } from "vscode/vscode/vs/workbench/services/extensions/common/extensions";
+import { ResponsiveState } from "vscode/vscode/vs/workbench/services/extensions/common/rpcProtocol";
+export interface IExtensionHostManager {
+    readonly pid: number | null;
+    readonly kind: ExtensionHostKind;
+    readonly startup: ExtensionHostStartup;
+    readonly friendyName: string;
+    readonly onDidExit: Event<[
+        number,
+        string | null
+    ]>;
+    readonly onDidChangeResponsiveState: Event<ResponsiveState>;
+    disconnect(): Promise<void>;
+    dispose(): void;
+    ready(): Promise<void>;
+    representsRunningLocation(runningLocation: ExtensionRunningLocation): boolean;
+    deltaExtensions(extensionsDelta: IExtensionDescriptionDelta): Promise<void>;
+    containsExtension(extensionId: ExtensionIdentifier): boolean;
+    activate(extension: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<boolean>;
+    activateByEvent(activationEvent: string, activationKind: ActivationKind): Promise<void>;
+    activationEventIsDone(activationEvent: string): boolean;
+    getInspectPort(tryEnableInspector: boolean): Promise<{
+        port: number;
+        host: string;
+    } | undefined>;
+    resolveAuthority(remoteAuthority: string, resolveAttempt: number): Promise<IResolveAuthorityResult>;
+    getCanonicalURI(remoteAuthority: string, uri: URI): Promise<URI | null>;
+    start(extensionRegistryVersionId: number, allExtensions: readonly IExtensionDescription[], myExtensions: ExtensionIdentifier[]): Promise<void>;
+    extensionTestsExecute(): Promise<number>;
+    setRemoteEnvironment(env: {
+        [key: string]: string | null;
+    }): Promise<void>;
+}

package/vscode/src/vs/workbench/services/extensions/common/extensionRunningLocationTracker.d.ts

@@ -0,0 +1,38 @@
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { ExtensionKind } from "vscode/vscode/vs/platform/environment/common/environment";
+import { ExtensionIdentifier, ExtensionIdentifierMap, IExtensionDescription } from "vscode/vscode/vs/platform/extensions/common/extensions";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { IWorkbenchEnvironmentService } from "vscode/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IReadOnlyExtensionDescriptionRegistry } from "vscode/vscode/vs/workbench/services/extensions/common/extensionDescriptionRegistry";
+import { ExtensionHostKind, IExtensionHostKindPicker } from "vscode/vscode/vs/workbench/services/extensions/common/extensionHostKind";
+import { IExtensionHostManager } from "./extensionHostManagers.js";
+import { IExtensionManifestPropertiesService } from "vscode/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService.service";
+import { ExtensionRunningLocation } from "@codingame/monaco-vscode-d7f659f5-da33-5ea8-a3b8-9b94f2cf5f33-common/vscode/vs/workbench/services/extensions/common/extensionRunningLocation";
+export declare class ExtensionRunningLocationTracker {
+    private readonly _registry;
+    private readonly _extensionHostKindPicker;
+    private readonly _environmentService;
+    private readonly _configurationService;
+    private readonly _logService;
+    private readonly _extensionManifestPropertiesService;
+    private _runningLocation;
+    private _maxLocalProcessAffinity;
+    private _maxLocalWebWorkerAffinity;
+    get maxLocalProcessAffinity(): number;
+    get maxLocalWebWorkerAffinity(): number;
+    constructor(_registry: IReadOnlyExtensionDescriptionRegistry, _extensionHostKindPicker: IExtensionHostKindPicker, _environmentService: IWorkbenchEnvironmentService, _configurationService: IConfigurationService, _logService: ILogService, _extensionManifestPropertiesService: IExtensionManifestPropertiesService);
+    set(extensionId: ExtensionIdentifier, runningLocation: ExtensionRunningLocation): void;
+    readExtensionKinds(extensionDescription: IExtensionDescription): ExtensionKind[];
+    getRunningLocation(extensionId: ExtensionIdentifier): ExtensionRunningLocation | null;
+    filterByRunningLocation(extensions: readonly IExtensionDescription[], desiredRunningLocation: ExtensionRunningLocation): IExtensionDescription[];
+    filterByExtensionHostKind(extensions: readonly IExtensionDescription[], desiredExtensionHostKind: ExtensionHostKind): IExtensionDescription[];
+    filterByExtensionHostManager(extensions: readonly IExtensionDescription[], extensionHostManager: IExtensionHostManager): IExtensionDescription[];
+    private _computeAffinity;
+    computeRunningLocation(localExtensions: IExtensionDescription[], remoteExtensions: IExtensionDescription[], isInitialAllocation: boolean): ExtensionIdentifierMap<ExtensionRunningLocation | null>;
+    private _doComputeRunningLocation;
+    initializeRunningLocation(localExtensions: IExtensionDescription[], remoteExtensions: IExtensionDescription[]): void;
+    deltaExtensions(toAdd: IExtensionDescription[], toRemove: ExtensionIdentifier[]): ExtensionIdentifierMap<ExtensionRunningLocation | null>;
+    private _updateRunningLocationForAddedExtensions;
+}
+export declare function filterExtensionDescriptions(extensions: readonly IExtensionDescription[], runningLocation: ExtensionIdentifierMap<ExtensionRunningLocation | null>, predicate: (extRunningLocation: ExtensionRunningLocation) => boolean): IExtensionDescription[];
+export declare function filterExtensionIdentifiers(extensions: readonly ExtensionIdentifier[], runningLocation: ExtensionIdentifierMap<ExtensionRunningLocation | null>, predicate: (extRunningLocation: ExtensionRunningLocation) => boolean): ExtensionIdentifier[];

package/vscode/src/vs/workbench/services/extensions/common/extensionRunningLocationTracker.js

@@ -1,12 +1,13 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { ExtensionIdentifierMap } from 'vscode/vscode/vs/platform/extensions/common/extensions';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
-import { determineExtensionHostKinds } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostKind';
+import { determineExtensionHostKinds, ExtensionHostKind, ExtensionRunningPreference } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostKind';
 import { IExtensionManifestPropertiesService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService.service';
-import { RemoteRunningLocation, LocalProcessRunningLocation, LocalWebWorkerRunningLocation } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionRunningLocation';
+import { RemoteRunningLocation, LocalProcessRunningLocation, LocalWebWorkerRunningLocation } from '@codingame/monaco-vscode-d7f659f5-da33-5ea8-a3b8-9b94f2cf5f33-common/vscode/vs/workbench/services/extensions/common/extensionRunningLocation';
 
 let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
     get maxLocalProcessAffinity() {
@@ -171,29 +172,29 @@ let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
         const localWebWorkerExtensions = [];
         for (const [extensionIdKey, extensionHostKind] of extensionHostKinds) {
             let runningLocation = null;
-            if (extensionHostKind === 1 ) {
+            if (extensionHostKind === ExtensionHostKind.LocalProcess) {
                 const extensionDescription = extensions.get(extensionIdKey);
                 if (extensionDescription) {
                     localProcessExtensions.push(extensionDescription);
                 }
             }
-            else if (extensionHostKind === 2 ) {
+            else if (extensionHostKind === ExtensionHostKind.LocalWebWorker) {
                 const extensionDescription = extensions.get(extensionIdKey);
                 if (extensionDescription) {
                     localWebWorkerExtensions.push(extensionDescription);
                 }
             }
-            else if (extensionHostKind === 3 ) {
+            else if (extensionHostKind === ExtensionHostKind.Remote) {
                 runningLocation = ( new RemoteRunningLocation());
             }
             result.set(extensionIdKey, runningLocation);
         }
-        const { affinities, maxAffinity } = this._computeAffinity(localProcessExtensions, 1 , isInitialAllocation);
+        const { affinities, maxAffinity } = this._computeAffinity(localProcessExtensions, ExtensionHostKind.LocalProcess, isInitialAllocation);
         for (const extension of localProcessExtensions) {
             const affinity = affinities.get(extension.identifier) || 0;
             result.set(extension.identifier, ( new LocalProcessRunningLocation(affinity)));
         }
-        const { affinities: localWebWorkerAffinities, maxAffinity: maxLocalWebWorkerAffinity } = this._computeAffinity(localWebWorkerExtensions, 2 , isInitialAllocation);
+        const { affinities: localWebWorkerAffinities, maxAffinity: maxLocalWebWorkerAffinity } = this._computeAffinity(localWebWorkerExtensions, ExtensionHostKind.LocalWebWorker, isInitialAllocation);
         for (const extension of localWebWorkerExtensions) {
             const affinity = localWebWorkerAffinities.get(extension.identifier) || 0;
             result.set(extension.identifier, ( new LocalWebWorkerRunningLocation(affinity)));
@@ -227,25 +228,25 @@ let ExtensionRunningLocationTracker = class ExtensionRunningLocationTracker {
         for (const extension of toAdd) {
             const extensionKind = this.readExtensionKinds(extension);
             const isRemote = extension.extensionLocation.scheme === Schemas.vscodeRemote;
-            const extensionHostKind = this._extensionHostKindPicker.pickExtensionHostKind(extension.identifier, extensionKind, !isRemote, isRemote, 0 );
+            const extensionHostKind = this._extensionHostKindPicker.pickExtensionHostKind(extension.identifier, extensionKind, !isRemote, isRemote, ExtensionRunningPreference.None);
             let runningLocation = null;
-            if (extensionHostKind === 1 ) {
+            if (extensionHostKind === ExtensionHostKind.LocalProcess) {
                 localProcessExtensions.push(extension);
             }
-            else if (extensionHostKind === 2 ) {
+            else if (extensionHostKind === ExtensionHostKind.LocalWebWorker) {
                 localWebWorkerExtensions.push(extension);
             }
-            else if (extensionHostKind === 3 ) {
+            else if (extensionHostKind === ExtensionHostKind.Remote) {
                 runningLocation = ( new RemoteRunningLocation());
             }
             this._runningLocation.set(extension.identifier, runningLocation);
         }
-        const { affinities } = this._computeAffinity(localProcessExtensions, 1 , false);
+        const { affinities } = this._computeAffinity(localProcessExtensions, ExtensionHostKind.LocalProcess, false);
         for (const extension of localProcessExtensions) {
             const affinity = affinities.get(extension.identifier) || 0;
             this._runningLocation.set(extension.identifier, ( new LocalProcessRunningLocation(affinity)));
         }
-        const { affinities: webWorkerExtensionsAffinities } = this._computeAffinity(localWebWorkerExtensions, 2 , false);
+        const { affinities: webWorkerExtensionsAffinities } = this._computeAffinity(localWebWorkerExtensions, ExtensionHostKind.LocalWebWorker, false);
         for (const extension of localWebWorkerExtensions) {
             const affinity = webWorkerExtensionsAffinities.get(extension.identifier) || 0;
             this._runningLocation.set(extension.identifier, ( new LocalWebWorkerRunningLocation(affinity)));

package/vscode/src/vs/workbench/services/extensions/common/extensionStorageMigration.d.ts

@@ -0,0 +1,2 @@
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+export declare function migrateExtensionStorage(fromExtensionId: string, toExtensionId: string, global: boolean, instantionService: IInstantiationService): Promise<void>;

package/vscode/src/vs/workbench/services/extensions/common/extensionStorageMigration.js

@@ -1,9 +1,11 @@
+
 import { getErrorMessage } from 'vscode/vscode/vs/base/common/errors';
 import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment.service';
 import { IExtensionStorageService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionStorage.service';
 import { FileSystemProviderErrorCode } from 'vscode/vscode/vs/platform/files/common/files';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
@@ -30,7 +32,7 @@ async function migrateExtensionStorage(fromExtensionId, toExtensionId, global, i
             }
             return uriIdentityService.extUri.joinPath(environmentService.workspaceStorageHome, workspaceContextService.getWorkspace().id, extensionId);
         };
-        const storageScope = global ? 0  : 1 ;
+        const storageScope = global ? StorageScope.PROFILE : StorageScope.WORKSPACE;
         if (!storageService.getBoolean(storageMigratedKey, storageScope, false) && !(migrateLowerCaseStorageKey && storageService.getBoolean(migrateLowerCaseStorageKey, storageScope, false))) {
             logService.info(`Migrating ${global ? 'global' : 'workspace'} extension storage from ${fromExtensionId} to ${toExtensionId}...`);
             const value = extensionStorageService.getExtensionState(fromExtensionId, global);
@@ -51,7 +53,7 @@ async function migrateExtensionStorage(fromExtensionId, toExtensionId, global, i
                 }
             }
             logService.info(`Migrated ${global ? 'global' : 'workspace'} extension storage from ${fromExtensionId} to ${toExtensionId}`);
-            storageService.store(storageMigratedKey, true, storageScope, 1 );
+            storageService.store(storageMigratedKey, true, storageScope, StorageTarget.MACHINE);
         }
     });
 }

package/vscode/src/vs/workbench/services/extensions/common/extensionsProposedApi.d.ts

@@ -0,0 +1,14 @@
+import { IExtensionDescription } from "vscode/vscode/vs/platform/extensions/common/extensions";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { IProductService } from "vscode/vscode/vs/platform/product/common/productService.service";
+import { IWorkbenchEnvironmentService } from "vscode/vscode/vs/workbench/services/environment/common/environmentService.service";
+export declare class ExtensionsProposedApi {
+    private readonly _logService;
+    private readonly _environmentService;
+    private readonly _envEnablesProposedApiForAll;
+    private readonly _envEnabledExtensions;
+    private readonly _productEnabledExtensions;
+    constructor(_logService: ILogService, _environmentService: IWorkbenchEnvironmentService, productService: IProductService);
+    updateEnabledApiProposals(extensions: IExtensionDescription[]): void;
+    private doUpdateEnabledApiProposals;
+}