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

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

@@ -0,0 +1,57 @@
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IMessagePassingProtocol } from "vscode/vscode/vs/base/parts/ipc/common/ipc";
+import { ILabelService } from "vscode/vscode/vs/platform/label/common/label.service";
+import { ILayoutService } from "vscode/vscode/vs/platform/layout/browser/layoutService.service";
+import { ILoggerService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { IProductService } from "vscode/vscode/vs/platform/product/common/productService.service";
+import { IStorageService } from "vscode/vscode/vs/platform/storage/common/storage.service";
+import { ITelemetryService } from "vscode/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IUserDataProfilesService } from "vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service";
+import { IWorkspaceContextService } from "vscode/vscode/vs/platform/workspace/common/workspace.service";
+import { IBrowserWorkbenchEnvironmentService } from "vscode/vscode/vs/workbench/services/environment/browser/environmentService.service";
+import { LocalWebWorkerRunningLocation } from "@codingame/monaco-vscode-d7f659f5-da33-5ea8-a3b8-9b94f2cf5f33-common/vscode/vs/workbench/services/extensions/common/extensionRunningLocation";
+import { ExtensionHostExtensions, ExtensionHostStartup, IExtensionHost } from "vscode/vscode/vs/workbench/services/extensions/common/extensions";
+export interface IWebWorkerExtensionHostInitData {
+    readonly extensions: ExtensionHostExtensions;
+}
+export interface IWebWorkerExtensionHostDataProvider {
+    getInitData(): Promise<IWebWorkerExtensionHostInitData>;
+}
+export declare class WebWorkerExtensionHost extends Disposable implements IExtensionHost {
+    readonly runningLocation: LocalWebWorkerRunningLocation;
+    readonly startup: ExtensionHostStartup;
+    private readonly _initDataProvider;
+    private readonly _telemetryService;
+    private readonly _contextService;
+    private readonly _labelService;
+    private readonly _logService;
+    private readonly _loggerService;
+    private readonly _environmentService;
+    private readonly _userDataProfilesService;
+    private readonly _productService;
+    private readonly _layoutService;
+    private readonly _storageService;
+    readonly pid: null;
+    readonly remoteAuthority: null;
+    extensions: ExtensionHostExtensions | null;
+    private readonly _onDidExit;
+    readonly onExit: Event<[
+        number,
+        string | null
+    ]>;
+    private _isTerminating;
+    private _protocolPromise;
+    private _protocol;
+    private readonly _extensionHostLogsLocation;
+    constructor(runningLocation: LocalWebWorkerRunningLocation, startup: ExtensionHostStartup, _initDataProvider: IWebWorkerExtensionHostDataProvider, _telemetryService: ITelemetryService, _contextService: IWorkspaceContextService, _labelService: ILabelService, _logService: ILogService, _loggerService: ILoggerService, _environmentService: IBrowserWorkbenchEnvironmentService, _userDataProfilesService: IUserDataProfilesService, _productService: IProductService, _layoutService: ILayoutService, _storageService: IStorageService);
+    protected _getWebWorkerExtensionHostIframeSrc(): Promise<string>;
+    start(): Promise<IMessagePassingProtocol>;
+    private _startInsideIframe;
+    private _performHandshake;
+    dispose(): void;
+    getInspectPort(): undefined;
+    enableInspectPort(): Promise<boolean>;
+    private _createExtHostInitData;
+}

package/vscode/src/vs/workbench/services/extensions/browser/webWorkerExtensionHost.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 { addDisposableListener } from 'vscode/vscode/vs/base/browser/dom';
 import { parentOriginHash } from 'vscode/vscode/vs/base/browser/iframe';
 import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
@@ -17,13 +18,16 @@ import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label.serv
 import { ILayoutService } from 'vscode/vscode/vs/platform/layout/browser/layoutService.service';
 import { ILogService, ILoggerService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
 import { isLoggingOnly } from 'vscode/vscode/vs/platform/telemetry/common/telemetryUtils';
 import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
+import { WorkbenchState } from 'vscode/vscode/vs/platform/workspace/common/workspace';
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
 import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService.service';
-import { isMessageOfType, createMessageOfType, UIKind } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostProtocol';
+import { ExtensionHostExitCode, isMessageOfType, MessageType, createMessageOfType, UIKind } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostProtocol';
+import { ExtensionHostStartup } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
 import { getNLSMessages, getNLSLanguage } from 'vscode/vscode/vs/nls.messages';
 
 let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
@@ -66,10 +70,10 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
             const quality = this._productService.quality;
             if (webEndpointUrlTemplate && commit && quality) {
                 const key = 'webWorkerExtensionHostIframeStableOriginUUID';
-                let stableOriginUUID = this._storageService.get(key, 1 );
+                let stableOriginUUID = this._storageService.get(key, StorageScope.WORKSPACE);
                 if (typeof stableOriginUUID === 'undefined') {
                     stableOriginUUID = generateUuid();
-                    this._storageService.store(key, stableOriginUUID, 1 , 1 );
+                    this._storageService.store(key, stableOriginUUID, StorageScope.WORKSPACE, StorageTarget.MACHINE);
                 }
                 const hash = await parentOriginHash(mainWindow.origin, stableOriginUUID);
                 const baseUrl = (webEndpointUrlTemplate
@@ -113,7 +117,7 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
             barrierHasError = true;
             onUnexpectedError(barrierError);
             clearTimeout(startTimeout);
-            this._onDidExit.fire([81 , barrierError.message]);
+            this._onDidExit.fire([ExtensionHostExitCode.UnexpectedError, barrierError.message]);
             barrier.open();
         };
         const resolveBarrier = (messagePort) => {
@@ -137,7 +141,7 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
                 err.message = message;
                 err.name = name;
                 err.stack = stack;
-                return rejectBarrier(81 , err);
+                return rejectBarrier(ExtensionHostExitCode.UnexpectedError, err);
             }
             if (event.data.type === 'vscode.bootstrap.nls') {
                 iframe.contentWindow.postMessage({
@@ -157,7 +161,7 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
             if (barrier.isOpen() || !(data instanceof MessagePort)) {
                 console.warn('UNEXPECTED message', event);
                 const err = ( new Error('UNEXPECTED message'));
-                return rejectBarrier(81 , err);
+                return rejectBarrier(ExtensionHostExitCode.UnexpectedError, err);
             }
             resolveBarrier(data);
         }));
@@ -188,7 +192,7 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
         return this._performHandshake(protocol);
     }
     async _performHandshake(protocol) {
-        await Event.toPromise(Event.filter(protocol.onMessage, msg => isMessageOfType(msg, 1 )));
+        await Event.toPromise(Event.filter(protocol.onMessage, msg => isMessageOfType(msg, MessageType.Ready)));
         if (this._isTerminating) {
             throw canceled();
         }
@@ -196,7 +200,7 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
         if (this._isTerminating) {
             throw canceled();
         }
-        await Event.toPromise(Event.filter(protocol.onMessage, msg => isMessageOfType(msg, 0 )));
+        await Event.toPromise(Event.filter(protocol.onMessage, msg => isMessageOfType(msg, MessageType.Initialized)));
         if (this._isTerminating) {
             throw canceled();
         }
@@ -207,7 +211,7 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
             return;
         }
         this._isTerminating = true;
-        this._protocol?.send(createMessageOfType(2 ));
+        this._protocol?.send(createMessageOfType(MessageType.Terminate));
         super.dispose();
     }
     getInspectPort() {
@@ -244,7 +248,7 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
                 workspaceStorageHome: this._environmentService.workspaceStorageHome,
                 extensionLogLevel: this._environmentService.extensionLogLevel
             },
-            workspace: this._contextService.getWorkbenchState() === 1  ? undefined : {
+            workspace: this._contextService.getWorkbenchState() === WorkbenchState.EMPTY ? undefined : {
                 configuration: workspace.configuration || undefined,
                 id: workspace.id,
                 name: this._labelService.getWorkspaceLabel(workspace),
@@ -267,7 +271,7 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
             logLevel: this._logService.getLevel(),
             loggers: [...this._loggerService.getRegisteredLoggers()],
             logsLocation: this._extensionHostLogsLocation,
-            autoStart: ((this.startup === 1) ),
+            autoStart: (this.startup === ExtensionHostStartup.EagerAutoStart),
             remote: {
                 authority: this._environmentService.remoteAuthority,
                 connectionData: null,

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

@@ -0,0 +1,20 @@
+import { IStat, FileType, IFileDeleteOptions, IFileOverwriteOptions, IFileWriteOptions, IFileSystemProviderWithFileReadWriteCapability } from "vscode/vscode/vs/platform/files/common/files";
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+export declare class FetchFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability {
+    readonly capabilities: number;
+    readonly onDidChangeCapabilities: Event<any>;
+    readonly onDidChangeFile: Event<any>;
+    readFile(resource: URI): Promise<Uint8Array>;
+    stat(_resource: URI): Promise<IStat>;
+    watch(): IDisposable;
+    writeFile(_resource: URI, _content: Uint8Array, _opts: IFileWriteOptions): Promise<void>;
+    readdir(_resource: URI): Promise<[
+        string,
+        FileType
+    ][]>;
+    mkdir(_resource: URI): Promise<void>;
+    delete(_resource: URI, _opts: IFileDeleteOptions): Promise<void>;
+    rename(_from: URI, _to: URI, _opts: IFileOverwriteOptions): Promise<void>;
+}

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

@@ -1,11 +1,12 @@
-import { createFileSystemProviderError, FileSystemProviderErrorCode, FileType } from 'vscode/vscode/vs/platform/files/common/files';
+
+import { FileSystemProviderCapabilities, createFileSystemProviderError, FileSystemProviderErrorCode, FileType } from 'vscode/vscode/vs/platform/files/common/files';
 import { Event } from 'vscode/vscode/vs/base/common/event';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { NotSupportedError } from 'vscode/vscode/vs/base/common/errors';
 
 class FetchFileSystemProvider {
     constructor() {
-        this.capabilities = 2048  + 2  + 1024 ;
+        this.capabilities = FileSystemProviderCapabilities.Readonly + FileSystemProviderCapabilities.FileReadWrite + FileSystemProviderCapabilities.PathCaseSensitive;
         this.onDidChangeCapabilities = Event.None;
         this.onDidChangeFile = Event.None;
     }

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

@@ -0,0 +1,203 @@
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { IDialogService } from "vscode/vscode/vs/platform/dialogs/common/dialogs.service";
+import { ExtensionIdentifier, IExtension, IExtensionContributions, 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 { IWorkbenchEnvironmentService } from "vscode/vscode/vs/workbench/services/environment/common/environmentService.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 { ExtensionDescriptionRegistrySnapshot, IActivationEventsReader } 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";
+import { ExtensionRunningLocationTracker } from "./extensionRunningLocationTracker.js";
+import { ActivationKind, ActivationTimes, ExtensionActivationReason, ExtensionPointContribution, IExtensionHost, IExtensionsStatus, IMessage, IResponsiveStateChangeEvent, IWillActivateEvent, WillStopExtensionHostsEvent } from "vscode/vscode/vs/workbench/services/extensions/common/extensions";
+import { IExtensionService } from "vscode/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { ExtensionsProposedApi } from "./extensionsProposedApi.js";
+import { IExtensionPoint } from "vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry";
+import { ILifecycleService } from "vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { IRemoteAgentService } from "vscode/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
+export declare abstract class AbstractExtensionService extends Disposable implements IExtensionService {
+    protected readonly _extensionsProposedApi: ExtensionsProposedApi;
+    protected readonly _extensionHostFactory: IExtensionHostFactory;
+    protected readonly _extensionHostKindPicker: IExtensionHostKindPicker;
+    protected readonly _instantiationService: IInstantiationService;
+    protected readonly _notificationService: INotificationService;
+    protected readonly _environmentService: IWorkbenchEnvironmentService;
+    protected readonly _telemetryService: ITelemetryService;
+    protected readonly _extensionEnablementService: IWorkbenchExtensionEnablementService;
+    protected readonly _fileService: IFileService;
+    protected readonly _productService: IProductService;
+    protected readonly _extensionManagementService: IWorkbenchExtensionManagementService;
+    private readonly _contextService;
+    private readonly _configurationService;
+    private readonly _extensionManifestPropertiesService;
+    protected readonly _logService: ILogService;
+    protected readonly _remoteAgentService: IRemoteAgentService;
+    protected readonly _remoteExtensionsScannerService: IRemoteExtensionsScannerService;
+    private readonly _lifecycleService;
+    protected readonly _remoteAuthorityResolverService: IRemoteAuthorityResolverService;
+    private readonly _dialogService;
+    _serviceBrand: undefined;
+    private readonly _hasLocalProcess;
+    private readonly _allowRemoteExtensionsInLocalWebWorker;
+    private readonly _onDidRegisterExtensions;
+    readonly onDidRegisterExtensions: import("vscode/vscode/vs/base/common/event").Event<void>;
+    private readonly _onDidChangeExtensionsStatus;
+    readonly onDidChangeExtensionsStatus: import("vscode/vscode/vs/base/common/event").Event<ExtensionIdentifier[]>;
+    private readonly _onDidChangeExtensions;
+    readonly onDidChangeExtensions: import("vscode/vscode/vs/base/common/event").Event<{
+        readonly added: ReadonlyArray<IExtensionDescription>;
+        readonly removed: ReadonlyArray<IExtensionDescription>;
+    }>;
+    private readonly _onWillActivateByEvent;
+    readonly onWillActivateByEvent: import("vscode/vscode/vs/base/common/event").Event<IWillActivateEvent>;
+    private readonly _onDidChangeResponsiveChange;
+    readonly onDidChangeResponsiveChange: import("vscode/vscode/vs/base/common/event").Event<IResponsiveStateChangeEvent>;
+    private readonly _onWillStop;
+    readonly onWillStop: import("vscode/vscode/vs/base/common/event").Event<WillStopExtensionHostsEvent>;
+    private readonly _activationEventReader;
+    private readonly _registry;
+    private readonly _installedExtensionsReady;
+    private readonly _extensionStatus;
+    private readonly _allRequestedActivateEvents;
+    private readonly _runningLocations;
+    private readonly _remoteCrashTracker;
+    private _deltaExtensionsQueue;
+    private _inHandleDeltaExtensions;
+    private readonly _extensionHostManagers;
+    private _resolveAuthorityAttempt;
+    constructor(options: {
+        hasLocalProcess: boolean;
+        allowRemoteExtensionsInLocalWebWorker: boolean;
+    }, _extensionsProposedApi: ExtensionsProposedApi, _extensionHostFactory: IExtensionHostFactory, _extensionHostKindPicker: IExtensionHostKindPicker, _instantiationService: IInstantiationService, _notificationService: INotificationService, _environmentService: IWorkbenchEnvironmentService, _telemetryService: ITelemetryService, _extensionEnablementService: IWorkbenchExtensionEnablementService, _fileService: IFileService, _productService: IProductService, _extensionManagementService: IWorkbenchExtensionManagementService, _contextService: IWorkspaceContextService, _configurationService: IConfigurationService, _extensionManifestPropertiesService: IExtensionManifestPropertiesService, _logService: ILogService, _remoteAgentService: IRemoteAgentService, _remoteExtensionsScannerService: IRemoteExtensionsScannerService, _lifecycleService: ILifecycleService, _remoteAuthorityResolverService: IRemoteAuthorityResolverService, _dialogService: IDialogService);
+    protected _getExtensionHostManagers(kind: ExtensionHostKind): IExtensionHostManager[];
+    protected _handleDeltaExtensions(item: DeltaExtensionsQueueItem): Promise<void>;
+    private _deltaExtensions;
+    private _updateExtensionsOnExtHosts;
+    private _updateExtensionsOnExtHost;
+    canAddExtension(extension: IExtensionDescription): boolean;
+    private _canAddExtension;
+    canRemoveExtension(extension: IExtensionDescription): boolean;
+    private _activateAddedExtensionIfNeeded;
+    protected _initialize(): Promise<void>;
+    private _resolveAndProcessExtensions;
+    private _handleExtensionTests;
+    private findTestExtensionHost;
+    private _releaseBarrier;
+    protected _resolveAuthorityInitial(remoteAuthority: string): Promise<ResolverResult>;
+    protected _resolveAuthorityAgain(): Promise<void>;
+    private _resolveAuthorityWithLogging;
+    protected _resolveAuthorityOnExtensionHosts(kind: ExtensionHostKind, remoteAuthority: string): Promise<ResolverResult>;
+    stopExtensionHosts(reason: string, auto?: boolean): Promise<boolean>;
+    protected _doStopExtensionHosts(): Promise<void>;
+    private _doStopExtensionHostsWithVeto;
+    private _startExtensionHostsIfNecessary;
+    private _createExtensionHostManager;
+    protected _doCreateExtensionHostManager(extensionHost: IExtensionHost, initialActivationEvents: string[]): IExtensionHostManager;
+    private _onExtensionHostCrashOrExit;
+    protected _onExtensionHostCrashed(extensionHost: IExtensionHostManager, code: number, signal: string | null): void;
+    private _getExtensionHostExitInfoWithTimeout;
+    private _onRemoteExtensionHostCrashed;
+    protected _logExtensionHostCrash(extensionHost: IExtensionHostManager): void;
+    startExtensionHosts(updates?: {
+        toAdd: IExtension[];
+        toRemove: string[];
+    }): Promise<void>;
+    activateByEvent(activationEvent: string, activationKind?: ActivationKind): Promise<void>;
+    private _activateByEvent;
+    activateById(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void>;
+    activationEventIsDone(activationEvent: string): boolean;
+    whenInstalledExtensionsRegistered(): Promise<boolean>;
+    get extensions(): IExtensionDescription[];
+    protected _getExtensionRegistrySnapshotWhenReady(): Promise<ExtensionDescriptionRegistrySnapshot>;
+    getExtension(id: string): Promise<IExtensionDescription | undefined>;
+    readExtensionPointContributions<T extends IExtensionContributions[keyof IExtensionContributions]>(extPoint: IExtensionPoint<T>): Promise<ExtensionPointContribution<T>[]>;
+    getExtensionsStatus(): {
+        [id: string]: IExtensionsStatus;
+    };
+    getInspectPorts(extensionHostKind: ExtensionHostKind, tryEnableInspector: boolean): Promise<{
+        port: number;
+        host: string;
+    }[]>;
+    setRemoteEnvironment(env: {
+        [key: string]: string | null;
+    }): Promise<void>;
+    private _safeInvokeIsEnabled;
+    private _doHandleExtensionPoints;
+    private _getOrCreateExtensionStatus;
+    private _handleExtensionPointMessage;
+    private static _handleExtensionPoint;
+    private _acquireInternalAPI;
+    _activateById(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void>;
+    private _onWillActivateExtension;
+    private _onDidActivateExtension;
+    private _onDidActivateExtensionError;
+    private _onExtensionRuntimeError;
+    protected abstract _resolveExtensions(): AsyncIterable<ResolvedExtensions>;
+    protected abstract _onExtensionHostExit(code: number): Promise<void>;
+    protected abstract _resolveAuthority(remoteAuthority: string): Promise<ResolverResult>;
+}
+export declare class ResolverExtensions {
+    readonly extensions: IExtensionDescription[];
+    constructor(extensions: IExtensionDescription[]);
+}
+export declare class LocalExtensions {
+    readonly extensions: IExtensionDescription[];
+    constructor(extensions: IExtensionDescription[]);
+}
+export declare class RemoteExtensions {
+    readonly extensions: IExtensionDescription[];
+    constructor(extensions: IExtensionDescription[]);
+}
+export type ResolvedExtensions = ResolverExtensions | LocalExtensions | RemoteExtensions;
+export interface IExtensionHostFactory {
+    createExtensionHost(runningLocations: ExtensionRunningLocationTracker, runningLocation: ExtensionRunningLocation, isInitialStart: boolean): IExtensionHost | null;
+}
+export declare class DeltaExtensionsQueueItem {
+    readonly toAdd: IExtension[];
+    readonly toRemove: string[] | IExtension[];
+    constructor(toAdd: IExtension[], toRemove: string[] | IExtension[]);
+}
+export declare function isResolverExtension(extension: IExtensionDescription): boolean;
+export declare function checkEnabledAndProposedAPI(logService: ILogService, extensionEnablementService: IWorkbenchExtensionEnablementService, extensionsProposedApi: ExtensionsProposedApi, extensions: IExtensionDescription[], ignoreWorkspaceTrust: boolean): IExtensionDescription[];
+export declare function filterEnabledExtensions(logService: ILogService, extensionEnablementService: IWorkbenchExtensionEnablementService, extensions: IExtensionDescription[], ignoreWorkspaceTrust: boolean): IExtensionDescription[];
+export declare function extensionIsEnabled(logService: ILogService, extensionEnablementService: IWorkbenchExtensionEnablementService, extension: IExtensionDescription, ignoreWorkspaceTrust: boolean): boolean;
+export declare class ExtensionStatus {
+    readonly id: ExtensionIdentifier;
+    private readonly _messages;
+    get messages(): IMessage[];
+    private _activationTimes;
+    get activationTimes(): ActivationTimes | null;
+    private _runtimeErrors;
+    get runtimeErrors(): Error[];
+    private _activationStarted;
+    get activationStarted(): boolean;
+    constructor(id: ExtensionIdentifier);
+    clearRuntimeStatus(): void;
+    addMessage(msg: IMessage): void;
+    setActivationTimes(activationTimes: ActivationTimes): void;
+    addRuntimeError(err: Error): void;
+    onWillActivate(): void;
+}
+export declare class ExtensionHostCrashTracker {
+    private static _TIME_LIMIT;
+    private static _CRASH_LIMIT;
+    private readonly _recentCrashes;
+    private _removeOldCrashes;
+    registerCrash(): void;
+    shouldAutomaticallyRestart(): boolean;
+}
+export declare class ImplicitActivationAwareReader implements IActivationEventsReader {
+    readActivationEvents(extensionDescription: IExtensionDescription): string[];
+}