Fix dispatching for browser entrypoint`

Refactor ActionDispatchContext and implementation for the browser side.
The used ALS polyfill is not reliable and does not work with all
browsers, v8 engines.

Author: tortmayr

packages/server/src/browser/di/app-module.ts

@@ -14,16 +14,15 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-// Side-effect import: patches Promise, timers, XHR, observers on the current realm to preserve async context across awaits.
-import { AsyncLocalStorage } from 'als-browser';
 import { ContainerModule } from 'inversify';
 import { ActionDispatchContext, InjectionContainer, LogLevel, LoggerConfigOptions, configureConsoleLogger } from '../../common/';
+import { BrowserDispatchContext } from './browser-dispatch-context';
 
 export function createAppModule(options: LoggerConfigOptions = {}): ContainerModule {
     const resolvedOptions: LoggerConfigOptions = { consoleLog: true, logLevel: LogLevel.info, ...options };
     return new ContainerModule((bind, unbind, isBound, rebind) => {
         bind(InjectionContainer).toDynamicValue(dynamicContext => dynamicContext.container);
-        bind(ActionDispatchContext).toDynamicValue(() => new AsyncLocalStorage<boolean>());
+        bind(ActionDispatchContext).toDynamicValue(() => new BrowserDispatchContext());
         const context = { bind, unbind, isBound, rebind };
         configureConsoleLogger(context, resolvedOptions);
     });

packages/server/src/browser/di/browser-dispatch-context.ts

@@ -0,0 +1,54 @@
+/********************************************************************************
+ * 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { Action } from '@eclipse-glsp/protocol';
+import { ActionDispatchContext } from '../../common/actions/action-dispatcher';
+import { ClientAction } from '../../common/protocol/client-action';
+
+/**
+ * Browser-compatible {@link ActionDispatchContext} that uses a simple flag instead of
+ * `AsyncLocalStorage`. Currently available polyfill implementations of `AsyncLocalStorage` do not work correctly
+ *  in certain browser/javascript engines (e.g. V8)
+ *
+ * The flag-based approach has one limitation:
+ * it cannot distinguish "within the handler's async continuation" from "new event that arrived during an await gap.
+ * This means, that subsequent client actions might be dispatched inline instead of being queued, if they arrive during an await gap.
+ * To prevent this, we always treat client-originated actions as out-of-context, ensuring they are queued rather than dispatched inline.
+ *
+ * There still is a corner case for server-originated actions that are dispatched in a different async chain e.g timer-based.
+ * However, in practice this means that these actions are dispatched inline instead of being queued, which does not cause any issues.
+ * Since they originated from a different async chain, there were no order guarantees with respect to the current action anyway.
+ */
+export class BrowserDispatchContext implements ActionDispatchContext {
+    protected active = false;
+
+    run<R>(callback: () => R): R {
+        const prior = this.active;
+        this.active = true;
+        const result = callback();
+        if (result instanceof Promise) {
+            return result.finally(() => {
+                this.active = prior;
+            }) as unknown as R;
+        }
+        this.active = prior;
+        return result;
+    }
+
+    isInContext(action: Action): boolean {
+        return this.active && !ClientAction.is(action);
+    }
+}

packages/server/src/browser/index.ts

@@ -14,5 +14,6 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 export * from './di/app-module';
+export * from './di/browser-dispatch-context';
 export * from './launch/worker-server-launcher';
 export * from './reexport';

packages/server/src/common/actions/action-dispatcher.ts

@@ -26,7 +26,7 @@ import {
     flatPush
 } from '@eclipse-glsp/protocol';
 import { inject, injectable, postConstruct } from 'inversify';
-import { ActionDispatchContext, ClientId } from '../di/service-identifiers';
+import { ClientId } from '../di/service-identifiers';
 import { ActionChannel } from '../utils/action-channel';
 import { GLSPServerError } from '../utils/glsp-server-error';
 import { Logger } from '../utils/logger';
@@ -113,6 +113,36 @@ export interface ActionDispatcher {
     ): Promise<Res | undefined>;
 }
 
+export const ActionDispatchContext = Symbol('ActionDispatchContext');
+
+/**
+ * Scope marker that lets the {@link ActionDispatcher} know whether a call to `dispatch()`
+ * originates from inside a running handler (reentrant) or from outside (external).
+ *
+ * The consumer loop wraps each action in {@link run} so that reentrant `dispatch()` calls
+ * (handler responses, injected dispatcher calls) can be recognized via {@link isInContext}
+ * and executed inline instead of being queued.
+ *
+ * Used by the {@link DefaultActionDispatcher} implementation.
+ */
+export interface ActionDispatchContext {
+    /**
+     * Executes the callback inside the dispatch context. While the callback (and its full
+     * async continuation) is running, {@link isInContext} returns `true` for reentrant calls.
+     */
+    run<R>(callback: () => R): R;
+
+    /**
+     * Returns `true` if the caller is executing inside a {@link run} callback, meaning the
+     * dispatch is reentrant (e.g. a handler response or an injected dispatcher call) and
+     * should run inline rather than being queued.
+     *
+     * Implementations may inspect the action to apply additional guards, e.g. to ensure
+     * client-originated actions are always queued regardless of context state.
+     */
+    isInContext(action: Action): boolean;
+}
+
 /**
  * Default {@link ActionDispatcher}. External dispatches are queued and processed one at a
  * time; dispatches made from within a running handler run inline with the containing action.
@@ -156,7 +186,7 @@ export class DefaultActionDispatcher implements ActionDispatcher, Disposable {
             return Promise.resolve();
         }
         // Reentrant dispatches run inline to preserve ordering with the containing action.
-        if (this.dispatchContext.getStore()) {
+        if (this.dispatchContext.isInContext(action)) {
             return this.doDispatch(action);
         }
         // External dispatches are queued and processed sequentially.
@@ -167,7 +197,7 @@ export class DefaultActionDispatcher implements ActionDispatcher, Disposable {
         // Run each action inside the dispatch context so reentrant dispatch() calls are recognized.
         for await (const entry of this.channel.consume()) {
             try {
-                await this.dispatchContext.run(true, () => this.doDispatch(entry.item));
+                await this.dispatchContext.run(() => this.doDispatch(entry.item));
                 entry.resolve();
             } catch (error) {
                 entry.reject(error);

packages/server/src/common/di/service-identifiers.ts

@@ -37,14 +37,3 @@ export const NavigationTargetProviders = Symbol('NavigationTargetProviders');
 export type ValidateLabelEditAdapterFactory = (validator: LabelEditValidator) => ValidateLabelEditAdapter;
 
 export const Operations = Symbol('Operations');
-
-/**
- * Scope marker that lets the {@link ActionDispatcher} know whether a call to `dispatch()`
- * originates from inside a running handler (reentrant) or from outside (external).
- */
-export interface ActionDispatchContext {
-    run<R>(store: boolean, callback: () => R): R;
-    getStore(): boolean | undefined;
-}
-
-export const ActionDispatchContext = Symbol('ActionDispatchContext');

packages/server/src/node/actions/action-dispatcher.spec.ts

@@ -14,18 +14,18 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { Action, Deferred, RequestAction, ResponseAction, UpdateModelAction } from '@eclipse-glsp/protocol';
-import { AsyncLocalStorage } from 'async_hooks';
 import { expect } from 'chai';
 import { Container, ContainerModule } from 'inversify';
 import * as sinon from 'sinon';
-import { DefaultActionDispatcher } from '../../common/actions/action-dispatcher';
+import { ActionDispatchContext, DefaultActionDispatcher } from '../../common/actions/action-dispatcher';
 import { ActionHandler } from '../../common/actions/action-handler';
 import { ActionHandlerRegistry } from '../../common/actions/action-handler-registry';
 import { ClientActionForwarder } from '../../common/actions/client-action-handler';
-import { ActionDispatchContext, ClientActionKinds, ClientId } from '../../common/di/service-identifiers';
+import { ClientActionKinds, ClientId } from '../../common/di/service-identifiers';
 import { ClientSessionManager } from '../../common/session/client-session-manager';
 import * as mock from '../../common/test/mock-util';
 import { Logger } from '../../common/utils/logger';
+import { NodeDispatchContext } from '../di/node-dispatch-context';
 
 function waitSync(timeInMillis: number): void {
     const start = Date.now();
@@ -52,7 +52,7 @@ describe('test DefaultActionDispatcher', () => {
             bind(ActionHandlerRegistry).toConstantValue(actionHandlerRegistry);
             bind(ClientActionKinds).toConstantValue(new Set(['response', 'response1', 'response2']));
             bind(ClientActionForwarder).toConstantValue(clientActionForwarderStub);
-            bind(ActionDispatchContext).toDynamicValue(() => new AsyncLocalStorage<boolean>());
+            bind(ActionDispatchContext).toDynamicValue(() => new NodeDispatchContext());
         })
     );
     const actionDispatcher = container.resolve(DefaultActionDispatcher);

packages/server/src/node/di/app-module.ts

@@ -14,17 +14,17 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { BindingContext } from '@eclipse-glsp/protocol/lib/di';
-import { AsyncLocalStorage } from 'async_hooks';
 import { ContainerModule } from 'inversify';
 import * as winston from 'winston';
 import { ActionDispatchContext, InjectionContainer, LogLevel, Logger, LoggerFactory, NullLogger, getRequestParentName } from '../../common';
 import { LaunchOptions } from '../launch/cli-parser';
+import { NodeDispatchContext } from './node-dispatch-context';
 import { WinstonLogger } from './winston-logger';
 
 export function createAppModule(options: LaunchOptions): ContainerModule {
     return new ContainerModule((bind, unbind, isBound, rebind) => {
         bind(InjectionContainer).toDynamicValue(dynamicContext => dynamicContext.container);
-        bind(ActionDispatchContext).toDynamicValue(() => new AsyncLocalStorage<boolean>());
+        bind(ActionDispatchContext).toDynamicValue(() => new NodeDispatchContext());
         const context = { bind, unbind, isBound, rebind };
         configureWinstonLogger(context, options);
     });

packages/server/src/node/di/node-dispatch-context.ts

@@ -0,0 +1,33 @@
+/********************************************************************************
+ * 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { AsyncLocalStorage } from 'async_hooks';
+import { ActionDispatchContext } from '../../common/actions/action-dispatcher';
+
+/**
+ * Node.js {@link ActionDispatchContext} backed by native `AsyncLocalStorage`.
+ */
+export class NodeDispatchContext implements ActionDispatchContext {
+    protected storage = new AsyncLocalStorage<boolean>();
+
+    run<R>(callback: () => R): R {
+        return this.storage.run(true, callback);
+    }
+
+    isInContext(): boolean {
+        return this.storage.getStore() === true;
+    }
+}

packages/server/src/node/index.ts

@@ -15,6 +15,7 @@
  ********************************************************************************/
 export * from './abstract-json-model-storage';
 export * from './di/app-module';
+export * from './di/node-dispatch-context';
 export * from './di/winston-logger';
 export * from './gmodel/gmodel-storage';
 export * from './launch/cli-parser';