@codingame/monaco-vscode-extensions-service-override 11.1.2 → 12.0.1

package/vscode/src/vs/workbench/services/extensionManagement/browser/extensionBisect.js

@@ -1,8 +1,11 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { localize, localize2 } from 'vscode/vscode/vs/nls';
 import { IExtensionManagementService, IGlobalExtensionEnablementService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement.service';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
-import { isResolverExtension } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { isResolverExtension, ExtensionType } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import 'vscode/vscode/vs/platform/instantiation/common/extensions';
 import { NotificationPriority } from 'vscode/vscode/vs/platform/notification/common/notification';
 import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
 import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host.service';
@@ -10,6 +13,7 @@ import { registerAction2, Action2, MenuId } from 'vscode/vscode/vs/platform/acti
 import { RawContextKey, ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
 import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
+import { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
 import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
@@ -20,7 +24,7 @@ import { areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement
 import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
 import { IWorkbenchExtensionEnablementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement.service';
 import { IExtensionBisectService } from 'vscode/vscode/vs/workbench/services/extensionManagement/browser/extensionBisect.service';
-import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import Severity from 'vscode/vscode/vs/base/common/severity';
 
 var ExtensionBisectService_1, ExtensionBisectUi_1;
 class BisectState {
@@ -30,9 +34,7 @@ class BisectState {
         }
         try {
             const data = JSON.parse(raw);
-            return (
-                 (new BisectState(data.extensions, data.low, data.high, data.mid))
-            );
+            return ( new BisectState(data.extensions, data.low, data.high, data.mid));
         }
         catch {
             return undefined;
@@ -51,8 +53,8 @@ let ExtensionBisectService = class ExtensionBisectService {
     constructor(logService, _storageService, _envService) {
         this._storageService = _storageService;
         this._envService = _envService;
-        this._disabled = ( (new Map()));
-        const raw = _storageService.get(ExtensionBisectService_1._storageKey, -1 );
+        this._disabled = ( new Map());
+        const raw = _storageService.get(ExtensionBisectService_1._storageKey, StorageScope.APPLICATION);
         this._state = BisectState.fromJSON(raw);
         if (this._state) {
             const { mid, high } = this._state;
@@ -83,20 +85,20 @@ let ExtensionBisectService = class ExtensionBisectService {
         return disabled ?? false;
     }
     _isEnabledInEnv(extension) {
-        return Array.isArray(this._envService.enableExtensions) && ( (this._envService.enableExtensions.some(id => areSameExtensions({ id }, extension.identifier))));
+        return Array.isArray(this._envService.enableExtensions) && ( this._envService.enableExtensions.some(id => areSameExtensions({ id }, extension.identifier)));
     }
     async start(extensions) {
         if (this._state) {
-            throw ( (new Error('invalid state')));
+            throw ( new Error('invalid state'));
         }
-        const extensionIds = ( (extensions.map(ext => ext.identifier.id)));
-        const newState = ( (new BisectState(extensionIds, 0, extensionIds.length, 0)));
-        this._storageService.store(ExtensionBisectService_1._storageKey, JSON.stringify(newState), -1 , 1 );
+        const extensionIds = ( extensions.map(ext => ext.identifier.id));
+        const newState = ( new BisectState(extensionIds, 0, extensionIds.length, 0));
+        this._storageService.store(ExtensionBisectService_1._storageKey, JSON.stringify(newState), StorageScope.APPLICATION, StorageTarget.MACHINE);
         await this._storageService.flush();
     }
     async next(seeingBad) {
         if (!this._state) {
-            throw ( (new Error('invalid state')));
+            throw ( new Error('invalid state'));
         }
         if (seeingBad && this._state.mid === 0 && this._state.high === this._state.extensions.length) {
             return { bad: true, id: '' };
@@ -105,28 +107,28 @@ let ExtensionBisectService = class ExtensionBisectService {
             await this.reset();
             return { id: this._state.extensions[this._state.low], bad: seeingBad };
         }
-        const nextState = ( (new BisectState(
+        const nextState = ( new BisectState(
             this._state.extensions,
             seeingBad ? this._state.low : this._state.mid,
             seeingBad ? this._state.mid : this._state.high
-        )));
-        this._storageService.store(ExtensionBisectService_1._storageKey, JSON.stringify(nextState), -1 , 1 );
+        ));
+        this._storageService.store(ExtensionBisectService_1._storageKey, JSON.stringify(nextState), StorageScope.APPLICATION, StorageTarget.MACHINE);
         await this._storageService.flush();
         return undefined;
     }
     async reset() {
-        this._storageService.remove(ExtensionBisectService_1._storageKey, -1 );
+        this._storageService.remove(ExtensionBisectService_1._storageKey, StorageScope.APPLICATION);
         await this._storageService.flush();
     }
 };
-ExtensionBisectService = ExtensionBisectService_1 = ( (__decorate([
-    ( (__param(0, ILogService))),
-    ( (__param(1, IStorageService))),
-    ( (__param(2, IWorkbenchEnvironmentService)))
-], ExtensionBisectService)));
+ExtensionBisectService = ExtensionBisectService_1 = ( __decorate([
+    ( __param(0, ILogService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, IWorkbenchEnvironmentService))
+], ExtensionBisectService));
 let ExtensionBisectUi = class ExtensionBisectUi {
     static { ExtensionBisectUi_1 = this; }
-    static { this.ctxIsBisectActive = ( (new RawContextKey('isExtensionBisectActive', false))); }
+    static { this.ctxIsBisectActive = ( new RawContextKey('isExtensionBisectActive', false)); }
     constructor(contextKeyService, _extensionBisectService, _notificationService, _commandService) {
         this._extensionBisectService = _extensionBisectService;
         this._notificationService = _notificationService;
@@ -138,11 +140,11 @@ let ExtensionBisectUi = class ExtensionBisectUi {
     }
     _showBisectPrompt() {
         const goodPrompt = {
-            label: ( localize(692, "I can't reproduce")),
+            label: ( localize(11393, "I can't reproduce")),
             run: () => this._commandService.executeCommand('extension.bisect.next', false)
         };
         const badPrompt = {
-            label: ( localize(693, "I can reproduce")),
+            label: ( localize(11394, "I can reproduce")),
             run: () => this._commandService.executeCommand('extension.bisect.next', true)
         };
         const stop = {
@@ -151,35 +153,35 @@ let ExtensionBisectUi = class ExtensionBisectUi {
         };
         const message = this._extensionBisectService.disabledCount === 1
             ? ( localize(
-            694,
+            11395,
             "Extension Bisect is active and has disabled 1 extension. Check if you can still reproduce the problem and proceed by selecting from these options."
         ))
             : ( localize(
-            695,
+            11396,
             "Extension Bisect is active and has disabled {0} extensions. Check if you can still reproduce the problem and proceed by selecting from these options.",
             this._extensionBisectService.disabledCount
         ));
-        this._notificationService.prompt(Severity$1.Info, message, [goodPrompt, badPrompt, stop], { sticky: true, priority: NotificationPriority.URGENT });
+        this._notificationService.prompt(Severity.Info, message, [goodPrompt, badPrompt, stop], { sticky: true, priority: NotificationPriority.URGENT });
     }
 };
-ExtensionBisectUi = ExtensionBisectUi_1 = ( (__decorate([
-    ( (__param(0, IContextKeyService))),
-    ( (__param(1, IExtensionBisectService))),
-    ( (__param(2, INotificationService))),
-    ( (__param(3, ICommandService)))
-], ExtensionBisectUi)));
-( (Registry.as(Extensions.Workbench))).registerWorkbenchContribution(ExtensionBisectUi, 3 );
+ExtensionBisectUi = ExtensionBisectUi_1 = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, IExtensionBisectService)),
+    ( __param(2, INotificationService)),
+    ( __param(3, ICommandService))
+], ExtensionBisectUi));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ExtensionBisectUi, LifecyclePhase.Restored);
 registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'extension.bisect.start',
-            title: ( localize2(696, 'Start Extension Bisect')),
+            title: ( localize2(11397, 'Start Extension Bisect')),
             category: Categories.Help,
             f1: true,
-            precondition: ( (ExtensionBisectUi.ctxIsBisectActive.negate())),
+            precondition: ( ExtensionBisectUi.ctxIsBisectActive.negate()),
             menu: {
                 id: MenuId.ViewContainerTitle,
-                when: ( (ContextKeyExpr.equals('viewContainer', 'workbench.view.extensions'))),
+                when: ( ContextKeyExpr.equals('viewContainer', 'workbench.view.extensions')),
                 group: '2_enablement',
                 order: 4
             }
@@ -191,15 +193,15 @@ registerAction2(class extends Action2 {
         const extensionManagement = accessor.get(IExtensionManagementService);
         const extensionEnablementService = accessor.get(IWorkbenchExtensionEnablementService);
         const extensionsBisect = accessor.get(IExtensionBisectService);
-        const extensions = (await extensionManagement.getInstalled(1 )).filter(ext => extensionEnablementService.isEnabled(ext));
+        const extensions = (await extensionManagement.getInstalled(ExtensionType.User)).filter(ext => extensionEnablementService.isEnabled(ext));
         const res = await dialogService.confirm({
-            message: ( localize(697, "Extension Bisect")),
+            message: ( localize(11398, "Extension Bisect")),
             detail: ( localize(
-                698,
+                11399,
                 "Extension Bisect will use binary search to find an extension that causes a problem. During the process the window reloads repeatedly (~{0} times). Each time you must confirm if you are still seeing problems.",
                 2 + Math.log2(extensions.length) | 0
             )),
-            primaryButton: ( localize(699, "&&Start Extension Bisect"))
+            primaryButton: ( localize(11400, "&&Start Extension Bisect"))
         });
         if (res.confirmed) {
             await extensionsBisect.start(extensions);
@@ -211,7 +213,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'extension.bisect.next',
-            title: ( localize2(700, 'Continue Extension Bisect')),
+            title: ( localize2(11401, 'Continue Extension Bisect')),
             category: Categories.Help,
             f1: true,
             precondition: ExtensionBisectUi.ctxIsBisectActive
@@ -245,24 +247,24 @@ registerAction2(class extends Action2 {
             return;
         }
         if (done.bad) {
-            await dialogService.info(( localize(701, "Extension Bisect")), ( localize(
-                702,
+            await dialogService.info(( localize(11402, "Extension Bisect")), ( localize(
+                11403,
                 "Extension Bisect is done but no extension has been identified. This might be a problem with {0}.",
                 productService.nameShort
             )));
         }
         else {
             const res = await dialogService.confirm({
-                type: Severity$1.Info,
-                message: ( localize(701, "Extension Bisect")),
-                primaryButton: ( localize(703, "&&Report Issue & Continue")),
-                cancelButton: ( localize(704, "Continue")),
+                type: Severity.Info,
+                message: ( localize(11402, "Extension Bisect")),
+                primaryButton: ( localize(11404, "&&Report Issue & Continue")),
+                cancelButton: ( localize(11405, "Continue")),
                 detail: ( localize(
-                    705,
+                    11406,
                     "Extension Bisect is done and has identified {0} as the extension causing the problem.",
                     done.id
                 )),
-                checkbox: { label: ( localize(706, "Keep this extension disabled")), checked: true }
+                checkbox: { label: ( localize(11407, "Keep this extension disabled")), checked: true }
             });
             if (res.checkboxChecked) {
                 await extensionEnablementService.disableExtension({ id: done.id }, undefined);
@@ -276,29 +278,29 @@ registerAction2(class extends Action2 {
     }
     async _checkForBad(dialogService, bisectService) {
         const { result } = await dialogService.prompt({
-            type: Severity$1.Info,
-            message: ( localize(707, "Extension Bisect")),
+            type: Severity.Info,
+            message: ( localize(11408, "Extension Bisect")),
             detail: ( localize(
-                708,
+                11409,
                 "Extension Bisect is active and has disabled {0} extensions. Check if you can still reproduce the problem and proceed by selecting from these options.",
                 bisectService.disabledCount
             )),
             buttons: [
                 {
-                    label: ( localize(709, "I ca&&n't reproduce")),
+                    label: ( localize(11410, "I ca&&n't reproduce")),
                     run: () => false
                 },
                 {
-                    label: ( localize(710, "I can &&reproduce")),
+                    label: ( localize(11411, "I can &&reproduce")),
                     run: () => true
                 },
                 {
-                    label: ( localize(711, "&&Stop Bisect")),
+                    label: ( localize(11412, "&&Stop Bisect")),
                     run: () => undefined
                 }
             ],
             cancelButton: {
-                label: ( localize(712, "&&Cancel Bisect")),
+                label: ( localize(11413, "&&Cancel Bisect")),
                 run: () => null
             }
         });
@@ -309,7 +311,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'extension.bisect.stop',
-            title: ( localize2(713, 'Stop Extension Bisect')),
+            title: ( localize2(11414, 'Stop Extension Bisect')),
             category: Categories.Help,
             f1: true,
             precondition: ExtensionBisectUi.ctxIsBisectActive

package/vscode/src/vs/workbench/services/extensions/browser/extensionService.d.ts

@@ -0,0 +1,74 @@
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { IDialogService } from "vscode/vscode/vs/platform/dialogs/common/dialogs.service";
+import { ExtensionKind } from "vscode/vscode/vs/platform/environment/common/environment";
+import { ExtensionIdentifier, IExtensionDescription } from "vscode/vscode/vs/platform/extensions/common/extensions";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { INotificationService } from "vscode/vscode/vs/platform/notification/common/notification.service";
+import { IProductService } from "vscode/vscode/vs/platform/product/common/productService.service";
+import { ResolverResult } from "vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver";
+import { IRemoteAuthorityResolverService } from "vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver.service";
+import { IRemoteExtensionsScannerService } from "vscode/vscode/vs/platform/remote/common/remoteExtensionsScanner.service";
+import { ITelemetryService } from "vscode/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IWorkspaceContextService } from "vscode/vscode/vs/platform/workspace/common/workspace.service";
+import { IWorkspaceTrustManagementService } from "vscode/vscode/vs/platform/workspace/common/workspaceTrust.service";
+import { IBrowserWorkbenchEnvironmentService } from "vscode/vscode/vs/workbench/services/environment/browser/environmentService.service";
+import { IWebExtensionsScannerService } from "vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement.service";
+import { IWorkbenchExtensionEnablementService } from "vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement.service";
+import { IWorkbenchExtensionManagementService } from "vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement.service";
+import { IWebWorkerExtensionHostDataProvider } from "./webWorkerExtensionHost.js";
+import { AbstractExtensionService, IExtensionHostFactory, ResolvedExtensions } from "../common/abstractExtensionService.js";
+import { ExtensionDescriptionRegistrySnapshot } from "vscode/vscode/vs/workbench/services/extensions/common/extensionDescriptionRegistry";
+import { ExtensionHostKind, ExtensionRunningPreference, IExtensionHostKindPicker } from "vscode/vscode/vs/workbench/services/extensions/common/extensionHostKind";
+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";
+import { ExtensionRunningLocationTracker } from "../common/extensionRunningLocationTracker.js";
+import { IExtensionHost } from "vscode/vscode/vs/workbench/services/extensions/common/extensions";
+import { IExtensionService } from "vscode/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { ExtensionsProposedApi } from "../common/extensionsProposedApi.js";
+import { ILifecycleService } from "vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { IRemoteAgentService } from "vscode/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
+import { IRemoteExplorerService } from "vscode/vscode/vs/workbench/services/remote/common/remoteExplorerService.service";
+import { IUserDataInitializationService } from "vscode/vscode/vs/workbench/services/userData/browser/userDataInit.service";
+import { IUserDataProfileService } from "vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service";
+export declare class ExtensionService extends AbstractExtensionService implements IExtensionService {
+    private readonly _browserEnvironmentService;
+    private readonly _webExtensionsScannerService;
+    private readonly _userDataInitializationService;
+    private readonly _userDataProfileService;
+    private readonly _workspaceTrustManagementService;
+    private readonly _remoteExplorerService;
+    constructor(extensionsProposedApi: ExtensionsProposedApi, extensionHostFactory: IExtensionHostFactory, extensionHostKindPicker: IExtensionHostKindPicker, instantiationService: IInstantiationService, notificationService: INotificationService, _browserEnvironmentService: IBrowserWorkbenchEnvironmentService, telemetryService: ITelemetryService, extensionEnablementService: IWorkbenchExtensionEnablementService, fileService: IFileService, productService: IProductService, extensionManagementService: IWorkbenchExtensionManagementService, contextService: IWorkspaceContextService, configurationService: IConfigurationService, extensionManifestPropertiesService: IExtensionManifestPropertiesService, _webExtensionsScannerService: IWebExtensionsScannerService, logService: ILogService, remoteAgentService: IRemoteAgentService, remoteExtensionsScannerService: IRemoteExtensionsScannerService, lifecycleService: ILifecycleService, remoteAuthorityResolverService: IRemoteAuthorityResolverService, _userDataInitializationService: IUserDataInitializationService, _userDataProfileService: IUserDataProfileService, _workspaceTrustManagementService: IWorkspaceTrustManagementService, _remoteExplorerService: IRemoteExplorerService, dialogService: IDialogService);
+    private _initFetchFileSystem;
+    private _scanWebExtensionsPromise;
+    protected _scanWebExtensions(): Promise<IExtensionDescription[]>;
+    private _resolveExtensionsDefault;
+    protected _resolveExtensions(): AsyncIterable<ResolvedExtensions>;
+    private _doResolveExtensions;
+    protected _onExtensionHostExit(code: number): Promise<void>;
+    protected _resolveAuthority(remoteAuthority: string): Promise<ResolverResult>;
+}
+export declare class BrowserExtensionHostFactory implements IExtensionHostFactory {
+    private readonly _extensionsProposedApi;
+    private readonly _scanWebExtensions;
+    private readonly _getExtensionRegistrySnapshotWhenReady;
+    protected readonly _instantiationService: IInstantiationService;
+    protected readonly _remoteAgentService: IRemoteAgentService;
+    protected readonly _remoteAuthorityResolverService: IRemoteAuthorityResolverService;
+    protected readonly _extensionEnablementService: IWorkbenchExtensionEnablementService;
+    private readonly _logService;
+    constructor(_extensionsProposedApi: ExtensionsProposedApi, _scanWebExtensions: () => Promise<IExtensionDescription[]>, _getExtensionRegistrySnapshotWhenReady: () => Promise<ExtensionDescriptionRegistrySnapshot>, _instantiationService: IInstantiationService, _remoteAgentService: IRemoteAgentService, _remoteAuthorityResolverService: IRemoteAuthorityResolverService, _extensionEnablementService: IWorkbenchExtensionEnablementService, _logService: ILogService);
+    createExtensionHost(runningLocations: ExtensionRunningLocationTracker, runningLocation: ExtensionRunningLocation, isInitialStart: boolean): IExtensionHost | null;
+    protected _createLocalExtensionHostDataProvider(runningLocations: ExtensionRunningLocationTracker, desiredRunningLocation: ExtensionRunningLocation, isInitialStart: boolean): IWebWorkerExtensionHostDataProvider;
+    private _createRemoteExtensionHostDataProvider;
+}
+export declare class BrowserExtensionHostKindPicker implements IExtensionHostKindPicker {
+    private readonly _logService;
+    constructor(_logService: ILogService);
+    pickExtensionHostKind(extensionId: ExtensionIdentifier, extensionKinds: ExtensionKind[], isInstalledLocally: boolean, isInstalledRemotely: boolean, preference: ExtensionRunningPreference): ExtensionHostKind | null;
+    static pickRunningLocation(extensionKinds: ExtensionKind[], isInstalledLocally: boolean, isInstalledRemotely: boolean, preference: ExtensionRunningPreference): ExtensionHostKind | null;
+}
+export declare class BrowserExtensionService extends ExtensionService {
+    constructor(instantiationService: IInstantiationService, notificationService: INotificationService, browserEnvironmentService: IBrowserWorkbenchEnvironmentService, telemetryService: ITelemetryService, extensionEnablementService: IWorkbenchExtensionEnablementService, fileService: IFileService, productService: IProductService, extensionManagementService: IWorkbenchExtensionManagementService, contextService: IWorkspaceContextService, configurationService: IConfigurationService, extensionManifestPropertiesService: IExtensionManifestPropertiesService, webExtensionsScannerService: IWebExtensionsScannerService, logService: ILogService, remoteAgentService: IRemoteAgentService, remoteExtensionsScannerService: IRemoteExtensionsScannerService, lifecycleService: ILifecycleService, remoteAuthorityResolverService: IRemoteAuthorityResolverService, userDataInitializationService: IUserDataInitializationService, userDataProfileService: IUserDataProfileService, workspaceTrustManagementService: IWorkspaceTrustManagementService, remoteExplorerService: IRemoteExplorerService, dialogService: IDialogService);
+}

package/vscode/src/vs/workbench/services/extensions/browser/extensionService.js

@@ -1,14 +1,17 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
+import 'vscode/vscode/vs/platform/instantiation/common/extensions';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { getLogs } from 'vscode/vscode/vs/platform/log/browser/log';
+import { getLogs } from '@codingame/monaco-vscode-256d5b78-0649-50e9-8354-2807f95f68f4-common/vscode/vs/platform/log/browser/log';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
 import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
+import { PersistentConnectionEventType } from '@codingame/monaco-vscode-2a94c04a-b85b-5669-b06b-89c1bfa11cb9-common/vscode/vs/platform/remote/common/remoteAgentConnection';
 import { RemoteAuthorityResolverError } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
 import { IRemoteAuthorityResolverService } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver.service';
 import { IRemoteExtensionsScannerService } from 'vscode/vscode/vs/platform/remote/common/remoteExtensionsScanner.service';
@@ -19,31 +22,33 @@ import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/
 import { IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService, IWebExtensionsScannerService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement.service';
 import { WebWorkerExtensionHost } from './webWorkerExtensionHost.js';
 import { FetchFileSystemProvider } from './webWorkerFileSystemProvider.js';
-import { AbstractExtensionService, ResolvedExtensions, checkEnabledAndProposedAPI } from '../common/abstractExtensionService.js';
-import { extensionRunningPreferenceToString, extensionHostKindToString } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostKind';
+import { AbstractExtensionService, RemoteExtensions, LocalExtensions, isResolverExtension, ResolverExtensions, checkEnabledAndProposedAPI } from '../common/abstractExtensionService.js';
+import { ExtensionHostKind, extensionRunningPreferenceToString, extensionHostKindToString, ExtensionRunningPreference } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostKind';
 import { IExtensionManifestPropertiesService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService.service';
 import { filterExtensionDescriptions } from '../common/extensionRunningLocationTracker.js';
-import { toExtensionDescription, ExtensionHostExtensions } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { toExtensionDescription, ExtensionHostStartup, ExtensionHostExtensions } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
 import '../common/extensionsProposedApi.js';
 import { dedupExtensions } from '../common/extensionsUtil.js';
 import { RemoteExtensionHost } from '../common/remoteExtensionHost.js';
+import { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
 import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
 import { IRemoteExplorerService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteExplorerService.service';
 import { IUserDataInitializationService } from 'vscode/vscode/vs/workbench/services/userData/browser/userDataInit.service';
 import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
+import { AsyncIterableObject } from 'vscode/vscode/vs/base/common/async';
 
 var BrowserExtensionHostKindPicker_1;
 let ExtensionService = class ExtensionService extends AbstractExtensionService {
     constructor(extensionsProposedApi, extensionHostFactory, extensionHostKindPicker, instantiationService, notificationService, _browserEnvironmentService, telemetryService, extensionEnablementService, fileService, productService, extensionManagementService, contextService, configurationService, extensionManifestPropertiesService, _webExtensionsScannerService, logService, remoteAgentService, remoteExtensionsScannerService, lifecycleService, remoteAuthorityResolverService, _userDataInitializationService, _userDataProfileService, _workspaceTrustManagementService, _remoteExplorerService, dialogService) {
-        super(extensionsProposedApi, extensionHostFactory, extensionHostKindPicker, instantiationService, notificationService, _browserEnvironmentService, telemetryService, extensionEnablementService, fileService, productService, extensionManagementService, contextService, configurationService, extensionManifestPropertiesService, logService, remoteAgentService, remoteExtensionsScannerService, lifecycleService, remoteAuthorityResolverService, dialogService);
+        super({ hasLocalProcess: false, allowRemoteExtensionsInLocalWebWorker: true }, extensionsProposedApi, extensionHostFactory, extensionHostKindPicker, instantiationService, notificationService, _browserEnvironmentService, telemetryService, extensionEnablementService, fileService, productService, extensionManagementService, contextService, configurationService, extensionManifestPropertiesService, logService, remoteAgentService, remoteExtensionsScannerService, lifecycleService, remoteAuthorityResolverService, dialogService);
         this._browserEnvironmentService = _browserEnvironmentService;
         this._webExtensionsScannerService = _webExtensionsScannerService;
         this._userDataInitializationService = _userDataInitializationService;
         this._userDataProfileService = _userDataProfileService;
         this._workspaceTrustManagementService = _workspaceTrustManagementService;
         this._remoteExplorerService = _remoteExplorerService;
-        lifecycleService.when(2 ).then(async () => {
+        lifecycleService.when(LifecyclePhase.Ready).then(async () => {
             await this._userDataInitializationService.initializeInstalledExtensions(this._instantiationService);
             this._initialize();
         });
@@ -55,37 +60,48 @@ let ExtensionService = class ExtensionService extends AbstractExtensionService {
         this._register(this._fileService.registerProvider(Schemas.https, provider));
     }
     async _scanWebExtensions() {
-        const system = [], user = [], development = [];
-        try {
-            await Promise.all([
-                this._webExtensionsScannerService.scanSystemExtensions().then(extensions => system.push(...( extensions.map(e => toExtensionDescription(e))))),
-                this._webExtensionsScannerService.scanUserExtensions(this._userDataProfileService.currentProfile.extensionsResource, { skipInvalidExtensions: true }).then(extensions => user.push(...( extensions.map(e => toExtensionDescription(e))))),
-                this._webExtensionsScannerService.scanExtensionsUnderDevelopment().then(extensions => development.push(...( extensions.map(e => toExtensionDescription(e, true)))))
-            ]);
-        }
-        catch (error) {
-            this._logService.error(error);
+        if (!this._scanWebExtensionsPromise) {
+            this._scanWebExtensionsPromise = (async () => {
+                const system = [], user = [], development = [];
+                try {
+                    await Promise.all([
+                        this._webExtensionsScannerService.scanSystemExtensions().then(extensions => system.push(...( extensions.map(e => toExtensionDescription(e))))),
+                        this._webExtensionsScannerService.scanUserExtensions(this._userDataProfileService.currentProfile.extensionsResource, { skipInvalidExtensions: true }).then(extensions => user.push(...( extensions.map(e => toExtensionDescription(e))))),
+                        this._webExtensionsScannerService.scanExtensionsUnderDevelopment().then(extensions => development.push(...( extensions.map(e => toExtensionDescription(e, true)))))
+                    ]);
+                }
+                catch (error) {
+                    this._logService.error(error);
+                }
+                return dedupExtensions(system, user, [], development, this._logService);
+            })();
         }
-        return dedupExtensions(system, user, [], development, this._logService);
+        return this._scanWebExtensionsPromise;
     }
-    async _resolveExtensionsDefault() {
+    async _resolveExtensionsDefault(emitter) {
         const [localExtensions, remoteExtensions] = await Promise.all([
             this._scanWebExtensions(),
             this._remoteExtensionsScannerService.scanExtensions()
         ]);
-        return ( new ResolvedExtensions(
-            localExtensions,
-            remoteExtensions,
-             false,
-             true
-        ));
+        if (remoteExtensions.length) {
+            emitter.emitOne(( new RemoteExtensions(remoteExtensions)));
+        }
+        emitter.emitOne(( new LocalExtensions(localExtensions)));
     }
-    async _resolveExtensions() {
+    _resolveExtensions() {
+        return ( new AsyncIterableObject(emitter => this._doResolveExtensions(emitter)));
+    }
+    async _doResolveExtensions(emitter) {
         if (!this._browserEnvironmentService.expectsResolverExtension) {
-            return this._resolveExtensionsDefault();
+            return this._resolveExtensionsDefault(emitter);
         }
         const remoteAuthority = this._environmentService.remoteAuthority;
         await this._workspaceTrustManagementService.workspaceResolved;
+        const localExtensions = await this._scanWebExtensions();
+        const resolverExtensions = localExtensions.filter(extension => isResolverExtension(extension));
+        if (resolverExtensions.length) {
+            emitter.emitOne(( new ResolverExtensions(resolverExtensions)));
+        }
         let resolverResult;
         try {
             resolverResult = await this._resolveAuthorityInitial(remoteAuthority);
@@ -95,20 +111,20 @@ let ExtensionService = class ExtensionService extends AbstractExtensionService {
                 console.log(`Error handled: Not showing a notification for the error`);
             }
             this._remoteAuthorityResolverService._setResolvedAuthorityError(remoteAuthority, err);
-            return this._resolveExtensionsDefault();
+            return this._resolveExtensionsDefault(emitter);
         }
         this._remoteAuthorityResolverService._setResolvedAuthority(resolverResult.authority, resolverResult.options);
         this._remoteExplorerService.setTunnelInformation(resolverResult.tunnelInformation);
         const connection = this._remoteAgentService.getConnection();
         if (connection) {
             connection.onDidStateChange(async (e) => {
-                if (e.type === 0 ) {
+                if (e.type === PersistentConnectionEventType.ConnectionLost) {
                     this._remoteAuthorityResolverService._clearResolvedAuthority(remoteAuthority);
                 }
             });
             connection.onReconnecting(() => this._resolveAuthorityAgain());
         }
-        return this._resolveExtensionsDefault();
+        return this._resolveExtensionsDefault(emitter);
     }
     async _onExtensionHostExit(code) {
         await this._doStopExtensionHosts();
@@ -118,7 +134,7 @@ let ExtensionService = class ExtensionService extends AbstractExtensionService {
         }
     }
     async _resolveAuthority(remoteAuthority) {
-        return this._resolveAuthorityOnExtensionHosts(2 , remoteAuthority);
+        return this._resolveAuthorityOnExtensionHosts(ExtensionHostKind.LocalWebWorker, remoteAuthority);
     }
 };
 ExtensionService = ( __decorate([
@@ -158,14 +174,16 @@ let BrowserExtensionHostFactory = class BrowserExtensionHostFactory {
     }
     createExtensionHost(runningLocations, runningLocation, isInitialStart) {
         switch (runningLocation.kind) {
-            case 1 : {
+            case ExtensionHostKind.LocalProcess: {
                 return null;
             }
-            case 2 : {
-                const startup = ((isInitialStart ? 2  : 1) );
+            case ExtensionHostKind.LocalWebWorker: {
+                const startup = (isInitialStart
+                    ? ExtensionHostStartup.EagerManualStart
+                    : ExtensionHostStartup.EagerAutoStart);
                 return this._instantiationService.createInstance(WebWorkerExtensionHost, runningLocation, startup, this._createLocalExtensionHostDataProvider(runningLocations, runningLocation, isInitialStart));
             }
-            case 3 : {
+            case ExtensionHostKind.Remote: {
                 const remoteAgentConnection = this._remoteAgentService.getConnection();
                 if (remoteAgentConnection) {
                     return this._instantiationService.createInstance(RemoteExtensionHost, runningLocation, this._createRemoteExtensionHostDataProvider(runningLocations, remoteAgentConnection.remoteAuthority));
@@ -202,7 +220,7 @@ let BrowserExtensionHostFactory = class BrowserExtensionHostFactory {
                 if (!remoteEnv) {
                     throw ( new Error('Cannot provide init data for remote extension host!'));
                 }
-                const myExtensions = runningLocations.filterByExtensionHostKind(snapshot.extensions, 3 );
+                const myExtensions = runningLocations.filterByExtensionHostKind(snapshot.extensions, ExtensionHostKind.Remote);
                 const extensions = ( new ExtensionHostExtensions(snapshot.versionId, snapshot.extensions, ( myExtensions.map(extension => extension.identifier))));
                 return {
                     connectionData: this._remoteAuthorityResolverService.getConnectionData(remoteAuthority),
@@ -238,32 +256,32 @@ let BrowserExtensionHostKindPicker = BrowserExtensionHostKindPicker_1 = class Br
         let canRunRemotely = false;
         for (const extensionKind of extensionKinds) {
             if (extensionKind === 'ui' && isInstalledRemotely) {
-                if (preference === 2 ) {
-                    return 3 ;
+                if (preference === ExtensionRunningPreference.Remote) {
+                    return ExtensionHostKind.Remote;
                 }
                 else {
                     canRunRemotely = true;
                 }
             }
             if (extensionKind === 'workspace' && isInstalledRemotely) {
-                if (preference === 0  || preference === 2 ) {
-                    return 3 ;
+                if (preference === ExtensionRunningPreference.None || preference === ExtensionRunningPreference.Remote) {
+                    return ExtensionHostKind.Remote;
                 }
                 else {
-                    result.push(3 );
+                    result.push(ExtensionHostKind.Remote);
                 }
             }
             if (extensionKind === 'web' && (isInstalledLocally || isInstalledRemotely)) {
-                if (preference === 0  || preference === 1 ) {
-                    return 2 ;
+                if (preference === ExtensionRunningPreference.None || preference === ExtensionRunningPreference.Local) {
+                    return ExtensionHostKind.LocalWebWorker;
                 }
                 else {
-                    result.push(2 );
+                    result.push(ExtensionHostKind.LocalWebWorker);
                 }
             }
         }
         if (canRunRemotely) {
-            result.push(3 );
+            result.push(ExtensionHostKind.Remote);
         }
         return (result.length > 0 ? result[0] : null);
     }