@theia/core 1.71.0-next.4 → 1.71.0-next.43

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@theia/core",
-  "version": "1.71.0-next.4+cdbc982c6",
+  "version": "1.71.0-next.43+e960af22f",
   "description": "Theia is a cloud & desktop IDE framework implemented in TypeScript.",
   "main": "lib/common/index.js",
   "typings": "lib/common/index.d.ts",
   "dependencies": {
-    "@babel/runtime": "^7.10.0",
+    "@babel/runtime": "^7.29.2",
     "@lumino/algorithm": "^2.0.4",
     "@lumino/commands": "^2.3.3",
     "@lumino/coreutils": "^2.2.2",
@@ -16,31 +16,31 @@
     "@lumino/signaling": "^2.1.5",
     "@lumino/virtualdom": "^2.0.4",
     "@lumino/widgets": "2.7.5",
-    "@parcel/watcher": "^2.5.0",
-    "@theia/application-package": "1.71.0-next.4+cdbc982c6",
-    "@theia/request": "1.71.0-next.4+cdbc982c6",
-    "@types/body-parser": "^1.16.4",
+    "@parcel/watcher": "^2.5.6",
+    "@theia/application-package": "1.71.0-next.43+e960af22f",
+    "@theia/request": "1.71.0-next.43+e960af22f",
+    "@types/body-parser": "^1.19.6",
     "@types/express": "^4.17.21",
     "@types/fs-extra": "^4.0.2",
     "@types/lodash.debounce": "4.0.3",
-    "@types/lodash.throttle": "^4.1.3",
-    "@types/markdown-it": "^14.1.0",
+    "@types/lodash.throttle": "^4.1.9",
+    "@types/markdown-it": "^14.1.2",
     "@types/markdown-it-emoji": "^3.0.1",
-    "@types/react": "^18.0.15",
-    "@types/react-dom": "^18.0.6",
-    "@types/route-parser": "^0.1.1",
-    "@types/safer-buffer": "^2.1.0",
+    "@types/react": "^18.3.28",
+    "@types/react-dom": "^18.3.7",
+    "@types/route-parser": "^0.1.7",
+    "@types/safer-buffer": "^2.1.3",
     "@types/uuid": "^9.0.8",
-    "@types/ws": "^8.5.5",
+    "@types/ws": "^8.18.1",
     "@types/yargs": "^15",
     "@vscode/codicons": "0.0.45",
-    "ajv": "^6.5.3",
-    "async-mutex": "^0.4.0",
-    "body-parser": "^1.17.2",
-    "cookie": "^1.0.2",
-    "dompurify": "^3.2.4",
+    "ajv": "^6.14.0",
+    "async-mutex": "^0.4.1",
+    "body-parser": "^1.20.4",
+    "cookie": "^1.1.1",
+    "dompurify": "^3.3.3",
     "drivelist": "^12.0.2",
-    "express": "^4.21.0",
+    "express": "^4.22.1",
     "fast-json-stable-stringify": "^2.1.0",
     "file-icons-js": "~1.0.3",
     "font-awesome": "^4.7.0",
@@ -48,32 +48,32 @@
     "fuzzy": "^0.1.3",
     "http-proxy-agent": "^5.0.0",
     "https-proxy-agent": "^5.0.0",
-    "iconv-lite": "^0.6.0",
-    "inversify": "^6.1.3",
-    "jschardet": "^2.1.1",
+    "iconv-lite": "^0.6.3",
+    "inversify": "^6.2.2",
+    "jschardet": "^2.3.0",
     "keytar": "7.9.0",
     "lodash.debounce": "^4.0.8",
     "lodash.throttle": "^4.1.1",
-    "markdown-it": "^14.1.0",
+    "markdown-it": "^14.1.1",
     "markdown-it-anchor": "^9.2.0",
     "markdown-it-emoji": "^3.0.0",
-    "msgpackr": "^1.10.2",
+    "msgpackr": "^1.11.9",
     "p-debounce": "^2.1.0",
     "perfect-scrollbar": "1.5.5",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
-    "react-tooltip": "^4.2.21",
-    "react-virtuoso": "^2.17.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-tooltip": "^4.5.1",
+    "react-virtuoso": "^2.19.1",
     "reflect-metadata": "^0.2.2",
     "route-parser": "^0.0.5",
     "safer-buffer": "^2.1.2",
-    "socket.io": "^4.5.3",
-    "socket.io-client": "^4.5.3",
+    "socket.io": "^4.8.3",
+    "socket.io-client": "^4.8.3",
     "tslib": "^2.6.2",
     "uuid": "^9.0.1",
     "vscode-languageserver-protocol": "3.17.5",
     "vscode-uri": "3.0.8",
-    "ws": "^8.17.1",
+    "ws": "^8.20.0",
     "yargs": "^15.3.1"
   },
   "peerDependencies": {
@@ -221,5 +221,5 @@
   "nyc": {
     "extends": "../../configs/nyc.json"
   },
-  "gitHead": "cdbc982c6456e257ba7ed8e01b8c71aa7ac67283"
+  "gitHead": "e960af22fd0721f7cd4a8f7d66e6e9d10c801962"
 }

package/src/browser/components/card.tsx

@@ -15,6 +15,7 @@
 // *****************************************************************************
 
 import * as React from 'react';
+import { buttonKeyboardProps, isActivationKey } from '../keyboard/keyboard-utils';
 
 export interface CardActionButton {
     /** Icon class (e.g., codicon) */
@@ -69,14 +70,22 @@ export const Card = React.memo(function Card(props: CardProps): React.ReactEleme
     } = props;
 
     const isInteractive = onClick !== undefined;
+    const [hasFocus, setHasFocus] = React.useState(false);
 
     const handleKeyDown = React.useCallback((e: React.KeyboardEvent<HTMLDivElement>) => {
-        if (onClick && (e.key === 'Enter' || e.key === ' ')) {
+        if (onClick && isActivationKey(e)) {
             e.preventDefault();
             onClick();
         }
     }, [onClick]);
 
+    const handleFocus = React.useCallback(() => setHasFocus(true), []);
+    const handleBlur = React.useCallback((e: React.FocusEvent<HTMLDivElement>) => {
+        if (!e.currentTarget.contains(e.relatedTarget as Node)) {
+            setHasFocus(false);
+        }
+    }, []);
+
     const cardClasses = [
         'theia-Card',
         isInteractive && 'theia-Card-interactive',
@@ -94,6 +103,8 @@ export const Card = React.memo(function Card(props: CardProps): React.ReactEleme
             role={isInteractive ? 'button' : undefined}
             tabIndex={isInteractive ? 0 : undefined}
             onKeyDown={isInteractive ? handleKeyDown : undefined}
+            onFocus={actionButtons ? handleFocus : undefined}
+            onBlur={actionButtons ? handleBlur : undefined}
         >
             {icon && (
                 <div className={`theia-Card-icon ${icon}`}></div>
@@ -115,7 +126,7 @@ export const Card = React.memo(function Card(props: CardProps): React.ReactEleme
                                     key={i}
                                     className={`theia-Card-action-btn ${btn.iconClass}`}
                                     title={btn.title}
-                                    aria-label={btn.title}
+                                    {...buttonKeyboardProps(btn.title, hasFocus ? 0 : -1)}
                                     onClick={btn.onClick}
                                 />
                             ))}

package/src/browser/keyboard/index.ts

@@ -18,3 +18,4 @@ export * from './keys';
 export * from './keyboard-layout-service';
 export * from './browser-keyboard-layout-provider';
 export * from './browser-keyboard-frontend-contribution';
+export * from './keyboard-utils';

package/src/browser/keyboard/keyboard-utils.ts

@@ -0,0 +1,37 @@
+// *****************************************************************************
+// 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
+// *****************************************************************************
+
+/**
+ * Query whether the keyboard event represents an element activation.
+ * That is, whether the user pressed `Enter` or `Space` on a focusable
+ * element with `role="button"` or similar interactive role.
+ */
+export function isActivationKey(e: React.KeyboardEvent | KeyboardEvent): boolean {
+    return e.key === 'Enter' || e.key === ' ';
+}
+
+/**
+ * Returns the ARIA/accessibility props that make a non-button HTML element
+ * keyboard-navigable and screen-reader-accessible as a button.
+ *
+ * Spread these onto the element alongside `onClick` and `onKeyDown`:
+ * ```tsx
+ * <div {...buttonKeyboardProps(label)} onClick={handler} onKeyDown={e => isActivationKey(e) && handler()} />
+ * ```
+ */
+export function buttonKeyboardProps(ariaLabel: string, tabIndex = 0): React.HTMLAttributes<HTMLElement> {
+    return { tabIndex, role: 'button', 'aria-label': ariaLabel };
+}

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

@@ -21,10 +21,13 @@ import { LocalConnectionProvider, RemoteConnectionProvider, ServiceConnectionPro
 import { ConnectionSource } from './connection-source';
 import { ConnectionCloseService, connectionCloseServicePath } from '../../common/messaging/connection-management';
 import { WebSocketConnectionProvider } from './ws-connection-provider';
+import { SocketWriteBuffer } from '../../common/messaging/socket-write-buffer';
 
 const backendServiceProvider = Symbol('backendServiceProvider');
 
 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(BrowserFrontendIdProvider).toSelf().inSingletonScope();
     bind(FrontendIdProvider).toService(BrowserFrontendIdProvider);

package/src/browser/messaging/ws-connection-source.ts

@@ -33,7 +33,8 @@ export class WebSocketConnectionSource implements ConnectionSource {
     @inject(FrontendIdProvider)
     protected readonly frontendIdProvider: FrontendIdProvider;
 
-    private readonly writeBuffer = new SocketWriteBuffer();
+    @inject(SocketWriteBuffer)
+    protected readonly writeBuffer: SocketWriteBuffer;
 
     private _socket: Socket;
     get socket(): Socket {
@@ -135,8 +136,8 @@ export class WebSocketConnectionSource implements ConnectionSource {
 
     connectNewChannel(): void {
         if (this.currentChannel) {
-            this.currentChannel.close();
             this.currentChannel.onCloseEmitter.fire({ reason: 'reconnecting channel' });
+            this.currentChannel.close();
         }
         this.writeBuffer.drain();
         this.currentChannel = this.createChannel();

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar.tsx

@@ -16,6 +16,7 @@
 
 import { inject, injectable, postConstruct } from 'inversify';
 import * as React from 'react';
+import { buttonKeyboardProps, isActivationKey } from '../../keyboard/keyboard-utils';
 import { ContextKeyService } from '../../context-key-service';
 import { CommandRegistry, Disposable, DisposableCollection, nls } from '../../../common';
 import { Anchor, ContextMenuAccess, ContextMenuRenderer } from '../../context-menu-renderer';
@@ -150,7 +151,10 @@ export class TabBarToolbar extends ReactWidget {
 
     protected renderMore(): React.ReactNode {
         return !!this.more.size && <div key='__more__' className={TabBarToolbar.Styles.TAB_BAR_TOOLBAR_ITEM + ' enabled'}>
-            <div id='__more__' className={codicon('ellipsis', true)} onClick={this.showMoreContextMenu}
+            <div id='__more__' className={codicon('ellipsis', true)}
+                {...buttonKeyboardProps(nls.localizeByDefault('More Actions...'))}
+                onClick={this.showMoreContextMenu}
+                onKeyDown={this.handleMoreKeyDown}
                 title={nls.localizeByDefault('More Actions...')} />
         </div>;
     }
@@ -162,6 +166,15 @@ export class TabBarToolbar extends ReactWidget {
         this.renderMoreContextMenu(anchor);
     };
 
+    protected handleMoreKeyDown = (event: React.KeyboardEvent) => {
+        if (isActivationKey(event)) {
+            event.preventDefault();
+            event.stopPropagation();
+            const { left, bottom } = (event.currentTarget as HTMLElement).getBoundingClientRect();
+            this.renderMoreContextMenu({ x: left, y: bottom });
+        }
+    };
+
     renderMoreContextMenu(anchor: Anchor): ContextMenuAccess {
         const toDisposeOnHide = new DisposableCollection();
         this.addClass('menu-open');

package/src/browser/shell/tab-bar-toolbar/tab-toolbar-item.tsx

@@ -23,6 +23,7 @@ import { KeybindingRegistry } from '../../keybinding';
 import { ACTION_ITEM } from '../../widgets';
 import { TabBarToolbar } from './tab-bar-toolbar';
 import * as React from 'react';
+import { buttonKeyboardProps, isActivationKey } from '../../keyboard/keyboard-utils';
 import { ActionMenuNode, GroupImpl, MenuNode } from '../../../common/menu';
 
 export interface TabBarToolbarItem {
@@ -195,16 +196,24 @@ export class RenderedToolbarItemImpl extends AbstractToolbarItemImpl<RenderedToo
     };
 
     protected executeCommand(e: React.MouseEvent<HTMLElement>, widget: Widget): void {
+        this.doExecuteCommand(e, widget);
+    };
+
+    protected doExecuteCommand(e: React.SyntheticEvent<HTMLElement>, widget: Widget): void {
         e.preventDefault();
         e.stopPropagation();
-
         if (!this.isEnabled(widget)) {
             return;
         }
-
         if (this.action.command) {
             this.commandRegistry.executeCommand(this.action.command, widget);
         }
+    }
+
+    protected onKeyDownEvent = (e: React.KeyboardEvent<HTMLElement>, widget: Widget) => {
+        if (isActivationKey(e)) {
+            this.doExecuteCommand(e, widget);
+        }
     };
 
     protected renderItem(widget: Widget): React.ReactNode {
@@ -249,7 +258,9 @@ export class RenderedToolbarItemImpl extends AbstractToolbarItemImpl<RenderedToo
             onMouseUp={this.onMouseUpEvent}
             onMouseOut={this.onMouseUpEvent} >
             <div id={this.action.id} className={classNames.join(' ')}
+                {...buttonKeyboardProps(tooltip)}
                 onClick={e => this.executeCommand(e, widget)}
+                onKeyDown={e => this.onKeyDownEvent(e, widget)}
                 title={tooltip} > {innerText}
             </div>
         </div>;

package/src/browser/style/card.css

@@ -101,11 +101,13 @@
     transition: opacity 0.15s;
 }
 
-.theia-Card:hover .theia-Card-footer-time {
+.theia-Card:hover .theia-Card-footer-time,
+.theia-Card:focus-within .theia-Card-footer-time {
     opacity: 0;
 }
 
-.theia-Card:hover .theia-Card-footer-actions {
+.theia-Card:hover .theia-Card-footer-actions,
+.theia-Card:focus-within .theia-Card-footer-actions {
     opacity: 1;
     pointer-events: auto;
 }

package/src/common/event.spec.ts

@@ -29,4 +29,84 @@ describe('Event Objects', () => {
         expect(counter).eq(1);
     });
 
+    describe('Emitter errorHandling option', () => {
+
+        it('should log errors by default', () => {
+            const emitter = new Emitter<void>();
+            const errors: unknown[] = [];
+            const originalError = console.error;
+            console.error = (e: unknown) => errors.push(e);
+
+            try {
+                emitter.event(() => { throw new Error('test error'); });
+                emitter.fire(undefined);
+
+                expect(errors).to.have.lengthOf(1);
+                expect((errors[0] as Error).message).to.equal('test error');
+            } finally {
+                console.error = originalError;
+            }
+        });
+
+        it('should propagate a single error when errorHandling is propagate', () => {
+            const emitter = new Emitter<void>({ errorHandling: 'propagate' });
+
+            emitter.event(() => { throw new Error('boom'); });
+
+            expect(() => emitter.fire(undefined)).to.throw('boom');
+        });
+
+        it('should call all listeners before propagating the error', () => {
+            const emitter = new Emitter<void>({ errorHandling: 'propagate' });
+            let secondCalled = false;
+
+            emitter.event(() => { throw new Error('first fails'); });
+            emitter.event(() => { secondCalled = true; });
+
+            expect(() => emitter.fire(undefined)).to.throw('first fails');
+            expect(secondCalled).to.be.true;
+        });
+
+        it('should throw AggregateError when multiple listeners fail with propagate', () => {
+            const emitter = new Emitter<void>({ errorHandling: 'propagate' });
+
+            emitter.event(() => { throw new Error('error 1'); });
+            emitter.event(() => { throw new Error('error 2'); });
+
+            try {
+                emitter.fire(undefined);
+                expect.fail('Expected an error to be thrown');
+            } catch (err) {
+                expect(err).to.be.instanceOf(AggregateError);
+                const aggregate = err as AggregateError;
+                expect(aggregate.errors).to.have.lengthOf(2);
+                expect(aggregate.errors[0].message).to.equal('error 1');
+                expect(aggregate.errors[1].message).to.equal('error 2');
+            }
+        });
+
+        it('should invoke custom error handler for each error', () => {
+            const errors: unknown[] = [];
+            const emitter = new Emitter<void>({ errorHandling: e => errors.push(e) });
+
+            emitter.event(() => { throw new Error('handled 1'); });
+            emitter.event(() => { throw new Error('handled 2'); });
+            emitter.fire(undefined);
+
+            expect(errors).to.have.lengthOf(2);
+            expect((errors[0] as Error).message).to.equal('handled 1');
+            expect((errors[1] as Error).message).to.equal('handled 2');
+        });
+
+        it('should not throw when no listeners fail with propagate', () => {
+            const emitter = new Emitter<void>({ errorHandling: 'propagate' });
+            let called = false;
+
+            emitter.event(() => { called = true; });
+            emitter.fire(undefined);
+
+            expect(called).to.be.true;
+        });
+    });
+
 });

package/src/common/event.ts

@@ -123,6 +123,8 @@ class CallbackList implements Iterable<Callback> {
     private _callbacks: Function[] | undefined;
     private _contexts: any[] | undefined;
 
+    constructor(private readonly errorHandling: ErrorHandlingStrategy = 'log') {}
+
     get length(): number {
         return this._callbacks && this._callbacks.length || 0;
     }
@@ -179,13 +181,25 @@ class CallbackList implements Iterable<Callback> {
 
     public invoke(...args: any[]): any[] {
         const ret: any[] = [];
+        const errors: unknown[] = [];
         for (const callback of this) {
             try {
                 ret.push(callback(...args));
             } catch (e) {
-                console.error(e);
+                if (this.errorHandling === 'propagate') {
+                    errors.push(e);
+                } else if (typeof this.errorHandling === 'function') {
+                    this.errorHandling(e);
+                } else {
+                    console.error(e);
+                }
             }
         }
+        if (errors.length === 1) {
+            throw errors[0];
+        } else if (errors.length > 1) {
+            throw new AggregateError(errors, 'Multiple event listeners failed');
+        }
         return ret;
     }
 
@@ -199,9 +213,24 @@ class CallbackList implements Iterable<Callback> {
     }
 }
 
+/**
+ * A strategy for handling errors in firing an emitter's event, one of
+ *
+ * - `'log'` (default): errors are caught and logged via `console.error`
+ * - `'propagate'`: all listeners are called; if any throw, the errors are collected
+ *   and re-thrown after all listeners complete (single error re-thrown directly,
+ *   multiple errors wrapped in an `AggregateError`)
+ * - `(error: unknown) => void`: a custom callback invoked for each error
+ */
+export type ErrorHandlingStrategy = 'log' | 'propagate' | ((error: unknown) => void);
+
 export interface EmitterOptions {
     onFirstListenerAdd?: Function;
     onLastListenerRemove?: Function;
+    /**
+     * How errors thrown by event listeners are handled during {@link Emitter.fire}.
+     */
+    errorHandling?: ErrorHandlingStrategy;
 }
 
 export class Emitter<T = any> {
@@ -229,7 +258,7 @@ export class Emitter<T = any> {
         if (!this._event) {
             this._event = Object.assign((listener: (e: T) => any, thisArgs?: any, disposables?: DisposableGroup) => {
                 if (!this._callbacks) {
-                    this._callbacks = new CallbackList();
+                    this._callbacks = new CallbackList(this._options?.errorHandling);
                 }
                 if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {
                     this._options.onFirstListenerAdd(this);

package/src/common/glob.ts

@@ -44,8 +44,8 @@ export interface SiblingClause {
     when: string;
 }
 
-const GLOBSTAR = '**';
-const GLOB_SPLIT = '/';
+export const GLOBSTAR = '**';
+export const GLOB_SPLIT = '/';
 const PATH_REGEX = '[/\\\\]';        // any slash or backslash
 const NO_PATH_REGEX = '[^/\\\\]';    // any non-slash and non-backslash
 const ALL_FORWARD_SLASHES = /\//g;

package/src/common/message-rpc/channel.spec.ts

@@ -18,6 +18,7 @@ import { assert, expect, spy, use } from 'chai';
 import * as spies from 'chai-spies';
 import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from './uint8-array-message-buffer';
 import { ChannelMultiplexer, ForwardingChannel, MessageProvider } from './channel';
+import { RpcProtocol } from './rpc-protocol';
 
 use(spies);
 
@@ -84,5 +85,120 @@ describe('Message Channel', () => {
 
             expect(openChannelSpy).to.be.called.exactly(4);
         });
+
+        it('should reject pending open() promises when underlying channel closes', async () => {
+            const pipe = new ChannelPipe();
+            const leftMultiplexer = new ChannelMultiplexer(pipe.left);
+            // Don't create a right multiplexer, so no AckOpen will arrive
+
+            const openPromise = leftMultiplexer.open('test');
+
+            // Close the underlying channel
+            pipe.left.onCloseEmitter.fire({ reason: 'test close' });
+
+            // The open promise should reject, not hang forever
+            try {
+                await openPromise;
+                assert.fail('Expected open() promise to be rejected');
+            } catch (err) {
+                expect(err).to.be.instanceOf(Error);
+                expect((err as Error).message).to.contain('test close');
+            }
+        });
+
+        it('should fire onClose on sub-channels when underlying channel closes', async () => {
+            const pipe = new ChannelPipe();
+            const leftMultiplexer = new ChannelMultiplexer(pipe.left);
+            const rightMultiplexer = new ChannelMultiplexer(pipe.right);
+
+            const leftChannel = await leftMultiplexer.open('test');
+            const rightChannel = rightMultiplexer.getOpenChannel('test');
+            assert.isDefined(rightChannel);
+
+            const leftCloseSpy = spy(() => { });
+            leftChannel.onClose(leftCloseSpy);
+
+            // Close the underlying channel from the remote side
+            pipe.left.onCloseEmitter.fire({ reason: 'underlying closed' });
+
+            expect(leftCloseSpy).to.have.been.called();
+        });
+    });
+
+    describe('Channel close event ordering', () => {
+        it('should not deliver onClose after close() has been called', () => {
+            const channel = new ForwardingChannel('test', () => { }, () => new Uint8ArrayWriteBuffer());
+
+            const closeSpy = spy(() => { });
+            channel.onClose(closeSpy);
+
+            // Bug pattern: close() first (disposes emitters), then fire (no-op)
+            channel.close();
+            channel.onCloseEmitter.fire({ reason: 'too late' });
+
+            // The listener should not be called because close() already disposed the emitter
+            expect(closeSpy).to.not.have.been.called();
+        });
+
+        it('should deliver onClose when fired before close()', () => {
+            const channel = new ForwardingChannel('test', () => { }, () => new Uint8ArrayWriteBuffer());
+
+            const closeSpy = spy(() => { });
+            channel.onClose(closeSpy);
+
+            // Correct pattern: fire first, then close
+            channel.onCloseEmitter.fire({ reason: 'proper close' });
+            channel.close();
+
+            expect(closeSpy).to.have.been.called();
+        });
+    });
+
+    describe('RPC protocol with write buffer overflow', () => {
+        it('should reject the promise when commit fails due to buffer overflow', async () => {
+            // Simulate a channel whose write buffer throws on commit (e.g. SocketWriteBuffer overflow)
+            const channel = new ForwardingChannel('test', () => { }, () => {
+                const buffer = new Uint8ArrayWriteBuffer();
+                buffer.onCommit(() => {
+                    throw new Error('Max disconnected buffer size exceeded');
+                });
+                return buffer;
+            });
+
+            const protocol = new RpcProtocol(channel, undefined, { mode: 'clientOnly' });
+
+            // sendRequest should return a rejected promise, not throw synchronously
+            const promise = protocol.sendRequest('testMethod', []);
+
+            try {
+                await promise;
+                assert.fail('Expected promise to be rejected');
+            } catch (err) {
+                expect(err).to.be.instanceOf(Error);
+                expect((err as Error).message).to.contain('buffer size exceeded');
+            }
+        });
+
+        it('should not leak pending requests when commit fails', async () => {
+            const channel = new ForwardingChannel('test', () => { }, () => {
+                const buffer = new Uint8ArrayWriteBuffer();
+                buffer.onCommit(() => {
+                    throw new Error('Max disconnected buffer size exceeded');
+                });
+                return buffer;
+            });
+
+            const protocol = new RpcProtocol(channel, undefined, { mode: 'clientOnly' });
+
+            // sendRequest should return a rejected promise and clean up pendingRequests
+            try {
+                await protocol.sendRequest('testMethod', []);
+            } catch {
+                // expected: the promise is rejected due to buffer overflow
+            }
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            expect((protocol as any).pendingRequests.size).to.equal(0);
+        });
     });
 });