@theia/core 1.71.0-next.8 → 1.71.0

package/src/common/performance/stopwatch.spec.ts

@@ -0,0 +1,321 @@
+// *****************************************************************************
+// Copyright (C) 2026 STMicroelectronics and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { Deferred } from '../promise-util';
+import { Measurement, MeasurementOptions } from './measurement';
+import { MeasurementContext } from './stopwatch';
+import { SimpleStopwatch } from './simple-stopwatch';
+
+/**
+ * A fake {@link Measurement} whose log methods are sinon spies, with a
+ * configurable duration returned by {@link stop}.
+ */
+class FakeMeasurement implements Measurement {
+    name: string;
+    elapsed?: number;
+    duration: number;
+
+    readonly log = sinon.spy();
+    readonly info = sinon.spy();
+    readonly debug = sinon.spy();
+    readonly warn = sinon.spy();
+    readonly error = sinon.spy();
+
+    readonly stop = sinon.spy((): number => {
+        if (this.elapsed === undefined) {
+            this.elapsed = this.duration;
+        }
+        return this.elapsed;
+    });
+
+    constructor(name: string, duration: number = 0) {
+        this.name = name;
+        this.duration = duration;
+    }
+}
+
+/**
+ * A fake {@link Stopwatch} that creates {@link FakeMeasurement}s with
+ * configurable durations and records all invocations of {@link start}.
+ */
+class FakeStopwatch extends SimpleStopwatch {
+    defaultDuration = 0;
+    readonly durationByName = new Map<string, number>();
+    readonly created: FakeMeasurement[] = [];
+
+    override readonly start = sinon.spy((name: string, _options?: MeasurementOptions): Measurement => {
+        const duration = this.durationByName.get(name) ?? this.defaultDuration;
+        const measurement = new FakeMeasurement(name, duration);
+        this.created.push(measurement);
+        return measurement;
+    });
+
+    constructor() {
+        super('test', () => 0);
+    }
+
+    /** Return the first measurement created with the given name, or `undefined`. */
+    measurementFor(name: string): FakeMeasurement | undefined {
+        return this.created.find(m => m.name === name);
+    }
+}
+
+class TestContribution { }
+class OtherTestContribution { }
+
+/**
+ * Allow any already-queued microtasks (such as `.then` callbacks attached to
+ * already-settled promises) to run before assertions.
+ */
+async function flushPromises(): Promise<void> {
+    for (let i = 0; i < 5; i++) {
+        await Promise.resolve();
+    }
+}
+
+describe('MeasurementContext', () => {
+
+    let stopwatch: FakeStopwatch;
+
+    beforeEach(() => {
+        stopwatch = new FakeStopwatch();
+    });
+
+    describe('ensureEntry', () => {
+
+        it('starts a per-contribution measurement', () => {
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 250);
+
+            context.ensureEntry(new TestContribution());
+
+            sinon.assert.calledWith(stopwatch.start, 'TestContribution.settled', sinon.match({ thresholdMillis: 250 }));
+        });
+
+        it('starts a per-contribution measurement only once per item', () => {
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 100);
+            const item = new TestContribution();
+
+            context.ensureEntry(item);
+            context.ensureEntry(item);
+            context.ensureEntry(item);
+
+            const started = stopwatch.start.getCalls().filter(c => c.args[0] === 'TestContribution.settled');
+            expect(started).to.have.length(1);
+        });
+
+        it('starts independent measurements for distinct items', () => {
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 100);
+
+            context.ensureEntry(new TestContribution());
+            context.ensureEntry(new TestContribution());
+
+            const started = stopwatch.start.getCalls().filter(c => c.args[0] === 'TestContribution.settled');
+            expect(started).to.have.length(2);
+        });
+    });
+
+    describe('trackSettlement', () => {
+
+        it('is a no-op for a synchronous result', async () => {
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 100);
+            const item = new TestContribution();
+            context.ensureEntry(item);
+
+            context.trackSettlement(item, undefined);
+            context.armAllSettled();
+            await flushPromises();
+
+            const perContribution = stopwatch.measurementFor('TestContribution.settled')!;
+            sinon.assert.notCalled(perContribution.debug);
+            sinon.assert.notCalled(perContribution.warn);
+            sinon.assert.notCalled(perContribution.info);
+
+            // Synchronous results do not increment allSettledPending, so arming fires the
+            // aggregate message immediately.
+            const allSettled = stopwatch.measurementFor('frontend-all-settled')!;
+            sinon.assert.calledOnce(allSettled.info);
+        });
+
+        it('does not log a per-contribution settlement when only one promise was tracked', async () => {
+            // The single lifecycle measurement already describes the duration of a solo tracked
+            // promise, so the per-contribution aggregate must stay silent.
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 100);
+            const item = new TestContribution();
+            context.ensureEntry(item);
+
+            context.trackSettlement(item, Promise.resolve());
+            context.armAllSettled();
+            await flushPromises();
+
+            const perContribution = stopwatch.measurementFor('TestContribution.settled')!;
+            sinon.assert.notCalled(perContribution.debug);
+            sinon.assert.notCalled(perContribution.warn);
+            sinon.assert.notCalled(perContribution.info);
+        });
+
+        it('logs a debug settlement message once multiple tracked promises all resolve under the threshold', async () => {
+            stopwatch.durationByName.set('TestContribution.settled', 50);
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 100);
+            const item = new TestContribution();
+            context.ensureEntry(item);
+
+            const first = new Deferred<void>();
+            const second = new Deferred<void>();
+            context.trackSettlement(item, first.promise);
+            context.trackSettlement(item, second.promise);
+
+            // Before any promise resolves, nothing has been logged.
+            const perContribution = stopwatch.measurementFor('TestContribution.settled')!;
+            sinon.assert.notCalled(perContribution.debug);
+
+            first.resolve();
+            await flushPromises();
+            sinon.assert.notCalled(perContribution.debug);
+
+            second.resolve();
+            await flushPromises();
+            sinon.assert.calledOnceWithExactly(perContribution.debug, 'Frontend TestContribution settled');
+            sinon.assert.notCalled(perContribution.warn);
+        });
+
+        it('logs a warn settlement message when multiple tracked promises exceed the threshold', async () => {
+            stopwatch.durationByName.set('TestContribution.settled', 500);
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 100);
+            const item = new TestContribution();
+            context.ensureEntry(item);
+
+            context.trackSettlement(item, Promise.resolve());
+            context.trackSettlement(item, Promise.resolve());
+            await flushPromises();
+
+            const perContribution = stopwatch.measurementFor('TestContribution.settled')!;
+            sinon.assert.calledOnceWithExactly(perContribution.warn, 'Frontend TestContribution took longer than expected to settle');
+            sinon.assert.notCalled(perContribution.debug);
+        });
+
+        it('treats a rejected promise as settled', async () => {
+            stopwatch.durationByName.set('TestContribution.settled', 10);
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 100);
+            const item = new TestContribution();
+            context.ensureEntry(item);
+
+            const rejecting = new Deferred<void>();
+            context.trackSettlement(item, Promise.resolve());
+            context.trackSettlement(item, rejecting.promise);
+            rejecting.reject(new Error('expected failure'));
+            await flushPromises();
+
+            const perContribution = stopwatch.measurementFor('TestContribution.settled')!;
+            sinon.assert.calledOnce(perContribution.debug);
+        });
+
+        it('tracks promises independently for each contribution', async () => {
+            stopwatch.durationByName.set('TestContribution.settled', 50);
+            stopwatch.durationByName.set('OtherTestContribution.settled', 50);
+            const context = new MeasurementContext<object>(stopwatch, 'Frontend', 100);
+
+            const a = new TestContribution();
+            const b = new OtherTestContribution();
+            context.ensureEntry(a);
+            context.ensureEntry(b);
+
+            context.trackSettlement(a, Promise.resolve());
+            context.trackSettlement(a, Promise.resolve());
+            context.trackSettlement(b, Promise.resolve());
+            await flushPromises();
+
+            // a had two tracked promises: logs once.
+            sinon.assert.calledOnce(stopwatch.measurementFor('TestContribution.settled')!.debug);
+            // b had a single tracked promise: logs nothing.
+            sinon.assert.notCalled(stopwatch.measurementFor('OtherTestContribution.settled')!.debug);
+        });
+    });
+
+    describe('armAllSettled', () => {
+
+        it('logs the aggregate message immediately when armed with zero pending promises', () => {
+            const context = new MeasurementContext(stopwatch, 'Frontend', 100);
+
+            context.armAllSettled();
+
+            const allSettled = stopwatch.measurementFor('frontend-all-settled')!;
+            sinon.assert.calledOnceWithExactly(allSettled.info, 'All frontend contributions settled');
+        });
+
+        it('defers the aggregate log until the last tracked promise settles', async () => {
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 100);
+            const item = new TestContribution();
+            context.ensureEntry(item);
+
+            const pending = new Deferred<void>();
+            context.trackSettlement(item, pending.promise);
+            context.armAllSettled();
+
+            const allSettled = stopwatch.measurementFor('frontend-all-settled')!;
+            sinon.assert.notCalled(allSettled.info);
+
+            pending.resolve();
+            await flushPromises();
+
+            sinon.assert.calledOnce(allSettled.info);
+        });
+
+        it('does not log the aggregate message when all promises settle before arming', async () => {
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 100);
+            const item = new TestContribution();
+            context.ensureEntry(item);
+
+            context.trackSettlement(item, Promise.resolve());
+            await flushPromises();
+
+            const allSettled = stopwatch.measurementFor('frontend-all-settled')!;
+            sinon.assert.notCalled(allSettled.info);
+        });
+
+        it('logs the aggregate message when arming after all tracked promises have already settled', async () => {
+            const context = new MeasurementContext<TestContribution>(stopwatch, 'Frontend', 100);
+            const item = new TestContribution();
+            context.ensureEntry(item);
+
+            context.trackSettlement(item, Promise.resolve());
+            await flushPromises();
+
+            const allSettled = stopwatch.measurementFor('frontend-all-settled')!;
+            sinon.assert.notCalled(allSettled.info);
+
+            context.armAllSettled();
+            sinon.assert.calledOnce(allSettled.info);
+        });
+
+        it('logs the aggregate message exactly once when multiple contributions finish', async () => {
+            const context = new MeasurementContext<object>(stopwatch, 'Frontend', 100);
+            const a = new TestContribution();
+            const b = new OtherTestContribution();
+            context.ensureEntry(a);
+            context.ensureEntry(b);
+
+            context.trackSettlement(a, Promise.resolve());
+            context.trackSettlement(b, Promise.resolve());
+            context.armAllSettled();
+            await flushPromises();
+
+            const allSettled = stopwatch.measurementFor('frontend-all-settled')!;
+            sinon.assert.calledOnce(allSettled.info);
+        });
+    });
+});

package/src/common/performance/stopwatch.ts

@@ -170,8 +170,8 @@ export abstract class Stopwatch {
             }
         }
 
-        const start = options.owner ? `${options.owner} start` : 'start';
-        const timeFromStart = `Finished ${(options.now() / 1000).toFixed(3)} s after ${start}`;
+        const origin = options.owner ?? 'application';
+        const timeFromStart = `${(options.now() / 1000).toFixed(3)} s since ${origin} start`;
         const whatWasMeasured = options.context ? `[${options.context}] ${activity}` : activity;
         this.logger.log(level, `${whatWasMeasured}: ${elapsed.toFixed(1)} ms [${timeFromStart}]`, ...(options.arguments ?? []));
     }
@@ -181,3 +181,104 @@ export abstract class Stopwatch {
     }
 
 }
+
+interface SettlementEntry {
+    name: string;
+    measurement: Measurement;
+    pending: number;
+    total: number;
+}
+
+/**
+ * Tracks the settlement of async work initiated by contributions during application startup.
+ *
+ * A contribution "settles" when all promises it returned from lifecycle methods (initialize, configure, onStart, etc.)
+ * have resolved. Individual settlement is only logged when a contribution returned promises from more than one lifecycle
+ * method; otherwise the single lifecycle measurement already describes the work. An aggregate "all settled" message is
+ * logged once all tracked promises across all contributions have resolved.
+ *
+ * Typical usage:
+ * 1. Create the context at the start of the application lifecycle.
+ * 2. Before each lifecycle call, call {@link ensureEntry} to start the per-contribution clock.
+ * 3. After each lifecycle call, call {@link trackSettlement} with the return value.
+ * 4. After the startup sequence completes, call {@link armAllSettled} to enable the aggregate message.
+ */
+export class MeasurementContext<T extends object = object> {
+
+    private readonly entries = new Map<T, SettlementEntry>();
+    private readonly allSettledMeasurement: Measurement;
+    private allSettledPending = 0;
+    private allSettledArmed = false;
+
+    constructor(
+        protected readonly stopwatch: Stopwatch,
+        protected readonly owner: string,
+        protected readonly thresholdMillis: number
+    ) {
+        this.allSettledMeasurement = this.stopwatch.start(`${owner.toLowerCase()}-all-settled`);
+    }
+
+    /**
+     * Ensure that settlement tracking has been started for the given contribution.
+     * Starts the per-contribution measurement clock on the first call for each contribution.
+     */
+    ensureEntry(item: T): void {
+        if (!this.entries.has(item)) {
+            const name = item.constructor.name;
+            this.entries.set(item, {
+                name,
+                measurement: this.stopwatch.start(`${name}.settled`, { thresholdMillis: this.thresholdMillis }),
+                pending: 0,
+                total: 0
+            });
+        }
+    }
+
+    /**
+     * Track a promise returned by a contribution's lifecycle method.
+     * Must be called after the corresponding {@link Stopwatch.startAsync} has completed so that
+     * the settlement log appears after the lifecycle measurement log.
+     */
+    trackSettlement(item: T, result: MaybePromise<unknown>): void {
+        if (result instanceof Promise) {
+            const entry = this.entries.get(item)!;
+            entry.pending++;
+            entry.total++;
+            this.allSettledPending++;
+            const onSettled = (): void => {
+                this.onPromiseSettled(item);
+            };
+            result.then(onSettled, onSettled);
+        }
+    }
+
+    /**
+     * Arm the aggregate "all settled" log message. Call this after the startup sequence has finished
+     * collecting all promises. If all promises have already settled, the message is logged immediately.
+     */
+    armAllSettled(): void {
+        this.allSettledArmed = true;
+        if (this.allSettledPending === 0) {
+            this.allSettledMeasurement.info(`All ${this.owner.toLowerCase()} contributions settled`);
+        }
+    }
+
+    private onPromiseSettled(item: T): void {
+        const entry = this.entries.get(item);
+        if (entry && --entry.pending === 0) {
+            const { name, measurement, total } = entry;
+            this.entries.delete(item);
+            if (total > 1) {
+                if (measurement.stop() > this.thresholdMillis) {
+                    measurement.warn(`${this.owner} ${name} took longer than expected to settle`);
+                } else {
+                    measurement.debug(`${this.owner} ${name} settled`);
+                }
+            }
+        }
+        if (--this.allSettledPending === 0 && this.allSettledArmed) {
+            this.allSettledMeasurement.info(`All ${this.owner.toLowerCase()} contributions settled`);
+        }
+    }
+
+}

package/src/common/preferences/index.ts

@@ -25,3 +25,4 @@ export * from './preference-service';
 export * from './injectable-preference-proxy';
 export * from './preference-proxy';
 export * from './preference-configurations';
+export * from './preference-utils';

package/src/common/preferences/preference-utils.ts

@@ -0,0 +1,28 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { nls } from '../nls';
+import { isOSX, isWindows } from '../os';
+
+/**
+ * Hint appended to API key preference descriptions on Linux, where environment variables
+ * set in `~/.bashrc` are not available to desktop-launched applications.
+ */
+export const LINUX_ENV_HINT = !isWindows && !isOSX
+    ? ' ' + nls.localize('theia/ai-core/preferences/linuxEnvHint',
+        'On Linux, make sure the variable is defined in `~/.profile` (not just `~/.bashrc`) if you launch the application from a desktop shortcut.' +
+        ' See the [documentation](https://theia-ide.org/docs/user_ai/#setting-api-keys) for details.')
+    : '';

package/src/common/resource.ts

@@ -311,13 +311,19 @@ export class InMemoryResources implements ResourceResolver {
 }
 
 export const MEMORY_TEXT = 'mem-txt';
+export const MEMORY_TEXT_READONLY = 'mem-txt-readonly';
 
 /**
  * Resource implementation for 'mem-txt' URI scheme where content is saved in URI query.
  */
 export class InMemoryTextResource implements Resource {
+
     constructor(readonly uri: URI) { }
 
+    get readOnly(): boolean {
+        return this.uri.scheme === MEMORY_TEXT_READONLY;
+    }
+
     async readContents(options?: { encoding?: string | undefined; } | undefined): Promise<string> {
         return this.uri.query;
     }
@@ -330,8 +336,8 @@ export class InMemoryTextResource implements Resource {
 @injectable()
 export class InMemoryTextResourceResolver implements ResourceResolver {
     resolve(uri: URI): MaybePromise<Resource> {
-        if (uri.scheme !== MEMORY_TEXT) {
-            throw new Error(`Expected a URI with ${MEMORY_TEXT} scheme. Was: ${uri}.`);
+        if (uri.scheme !== MEMORY_TEXT && uri.scheme !== MEMORY_TEXT_READONLY) {
+            throw new Error(`Expected a URI with ${MEMORY_TEXT} or ${MEMORY_TEXT_READONLY} scheme. Was: ${uri}.`);
         }
         return new InMemoryTextResource(uri);
     }

package/src/electron-browser/menu/electron-main-menu-factory.ts

@@ -233,7 +233,11 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
                 }
             };
 
-            const role = this.roleFor(menu.id);
+            // Only assign Electron roles when no custom args are present.
+            // Custom args indicate that command handlers have context-dependent
+            // behavior (e.g. chat view copying the whole message when there is
+            // no DOM selection) that would be bypassed by the native role.
+            const role = args.length === 0 ? this.roleFor(menu.id) : undefined;
             if (role) {
                 menuItem.role = role;
                 delete menuItem.execute;

package/src/electron-browser/messaging/electron-messaging-frontend-module.ts

@@ -26,11 +26,14 @@ import { LocalConnectionProvider, RemoteConnectionProvider, ServiceConnectionPro
 import { WebSocketConnectionProvider } from '../../browser/messaging/ws-connection-provider';
 import { ConnectionCloseService, connectionCloseServicePath } from '../../common/messaging/connection-management';
 import { WebSocketConnectionSource } from '../../browser/messaging/ws-connection-source';
+import { SocketWriteBuffer } from '../../common/messaging/socket-write-buffer';
 
 const backendServiceProvider = Symbol('backendServiceProvider2');
 const localServiceProvider = Symbol('localServiceProvider');
 
 export const messagingFrontendModule = new ContainerModule(bind => {
+    // Transient: each connection source gets its own private buffer instance.
+    bind(SocketWriteBuffer).toSelf();
     bind(ConnectionCloseService).toDynamicValue(ctx => WebSocketConnectionProvider.createProxy(ctx.container, connectionCloseServicePath)).inSingletonScope();
     bind(ElectronWebSocketConnectionSource).toSelf().inSingletonScope();
     bind(WebSocketConnectionSource).toService(ElectronWebSocketConnectionSource);

package/src/electron-browser/window/electron-window-module.ts

@@ -32,6 +32,7 @@ import { ExternalAppOpenHandler } from './external-app-open-handler';
 import { ElectronUriHandlerContribution } from '../electron-uri-handler';
 import { bindRootContributionProvider } from '../../common';
 import { WindowTitleContribution } from '../../browser/window/window-title-service';
+import { WindowFocusService } from '../../browser/window/window-focus-service';
 import { WindowZoomStatusBarItem } from './window-zoom-status-bar-item';
 import '../../../src/electron-browser/style/window-zoom-action-bar.css';
 
@@ -50,6 +51,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(ExternalAppOpenHandler).toSelf().inSingletonScope();
     bind(OpenHandler).toService(ExternalAppOpenHandler);
     bindRootContributionProvider(bind, WindowTitleContribution);
+    bind(WindowFocusService).toSelf().inSingletonScope();
     bind(WindowZoomStatusBarItem).toSelf().inSingletonScope();
     bind(FrontendApplicationContribution).toService(WindowZoomStatusBarItem);
 });

package/src/electron-main/electron-api-main.ts

@@ -136,6 +136,8 @@ export class TheiaMainApi implements ElectronMainApplicationContribution {
             }
             popup.popup({
                 window: electronWindow,
+                x,
+                y,
                 callback: () => {
                     this.openPopups.delete(menuId);
                     event.sender.send(CHANNEL_ON_CLOSE_POPUP, menuId);
@@ -343,13 +345,13 @@ export namespace TheiaRendererAPI {
         const disposables = new DisposableCollection();
 
         return new Promise<boolean>(resolve => {
-            wc.send(CHANNEL_REQUEST_CLOSE, stopReason, confirmChannel, cancelChannel);
             createDisposableListener(ipcMain, confirmChannel, e => {
                 resolve(true);
             }, disposables);
             createDisposableListener(ipcMain, cancelChannel, e => {
                 resolve(false);
             }, disposables);
+            wc.send(CHANNEL_REQUEST_CLOSE, stopReason, confirmChannel, cancelChannel);
         }).finally(() => disposables.dispose());
     }
 
@@ -360,13 +362,13 @@ export namespace TheiaRendererAPI {
         const disposables = new DisposableCollection();
 
         return new Promise<boolean>(resolve => {
-            mainWindow.send(CHANNEL_REQUEST_SECONDARY_CLOSE, secondaryWindow.mainFrame.name, confirmChannel, cancelChannel);
             createDisposableListener(ipcMain, confirmChannel, e => {
                 resolve(true);
             }, disposables);
             createDisposableListener(ipcMain, cancelChannel, e => {
                 resolve(false);
             }, disposables);
+            mainWindow.send(CHANNEL_REQUEST_SECONDARY_CLOSE, secondaryWindow.mainFrame.name, confirmChannel, cancelChannel);
         }).finally(() => disposables.dispose());
     }
 

package/src/electron-main/electron-main-application-module.ts

@@ -15,8 +15,10 @@
 // *****************************************************************************
 
 import { ContainerModule } from 'inversify';
+import { performance } from 'perf_hooks';
 import { generateUuid } from '../common/uuid';
 import { bindRootContributionProvider } from '../common/contribution-provider';
+import { Stopwatch, SimpleStopwatch } from '../common/performance';
 import { RpcConnectionHandler } from '../common/messaging/proxy-factory';
 import { ElectronSecurityToken } from '../electron-common/electron-token';
 import { ElectronMainWindowService, electronMainWindowServicePath } from '../electron-common/electron-main-window-service';
@@ -34,6 +36,7 @@ const electronSecurityToken: ElectronSecurityToken = { value: generateUuid() };
 (global as any)[ElectronSecurityToken] = electronSecurityToken;
 
 export default new ContainerModule(bind => {
+    bind(Stopwatch).toConstantValue(new SimpleStopwatch('electron main', () => performance.now()));
     bind(ElectronMainApplication).toSelf().inSingletonScope();
     bind(ElectronMessagingContribution).toSelf().inSingletonScope();
     bind(ElectronMainApplicationContribution).toService(ElectronMessagingContribution);