@nmtjs/client 0.15.0-beta.8 → 0.15.0

package/dist/core.js

@@ -1,14 +1,13 @@
-import { anyAbortSignal, createFuture, MAX_UINT32, noopFn } from '@nmtjs/common';
+import { anyAbortSignal, createFuture, MAX_UINT32, noopFn, withTimeout, } from '@nmtjs/common';
 import { ClientMessageType, ConnectionType, ErrorCode, ProtocolBlob, ServerMessageType, } from '@nmtjs/protocol';
 import { ProtocolError, ProtocolServerBlobStream, ProtocolServerRPCStream, ProtocolServerStream, versions, } from '@nmtjs/protocol/client';
-import { EventEmitter } from "./events.js";
-import { ClientStreams, ServerStreams } from "./streams.js";
+import { EventEmitter } from './events.js';
+import { ClientStreams, ServerStreams } from './streams.js';
 export { ErrorCode, ProtocolBlob, } from '@nmtjs/protocol';
-export * from "./types.js";
+export * from './types.js';
 export class ClientError extends ProtocolError {
 }
-const DEFAULT_RECONNECT_TIMEOUT = 1000;
-const DEFAULT_MAX_RECONNECT_TIMEOUT = 60000;
+const DEFAULT_RECONNECT_REASON = 'connect_error';
 /**
  * @todo Add error logging in ClientStreamPull rejection handler for easier debugging
  * @todo Consider edge case where callId/streamId overflow at MAX_UINT32 with existing entries
@@ -28,10 +27,16 @@ export class BaseClient extends EventEmitter {
     callId = 0;
     streamId = 0;
     cab = null;
-    reconnectTimeout = DEFAULT_RECONNECT_TIMEOUT;
     connecting = null;
-    state = 'disconnected';
-    #auth;
+    _state = 'disconnected';
+    _lastDisconnectReason = 'server';
+    _disposed = false;
+    pingNonce = 0;
+    pendingPings = new Map();
+    plugins = [];
+    clientDisconnectAsReconnect = false;
+    clientDisconnectOverrideReason = null;
+    authValue;
     constructor(options, transportFactory, transportOptions) {
         super();
         this.options = options;
@@ -40,46 +45,55 @@ export class BaseClient extends EventEmitter {
         this.protocol = versions[options.protocol];
         const { format, protocol } = this.options;
         this.transport = this.transportFactory({ protocol, format }, this.transportOptions);
-        if (this.transport.type === ConnectionType.Bidirectional &&
-            this.options.autoreconnect) {
-            this.on('disconnected', async (reason) => {
-                while (this.state === 'disconnected') {
-                    const timeout = new Promise((resolve) => setTimeout(resolve, this.reconnectTimeout));
-                    this.reconnectTimeout = Math.min(this.reconnectTimeout * 2, DEFAULT_MAX_RECONNECT_TIMEOUT);
-                    await timeout;
-                    await this.connect().catch(noopFn);
-                }
-            });
-            this.on('connected', () => {
-                this.reconnectTimeout = DEFAULT_RECONNECT_TIMEOUT;
-            });
-            if (globalThis.window) {
-                globalThis.window.addEventListener('pageshow', () => {
-                    if (this.state === 'disconnected')
-                        this.connect();
-                });
-            }
+        this.plugins = this.options.plugins?.map((plugin) => plugin(this)) ?? [];
+        for (const plugin of this.plugins) {
+            plugin.onInit?.();
         }
     }
+    dispose() {
+        this._disposed = true;
+        this.stopAllPendingPings('dispose');
+        for (let i = this.plugins.length - 1; i >= 0; i--) {
+            this.plugins[i].dispose?.();
+        }
+    }
+    get state() {
+        return this._state;
+    }
+    get lastDisconnectReason() {
+        return this._lastDisconnectReason;
+    }
+    get transportType() {
+        return this.transport.type;
+    }
+    isDisposed() {
+        return this._disposed;
+    }
+    requestReconnect(reason) {
+        return this.disconnect({ reconnect: true, reason });
+    }
     get auth() {
-        return this.#auth;
+        return this.authValue;
     }
     set auth(value) {
-        this.#auth = value;
+        this.authValue = value;
     }
     connect() {
-        if (this.state === 'connected')
+        if (this._state === 'connected')
             return Promise.resolve();
         if (this.connecting)
             return this.connecting;
+        if (this._disposed)
+            return Promise.reject(new Error('Client is disposed'));
         const _connect = async () => {
             if (this.transport.type === ConnectionType.Bidirectional) {
+                const client = this;
                 this.cab = new AbortController();
                 const protocol = this.protocol;
                 const serverStreams = this.serverStreams;
                 const transport = {
                     send: (buffer) => {
-                        this.#send(buffer).catch(noopFn);
+                        this.send(buffer).catch(noopFn);
                     },
                 };
                 this.messageContext = {
@@ -87,12 +101,19 @@ export class BaseClient extends EventEmitter {
                     encoder: this.options.format,
                     decoder: this.options.format,
                     addClientStream: (blob) => {
-                        const streamId = this.#getStreamId();
+                        const streamId = this.getStreamId();
                         return this.clientStreams.add(blob.source, streamId, blob.metadata);
                     },
                     addServerStream(streamId, metadata) {
                         const stream = new ProtocolServerBlobStream(metadata, {
                             pull: (controller) => {
+                                client.emitStreamEvent({
+                                    direction: 'outgoing',
+                                    streamType: 'server_blob',
+                                    action: 'pull',
+                                    streamId,
+                                    byteLength: 65535,
+                                });
                                 transport.send(protocol.encodeMessage(this, ClientMessageType.ServerStreamPull, { streamId, size: 65535 /* 64kb by default */ }));
                             },
                             close: () => {
@@ -104,13 +125,19 @@ export class BaseClient extends EventEmitter {
                         return ({ signal } = {}) => {
                             if (signal)
                                 signal.addEventListener('abort', () => {
+                                    client.emitStreamEvent({
+                                        direction: 'outgoing',
+                                        streamType: 'server_blob',
+                                        action: 'abort',
+                                        streamId,
+                                    });
                                     transport.send(protocol.encodeMessage(this, ClientMessageType.ServerStreamAbort, { streamId }));
                                     serverStreams.abort(streamId);
                                 }, { once: true });
                             return stream;
                         };
                     },
-                    streamId: this.#getStreamId.bind(this),
+                    streamId: this.getStreamId.bind(this),
                 };
                 return this.transport.connect({
                     auth: this.auth,
@@ -121,17 +148,40 @@ export class BaseClient extends EventEmitter {
                 });
             }
         };
+        let emitDisconnectOnFailure = null;
         this.connecting = _connect()
             .then(() => {
-            this.state = 'connected';
+            this._state = 'connected';
+        })
+            .catch((error) => {
+            if (this.transport.type === ConnectionType.Bidirectional) {
+                emitDisconnectOnFailure = DEFAULT_RECONNECT_REASON;
+            }
+            throw error;
         })
             .finally(() => {
             this.connecting = null;
+            if (emitDisconnectOnFailure && !this._disposed) {
+                this._state = 'disconnected';
+                this._lastDisconnectReason = emitDisconnectOnFailure;
+                void this.onDisconnect(emitDisconnectOnFailure);
+            }
         });
         return this.connecting;
     }
-    async disconnect() {
+    async disconnect(options = {}) {
         if (this.transport.type === ConnectionType.Bidirectional) {
+            // Ensure connect() won't short-circuit while the transport is closing.
+            this._state = 'disconnected';
+            this._lastDisconnectReason = 'client';
+            if (options.reconnect) {
+                this.clientDisconnectAsReconnect = true;
+                this.clientDisconnectOverrideReason = options.reason ?? 'server';
+            }
+            else {
+                this.clientDisconnectAsReconnect = false;
+                this.clientDisconnectOverrideReason = null;
+            }
             this.cab.abort();
             await this.transport.disconnect();
             this.messageContext = null;
@@ -153,11 +203,18 @@ export class BaseClient extends EventEmitter {
         if (this.cab?.signal)
             signals.push(this.cab.signal);
         const signal = signals.length ? anyAbortSignal(...signals) : undefined;
-        const callId = this.#getCallId();
+        const callId = this.getCallId();
         const call = createFuture();
         call.procedure = procedure;
         call.signal = signal;
         this.calls.set(callId, call);
+        this.emitClientEvent({
+            kind: 'rpc_request',
+            timestamp: Date.now(),
+            callId,
+            procedure,
+            body: payload,
+        });
         // Check if signal is already aborted before proceeding
         if (signal?.aborted) {
             this.calls.delete(callId);
@@ -171,7 +228,7 @@ export class BaseClient extends EventEmitter {
                     if (this.transport.type === ConnectionType.Bidirectional &&
                         this.messageContext) {
                         const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.RpcAbort, { callId });
-                        this.#send(buffer).catch(noopFn);
+                        this.send(buffer).catch(noopFn);
                     }
                 }, { once: true });
             }
@@ -179,7 +236,7 @@ export class BaseClient extends EventEmitter {
                 const transformedPayload = this.transformer.encode(procedure, payload);
                 if (this.transport.type === ConnectionType.Bidirectional) {
                     const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.Rpc, { callId, procedure, payload: transformedPayload });
-                    await this.#send(buffer, signal);
+                    await this.send(buffer, signal);
                 }
                 else {
                     const response = await this.transport.call({
@@ -187,10 +244,17 @@ export class BaseClient extends EventEmitter {
                         format: this.options.format,
                         auth: this.auth,
                     }, { callId, procedure, payload: transformedPayload }, { signal, _stream_response: options._stream_response });
-                    this.#handleCallResponse(callId, response);
+                    this.handleCallResponse(callId, response);
                 }
             }
             catch (error) {
+                this.emitClientEvent({
+                    kind: 'rpc_error',
+                    timestamp: Date.now(),
+                    callId,
+                    procedure,
+                    error,
+                });
                 call.reject(error);
             }
         }
@@ -200,6 +264,9 @@ export class BaseClient extends EventEmitter {
                     controller.abort();
                 });
             }
+            if (options._stream_response && typeof value === 'function') {
+                return value;
+            }
             controller.abort();
             return value;
         }, (err) => {
@@ -221,97 +288,304 @@ export class BaseClient extends EventEmitter {
         }
     }
     async onConnect() {
-        this.state = 'connected';
+        this._state = 'connected';
+        this._lastDisconnectReason = 'server';
+        this.emitClientEvent({
+            kind: 'connected',
+            timestamp: Date.now(),
+            transportType: this.transport.type === ConnectionType.Bidirectional
+                ? 'bidirectional'
+                : 'unidirectional',
+        });
+        for (const plugin of this.plugins) {
+            await plugin.onConnect?.();
+        }
         this.emit('connected');
     }
     async onDisconnect(reason) {
-        this.state = 'disconnected';
-        this.emit('disconnected', reason);
-        this.clientStreams.clear(reason);
-        this.serverStreams.clear(reason);
-        this.rpcStreams.clear(reason);
+        const effectiveReason = reason === 'client' && this.clientDisconnectAsReconnect
+            ? (this.clientDisconnectOverrideReason ?? 'server')
+            : reason;
+        this.clientDisconnectAsReconnect = false;
+        this.clientDisconnectOverrideReason = null;
+        this._state = 'disconnected';
+        this._lastDisconnectReason = effectiveReason;
+        this.emitClientEvent({
+            kind: 'disconnected',
+            timestamp: Date.now(),
+            reason: effectiveReason,
+        });
+        // Connection is gone, never keep old message context around.
+        this.messageContext = null;
+        this.stopAllPendingPings(effectiveReason);
+        // Fail-fast: do not keep pending calls around across disconnects.
+        if (this.calls.size) {
+            const error = new ProtocolError(ErrorCode.ConnectionError, 'Disconnected', { reason: effectiveReason });
+            for (const call of this.calls.values()) {
+                call.reject(error);
+            }
+            this.calls.clear();
+        }
+        if (this.cab) {
+            try {
+                this.cab.abort(reason);
+            }
+            catch {
+                this.cab.abort();
+            }
+            this.cab = null;
+        }
+        this.emit('disconnected', effectiveReason);
+        for (let i = this.plugins.length - 1; i >= 0; i--) {
+            await this.plugins[i].onDisconnect?.(effectiveReason);
+        }
+        void this.clientStreams.clear(effectiveReason);
+        void this.serverStreams.clear(effectiveReason);
+        void this.rpcStreams.clear(effectiveReason);
+    }
+    nextPingNonce() {
+        if (this.pingNonce >= MAX_UINT32)
+            this.pingNonce = 0;
+        return this.pingNonce++;
+    }
+    ping(timeout, signal) {
+        if (!this.messageContext ||
+            this.transport.type !== ConnectionType.Bidirectional) {
+            return Promise.reject(new Error('Client is not connected'));
+        }
+        const nonce = this.nextPingNonce();
+        const future = createFuture();
+        this.pendingPings.set(nonce, future);
+        const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.Ping, { nonce });
+        return this.send(buffer, signal)
+            .then(() => withTimeout(future.promise, timeout, new Error('Heartbeat timeout')))
+            .finally(() => {
+            this.pendingPings.delete(nonce);
+        });
+    }
+    stopAllPendingPings(reason) {
+        if (!this.pendingPings.size)
+            return;
+        const error = new Error('Heartbeat stopped', { cause: reason });
+        for (const pending of this.pendingPings.values())
+            pending.reject(error);
+        this.pendingPings.clear();
     }
     async onMessage(buffer) {
         if (!this.messageContext)
             return;
         const message = this.protocol.decodeMessage(this.messageContext, buffer);
+        for (const plugin of this.plugins) {
+            plugin.onServerMessage?.(message, buffer);
+        }
+        this.emitClientEvent({
+            kind: 'server_message',
+            timestamp: Date.now(),
+            messageType: message.type,
+            rawByteLength: buffer.byteLength,
+            body: message,
+        });
         switch (message.type) {
             case ServerMessageType.RpcResponse:
-                this.#handleRPCResponseMessage(message);
+                this.handleRPCResponseMessage(message);
                 break;
             case ServerMessageType.RpcStreamResponse:
-                this.#handleRPCStreamResponseMessage(message);
+                this.handleRPCStreamResponseMessage(message);
+                break;
+            case ServerMessageType.Pong: {
+                const pending = this.pendingPings.get(message.nonce);
+                if (pending) {
+                    this.pendingPings.delete(message.nonce);
+                    pending.resolve();
+                }
+                this.emit('pong', message.nonce);
+                break;
+            }
+            case ServerMessageType.Ping: {
+                if (this.messageContext) {
+                    const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.Pong, { nonce: message.nonce });
+                    this.send(buffer).catch(noopFn);
+                }
                 break;
+            }
             case ServerMessageType.RpcStreamChunk:
+                this.emitStreamEvent({
+                    direction: 'incoming',
+                    streamType: 'rpc',
+                    action: 'push',
+                    callId: message.callId,
+                    byteLength: message.chunk.byteLength,
+                });
                 this.rpcStreams.push(message.callId, message.chunk);
                 break;
             case ServerMessageType.RpcStreamEnd:
+                this.emitStreamEvent({
+                    direction: 'incoming',
+                    streamType: 'rpc',
+                    action: 'end',
+                    callId: message.callId,
+                });
                 this.rpcStreams.end(message.callId);
                 this.calls.delete(message.callId);
                 break;
             case ServerMessageType.RpcStreamAbort:
+                this.emitStreamEvent({
+                    direction: 'incoming',
+                    streamType: 'rpc',
+                    action: 'abort',
+                    callId: message.callId,
+                    reason: message.reason,
+                });
                 this.rpcStreams.abort(message.callId);
                 this.calls.delete(message.callId);
                 break;
             case ServerMessageType.ServerStreamPush:
+                this.emitStreamEvent({
+                    direction: 'incoming',
+                    streamType: 'server_blob',
+                    action: 'push',
+                    streamId: message.streamId,
+                    byteLength: message.chunk.byteLength,
+                });
                 this.serverStreams.push(message.streamId, message.chunk);
                 break;
             case ServerMessageType.ServerStreamEnd:
+                this.emitStreamEvent({
+                    direction: 'incoming',
+                    streamType: 'server_blob',
+                    action: 'end',
+                    streamId: message.streamId,
+                });
                 this.serverStreams.end(message.streamId);
                 break;
             case ServerMessageType.ServerStreamAbort:
+                this.emitStreamEvent({
+                    direction: 'incoming',
+                    streamType: 'server_blob',
+                    action: 'abort',
+                    streamId: message.streamId,
+                    reason: message.reason,
+                });
                 this.serverStreams.abort(message.streamId);
                 break;
             case ServerMessageType.ClientStreamPull:
+                this.emitStreamEvent({
+                    direction: 'incoming',
+                    streamType: 'client_blob',
+                    action: 'pull',
+                    streamId: message.streamId,
+                    byteLength: message.size,
+                });
                 this.clientStreams.pull(message.streamId, message.size).then((chunk) => {
                     if (chunk) {
+                        this.emitStreamEvent({
+                            direction: 'outgoing',
+                            streamType: 'client_blob',
+                            action: 'push',
+                            streamId: message.streamId,
+                            byteLength: chunk.byteLength,
+                        });
                         const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.ClientStreamPush, { streamId: message.streamId, chunk });
-                        this.#send(buffer).catch(noopFn);
+                        this.send(buffer).catch(noopFn);
                     }
                     else {
+                        this.emitStreamEvent({
+                            direction: 'outgoing',
+                            streamType: 'client_blob',
+                            action: 'end',
+                            streamId: message.streamId,
+                        });
                         const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.ClientStreamEnd, { streamId: message.streamId });
-                        this.#send(buffer).catch(noopFn);
+                        this.send(buffer).catch(noopFn);
                         this.clientStreams.end(message.streamId);
                     }
                 }, () => {
+                    this.emitStreamEvent({
+                        direction: 'outgoing',
+                        streamType: 'client_blob',
+                        action: 'abort',
+                        streamId: message.streamId,
+                    });
                     const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.ClientStreamAbort, { streamId: message.streamId });
-                    this.#send(buffer).catch(noopFn);
+                    this.send(buffer).catch(noopFn);
                     this.clientStreams.remove(message.streamId);
                 });
                 break;
             case ServerMessageType.ClientStreamAbort:
+                this.emitStreamEvent({
+                    direction: 'incoming',
+                    streamType: 'client_blob',
+                    action: 'abort',
+                    streamId: message.streamId,
+                    reason: message.reason,
+                });
                 this.clientStreams.abort(message.streamId);
                 break;
         }
     }
-    #handleRPCResponseMessage(message) {
+    handleRPCResponseMessage(message) {
         const { callId, result, error } = message;
         const call = this.calls.get(callId);
         if (!call)
             return;
         if (error) {
+            this.emitClientEvent({
+                kind: 'rpc_error',
+                timestamp: Date.now(),
+                callId,
+                procedure: call.procedure,
+                error,
+            });
             call.reject(new ProtocolError(error.code, error.message, error.data));
         }
         else {
             try {
                 const transformed = this.transformer.decode(call.procedure, result);
+                this.emitClientEvent({
+                    kind: 'rpc_response',
+                    timestamp: Date.now(),
+                    callId,
+                    procedure: call.procedure,
+                    body: transformed,
+                });
                 call.resolve(transformed);
             }
             catch (error) {
+                this.emitClientEvent({
+                    kind: 'rpc_error',
+                    timestamp: Date.now(),
+                    callId,
+                    procedure: call.procedure,
+                    error,
+                });
                 call.reject(new ProtocolError(ErrorCode.ClientRequestError, 'Unable to decode response', error));
             }
         }
     }
-    #handleRPCStreamResponseMessage(message) {
+    handleRPCStreamResponseMessage(message) {
         const call = this.calls.get(message.callId);
         if (message.error) {
             if (!call)
                 return;
+            this.emitClientEvent({
+                kind: 'rpc_error',
+                timestamp: Date.now(),
+                callId: message.callId,
+                procedure: call.procedure,
+                error: message.error,
+            });
             call.reject(new ProtocolError(message.error.code, message.error.message, message.error.data));
         }
         else {
             if (call) {
                 const { procedure, signal } = call;
+                this.emitClientEvent({
+                    kind: 'rpc_response',
+                    timestamp: Date.now(),
+                    callId: message.callId,
+                    procedure,
+                    stream: true,
+                });
                 const stream = new ProtocolServerRPCStream({
                     start: (controller) => {
                         if (signal) {
@@ -325,7 +599,7 @@ export class BaseClient extends EventEmitter {
                                         this.calls.delete(message.callId);
                                         if (this.messageContext) {
                                             const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.RpcAbort, { callId: message.callId, reason: signal.reason });
-                                            this.#send(buffer).catch(noopFn);
+                                            this.send(buffer).catch(noopFn);
                                         }
                                     }
                                 }, { once: true });
@@ -334,10 +608,6 @@ export class BaseClient extends EventEmitter {
                     transform: (chunk) => {
                         return this.transformer.decode(procedure, this.options.format.decode(chunk));
                     },
-                    pull: () => {
-                        const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.RpcPull, { callId: message.callId });
-                        this.#send(buffer).catch(noopFn);
-                    },
                     readableStrategy: { highWaterMark: 0 },
                 });
                 this.rpcStreams.add(message.callId, stream);
@@ -349,15 +619,22 @@ export class BaseClient extends EventEmitter {
                 // Need to send an abort for the stream to avoid resource leaks from server side
                 if (this.messageContext) {
                     const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.RpcAbort, { callId: message.callId });
-                    this.#send(buffer).catch(noopFn);
+                    this.send(buffer).catch(noopFn);
                 }
             }
         }
     }
-    #handleCallResponse(callId, response) {
+    handleCallResponse(callId, response) {
         const call = this.calls.get(callId);
         if (response.type === 'rpc_stream') {
             if (call) {
+                this.emitClientEvent({
+                    kind: 'rpc_response',
+                    timestamp: Date.now(),
+                    callId,
+                    procedure: call.procedure,
+                    stream: true,
+                });
                 const stream = new ProtocolServerStream({
                     transform: (chunk) => {
                         return this.transformer.decode(call.procedure, this.options.format.decode(chunk));
@@ -365,7 +642,38 @@ export class BaseClient extends EventEmitter {
                 });
                 this.rpcStreams.add(callId, stream);
                 call.resolve(({ signal }) => {
-                    response.stream.pipeTo(stream.writable, { signal }).catch(noopFn);
+                    const reader = response.stream.getReader();
+                    let onAbort;
+                    if (signal) {
+                        onAbort = () => {
+                            reader.cancel(signal.reason).catch(noopFn);
+                            this.rpcStreams.abort(callId).catch(noopFn);
+                        };
+                        if (signal.aborted)
+                            onAbort();
+                        else
+                            signal.addEventListener('abort', onAbort, { once: true });
+                    }
+                    void (async () => {
+                        try {
+                            while (true) {
+                                const { done, value } = await reader.read();
+                                if (done)
+                                    break;
+                                await this.rpcStreams.push(callId, value);
+                            }
+                            await this.rpcStreams.end(callId);
+                        }
+                        catch {
+                            await this.rpcStreams.abort(callId).catch(noopFn);
+                        }
+                        finally {
+                            reader.releaseLock();
+                            if (signal && onAbort) {
+                                signal.removeEventListener('abort', onAbort);
+                            }
+                        }
+                    })();
                     return stream;
                 });
             }
@@ -378,9 +686,16 @@ export class BaseClient extends EventEmitter {
         }
         else if (response.type === 'blob') {
             if (call) {
+                this.emitClientEvent({
+                    kind: 'rpc_response',
+                    timestamp: Date.now(),
+                    callId,
+                    procedure: call.procedure,
+                    stream: true,
+                });
                 const { metadata, source } = response;
                 const stream = new ProtocolServerBlobStream(metadata);
-                this.serverStreams.add(this.#getStreamId(), stream);
+                this.serverStreams.add(this.getStreamId(), stream);
                 call.resolve(({ signal }) => {
                     source.pipeTo(stream.writable, { signal }).catch(noopFn);
                     return stream;
@@ -397,30 +712,63 @@ export class BaseClient extends EventEmitter {
             if (!call)
                 return;
             try {
-                const transformed = this.transformer.decode(call.procedure, response.result);
+                const decodedPayload = response.result.byteLength === 0
+                    ? undefined
+                    : this.options.format.decode(response.result);
+                const transformed = this.transformer.decode(call.procedure, decodedPayload);
+                this.emitClientEvent({
+                    kind: 'rpc_response',
+                    timestamp: Date.now(),
+                    callId,
+                    procedure: call.procedure,
+                    body: transformed,
+                });
                 call.resolve(transformed);
             }
             catch (error) {
+                this.emitClientEvent({
+                    kind: 'rpc_error',
+                    timestamp: Date.now(),
+                    callId,
+                    procedure: call.procedure,
+                    error,
+                });
                 call.reject(new ProtocolError(ErrorCode.ClientRequestError, 'Unable to decode response', error));
             }
         }
     }
-    #send(buffer, signal) {
+    send(buffer, signal) {
         if (this.transport.type === ConnectionType.Unidirectional)
             throw new Error('Invalid transport type for send');
         return this.transport.send(buffer, { signal });
     }
-    #getStreamId() {
+    emitStreamEvent(event) {
+        this.emitClientEvent({
+            kind: 'stream_event',
+            timestamp: Date.now(),
+            ...event,
+        });
+    }
+    getStreamId() {
         if (this.streamId >= MAX_UINT32) {
             this.streamId = 0;
         }
         return this.streamId++;
     }
-    #getCallId() {
+    getCallId() {
         if (this.callId >= MAX_UINT32) {
             this.callId = 0;
         }
         return this.callId++;
     }
+    emitClientEvent(event) {
+        for (const plugin of this.plugins) {
+            try {
+                const result = plugin.onClientEvent?.(event);
+                Promise.resolve(result).catch(noopFn);
+            }
+            catch { }
+        }
+    }
 }
 //# sourceMappingURL=core.js.map