@eclipse-glsp/server 2.6.0 → 2.7.0-next.7

package/src/browser/di/browser-action-dispatch-scope.ts

@@ -0,0 +1,67 @@
+/********************************************************************************
+ * 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 { injectable } from 'inversify';
+import { ActionDispatchScope } from '../../common/actions/action-dispatcher';
+import { ClientAction } from '../../common/protocol/client-action';
+
+/**
+ * Browser-compatible {@link ActionDispatchScope} backed by a single boolean flag, used because
+ * available `AsyncLocalStorage` polyfills do not work reliably across browser engines (e.g. V8).
+ *
+ * The flag cannot distinguish "still inside the handler's async continuation" from "unrelated
+ * event fired during the handler's await". Any dispatch arriving in such a gap is observed as
+ * reentrant and routed inline. Client-originated actions are explicitly treated as non-reentrant
+ * to cover the dominant case, but server-side dispatches from non-handler contexts (timer
+ * callbacks, event listeners, adopter code) cannot be filtered this way and may interleave with
+ * the in-flight handler.
+ *
+ * The dispatcher normally serializes handler execution; the inline interleaving breaks that
+ * guarantee. A handler that pauses on `await` may resume to find that another handler has mutated
+ * state in between (model state, command stack, caches), leading to unexpected behavior.
+ * Avoid dispatching from non-handler contexts where possible.
+ */
+@injectable()
+export class BrowserActionDispatchScope implements ActionDispatchScope {
+    protected active = false;
+
+    // Assumes serial invocation by the dispatcher's queue processor; concurrent enter() calls
+    // would corrupt the prior-restore logic and leave the flag stuck.
+    enter<R>(callback: () => R): R {
+        const prior = this.active;
+        this.active = true;
+        let result: R;
+        try {
+            result = callback();
+        } catch (error) {
+            this.active = prior;
+            throw error;
+        }
+        if (result instanceof Promise) {
+            // Cast required because TS cannot prove the .finally() result matches the generic R.
+            return result.finally(() => {
+                this.active = prior;
+            }) as unknown as R;
+        }
+        this.active = prior;
+        return result;
+    }
+
+    isReentrant(action: Action): boolean {
+        return this.active && !ClientAction.is(action);
+    }
+}

package/src/browser/index.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2024 EclipseSource and others.
+ * Copyright (c) 2022-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
@@ -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-action-dispatch-scope';
 export * from './launch/worker-server-launcher';
 export * from './reexport';

package/src/common/actions/action-dispatcher.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2023 STMicroelectronics and others.
+ * Copyright (c) 2022-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
@@ -15,19 +15,21 @@
  ********************************************************************************/
 import {
     Action,
+    Deferred,
     Disposable,
     MaybeArray,
+    RejectAction,
     RequestAction,
     ResponseAction,
     SetModelAction,
     UpdateModelAction,
     flatPush
 } from '@eclipse-glsp/protocol';
-import { inject, injectable } from 'inversify';
+import { inject, injectable, postConstruct } from 'inversify';
 import { ClientId } from '../di/service-identifiers';
+import { ActionQueue } from '../utils/action-queue';
 import { GLSPServerError } from '../utils/glsp-server-error';
 import { Logger } from '../utils/logger';
-import { PromiseQueue } from '../utils/promise-queue';
 import { ActionHandler } from './action-handler';
 import { ActionHandlerRegistry } from './action-handler-registry';
 import { ClientActionForwarder } from './client-action-handler';
@@ -41,6 +43,8 @@ export const ActionDispatcher = Symbol('ActionDispatcher');
 export interface ActionDispatcher {
     /**
      * Processes the given action by dispatching it to all registered handlers.
+     * Responses matching a pending {@link request} short-circuit and resolve that
+     * request without being passed to handlers.
      *
      * @param action The action that should be dispatched.
      * @returns A promise indicating when the action processing is complete.
@@ -65,10 +69,92 @@ export interface ActionDispatcher {
      */
     dispatchAfterNextUpdate(actions: Action[]): void;
     dispatchAfterNextUpdate(...actions: Action[]): void;
+
+    /**
+     * Dispatches a request action and returns a promise that resolves when a matching response
+     * action is dispatched or rejects if the response is a {@link RejectAction}. The response is
+     * _not_ passed to the registered action handlers. Instead, it is the responsibility of the
+     * caller of this method to handle the response properly.
+     *
+     * If the request's `kind` is registered in `ClientActionKinds`, it is forwarded to the client
+     * via {@link ClientActionForwarder}. If server-side handlers are registered, they are also
+     * executed.
+     *
+     * Only the first matching response resolves the request. Any additional or late responses
+     * are dispatched as normal actions.
+     *
+     * The promise waits indefinitely until a response arrives or the dispatcher is disposed.
+     * Use {@link requestUntil} if a timeout is needed.
+     *
+     * Note: mutates `action.requestId` (if unset) and `action.timeout`.
+     *
+     * @param action The request action to dispatch.
+     * @returns A promise that resolves with the matching response action.
+     */
+    request<Res extends ResponseAction>(action: RequestAction<Res>): Promise<Res>;
+
+    /**
+     * Dispatches a request and waits for a response until the timeout given in `timeoutMs` has
+     * been reached. The returned promise is resolved when a response with a matching identifier
+     * is dispatched or when the timeout has been reached. That response is _not_ passed to the
+     * registered action handlers. Instead, it is the responsibility of the caller of this method
+     * to handle the response properly.
+     * If `rejectOnTimeout` is set to `false` (default) the returned promise will be resolved with
+     * no value, otherwise it will be rejected.
+     *
+     * Note: mutates `action.requestId` (if unset) and `action.timeout`.
+     *
+     * @param action The request action to dispatch.
+     * @param timeoutMs Maximum wait time in milliseconds. Defaults to
+     *        {@link RequestAction.timeout} if set, otherwise 2000 ms.
+     * @param rejectOnTimeout Whether to reject the promise on timeout.
+     * @returns The matching response, or `undefined` on soft timeout.
+     */
+    requestUntil<Res extends ResponseAction>(
+        action: RequestAction<Res>,
+        timeoutMs?: number,
+        rejectOnTimeout?: boolean
+    ): Promise<Res | undefined>;
 }
 
+export const ActionDispatchScope = Symbol('ActionDispatchScope');
+
+/**
+ * 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 {@link DefaultActionDispatcher.processActionQueue} loop wraps each action in {@link enter}
+ * so that reentrant `dispatch()` calls (handler responses, injected dispatcher calls) can be
+ * recognized via {@link isReentrant} and executed inline instead of being queued.
+ *
+ * Used by the {@link DefaultActionDispatcher} implementation.
+ */
+export interface ActionDispatchScope {
+    /**
+     * Executes the callback inside the dispatch scope. While the callback (and its full async
+     * continuation) is running, {@link isReentrant} returns `true` for reentrant calls.
+     */
+    enter<R>(callback: () => R): R;
+
+    /**
+     * Returns `true` if the given dispatch is reentrant — i.e. it originates from within a
+     * running {@link enter} callback (handler response or 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 scope state.
+     */
+    isReentrant(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.
+ */
 @injectable()
 export class DefaultActionDispatcher implements ActionDispatcher, Disposable {
+    protected static readonly STALE_TIMEOUT_GRACE_MS = 30_000;
+
     @inject(ActionHandlerRegistry)
     protected actionHandlerRegistry: ActionHandlerRegistry;
 
@@ -81,15 +167,50 @@ export class DefaultActionDispatcher implements ActionDispatcher, Disposable {
     @inject(ClientId)
     protected clientId: string;
 
-    protected actionQueue = new PromiseQueue();
+    @inject(ActionDispatchScope)
+    protected dispatchScope: ActionDispatchScope;
+
+    protected actionQueue = new ActionQueue<Action>();
+
     protected postUpdateQueue: Action[] = [];
+    protected readonly pendingRequests = new Map<string, Deferred<ResponseAction | undefined>>();
+    protected readonly requestTimeouts = new Map<string, NodeJS.Timeout>();
+    protected nextRequestId = 1;
+
+    @postConstruct()
+    protected initialize(): void {
+        // Fire-and-forget: the loop is meant to run for the dispatcher's lifetime; surface any
+        // unexpected termination via the logger instead of an unhandled rejection.
+        this.processActionQueue().catch(error => this.logger.error('Action queue processor terminated unexpectedly', error));
+    }
+
+    protected generateRequestId(): string {
+        return `server_${this.clientId}_${this.nextRequestId++}`;
+    }
 
     dispatch(action: Action): Promise<void> {
-        // Dont queue actions that are just delegated to the client
-        if (this.clientActionForwarder.shouldForwardToClient(action)) {
+        // Intercept first to avoid deadlock: a handler may be awaiting this response.
+        if (this.interceptPendingResponse(action)) {
+            return Promise.resolve();
+        }
+        // Reentrant dispatches run inline to preserve ordering with the containing action.
+        if (this.dispatchScope.isReentrant(action)) {
             return this.doDispatch(action);
         }
-        return this.actionQueue.enqueue(() => this.doDispatch(action));
+        // External dispatches are queued and processed sequentially.
+        return this.actionQueue.push(action);
+    }
+
+    protected async processActionQueue(): Promise<void> {
+        // Process each action inside the dispatch scope so reentrant dispatch() calls are recognized.
+        for await (const entry of this.actionQueue.consume()) {
+            try {
+                await this.dispatchScope.enter(() => this.doDispatch(entry.item));
+                entry.resolve();
+            } catch (error) {
+                entry.reject(error);
+            }
+        }
     }
 
     protected async doDispatch(action: Action): Promise<void> {
@@ -107,35 +228,37 @@ export class DefaultActionDispatcher implements ActionDispatcher, Disposable {
             responses.push(...response);
         }
 
-        if (this.postUpdateQueue.length > 0 && (UpdateModelAction.is(action) || SetModelAction.is(action))) {
-            responses.push(...this.postUpdateQueue);
-            this.postUpdateQueue = [];
-        }
+        // Append post-update actions to responses so they are dispatched in the same inline
+        // batch as the handler responses, preserving sequential order.
+        responses.push(...this.drainPostUpdateQueue(action));
 
         await this.dispatchResponses(responses);
     }
 
-    protected async executeHandler(handler: ActionHandler, request: Action): Promise<Action[]> {
-        const responseActions = await handler.execute(request);
-        return responseActions.map(action => respond(request, action));
+    protected async executeHandler(handler: ActionHandler, action: Action): Promise<Action[]> {
+        const responseActions = await handler.execute(action);
+        return responseActions.map(response => respond(action, response));
     }
 
-    protected dispatchResponses(actions: Action[]): Promise<void> {
-        if (actions.length === 0) {
-            return Promise.resolve();
+    protected async dispatchResponses(actions: Action[]): Promise<void> {
+        // Sequential dispatch inside the current dispatch scope. Each response goes inline via
+        // the reentrant path, or is intercepted if it resolves a pending request().
+        for (const action of actions) {
+            await this.dispatch(action);
         }
-        const responseQueue = new PromiseQueue();
-        const responses = actions.map(action => responseQueue.enqueue(() => this.doDispatch(action)));
-        return Promise.all(responses).then(() => Promise.resolve());
     }
 
-    dispatchAll(...actions: MaybeArray<Action>[]): Promise<void> {
+    async dispatchAll(...actions: MaybeArray<Action>[]): Promise<void> {
         if (actions.length === 0) {
-            return Promise.resolve();
+            return;
         }
         const flat: Action[] = [];
         flatPush(flat, actions);
-        return Promise.all(flat.map(action => this.dispatch(action))).then(() => Promise.resolve());
+        // Sequential dispatch: external calls were already FIFO via the queue, but reentrant
+        // calls also need deterministic ordering so handlers see each other's effects in order.
+        for (const action of flat) {
+            await this.dispatch(action);
+        }
     }
 
     dispatchAfterNextUpdate(...actions: MaybeArray<Action>[]): void {
@@ -144,8 +267,152 @@ export class DefaultActionDispatcher implements ActionDispatcher, Disposable {
         }
     }
 
+    request<Res extends ResponseAction>(action: RequestAction<Res>): Promise<Res> {
+        return this.doRequest(action, undefined, true) as Promise<Res>;
+    }
+
+    requestUntil<Res extends ResponseAction>(
+        action: RequestAction<Res>,
+        timeoutMs: number = action.timeout ?? 2000,
+        rejectOnTimeout = false
+    ): Promise<Res | undefined> {
+        return this.doRequest(action, timeoutMs, rejectOnTimeout);
+    }
+
+    protected doRequest<Res extends ResponseAction>(
+        action: RequestAction<Res>,
+        timeoutMs: number | undefined,
+        rejectOnTimeout: boolean
+    ): Promise<Res | undefined> {
+        if (!action.requestId || action.requestId === '') {
+            action.requestId = this.generateRequestId();
+        }
+        // Stamp the effective timeout onto the action so the receiving side
+        // (handleServerRequest/handleClientRequest) can respect it.
+        action.timeout = timeoutMs;
+
+        const deferred = new Deferred<ResponseAction | undefined>();
+        this.pendingRequests.set(action.requestId, deferred);
+
+        if (timeoutMs !== undefined) {
+            const timeout = setTimeout(() => {
+                if (this.pendingRequests.delete(action.requestId)) {
+                    // Keep the requestTimeouts entry briefly as a stale marker so a late response
+                    // can be filtered, then drop it after a grace period to avoid leaking markers
+                    // for requests whose late responses never arrive.
+                    const cleanup = setTimeout(
+                        () => this.requestTimeouts.delete(action.requestId),
+                        DefaultActionDispatcher.STALE_TIMEOUT_GRACE_MS
+                    );
+                    cleanup.unref?.();
+                    const message = `Request '${action.requestId}' (${action.kind}) timed out after ${timeoutMs}ms`;
+                    if (rejectOnTimeout) {
+                        deferred.reject(new Error(message));
+                    } else {
+                        this.logger.info(message);
+                        deferred.resolve(undefined);
+                    }
+                }
+            }, timeoutMs);
+
+            this.requestTimeouts.set(action.requestId, timeout);
+        }
+
+        // dispatch() routes correctly on its own: external callers queue, handler-internal
+        // callers run inline via the ActionDispatchScope. The matching response resolves
+        // the deferred out-of-band via interceptPendingResponse().
+        const dispatchPromise = this.dispatch(action);
+
+        dispatchPromise.catch(error => {
+            if (this.pendingRequests.delete(action.requestId)) {
+                const timeout = this.requestTimeouts.get(action.requestId);
+                if (timeout !== undefined) {
+                    clearTimeout(timeout);
+                    this.requestTimeouts.delete(action.requestId);
+                }
+                deferred.reject(error);
+            }
+        });
+
+        return deferred.promise as Promise<Res | undefined>;
+    }
+
+    /**
+     * If the given action is a {@link SetModelAction} or {@link UpdateModelAction} and there are actions
+     * queued via {@link dispatchAfterNextUpdate}, drain and return them.
+     *
+     * @returns The drained actions, or an empty array if nothing to drain.
+     */
+    protected drainPostUpdateQueue(action: Action): Action[] {
+        if (this.postUpdateQueue.length > 0 && (UpdateModelAction.is(action) || SetModelAction.is(action))) {
+            const actions = [...this.postUpdateQueue];
+            this.postUpdateQueue = [];
+            return actions;
+        }
+        return [];
+    }
+
+    /**
+     * Checks whether the given action is a response matching a pending {@link request} or
+     * {@link requestUntil} call. If matched, resolves (or rejects) the corresponding deferred
+     * and returns `true` so the caller can short-circuit normal dispatch.
+     *
+     * For responses with a valid `responseId` but no matching pending request, checks for a stale
+     * timeout entry (timed-out request) and clears the `responseId` so the action is not forwarded
+     * by {@link ClientActionForwarder}. If no stale entry exists, the `responseId` is left intact
+     * for normal forwarding.
+     */
+    protected interceptPendingResponse(action: Action): boolean {
+        if (!ResponseAction.hasValidResponseId(action)) {
+            return false;
+        }
+        const deferred = this.pendingRequests.get(action.responseId);
+        if (deferred !== undefined) {
+            this.pendingRequests.delete(action.responseId);
+            const timeout = this.requestTimeouts.get(action.responseId);
+            if (timeout !== undefined) {
+                clearTimeout(timeout);
+                this.requestTimeouts.delete(action.responseId);
+            }
+            // Intercepted responses skip doDispatch, so drain post-update actions here when the
+            // response is an UpdateModel/SetModel. RejectAction does not trigger a drain; pending
+            // post-update actions stay queued until the next successful update.
+            const postUpdateActions = this.drainPostUpdateQueue(action);
+            if (RejectAction.is(action)) {
+                deferred.reject(new Error(`${action.message}${action.detail ? ': ' + action.detail : ''}`));
+            } else {
+                deferred.resolve(action);
+            }
+            if (postUpdateActions.length > 0) {
+                // Fire-and-forget: callers of request() expect the resolved response, not the
+                // unrelated post-update fan-out; awaiting here would couple them unnecessarily.
+                this.dispatchResponses(postUpdateActions).catch(error =>
+                    this.logger.error('Failed to dispatch post-update actions', error)
+                );
+            }
+            return true;
+        }
+        // Late response for a timed-out request: clear responseId so ClientActionForwarder does
+        // not re-emit it to the client.
+        const staleTimeout = this.requestTimeouts.get(action.responseId);
+        if (staleTimeout !== undefined) {
+            clearTimeout(staleTimeout);
+            this.requestTimeouts.delete(action.responseId);
+            this.logger.debug(`Late response for timed-out request '${action.responseId}', dispatching as normal action`);
+            action.responseId = '';
+        }
+        return false;
+    }
+
     dispose(): void {
-        this.actionQueue.clear();
+        // Reject queued actions: no further processing should happen after dispose.
+        this.actionQueue.rejectPending(new Error('ActionDispatcher disposed'));
+        this.actionQueue.stop();
+        this.pendingRequests.forEach((deferred, id) => deferred.reject(new Error(`Request '${id}' cancelled: dispatcher disposed`)));
+        this.pendingRequests.clear();
+        this.requestTimeouts.forEach(timeout => clearTimeout(timeout));
+        this.requestTimeouts.clear();
+        this.postUpdateQueue = [];
     }
 }
 
@@ -158,7 +425,7 @@ export class DefaultActionDispatcher implements ActionDispatcher, Disposable {
  */
 export function respond(request: Action, response: Action): Action {
     if (RequestAction.is(request) && ResponseAction.is(response)) {
-        (response as any).responseId = request.requestId;
+        response.responseId = request.requestId;
     }
     return response;
 }

package/src/common/actions/client-action-handler.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2023 STMicroelectronics and others.
+ * Copyright (c) 2022-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
@@ -54,6 +54,6 @@ export class ClientActionForwarder {
         if (ClientAction.is(action)) {
             return false;
         }
-        return this.actionKinds.has(action.kind) || ResponseAction.is(action);
+        return this.actionKinds.has(action.kind) || ResponseAction.hasValidResponseId(action);
     }
 }

package/src/common/actions/global-action-provider.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2023 STMicroelectronics and others.
+ * Copyright (c) 2022-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
@@ -51,7 +51,7 @@ export class DefaultGlobalActionProvider implements GlobalActionProvider {
         const container = serverContainer.createChild();
         const clientSessionModule = createClientSessionModule({
             clientId: 'tempId',
-            // eslint-disable-next-line @typescript-eslint/no-empty-function
+
             glspClient: { process: () => {} },
             clientActionKinds: []
         });

package/src/common/command/recording-command.spec.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023-2024 EclipseSource and others.
+ * Copyright (c) 2023-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
@@ -53,7 +53,6 @@ describe('RecordingCommand', () => {
     });
 
     it('should be undoable after execution', async () => {
-        // eslint-disable-next-line @typescript-eslint/no-empty-function
         const command = new TestRecordingCommand(jsonObject, () => {});
         expect(command.canUndo()).to.be.false;
         await command.execute();

package/src/common/di/service-identifiers.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2023 STMicroelectronics and others.
+ * Copyright (c) 2022-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

package/src/common/features/clipboard/request-clipboard-data-action-handler.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2023 STMicroelectronics and others.
+ * Copyright (c) 2022-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
@@ -44,7 +44,7 @@ export class RequestClipboardDataActionHandler implements ActionHandler {
         selectedElements.forEach(element => {
             schemas.push(this.modelSerializer.createSchema(element));
         });
-        // eslint-disable-next-line no-null/no-null
+
         clipboardData['application/json'] = JSON.stringify(schemas, undefined, 2);
         return [SetClipboardDataAction.create(clipboardData)];
     }

package/src/common/features/contextactions/context-actions-provider-registry.spec.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2023 STMicroelectronics and others.
+ * Copyright (c) 2022-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
@@ -15,11 +15,11 @@
  ********************************************************************************/
 import { GModelElement } from '@eclipse-glsp/graph';
 import { Args, LabeledAction, Point } from '@eclipse-glsp/protocol';
+import { expect } from 'chai';
 import { CommandPaletteActionProvider } from './command-palette-action-provider';
 import { ContextActionsProvider } from './context-actions-provider';
 import { ContextActionsProviderRegistry } from './context-actions-provider-registry';
 import { DefaultToolPaletteItemProvider } from './tool-palette-item-provider';
-import { expect } from 'chai';
 
 describe('Test DefaultContextActionsProviderRegistry', () => {
     it('check if default registry is empty', () => {

package/src/common/features/layout/computed-bounds-action-handler.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2023 STMicroelectronics and others.
+ * Copyright (c) 2022-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

package/src/common/features/model/model-submission-handler.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2024 STMicroelectronics and others.
+ * Copyright (c) 2022-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

package/src/common/features/model/request-model-action-handler.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2025 STMicroelectronics and others.
+ * Copyright (c) 2022-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

package/src/common/features/progress/progress-service.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 EclipseSource and others.
+ * Copyright (c) 2023-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

package/src/common/index.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2024 STMicroelectronics and others.
+ * Copyright (c) 2022-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
@@ -95,6 +95,7 @@ export * from './session/client-session-factory';
 export * from './session/client-session-initializer';
 export * from './session/client-session-listener';
 export * from './session/client-session-manager';
+export * from './utils/action-queue';
 export * from './utils/args-util';
 export * from './utils/client-options-util';
 export * from './utils/console-logger';