@codingame/monaco-vscode-extensions-service-override 25.1.2 → 26.0.1

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

@@ -41,7 +41,7 @@ import { ExtensionHostManager } from './extensionHostManager.js';
 import { IExtensionManifestPropertiesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService.service';
 import { RemoteRunningLocation, LocalProcessRunningLocation, LocalWebWorkerRunningLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensionRunningLocation';
 import { ExtensionRunningLocationTracker, filterExtensionIdentifiers } from './extensionRunningLocationTracker.js';
-import { toExtensionDescription, ExtensionHostStartup, ActivationKind, ExtensionPointContribution, ActivationTimes, toExtension } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions';
+import { toExtensionDescription, ActivationKind, ExtensionHostStartup, ExtensionPointContribution, ActivationTimes, toExtension } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions';
 import { ExtensionsRegistry, ExtensionMessageCollector } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
 import { LazyCreateExtensionHostManager } from './lazyCreateExtensionHostManager.js';
 import { ResponsiveState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/rpcProtocol';
@@ -55,7 +55,29 @@ var AbstractExtensionService_1;
 const hasOwnProperty = Object.hasOwnProperty;
 const NO_OP_VOID_PROMISE = Promise.resolve(undefined);
 let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtensionService extends Disposable {
-    constructor(options, _extensionsProposedApi, _extensionHostFactory, _extensionHostKindPicker, _instantiationService, _notificationService, _environmentService, _telemetryService, _extensionEnablementService, _fileService, _productService, _extensionManagementService, _contextService, _configurationService, _extensionManifestPropertiesService, _logService, _remoteAgentService, _remoteExtensionsScannerService, _lifecycleService, _remoteAuthorityResolverService, _dialogService) {
+    constructor(
+        options,
+        _extensionsProposedApi,
+        _extensionHostFactory,
+        _extensionHostKindPicker,
+        _instantiationService,
+        _notificationService,
+        _environmentService,
+        _telemetryService,
+        _extensionEnablementService,
+        _fileService,
+        _productService,
+        _extensionManagementService,
+        _contextService,
+        _configurationService,
+        _extensionManifestPropertiesService,
+        _logService,
+        _remoteAgentService,
+        _remoteExtensionsScannerService,
+        _lifecycleService,
+        _remoteAuthorityResolverService,
+        _dialogService
+    ) {
         super();
         this._extensionsProposedApi = _extensionsProposedApi;
         this._extensionHostFactory = _extensionHostFactory;
@@ -81,7 +103,9 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         this.onDidRegisterExtensions = this._onDidRegisterExtensions.event;
         this._onDidChangeExtensionsStatus = this._register(( new Emitter()));
         this.onDidChangeExtensionsStatus = this._onDidChangeExtensionsStatus.event;
-        this._onDidChangeExtensions = this._register(( new Emitter({ leakWarningThreshold: 400 })));
+        this._onDidChangeExtensions = this._register(( new Emitter({
+            leakWarningThreshold: 400
+        })));
         this.onDidChangeExtensions = this._onDidChangeExtensions.event;
         this._onWillActivateByEvent = this._register(( new Emitter()));
         this.onWillActivateByEvent = this._onWillActivateByEvent.event;
@@ -94,6 +118,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         this._installedExtensionsReady = ( new Barrier());
         this._extensionStatus = ( new ExtensionIdentifierMap());
         this._allRequestedActivateEvents = ( new Set());
+        this._pendingRemoteActivationEvents = ( new Set());
         this._remoteCrashTracker = ( new ExtensionHostCrashTracker());
         this._deltaExtensionsQueue = [];
         this._inHandleDeltaExtensions = false;
@@ -115,23 +140,27 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             this._logService,
             this._extensionManifestPropertiesService
         ));
-        this._register(this._extensionEnablementService.onEnablementChanged((extensions) => {
+        this._register(this._extensionEnablementService.onEnablementChanged(extensions => {
             const toAdd = [];
             const toRemove = [];
             for (const extension of extensions) {
                 if (this._safeInvokeIsEnabled(extension)) {
                     toAdd.push(extension);
-                }
-                else {
+                } else {
                     toRemove.push(extension);
                 }
             }
             if (isCI) {
-                this._logService.info(`AbstractExtensionService.onEnablementChanged fired for ${( extensions.map(e => e.identifier.id)).join(', ')}`);
+                this._logService.info(`AbstractExtensionService.onEnablementChanged fired for ${( extensions.map(e => e.identifier.id)).join(", ")}`);
             }
             this._handleDeltaExtensions(( new DeltaExtensionsQueueItem(toAdd, toRemove)));
         }));
-        this._register(this._extensionManagementService.onDidChangeProfile(({ added, removed }) => {
+        this._register(this._extensionManagementService.onDidChangeProfile((
+            {
+                added,
+                removed
+            }
+        ) => {
             if (added.length || removed.length) {
                 if (isCI) {
                     this._logService.info(`AbstractExtensionService.onDidChangeProfile fired`);
@@ -147,10 +176,13 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                 this._handleDeltaExtensions(( new DeltaExtensionsQueueItem(extensions, [])));
             }
         }));
-        this._register(this._extensionManagementService.onDidInstallExtensions((result) => {
+        this._register(this._extensionManagementService.onDidInstallExtensions(result => {
             const extensions = [];
             const toRemove = [];
-            for (const { local, operation } of result) {
+            for (const {
+                local,
+                operation
+            } of result) {
                 if (local && local.isValid && operation !== InstallOperation.Migrate && this._safeInvokeIsEnabled(local)) {
                     extensions.push(local);
                     if (operation === InstallOperation.Update) {
@@ -160,15 +192,19 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             }
             if (extensions.length) {
                 if (isCI) {
-                    this._logService.info(`AbstractExtensionService.onDidInstallExtensions fired for ${( extensions.map(e => e.identifier.id)).join(', ')}`);
+                    this._logService.info(
+                        `AbstractExtensionService.onDidInstallExtensions fired for ${( extensions.map(e => e.identifier.id)).join(", ")}`
+                    );
                 }
                 this._handleDeltaExtensions(( new DeltaExtensionsQueueItem(extensions, toRemove)));
             }
         }));
-        this._register(this._extensionManagementService.onDidUninstallExtension((event) => {
+        this._register(this._extensionManagementService.onDidUninstallExtension(event => {
             if (!event.error) {
                 if (isCI) {
-                    this._logService.info(`AbstractExtensionService.onDidUninstallExtension fired for ${event.identifier.id}`);
+                    this._logService.info(
+                        `AbstractExtensionService.onDidUninstallExtension fired for ${event.identifier.id}`
+                    );
                 }
                 this._handleDeltaExtensions(( new DeltaExtensionsQueueItem([], [event.identifier.id])));
             }
@@ -180,20 +216,18 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                         await this._remoteAgentService.endConnection();
                         await this._doStopExtensionHosts();
                         this._remoteAgentService.getConnection()?.dispose();
-                    }
-                    catch {
-                        this._logService.warn('Error while disconnecting remote agent');
+                    } catch {
+                        this._logService.warn("Error while disconnecting remote agent");
                     }
                 }, {
-                    id: 'join.disconnectRemote',
-                    label: ( localize(13996, "Disconnect Remote Agent")),
+                    id: "join.disconnectRemote",
+                    label: ( localize(14383, "Disconnect Remote Agent")),
                     order: WillShutdownJoinerOrder.Last
                 });
-            }
-            else {
+            } else {
                 event.join(this._doStopExtensionHosts(), {
-                    id: 'join.stopExtensionHosts',
-                    label: ( localize(13997, "Stopping Extension Hosts")),
+                    id: "join.stopExtensionHosts",
+                    label: ( localize(14384, "Stopping Extension Hosts"))
                 });
             }
         }));
@@ -210,26 +244,25 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         try {
             this._inHandleDeltaExtensions = true;
             await this._installedExtensionsReady.wait();
-            lock = await this._registry.acquireLock('handleDeltaExtensions');
+            lock = await this._registry.acquireLock("handleDeltaExtensions");
             while (this._deltaExtensionsQueue.length > 0) {
                 const item = this._deltaExtensionsQueue.shift();
                 await this._deltaExtensions(lock, item.toAdd, item.toRemove);
             }
-        }
-        finally {
+        } finally {
             this._inHandleDeltaExtensions = false;
             lock?.dispose();
         }
     }
     async _deltaExtensions(lock, _toAdd, _toRemove) {
         if (isCI) {
-            this._logService.info(`AbstractExtensionService._deltaExtensions: toAdd: [${( _toAdd.map(e => e.identifier.id)).join(',')}] toRemove: [${( _toRemove.map(e => typeof e === 'string' ? e : e.identifier.id)).join(',')}]`);
+            this._logService.info(`AbstractExtensionService._deltaExtensions: toAdd: [${( _toAdd.map(e => e.identifier.id)).join(",")}] toRemove: [${( _toRemove.map(e => typeof e === "string" ? e : e.identifier.id)).join(",")}]`);
         }
         let toRemove = [];
         for (let i = 0, len = _toRemove.length; i < len; i++) {
             const extensionOrId = _toRemove[i];
-            const extensionId = (typeof extensionOrId === 'string' ? extensionOrId : extensionOrId.identifier.id);
-            const extension = (typeof extensionOrId === 'string' ? null : extensionOrId);
+            const extensionId = (typeof extensionOrId === "string" ? extensionOrId : extensionOrId.identifier.id);
+            const extension = (typeof extensionOrId === "string" ? null : extensionOrId);
             const extensionDescription = this._registry.getExtensionDescription(extensionId);
             if (!extensionDescription) {
                 continue;
@@ -258,15 +291,18 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             return;
         }
         const result = this._registry.deltaExtensions(lock, toAdd, ( toRemove.map(e => e.identifier)));
-        this._onDidChangeExtensions.fire({ added: toAdd, removed: toRemove });
+        this._onDidChangeExtensions.fire({
+            added: toAdd,
+            removed: toRemove
+        });
         toRemove = toRemove.concat(result.removedDueToLooping);
         if (result.removedDueToLooping.length > 0) {
             this._notificationService.notify({
                 severity: Severity.Error,
                 message: ( localize(
-                    13998,
+                    14385,
                     "The following extensions contain dependency loops and have been disabled: {0}",
-                    ( result.removedDueToLooping.map(e => `'${e.identifier.value}'`)).join(', ')
+                    ( result.removedDueToLooping.map(e => `'${e.identifier.value}'`)).join(", ")
                 ))
             });
         }
@@ -286,14 +322,27 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
     }
     async _updateExtensionsOnExtHost(extensionHostManager, versionId, toAdd, toRemove, removedRunningLocation) {
         const myToAdd = this._runningLocations.filterByExtensionHostManager(toAdd, extensionHostManager);
-        const myToRemove = filterExtensionIdentifiers(toRemove, removedRunningLocation, extRunningLocation => extensionHostManager.representsRunningLocation(extRunningLocation));
+        const myToRemove = filterExtensionIdentifiers(
+            toRemove,
+            removedRunningLocation,
+            extRunningLocation => extensionHostManager.representsRunningLocation(extRunningLocation)
+        );
         const addActivationEvents = ImplicitActivationEvents.createActivationEventsMap(toAdd);
         if (isCI) {
-            const printExtIds = (extensions) => ( extensions.map(e => e.identifier.value)).join(',');
-            const printIds = (extensions) => ( extensions.map(e => e.value)).join(',');
-            this._logService.info(`AbstractExtensionService: Calling deltaExtensions: toRemove: [${printIds(toRemove)}], toAdd: [${printExtIds(toAdd)}], myToRemove: [${printIds(myToRemove)}], myToAdd: [${printExtIds(myToAdd)}],`);
-        }
-        await extensionHostManager.deltaExtensions({ versionId, toRemove, toAdd, addActivationEvents, myToRemove, myToAdd: ( myToAdd.map(extension => extension.identifier)) });
+            const printExtIds = extensions => ( extensions.map(e => e.identifier.value)).join(",");
+            const printIds = extensions => ( extensions.map(e => e.value)).join(",");
+            this._logService.info(
+                `AbstractExtensionService: Calling deltaExtensions: toRemove: [${printIds(toRemove)}], toAdd: [${printExtIds(toAdd)}], myToRemove: [${printIds(myToRemove)}], myToAdd: [${printExtIds(myToAdd)}],`
+            );
+        }
+        await extensionHostManager.deltaExtensions({
+            versionId,
+            toRemove,
+            toAdd,
+            addActivationEvents,
+            myToRemove,
+            myToAdd: ( myToAdd.map(extension => extension.identifier))
+        });
     }
     canAddExtension(extension) {
         return this._canAddExtension(extension, []);
@@ -302,7 +351,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         const existing = this._registry.getExtensionDescriptionByIdOrUUID(extension.identifier, extension.id);
         if (existing) {
             const isBeingRemoved = ( extensionsBeingRemoved.some(
-                (extensionDescription) => ExtensionIdentifier.equals(extension.identifier, extensionDescription.identifier)
+                extensionDescription => ExtensionIdentifier.equals(extension.identifier, extensionDescription.identifier)
             ));
             if (!isBeingRemoved) {
                 return false;
@@ -310,7 +359,13 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         }
         const extensionKinds = this._runningLocations.readExtensionKinds(extension);
         const isRemote = extension.extensionLocation.scheme === Schemas.vscodeRemote;
-        const extensionHostKind = this._extensionHostKindPicker.pickExtensionHostKind(extension.identifier, extensionKinds, !isRemote, isRemote, ExtensionRunningPreference.None);
+        const extensionHostKind = this._extensionHostKindPicker.pickExtensionHostKind(
+            extension.identifier,
+            extensionKinds,
+            !isRemote,
+            isRemote,
+            ExtensionRunningPreference.None
+        );
         if (extensionHostKind === null) {
             return false;
         }
@@ -327,52 +382,49 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         return true;
     }
     async _activateAddedExtensionIfNeeded(extensionDescription) {
-        let shouldActivate = false;
         let shouldActivateReason = null;
         let hasWorkspaceContains = false;
         const activationEvents = this._activationEventReader.readActivationEvents(extensionDescription);
         for (const activationEvent of activationEvents) {
             if (( this._allRequestedActivateEvents.has(activationEvent))) {
-                shouldActivate = true;
                 shouldActivateReason = activationEvent;
                 break;
             }
-            if (activationEvent === '*') {
-                shouldActivate = true;
+            if (activationEvent === "*") {
                 shouldActivateReason = activationEvent;
                 break;
             }
             if (/^workspaceContains/.test(activationEvent)) {
                 hasWorkspaceContains = true;
             }
-            if (activationEvent === 'onStartupFinished') {
-                shouldActivate = true;
+            if (activationEvent === "onStartupFinished") {
                 shouldActivateReason = activationEvent;
                 break;
             }
         }
-        if (shouldActivate) {
-            await Promise.all(( this._extensionHostManagers.map(
-                extHostManager => extHostManager.activate(extensionDescription.identifier, { startup: false, extensionId: extensionDescription.identifier, activationEvent: shouldActivateReason })
-            ))).then(() => { });
-        }
-        else if (hasWorkspaceContains) {
+        if (!shouldActivateReason && hasWorkspaceContains) {
             const workspace = await this._contextService.getCompleteWorkspace();
             const forceUsingSearch = !!this._environmentService.remoteAuthority;
             const host = {
                 logService: this._logService,
                 folders: ( workspace.folders.map(folder => folder.uri)),
                 forceUsingSearch: forceUsingSearch,
-                exists: (uri) => this._fileService.exists(uri),
-                checkExists: (folders, includes, token) => this._instantiationService.invokeFunction((accessor) => checkGlobFileExists(accessor, folders, includes, token))
+                exists: uri => this._fileService.exists(uri),
+                checkExists: (folders, includes, token) => this._instantiationService.invokeFunction(accessor => checkGlobFileExists(accessor, folders, includes, token))
             };
             const result = await checkActivateWorkspaceContainsExtension(host, extensionDescription);
-            if (!result) {
-                return;
+            if (result) {
+                shouldActivateReason = result.activationEvent;
             }
+        }
+        if (shouldActivateReason) {
             await Promise.all(( this._extensionHostManagers.map(
-                extHostManager => extHostManager.activate(extensionDescription.identifier, { startup: false, extensionId: extensionDescription.identifier, activationEvent: result.activationEvent })
-            ))).then(() => { });
+                extHostManager => extHostManager.activate(extensionDescription.identifier, {
+                    startup: false,
+                    extensionId: extensionDescription.identifier,
+                    activationEvent: shouldActivateReason
+                })
+            )));
         }
     }
     _initializeIfNeeded() {
@@ -382,35 +434,75 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         return this._initializePromise;
     }
     async _initialize() {
-        mark('code/willLoadExtensions');
+        mark("code/willLoadExtensions");
         this._startExtensionHostsIfNecessary(true, []);
-        const lock = await this._registry.acquireLock('_initialize');
+        const lock = await this._registry.acquireLock("_initialize");
         try {
             await this._resolveAndProcessExtensions(lock);
             this._startOnDemandExtensionHosts();
-        }
-        finally {
+        } finally {
             lock.dispose();
         }
         this._releaseBarrier();
-        mark('code/didLoadExtensions');
+        mark("code/didLoadExtensions");
+        this._activateDeferredRemoteEvents();
         await this._handleExtensionTests();
     }
+    async _activateDeferredRemoteEvents() {
+        if (this._pendingRemoteActivationEvents.size === 0) {
+            return;
+        }
+        const remoteExtensionHosts = this._getExtensionHostManagers(ExtensionHostKind.Remote);
+        if (remoteExtensionHosts.length === 0) {
+            this._pendingRemoteActivationEvents.clear();
+            return;
+        }
+        await Promise.all(( remoteExtensionHosts.map(extHost => extHost.ready())));
+        for (const activationEvent of this._pendingRemoteActivationEvents) {
+            const result = Promise.all(( remoteExtensionHosts.map(
+                extHostManager => extHostManager.activateByEvent(activationEvent, ActivationKind.Normal)
+            ))).then(() => {});
+            this._onWillActivateByEvent.fire({
+                event: activationEvent,
+                activation: result,
+                activationKind: ActivationKind.Normal
+            });
+        }
+        this._pendingRemoteActivationEvents.clear();
+    }
     async _resolveAndProcessExtensions(lock) {
         let resolverExtensions = [];
         let localExtensions = [];
         let remoteExtensions = [];
         for await (const extensions of this._resolveExtensions()) {
             if (extensions instanceof ResolverExtensions) {
-                resolverExtensions = checkEnabledAndProposedAPI(this._logService, this._extensionEnablementService, this._extensionsProposedApi, extensions.extensions, false);
+                resolverExtensions = checkEnabledAndProposedAPI(
+                    this._logService,
+                    this._extensionEnablementService,
+                    this._extensionsProposedApi,
+                    extensions.extensions,
+                    false
+                );
                 this._registry.deltaExtensions(lock, resolverExtensions, []);
                 this._doHandleExtensionPoints(resolverExtensions, true);
             }
             if (extensions instanceof LocalExtensions) {
-                localExtensions = checkEnabledAndProposedAPI(this._logService, this._extensionEnablementService, this._extensionsProposedApi, extensions.extensions, false);
+                localExtensions = checkEnabledAndProposedAPI(
+                    this._logService,
+                    this._extensionEnablementService,
+                    this._extensionsProposedApi,
+                    extensions.extensions,
+                    false
+                );
             }
             if (extensions instanceof RemoteExtensions) {
-                remoteExtensions = checkEnabledAndProposedAPI(this._logService, this._extensionEnablementService, this._extensionsProposedApi, extensions.extensions, false);
+                remoteExtensions = checkEnabledAndProposedAPI(
+                    this._logService,
+                    this._extensionEnablementService,
+                    this._extensionsProposedApi,
+                    extensions.extensions,
+                    false
+                );
             }
         }
         this._runningLocations.initializeRunningLocation(localExtensions, remoteExtensions);
@@ -445,9 +537,9 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             this._notificationService.notify({
                 severity: Severity.Error,
                 message: ( localize(
-                    13998,
+                    14385,
                     "The following extensions contain dependency loops and have been disabled: {0}",
-                    ( result.removedDueToLooping.map(e => `'${e.identifier.value}'`)).join(', ')
+                    ( result.removedDueToLooping.map(e => `'${e.identifier.value}'`)).join(", ")
                 ))
             });
         }
@@ -460,7 +552,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         const extensionHostManager = this.findTestExtensionHost(this._environmentService.extensionTestsLocationURI);
         if (!extensionHostManager) {
             const msg = ( localize(
-                13999,
+                14386,
                 "No extension host found that can launch the test runner at {0}.",
                 (this._environmentService.extensionTestsLocationURI.toString())
             ));
@@ -474,8 +566,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             if (isCI) {
                 this._logService.info(`Extension host test runner exit code: ${exitCode}`);
             }
-        }
-        catch (err) {
+        } catch (err) {
             if (isCI) {
                 this._logService.error(`Extension host test runner error`, err);
             }
@@ -495,8 +586,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         if (runningLocation === null) {
             if (testLocation.scheme === Schemas.vscodeRemote) {
                 runningLocation = ( new RemoteRunningLocation());
-            }
-            else {
+            } else {
                 runningLocation = ( new LocalProcessRunningLocation(0));
             }
         }
@@ -512,11 +602,10 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
     }
     async _resolveAuthorityInitial(remoteAuthority) {
         const MAX_ATTEMPTS = 5;
-        for (let attempt = 1;; attempt++) {
+        for (let attempt = 1; ; attempt++) {
             try {
                 return this._resolveAuthorityWithLogging(remoteAuthority);
-            }
-            catch (err) {
+            } catch (err) {
                 if (RemoteAuthorityResolverError.isNoResolverFound(err)) {
                     throw err;
                 }
@@ -538,8 +627,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         try {
             const result = await this._resolveAuthorityWithLogging(remoteAuthority);
             this._remoteAuthorityResolverService._setResolvedAuthority(result.authority, result.options);
-        }
-        catch (err) {
+        } catch (err) {
             this._remoteAuthorityResolverService._setResolvedAuthorityError(remoteAuthority, err);
         }
     }
@@ -551,12 +639,16 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             mark(`code/willResolveAuthority/${authorityPrefix}`);
             const result = await this._resolveAuthority(remoteAuthority);
             mark(`code/didResolveAuthorityOK/${authorityPrefix}`);
-            this._logService.info(`resolveAuthority(${authorityPrefix}) returned '${result.authority.connectTo}' after ${sw.elapsed()} ms`);
+            this._logService.info(
+                `resolveAuthority(${authorityPrefix}) returned '${result.authority.connectTo}' after ${sw.elapsed()} ms`
+            );
             return result;
-        }
-        catch (err) {
+        } catch (err) {
             mark(`code/didResolveAuthorityError/${authorityPrefix}`);
-            this._logService.error(`resolveAuthority(${authorityPrefix}) returned an error after ${sw.elapsed()} ms`, err);
+            this._logService.error(
+                `resolveAuthority(${authorityPrefix}) returned an error after ${sw.elapsed()} ms`,
+                err
+            );
             throw err;
         }
     }
@@ -571,7 +663,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         )));
         let bestErrorResult = null;
         for (const result of results) {
-            if (result.type === 'ok') {
+            if (result.type === "ok") {
                 return result.value;
             }
             if (!bestErrorResult) {
@@ -590,7 +682,8 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             bestErrorResult.error.detail
         ));
     }
-    stopExtensionHosts(reason, auto) {
+    async stopExtensionHosts(reason, auto) {
+        await this._initializeIfNeeded();
         return this._doStopExtensionHostsWithVeto(reason, auto);
     }
     async _doStopExtensionHosts() {
@@ -619,18 +712,17 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             auto,
             veto(value, reason) {
                 vetos.push(value);
-                if (typeof value === 'boolean') {
+                if (typeof value === "boolean") {
                     if (value === true) {
                         vetoReasons.add(reason);
                     }
-                }
-                else {
+                } else {
                     value.then(value => {
                         if (value) {
                             vetoReasons.add(reason);
                         }
                     }).catch(error => {
-                        vetoReasons.add(( localize(14000, "{0} (Error: {1})", reason, toErrorMessage(error))));
+                        vetoReasons.add(( localize(14387, "{0} (Error: {1})", reason, toErrorMessage(error))));
                     });
                 }
             }
@@ -638,18 +730,19 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         const veto = await handleVetos(vetos, error => this._logService.error(error));
         if (!veto) {
             await this._doStopExtensionHosts();
-        }
-        else {
+        } else {
             if (!auto) {
                 const vetoReasonsArray = Array.from(vetoReasons);
-                this._logService.warn(`Extension host was not stopped because of veto (stop reason: ${reason}, veto reason: ${vetoReasonsArray.join(', ')})`);
-                const { confirmed } = await this._dialogService.confirm({
+                this._logService.warn(
+                    `Extension host was not stopped because of veto (stop reason: ${reason}, veto reason: ${vetoReasonsArray.join(", ")})`
+                );
+                const {
+                    confirmed
+                } = await this._dialogService.confirm({
                     type: Severity.Warning,
-                    message: ( localize(14001, "Please confirm restart of extensions.")),
-                    detail: vetoReasonsArray.length === 1 ?
-                        vetoReasonsArray[0] :
-                        vetoReasonsArray.join('\n -'),
-                    primaryButton: ( localize(14002, "Restart Anyway"))
+                    message: ( localize(14388, "Please confirm restart of extensions.")),
+                    detail: vetoReasonsArray.length === 1 ? vetoReasonsArray[0] : vetoReasonsArray.join("\n -"),
+                    primaryButton: ( localize(14389, "Restart Anyway"))
                 });
                 if (confirmed) {
                     return true;
@@ -685,13 +778,17 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         }
         const processManager = this._doCreateExtensionHostManager(extensionHost, initialActivationEvents);
         const disposableStore = ( new DisposableStore());
-        disposableStore.add(processManager.onDidExit(([code, signal]) => this._onExtensionHostCrashOrExit(processManager, code, signal)));
-        disposableStore.add(processManager.onDidChangeResponsiveState((responsiveState) => {
-            this._logService.info(`Extension host (${processManager.friendyName}) is ${responsiveState === ResponsiveState.Responsive ? 'responsive' : 'unresponsive'}.`);
+        disposableStore.add(processManager.onDidExit(
+            ([code, signal]) => this._onExtensionHostCrashOrExit(processManager, code, signal)
+        ));
+        disposableStore.add(processManager.onDidChangeResponsiveState(responsiveState => {
+            this._logService.info(
+                `Extension host (${processManager.friendyName}) is ${responsiveState === ResponsiveState.Responsive ? "responsive" : "unresponsive"}.`
+            );
             this._onDidChangeResponsiveChange.fire({
                 extensionHostKind: processManager.kind,
                 isResponsive: responsiveState === ResponsiveState.Responsive,
-                getInspectListener: (tryEnableInspector) => {
+                getInspectListener: tryEnableInspector => {
                     return processManager.getInspectPort(tryEnableInspector);
                 }
             });
@@ -701,9 +798,19 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
     _doCreateExtensionHostManager(extensionHost, initialActivationEvents) {
         const internalExtensionService = this._acquireInternalAPI(extensionHost);
         if (extensionHost.startup === ExtensionHostStartup.LazyAutoStart) {
-            return this._instantiationService.createInstance(LazyCreateExtensionHostManager, extensionHost, initialActivationEvents, internalExtensionService);
-        }
-        return this._instantiationService.createInstance(ExtensionHostManager, extensionHost, initialActivationEvents, internalExtensionService);
+            return this._instantiationService.createInstance(
+                LazyCreateExtensionHostManager,
+                extensionHost,
+                initialActivationEvents,
+                internalExtensionService
+            );
+        }
+        return this._instantiationService.createInstance(
+            ExtensionHostManager,
+            extensionHost,
+            initialActivationEvents,
+            internalExtensionService
+        );
     }
     _onExtensionHostCrashOrExit(extensionHost, code, signal) {
         const isExtensionDevHost = parseExtensionDevOptions(this._environmentService).isExtensionDevHost;
@@ -714,11 +821,12 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         this._onExtensionHostExit(code);
     }
     _onExtensionHostCrashed(extensionHost, code, signal) {
-        console.error(`Extension host (${extensionHost.friendyName}) terminated unexpectedly. Code: ${code}, Signal: ${signal}`);
+        console.error(
+            `Extension host (${extensionHost.friendyName}) terminated unexpectedly. Code: ${code}, Signal: ${signal}`
+        );
         if (extensionHost.kind === ExtensionHostKind.LocalProcess) {
             this._doStopExtensionHosts();
-        }
-        else if (extensionHost.kind === ExtensionHostKind.Remote) {
+        } else if (extensionHost.kind === ExtensionHostKind.Remote) {
             if (signal) {
                 this._onRemoteExtensionHostCrashed(extensionHost, signal);
             }
@@ -728,9 +836,9 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
     _getExtensionHostExitInfoWithTimeout(reconnectionToken) {
         return ( new Promise((resolve, reject) => {
             const timeoutHandle = setTimeout(() => {
-                reject(( new Error('getExtensionHostExitInfo timed out')));
+                reject(( new Error("getExtensionHostExitInfo timed out")));
             }, 2000);
-            this._remoteAgentService.getExtensionHostExitInfo(reconnectionToken).then((r) => {
+            this._remoteAgentService.getExtensionHostExitInfo(reconnectionToken).then(r => {
                 clearTimeout(timeoutHandle);
                 resolve(r);
             }, reject);
@@ -740,29 +848,30 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         try {
             const info = await this._getExtensionHostExitInfoWithTimeout(reconnectionToken);
             if (info) {
-                this._logService.error(`Extension host (${extensionHost.friendyName}) terminated unexpectedly with code ${info.code}.`);
+                this._logService.error(
+                    `Extension host (${extensionHost.friendyName}) terminated unexpectedly with code ${info.code}.`
+                );
             }
             this._logExtensionHostCrash(extensionHost);
             this._remoteCrashTracker.registerCrash();
             if (this._remoteCrashTracker.shouldAutomaticallyRestart()) {
                 this._logService.info(`Automatically restarting the remote extension host.`);
-                this._notificationService.status(( localize(14003, "The remote extension host terminated unexpectedly. Restarting...")), { hideAfter: 5000 });
+                this._notificationService.status(( localize(14390, "The remote extension host terminated unexpectedly. Restarting...")), {
+                    hideAfter: 5000
+                });
                 this._startExtensionHostsIfNecessary(false, Array.from(( this._allRequestedActivateEvents.keys())));
-            }
-            else {
+            } else {
                 this._notificationService.prompt(Severity.Error, ( localize(
-                    14004,
+                    14391,
                     "Remote Extension host terminated unexpectedly 3 times within the last 5 minutes."
                 )), [{
-                        label: ( localize(14005, "Restart Remote Extension Host")),
-                        run: () => {
-                            this._startExtensionHostsIfNecessary(false, Array.from(( this._allRequestedActivateEvents.keys())));
-                        }
-                    }]);
+                    label: ( localize(14392, "Restart Remote Extension Host")),
+                    run: () => {
+                        this._startExtensionHostsIfNecessary(false, Array.from(( this._allRequestedActivateEvents.keys())));
+                    }
+                }]);
             }
-        }
-        catch (err) {
-        }
+        } catch (err) {}
     }
     _logExtensionHostCrash(extensionHost) {
         const activatedExtensions = [];
@@ -772,10 +881,13 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             }
         }
         if (activatedExtensions.length > 0) {
-            this._logService.error(`Extension host (${extensionHost.friendyName}) terminated unexpectedly. The following extensions were running: ${( activatedExtensions.map(id => id.value)).join(', ')}`);
-        }
-        else {
-            this._logService.error(`Extension host (${extensionHost.friendyName}) terminated unexpectedly. No extensions were activated.`);
+            this._logService.error(
+                `Extension host (${extensionHost.friendyName}) terminated unexpectedly. The following extensions were running: ${( activatedExtensions.map(id => id.value)).join(", ")}`
+            );
+        } else {
+            this._logService.error(
+                `Extension host (${extensionHost.friendyName}) terminated unexpectedly. No extensions were activated.`
+            );
         }
     }
     async startExtensionHosts(updates) {
@@ -783,14 +895,13 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         if (updates) {
             await this._handleDeltaExtensions(( new DeltaExtensionsQueueItem(updates.toAdd, updates.toRemove)));
         }
-        const lock = await this._registry.acquireLock('startExtensionHosts');
+        const lock = await this._registry.acquireLock("startExtensionHosts");
         try {
             this._startExtensionHostsIfNecessary(false, Array.from(( this._allRequestedActivateEvents.keys())));
             this._startOnDemandExtensionHosts();
             const localProcessExtensionHosts = this._getExtensionHostManagers(ExtensionHostKind.LocalProcess);
             await Promise.all(( localProcessExtensionHosts.map(extHost => extHost.ready())));
-        }
-        finally {
+        } finally {
             lock.dispose();
         }
     }
@@ -810,8 +921,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                 return NO_OP_VOID_PROMISE;
             }
             return this._activateByEvent(activationEvent, activationKind);
-        }
-        else {
+        } else {
             this._allRequestedActivateEvents.add(activationEvent);
             if (activationKind === ActivationKind.Immediate) {
                 void this._initializeIfNeeded();
@@ -821,12 +931,22 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         }
     }
     _activateByEvent(activationEvent, activationKind) {
-        const result = Promise.all(( this._extensionHostManagers.map(
+        let managers;
+        if (activationKind === ActivationKind.Immediate) {
+            managers = this._extensionHostManagers.filter(
+                extHostManager => extHostManager.kind === ExtensionHostKind.LocalProcess || extHostManager.kind === ExtensionHostKind.LocalWebWorker
+            );
+            this._pendingRemoteActivationEvents.add(activationEvent);
+        } else {
+            managers = [...this._extensionHostManagers];
+        }
+        const result = Promise.all(( managers.map(
             extHostManager => extHostManager.activateByEvent(activationEvent, activationKind)
-        ))).then(() => { });
+        ))).then(() => {});
         this._onWillActivateByEvent.fire({
             event: activationEvent,
-            activation: result
+            activation: result,
+            activationKind
         });
         return result;
     }
@@ -880,31 +1000,32 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                     activationStarted: extensionStatus?.activationStarted ?? false,
                     activationTimes: extensionStatus?.activationTimes ?? undefined,
                     runtimeErrors: extensionStatus?.runtimeErrors ?? [],
-                    runningLocation: this._runningLocations.getRunningLocation(extension.identifier),
+                    runningLocation: this._runningLocations.getRunningLocation(extension.identifier)
                 };
             }
         }
         return result;
     }
     async getInspectPorts(extensionHostKind, tryEnableInspector) {
-        const result = await Promise.all(( this._getExtensionHostManagers(extensionHostKind).map(async (extHost) => {
+        const result = await Promise.all(( this._getExtensionHostManagers(extensionHostKind).map(async extHost => {
             let portInfo = await extHost.getInspectPort(tryEnableInspector);
             if (portInfo !== undefined) {
-                portInfo = { ...portInfo, devtoolsLabel: extHost.friendyName };
+                portInfo = {
+                    ...portInfo,
+                    devtoolsLabel: extHost.friendyName
+                };
             }
             return portInfo;
         })));
         return result.filter(isDefined);
     }
     async setRemoteEnvironment(env) {
-        await ( this._extensionHostManagers
-            .map(manager => manager.setRemoteEnvironment(env)));
+        await ( this._extensionHostManagers.map(manager => manager.setRemoteEnvironment(env)));
     }
     _safeInvokeIsEnabled(extension) {
         try {
             return this._extensionEnablementService.isEnabled(extension);
-        }
-        catch (err) {
+        } catch (err) {
             return false;
         }
     }
@@ -919,10 +1040,12 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                 }
             }
         }
-        const messageHandler = (msg) => this._handleExtensionPointMessage(msg);
+        const messageHandler = msg => this._handleExtensionPointMessage(msg);
         const availableExtensions = this._registry.getAllExtensionDescriptions();
         const extensionPoints = ExtensionsRegistry.getExtensionPoints();
-        mark(onlyResolverExtensionPoints ? 'code/willHandleResolverExtensionPoints' : 'code/willHandleExtensionPoints');
+        mark(
+            onlyResolverExtensionPoints ? "code/willHandleResolverExtensionPoints" : "code/willHandleExtensionPoints"
+        );
         for (const extensionPoint of extensionPoints) {
             if (affectedExtensionPoints[extensionPoint.name] && (!onlyResolverExtensionPoints || extensionPoint.canHandleResolver)) {
                 mark(`code/willHandleExtensionPoint/${extensionPoint.name}`);
@@ -930,7 +1053,9 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                 mark(`code/didHandleExtensionPoint/${extensionPoint.name}`);
             }
         }
-        mark(onlyResolverExtensionPoints ? 'code/didHandleResolverExtensionPoints' : 'code/didHandleExtensionPoints');
+        mark(
+            onlyResolverExtensionPoints ? "code/didHandleResolverExtensionPoints" : "code/didHandleExtensionPoints"
+        );
     }
     _getOrCreateExtensionStatus(extensionId) {
         if (!( this._extensionStatus.has(extensionId))) {
@@ -945,23 +1070,35 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         const strMsg = `[${msg.extensionId.value}]: ${msg.message}`;
         if (msg.type === Severity.Error) {
             if (extension && extension.isUnderDevelopment) {
-                this._notificationService.notify({ severity: Severity.Error, message: strMsg });
+                this._notificationService.notify({
+                    severity: Severity.Error,
+                    message: strMsg
+                });
             }
             this._logService.error(strMsg);
-        }
-        else if (msg.type === Severity.Warning) {
+        } else if (msg.type === Severity.Warning) {
             if (extension && extension.isUnderDevelopment) {
-                this._notificationService.notify({ severity: Severity.Warning, message: strMsg });
+                this._notificationService.notify({
+                    severity: Severity.Warning,
+                    message: strMsg
+                });
             }
             this._logService.warn(strMsg);
-        }
-        else {
+        } else {
             this._logService.info(strMsg);
         }
         if (msg.extensionId && this._environmentService.isBuilt && !this._environmentService.isExtensionDevelopment) {
-            const { type, extensionId, extensionPointId, message } = msg;
-            this._telemetryService.publicLog2('extensionsMessage', {
-                type, extensionId: extensionId.value, extensionPointId, message
+            const {
+                type,
+                extensionId,
+                extensionPointId,
+                message
+            } = msg;
+            this._telemetryService.publicLog2("extensionsMessage", {
+                type,
+                extensionId: extensionId.value,
+                extensionPointId,
+                message
             });
         }
     }
@@ -983,11 +1120,23 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             _activateById: (extensionId, reason) => {
                 return this._activateById(extensionId, reason);
             },
-            _onWillActivateExtension: (extensionId) => {
+            _onWillActivateExtension: extensionId => {
                 return this._onWillActivateExtension(extensionId, extensionHost.runningLocation);
             },
-            _onDidActivateExtension: (extensionId, codeLoadingTime, activateCallTime, activateResolvedTime, activationReason) => {
-                return this._onDidActivateExtension(extensionId, codeLoadingTime, activateCallTime, activateResolvedTime, activationReason);
+            _onDidActivateExtension: (
+                extensionId,
+                codeLoadingTime,
+                activateCallTime,
+                activateResolvedTime,
+                activationReason
+            ) => {
+                return this._onDidActivateExtension(
+                    extensionId,
+                    codeLoadingTime,
+                    activateCallTime,
+                    activateResolvedTime,
+                    activationReason
+                );
             },
             _onDidActivateExtensionError: (extensionId, error) => {
                 return this._onDidActivateExtensionError(extensionId, error);
@@ -1009,13 +1158,19 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         const extensionStatus = this._getOrCreateExtensionStatus(extensionId);
         extensionStatus.onWillActivate();
     }
-    _onDidActivateExtension(extensionId, codeLoadingTime, activateCallTime, activateResolvedTime, activationReason) {
+    _onDidActivateExtension(
+        extensionId,
+        codeLoadingTime,
+        activateCallTime,
+        activateResolvedTime,
+        activationReason
+    ) {
         const extensionStatus = this._getOrCreateExtensionStatus(extensionId);
         extensionStatus.setActivationTimes(( new ActivationTimes(codeLoadingTime, activateCallTime, activateResolvedTime, activationReason)));
         this._onDidChangeExtensionsStatus.fire([extensionId]);
     }
     _onDidActivateExtensionError(extensionId, error) {
-        this._telemetryService.publicLog2('extensionActivationError', {
+        this._telemetryService.publicLog2("extensionActivationError", {
             extensionId: extensionId.value,
             error: error.message
         });
@@ -1026,25 +1181,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         this._onDidChangeExtensionsStatus.fire([extensionId]);
     }
 };
-AbstractExtensionService = AbstractExtensionService_1 = ( __decorate([
-    ( __param(4, IInstantiationService)),
-    ( __param(5, INotificationService)),
-    ( __param(6, IWorkbenchEnvironmentService)),
-    ( __param(7, ITelemetryService)),
-    ( __param(8, IWorkbenchExtensionEnablementService)),
-    ( __param(9, IFileService)),
-    ( __param(10, IProductService)),
-    ( __param(11, IWorkbenchExtensionManagementService)),
-    ( __param(12, IWorkspaceContextService)),
-    ( __param(13, IConfigurationService)),
-    ( __param(14, IExtensionManifestPropertiesService)),
-    ( __param(15, ILogService)),
-    ( __param(16, IRemoteAgentService)),
-    ( __param(17, IRemoteExtensionsScannerService)),
-    ( __param(18, ILifecycleService)),
-    ( __param(19, IRemoteAuthorityResolverService)),
-    ( __param(20, IDialogService))
-], AbstractExtensionService));
+AbstractExtensionService = AbstractExtensionService_1 = ( __decorate([( __param(4, IInstantiationService)), ( __param(5, INotificationService)), ( __param(6, IWorkbenchEnvironmentService)), ( __param(7, ITelemetryService)), ( __param(8, IWorkbenchExtensionEnablementService)), ( __param(9, IFileService)), ( __param(10, IProductService)), ( __param(11, IWorkbenchExtensionManagementService)), ( __param(12, IWorkspaceContextService)), ( __param(13, IConfigurationService)), ( __param(14, IExtensionManifestPropertiesService)), ( __param(15, ILogService)), ( __param(16, IRemoteAgentService)), ( __param(17, IRemoteExtensionsScannerService)), ( __param(18, ILifecycleService)), ( __param(19, IRemoteAuthorityResolverService)), ( __param(20, IDialogService))], AbstractExtensionService));
 class ExtensionHostCollection extends Disposable {
     constructor() {
         super(...arguments);
@@ -1136,9 +1273,15 @@ class DeltaExtensionsQueueItem {
     }
 }
 function isResolverExtension(extension) {
-    return !!extension.activationEvents?.some(activationEvent => activationEvent.startsWith('onResolveRemoteAuthority:'));
+    return !!extension.activationEvents?.some(activationEvent => activationEvent.startsWith("onResolveRemoteAuthority:"));
 }
-function checkEnabledAndProposedAPI(logService, extensionEnablementService, extensionsProposedApi, extensions, ignoreWorkspaceTrust) {
+function checkEnabledAndProposedAPI(
+    logService,
+    extensionEnablementService,
+    extensionsProposedApi,
+    extensions,
+    ignoreWorkspaceTrust
+) {
     extensionsProposedApi.updateEnabledApiProposals(extensions);
     return filterEnabledExtensions(logService, extensionEnablementService, extensions, ignoreWorkspaceTrust);
 }
@@ -1147,20 +1290,22 @@ function filterEnabledExtensions(logService, extensionEnablementService, extensi
     for (const extension of extensions) {
         if (extension.isUnderDevelopment) {
             enabledExtensions.push(extension);
-        }
-        else {
+        } else {
             extensionsToCheck.push(extension);
             mappedExtensions.push(toExtension(extension));
         }
     }
-    const enablementStates = extensionEnablementService.getEnablementStates(mappedExtensions, ignoreWorkspaceTrust ? { trusted: true } : undefined);
+    const enablementStates = extensionEnablementService.getEnablementStates(mappedExtensions, ignoreWorkspaceTrust ? {
+        trusted: true
+    } : undefined);
     for (let index = 0; index < enablementStates.length; index++) {
         if (extensionEnablementService.isEnabledEnablementState(enablementStates[index])) {
             enabledExtensions.push(extensionsToCheck[index]);
-        }
-        else {
+        } else {
             if (isCI) {
-                logService.info(`filterEnabledExtensions: extension '${extensionsToCheck[index].identifier.value}' is disabled`);
+                logService.info(
+                    `filterEnabledExtensions: extension '${extensionsToCheck[index].identifier.value}' is disabled`
+                );
             }
         }
     }
@@ -1216,8 +1361,12 @@ class ExtensionHostCrashTracker {
     constructor() {
         this._recentCrashes = [];
     }
-    static { this._TIME_LIMIT = 5 * 60 * 1000; }
-    static { this._CRASH_LIMIT = 3; }
+    static {
+        this._TIME_LIMIT = 5 * 60 * 1000;
+    }
+    static {
+        this._CRASH_LIMIT = 3;
+    }
     _removeOldCrashes() {
         const limit = Date.now() - ExtensionHostCrashTracker._TIME_LIMIT;
         while (this._recentCrashes.length > 0 && this._recentCrashes[0].timestamp < limit) {
@@ -1226,7 +1375,9 @@ class ExtensionHostCrashTracker {
     }
     registerCrash() {
         this._removeOldCrashes();
-        this._recentCrashes.push({ timestamp: Date.now() });
+        this._recentCrashes.push({
+            timestamp: Date.now()
+        });
     }
     shouldAutomaticallyRestart() {
         this._removeOldCrashes();
@@ -1241,7 +1392,7 @@ class ImplicitActivationAwareReader {
 class ActivationFeatureMarkdowneRenderer extends Disposable {
     constructor() {
         super(...arguments);
-        this.type = 'markdown';
+        this.type = "markdown";
     }
     shouldRender(manifest) {
         return !!manifest.activationEvents;
@@ -1256,17 +1407,17 @@ class ActivationFeatureMarkdowneRenderer extends Disposable {
         }
         return {
             data,
-            dispose: () => { }
+            dispose: () => {}
         };
     }
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
-    id: 'activationEvents',
-    label: ( localize(14006, "Activation Events")),
+    id: "activationEvents",
+    label: ( localize(14393, "Activation Events")),
     access: {
         canToggle: false
     },
-    renderer: ( new SyncDescriptor(ActivationFeatureMarkdowneRenderer)),
+    renderer: ( new SyncDescriptor(ActivationFeatureMarkdowneRenderer))
 });
 
 export { AbstractExtensionService, DeltaExtensionsQueueItem, ExtensionHostCrashTracker, ExtensionStatus, ImplicitActivationAwareReader, LocalExtensions, RemoteExtensions, ResolverExtensions, checkEnabledAndProposedAPI, filterEnabledExtensions, isResolverExtension };