@eclipse-glsp/server 2.6.0-next.3 → 2.7.0-next.6

package/src/node/actions/action-dispatcher.spec.ts

@@ -0,0 +1,656 @@
+/********************************************************************************
+ * 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
+ * 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, Deferred, RequestAction, ResponseAction, UpdateModelAction } from '@eclipse-glsp/protocol';
+import { expect } from 'chai';
+import { Container, ContainerModule } from 'inversify';
+import * as sinon from 'sinon';
+import { ActionDispatchScope, 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 { 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 { NodeActionDispatchScope } from '../di/node-action-dispatch-scope';
+
+function waitSync(timeInMillis: number): void {
+    const start = Date.now();
+    let now = start;
+    while (now - start < timeInMillis) {
+        now = Date.now();
+    }
+}
+
+describe('test DefaultActionDispatcher', () => {
+    const container = new Container();
+    const clientId = 'myClientId';
+    const actionHandlerRegistry = new ActionHandlerRegistry();
+    let registry_get_stub: sinon.SinonStub<[string], ActionHandler[]>;
+    const sandbox = sinon.createSandbox();
+
+    const clientActionForwarderStub = sinon.createStubInstance(ClientActionForwarder);
+
+    container.load(
+        new ContainerModule(bind => {
+            bind(Logger).toConstantValue(new mock.StubLogger());
+            bind(ClientSessionManager).toConstantValue(new mock.StubClientSessionManager());
+            bind(ClientId).toConstantValue(clientId);
+            bind(ActionHandlerRegistry).toConstantValue(actionHandlerRegistry);
+            bind(ClientActionKinds).toConstantValue(new Set(['response', 'response1', 'response2']));
+            bind(ClientActionForwarder).toConstantValue(clientActionForwarderStub);
+            bind(ActionDispatchScope).to(NodeActionDispatchScope);
+        })
+    );
+    const actionDispatcher = container.resolve(DefaultActionDispatcher);
+
+    beforeEach(() => {
+        registry_get_stub = sandbox.stub(actionHandlerRegistry, 'get');
+    });
+
+    afterEach(() => {
+        sandbox.restore();
+    });
+
+    describe('test with one-way actions (no response actions)', () => {
+        it('dispatch- unhandled action', async () => {
+            mock.expectToThrowAsync(() => actionDispatcher.dispatch({ kind: 'unhandled' }));
+        });
+
+        it('dispatch - one action', async () => {
+            // Mock setup
+            const action = 'action';
+            const handler = new mock.StubActionHandler([action]);
+            const getHandler = (kind: string): ActionHandler[] => (kind === action ? [handler] : []);
+            registry_get_stub.callsFake(getHandler);
+            const spy_handler_execute = sinon.spy(handler, 'execute');
+            // Test execution
+            await actionDispatcher.dispatch({ kind: action });
+            expect(spy_handler_execute.calledOnce).true;
+        });
+
+        describe('test multi dispatch with single-handled actions', () => {
+            // Mock Setup
+            const action1 = 'a1';
+            const action2 = 'a2';
+            const action3 = 'a3';
+
+            const handler1 = new mock.StubActionHandler([action1]);
+            const handler2 = new mock.StubActionHandler([action2]);
+            const handler3 = new mock.StubActionHandler([action3]);
+
+            const spy_handler1_execute = sinon.stub(handler1, 'execute').returns([]);
+            const spy_handler2_execute = sinon.stub(handler2, 'execute').returns([]);
+            const spy_handler3_execute = sinon.stub(handler3, 'execute').returns([]);
+            const handlerMockImpl = (kind: string): ActionHandler[] => {
+                switch (kind) {
+                    case action1:
+                        return [handler1];
+                    case action2:
+                        return [handler2];
+                    case action3:
+                        return [handler3];
+                    default:
+                        return [];
+                }
+            };
+
+            it('dispatch - multiple actions', async () => {
+                // Mock setup
+                registry_get_stub.callsFake(handlerMockImpl);
+                // Test execution
+                actionDispatcher.dispatch({ kind: action1 });
+                actionDispatcher.dispatch({ kind: action2 });
+                await actionDispatcher.dispatch({ kind: action3 });
+                // Check if all handlers have been called
+                expect(spy_handler1_execute.called).true;
+                expect(spy_handler2_execute.called).true;
+                expect(spy_handler3_execute.called).true;
+                // Check if all handlers have been called in the right order
+                sinon.assert.callOrder(spy_handler1_execute, spy_handler2_execute, spy_handler3_execute);
+            });
+
+            it('dispatchAll- multiple actions', async () => {
+                // Mock setup
+                registry_get_stub.callsFake(handlerMockImpl);
+                // Test execution
+                await actionDispatcher.dispatchAll([{ kind: action1 }, { kind: action2 }, { kind: action3 }]);
+                // Check if all handlers have been called
+                expect(spy_handler1_execute.calledOnce);
+                expect(spy_handler2_execute.calledOnce);
+                expect(spy_handler3_execute.calledOnce);
+                // Check if all handlers have been called in the right order
+                sinon.assert.callOrder(spy_handler1_execute, spy_handler2_execute, spy_handler3_execute);
+            });
+
+            it('dispatch - multiple actions (racing execution times)', async () => {
+                // Mock setup
+                registry_get_stub.callsFake(handlerMockImpl);
+                spy_handler1_execute.callsFake((_action: Action) => {
+                    waitSync(500);
+                    return [];
+                });
+                spy_handler2_execute.callsFake((_action: Action) => {
+                    waitSync(200);
+                    return [];
+                });
+                spy_handler3_execute.callsFake((_action: Action) => {
+                    waitSync(100);
+                    return [];
+                });
+                // Test execution
+                actionDispatcher.dispatch({ kind: action1 });
+                actionDispatcher.dispatch({ kind: action2 });
+                await actionDispatcher.dispatch({ kind: action3 });
+                // Check if all handlers have been called
+                expect(spy_handler1_execute.calledOnce);
+                expect(spy_handler2_execute.calledOnce);
+                expect(spy_handler3_execute.calledOnce);
+                // Check if all handlers have been called in the right order
+                sinon.assert.callOrder(spy_handler1_execute, spy_handler2_execute, spy_handler3_execute);
+            });
+        });
+
+        it('dispatch- one action & multiple handlers', async () => {
+            // Mock setup
+            const action1 = 'a1';
+
+            const handler1 = new mock.StubActionHandler([action1]);
+            const handler2 = new mock.StubActionHandler([action1]);
+
+            registry_get_stub.callsFake((kind: string) => (kind === action1 ? [handler1, handler2] : []));
+            const spy_handler1_execute = sinon.spy(handler1, 'execute');
+            const spy_handler2_execute = sinon.spy(handler2, 'execute');
+            // Test execution
+            await actionDispatcher.dispatch({ kind: action1 });
+            expect(spy_handler1_execute.calledOnce);
+            expect(spy_handler2_execute.calledOnce);
+            sinon.assert.callOrder(spy_handler1_execute, spy_handler2_execute);
+        });
+    });
+
+    describe('test with handler response actions ', () => {
+        it('dispatch - one action & one handler response action', async () => {
+            // Mock setup
+            const request = 'request';
+            const response = 'response';
+
+            const requestHandler = new mock.StubActionHandler([request]);
+            const responseHandler = new mock.StubActionHandler([response]);
+
+            const spy_requestHandler_execute = sinon.stub(requestHandler, 'execute').returns([{ kind: response }]);
+            const spy_responseHandler_execute = sinon.spy(responseHandler, 'execute');
+            registry_get_stub.callsFake((kind: string) => {
+                switch (kind) {
+                    case request:
+                        return [requestHandler];
+                    case response:
+                        return [responseHandler];
+                    default:
+                        return [];
+                }
+            });
+            // Test execution
+            await actionDispatcher.dispatch({ kind: request });
+            // Add a delay so that the action dispatcher has time to dispatch the handler response
+            await mock.delay(200);
+            // Check if all handlers have been called
+            expect(spy_requestHandler_execute.calledOnce);
+            expect(spy_responseHandler_execute.calledOnce);
+        });
+
+        it('dispatch - multiple actions & multiple response', async () => {
+            // Mock setup
+            const request1 = 'request1';
+            const request2 = 'request2';
+            const response1 = 'response1';
+            const response2 = 'response2';
+
+            const responseHandler1 = new mock.StubActionHandler([response1]);
+            const responseHandler2 = new mock.StubActionHandler([response2]);
+            const requestHandler1 = new mock.StubActionHandler([request1]);
+            const requestHandler2 = new mock.StubActionHandler([request2]);
+
+            const spy_requestHandler1_execute = sinon.stub(requestHandler1, 'execute').returns([{ kind: response1 }, { kind: response2 }]);
+            const spy_requestHandler2_execute = sinon.stub(requestHandler2, 'execute').returns([{ kind: response2 }]);
+            const spy_responseHandler1_execute = sinon.spy(responseHandler1, 'execute');
+            const spy_responseHandler2_execute = sinon.spy(responseHandler2, 'execute');
+            registry_get_stub.callsFake((kind: string) => {
+                switch (kind) {
+                    case request1:
+                        return [requestHandler1];
+                    case request2:
+                        return [requestHandler2];
+                    case response1:
+                        return [responseHandler1, responseHandler2];
+                    case response2:
+                        return [responseHandler2];
+                    default:
+                        return [];
+                }
+            });
+            // Test execution
+            actionDispatcher.dispatch({ kind: request1 });
+            await actionDispatcher.dispatch({ kind: request2 });
+
+            // Add a delay so that the action dispatcher has time to dispatch the handler response
+            await mock.delay(100);
+            // Check if all handlers have been called correctly
+            expect(spy_requestHandler1_execute.calledOnce);
+            expect(spy_requestHandler2_execute.calledOnce);
+            expect(spy_responseHandler1_execute.calledOnce);
+            expect(spy_responseHandler2_execute.calledThrice);
+            // Check if all handlers have been called in the right order
+            sinon.assert.callOrder(spy_requestHandler1_execute, spy_requestHandler2_execute);
+            sinon.assert.callOrder(spy_responseHandler1_execute, spy_responseHandler2_execute);
+        });
+    });
+
+    describe('test dispatch after next update', () => {
+        it('dispatchAfterNextUpdate', async () => {
+            // Mock setup
+            const updateModelAction = UpdateModelAction.create({ id: 'newRoot', type: 'myType' });
+            const intermediateAction = 'intermediate';
+            const postUpdateAction = 'postUpdate';
+            const handler = new mock.StubActionHandler([updateModelAction.kind, intermediateAction]);
+            const postUpdateHandler = new mock.StubActionHandler([postUpdateAction]);
+
+            const getHandler = (kind: string): ActionHandler[] => {
+                if (kind === updateModelAction.kind || kind === intermediateAction) {
+                    return [handler];
+                } else if (kind === postUpdateAction) {
+                    return [postUpdateHandler];
+                }
+
+                return [];
+            };
+            registry_get_stub.callsFake(getHandler);
+            const spy_postUpdateHandler_execute = sinon.spy(postUpdateHandler, 'execute');
+
+            // Test execution
+            actionDispatcher.dispatchAfterNextUpdate({ kind: postUpdateAction });
+            expect(spy_postUpdateHandler_execute.called).to.be.false;
+            await actionDispatcher.dispatch({ kind: intermediateAction });
+            expect(spy_postUpdateHandler_execute.called).to.be.false;
+            await actionDispatcher.dispatch(updateModelAction);
+            expect(spy_postUpdateHandler_execute.calledOnce);
+            // Check that action does not get dispatched again
+            await actionDispatcher.dispatch(updateModelAction);
+            expect(spy_postUpdateHandler_execute.calledOnce);
+        });
+    });
+
+    describe('test request/response', () => {
+        it('request - resolves when matching response is dispatched', async () => {
+            const requestAction: RequestAction<ResponseAction> = {
+                kind: 'testRequest',
+                requestId: 'req_1'
+            };
+            const responseAction: ResponseAction = {
+                kind: 'testResponse',
+                responseId: 'req_1'
+            };
+
+            // Configure forwarder: testRequest is forwarded to the client
+            clientActionForwarderStub.shouldForwardToClient.callsFake(action => action.kind === 'testRequest');
+            clientActionForwarderStub.handle.callsFake(action => action.kind === 'testRequest');
+            registry_get_stub.callsFake(() => []);
+
+            const responsePromise = actionDispatcher.request(requestAction);
+            await actionDispatcher.dispatch(responseAction);
+
+            const result = await responsePromise;
+            expect(result.responseId).to.equal('req_1');
+        });
+
+        it('request - response bypasses queue even when queue is busy', async () => {
+            const requestAction: RequestAction<ResponseAction> = {
+                kind: 'testRequest',
+                requestId: 'req_deadlock'
+            };
+            const responseAction: ResponseAction = {
+                kind: 'testResponse',
+                responseId: 'req_deadlock'
+            };
+
+            clientActionForwarderStub.shouldForwardToClient.callsFake(action => action.kind === 'testRequest');
+            clientActionForwarderStub.handle.callsFake(action => action.kind === 'testRequest');
+
+            const handlerRunning = new Deferred<void>();
+
+            const slowAction = 'slowAction';
+            const slowHandler = new mock.StubActionHandler([slowAction]);
+            slowHandler.execute = async () => {
+                const resultPromise = actionDispatcher.request(requestAction);
+                handlerRunning.resolve();
+                const result = await resultPromise;
+                expect(result.responseId).to.equal('req_deadlock');
+                return [];
+            };
+            registry_get_stub.callsFake((kind: string) => (kind === slowAction ? [slowHandler] : []));
+
+            const dispatchPromise = actionDispatcher.dispatch({ kind: slowAction });
+            await handlerRunning.promise;
+
+            // Response must resolve even though the queue is busy
+            await actionDispatcher.dispatch(responseAction);
+            await dispatchPromise;
+        });
+
+        it('request - resolves for locally handled request (server→server)', async () => {
+            const localRequestKind = 'localRequest';
+            const localResponseKind = 'localResponse';
+
+            const handler = new mock.StubActionHandler([localRequestKind]);
+            sinon.stub(handler, 'execute').callsFake(() => {
+                const response: ResponseAction = { kind: localResponseKind, responseId: '' };
+                return [response];
+            });
+            registry_get_stub.callsFake((kind: string) => (kind === localRequestKind ? [handler] : []));
+
+            const requestAction: RequestAction<ResponseAction> = {
+                kind: localRequestKind,
+                requestId: ''
+            };
+
+            const result = await actionDispatcher.request(requestAction);
+            expect(result).to.exist;
+            expect(result.responseId).to.equal(requestAction.requestId);
+        });
+
+        it('request - resolves for locally handled request called from inside a handler', async () => {
+            const innerRequestKind = 'innerRequest';
+            const innerResponseKind = 'innerResponse';
+            const outerActionKind = 'outerAction';
+
+            const innerHandler = new mock.StubActionHandler([innerRequestKind]);
+            sinon.stub(innerHandler, 'execute').callsFake(() => {
+                const response: ResponseAction = { kind: innerResponseKind, responseId: '' };
+                return [response];
+            });
+
+            const outerHandler = new mock.StubActionHandler([outerActionKind]);
+            outerHandler.execute = async () => {
+                const innerRequest: RequestAction<ResponseAction> = {
+                    kind: innerRequestKind,
+                    requestId: ''
+                };
+                const result = await actionDispatcher.request(innerRequest);
+                expect(result).to.exist;
+                return [];
+            };
+
+            registry_get_stub.callsFake((kind: string) => {
+                if (kind === outerActionKind) return [outerHandler];
+                if (kind === innerRequestKind) return [innerHandler];
+                return [];
+            });
+
+            // This must not deadlock
+            await actionDispatcher.dispatch({ kind: outerActionKind });
+        });
+
+        it('requestUntil - rejects on timeout when rejectOnTimeout is true', async () => {
+            const requestAction: RequestAction<ResponseAction> = {
+                kind: 'testRequest',
+                requestId: 'req_hard'
+            };
+
+            clientActionForwarderStub.shouldForwardToClient.callsFake(action => action.kind === 'testRequest');
+            clientActionForwarderStub.handle.callsFake(action => action.kind === 'testRequest');
+            registry_get_stub.callsFake(() => []);
+
+            try {
+                await actionDispatcher.requestUntil(requestAction, 100, true);
+                expect.fail('Should have thrown');
+            } catch (error: unknown) {
+                expect((error as Error).message).to.include('timed out');
+            }
+        });
+
+        it('requestUntil - resolves undefined on timeout when rejectOnTimeout is false', async () => {
+            const requestAction: RequestAction<ResponseAction> = {
+                kind: 'testRequest',
+                requestId: 'req_soft'
+            };
+
+            clientActionForwarderStub.shouldForwardToClient.callsFake(action => action.kind === 'testRequest');
+            clientActionForwarderStub.handle.callsFake(action => action.kind === 'testRequest');
+            registry_get_stub.callsFake(() => []);
+
+            const result = await actionDispatcher.requestUntil(requestAction, 100, false);
+            expect(result).to.be.undefined;
+        });
+
+        it('request - auto-generates requestId when empty', async () => {
+            const requestAction: RequestAction<ResponseAction> = {
+                kind: 'testRequest',
+                requestId: ''
+            };
+
+            clientActionForwarderStub.shouldForwardToClient.callsFake(action => action.kind === 'testRequest');
+            clientActionForwarderStub.handle.callsFake(action => action.kind === 'testRequest');
+            registry_get_stub.callsFake(() => []);
+
+            const responsePromise = actionDispatcher.request(requestAction);
+            expect(requestAction.requestId).to.match(/^server_.*_\d+$/);
+
+            await actionDispatcher.dispatch({
+                kind: 'testResponse',
+                responseId: requestAction.requestId
+            } as ResponseAction);
+
+            const result = await responsePromise;
+            expect(result).to.exist;
+        });
+
+        it('request - rejects when dispatch fails (no handler, not a client action)', async () => {
+            const requestAction: RequestAction<ResponseAction> = {
+                kind: 'unknownRequest',
+                requestId: 'req_fail'
+            };
+
+            // NOT forwarded to client, no handler registered → dispatch throws
+            clientActionForwarderStub.shouldForwardToClient.returns(false);
+            clientActionForwarderStub.handle.returns(false);
+            registry_get_stub.callsFake(() => []);
+
+            try {
+                await actionDispatcher.request(requestAction);
+                expect.fail('Should have thrown');
+            } catch (error: unknown) {
+                expect((error as Error).message).to.include('No handler registered');
+            }
+        });
+
+        it('requestUntil - late response after timeout has responseId cleared', async () => {
+            const requestAction: RequestAction<ResponseAction> = {
+                kind: 'testRequest',
+                requestId: 'req_late'
+            };
+
+            clientActionForwarderStub.shouldForwardToClient.callsFake(action => action.kind === 'testRequest');
+            clientActionForwarderStub.handle.callsFake(action => action.kind === 'testRequest');
+            // Register a no-op handler for testResponse so the late response can be dispatched normally
+            const noopHandler = new mock.StubActionHandler(['testResponse']);
+            registry_get_stub.callsFake((kind: string) => (kind === 'testResponse' ? [noopHandler] : []));
+
+            // Request times out
+            try {
+                await actionDispatcher.requestUntil(requestAction, 50, true);
+                expect.fail('Should have thrown');
+            } catch (error: unknown) {
+                expect((error as Error).message).to.include('timed out');
+            }
+
+            // Late response arrives — responseId should be cleared, dispatched as normal action
+            const lateResponse: ResponseAction = { kind: 'testResponse', responseId: 'req_late' };
+            await actionDispatcher.dispatch(lateResponse);
+            expect(lateResponse.responseId).to.equal('');
+        });
+
+        it('request - resolves when response intercept happens from inside doDispatch', async () => {
+            // A local handler for the request kind returns the matching response action directly.
+            // The response is dispatched via dispatchResponses() -> dispatch() and intercepted
+            // via the reentrant path (not via the external dispatch() entry).
+            const requestKind = 'inlineRequest';
+            const responseKind = 'inlineResponse';
+
+            const handler = new mock.StubActionHandler([requestKind]);
+            sinon.stub(handler, 'execute').callsFake(() => [{ kind: responseKind, responseId: '' } as ResponseAction]);
+            registry_get_stub.callsFake((kind: string) => (kind === requestKind ? [handler] : []));
+
+            const requestAction: RequestAction<ResponseAction> = { kind: requestKind, requestId: '' };
+            const result = await actionDispatcher.request(requestAction);
+
+            expect(result.responseId).to.equal(requestAction.requestId);
+        });
+    });
+
+    describe('test reentrancy and ordering', () => {
+        it('dispatch from within a handler runs inline before the next queued action', async () => {
+            const outerKind = 'reentrantOuter';
+            const innerKind = 'reentrantInner';
+            const followerKind = 'reentrantFollower';
+
+            const events: string[] = [];
+
+            const innerHandler = new mock.StubActionHandler([innerKind]);
+            sinon.stub(innerHandler, 'execute').callsFake(() => {
+                events.push('inner');
+                return [];
+            });
+
+            const outerHandler = new mock.StubActionHandler([outerKind]);
+            outerHandler.execute = async () => {
+                events.push('outer-start');
+                await actionDispatcher.dispatch({ kind: innerKind });
+                events.push('outer-end');
+                return [];
+            };
+
+            const followerHandler = new mock.StubActionHandler([followerKind]);
+            sinon.stub(followerHandler, 'execute').callsFake(() => {
+                events.push('follower');
+                return [];
+            });
+
+            registry_get_stub.callsFake((kind: string) => {
+                if (kind === outerKind) return [outerHandler];
+                if (kind === innerKind) return [innerHandler];
+                if (kind === followerKind) return [followerHandler];
+                return [];
+            });
+
+            actionDispatcher.dispatch({ kind: outerKind });
+            await actionDispatcher.dispatch({ kind: followerKind });
+
+            expect(events).to.deep.equal(['outer-start', 'inner', 'outer-end', 'follower']);
+        });
+
+        it('handler response actions are dispatched in order without an ephemeral queue', async () => {
+            const requestKind = 'orderedRequest';
+            const firstResponse = 'orderedResponse1';
+            const secondResponse = 'orderedResponse2';
+            const order: string[] = [];
+
+            const requestHandler = new mock.StubActionHandler([requestKind]);
+            sinon.stub(requestHandler, 'execute').callsFake(() => [{ kind: firstResponse }, { kind: secondResponse }]);
+
+            const firstHandler = new mock.StubActionHandler([firstResponse]);
+            sinon.stub(firstHandler, 'execute').callsFake(async () => {
+                await mock.delay(20);
+                order.push(firstResponse);
+                return [];
+            });
+
+            const secondHandler = new mock.StubActionHandler([secondResponse]);
+            sinon.stub(secondHandler, 'execute').callsFake(() => {
+                order.push(secondResponse);
+                return [];
+            });
+
+            registry_get_stub.callsFake((kind: string) => {
+                if (kind === requestKind) return [requestHandler];
+                if (kind === firstResponse) return [firstHandler];
+                if (kind === secondResponse) return [secondHandler];
+                return [];
+            });
+
+            await actionDispatcher.dispatch({ kind: requestKind });
+            expect(order).to.deep.equal([firstResponse, secondResponse]);
+        });
+    });
+
+    describe('test dispose', () => {
+        it('dispose - rejects all pending requests', async () => {
+            const requestAction: RequestAction<ResponseAction> = {
+                kind: 'testRequest',
+                requestId: 'req_dispose'
+            };
+
+            clientActionForwarderStub.shouldForwardToClient.callsFake(action => action.kind === 'testRequest');
+            clientActionForwarderStub.handle.callsFake(action => action.kind === 'testRequest');
+            registry_get_stub.callsFake(() => []);
+
+            const responsePromise = actionDispatcher.request(requestAction);
+            actionDispatcher.dispose();
+
+            try {
+                await responsePromise;
+                expect.fail('Should have thrown');
+            } catch (error: unknown) {
+                expect((error as Error).message).to.include('cancelled');
+                expect((error as Error).message).to.include('req_dispose');
+            }
+        });
+
+        it('dispose - rejects queued dispatch() promises instead of orphaning them', async () => {
+            // Use a fresh dispatcher so the shared one is not affected.
+            const localDispatcher = container.resolve(DefaultActionDispatcher);
+            const slowKind = 'slowDispose';
+            const queuedKind = 'queuedDispose';
+
+            const slowHandler = new mock.StubActionHandler([slowKind]);
+            const slowStarted = new Deferred<void>();
+            const releaseSlow = new Deferred<void>();
+            slowHandler.execute = async () => {
+                slowStarted.resolve();
+                await releaseSlow.promise;
+                return [];
+            };
+
+            registry_get_stub.callsFake((kind: string) => (kind === slowKind ? [slowHandler] : []));
+
+            const slowPromise = localDispatcher.dispatch({ kind: slowKind });
+            await slowStarted.promise;
+            const queuedPromise = localDispatcher.dispatch({ kind: queuedKind });
+
+            localDispatcher.dispose();
+
+            try {
+                await queuedPromise;
+                expect.fail('Queued dispatch should have rejected');
+            } catch (error: unknown) {
+                expect((error as Error).message).to.include('ActionDispatcher disposed');
+            }
+
+            // Let the slow handler finish so the local dispatcher's consumer loop can exit cleanly.
+            releaseSlow.resolve();
+            await slowPromise;
+        });
+    });
+});

package/src/node/di/app-module.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
@@ -16,13 +16,15 @@
 import { BindingContext } from '@eclipse-glsp/protocol/lib/di';
 import { ContainerModule } from 'inversify';
 import * as winston from 'winston';
-import { InjectionContainer, LogLevel, Logger, LoggerFactory, NullLogger, getRequestParentName } from '../../common';
+import { ActionDispatchScope, InjectionContainer, LogLevel, Logger, LoggerFactory, NullLogger, getRequestParentName } from '../../common';
 import { LaunchOptions } from '../launch/cli-parser';
+import { NodeActionDispatchScope } from './node-action-dispatch-scope';
 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(ActionDispatchScope).to(NodeActionDispatchScope).inSingletonScope();
         const context = { bind, unbind, isBound, rebind };
         configureWinstonLogger(context, options);
     });