@nmtjs/protocol 0.14.5 → 0.15.0-beta.1

package/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2024 Denis Ilchyshyn
+Copyright (c) 2025 Denys Ilchyshyn
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/README.md

@@ -6,4 +6,4 @@
 - binary data streaming and event subscriptions
 - contract-based API
 - end-to-end type safety
-- CPU-intensive task execution on separate workers
+- CPU-intensive task execution on separate workers

package/package.json

@@ -2,40 +2,35 @@
   "name": "@nmtjs/protocol",
   "type": "module",
   "exports": {
-    ".": {
-      "types": "./dist/common/index.d.ts",
-      "import": "./dist/common/index.js",
-      "module-sync": "./dist/common/index.js"
-    },
-    "./server": {
-      "types": "./dist/server/index.d.ts",
-      "import": "./dist/server/index.js",
-      "module-sync": "./dist/server/index.js"
-    },
-    "./client": {
-      "types": "./dist/client/index.d.ts",
-      "import": "./dist/client/index.js",
-      "module-sync": "./dist/client/index.js"
-    }
+    ".": "./dist/common/index.js",
+    "./server": "./dist/server/index.js",
+    "./client": "./dist/client/index.js"
   },
   "dependencies": {
-    "@nmtjs/common": "0.14.5",
-    "@nmtjs/type": "0.14.5",
-    "@nmtjs/core": "0.14.5"
+    "hookable": "6.0.0-rc.1",
+    "@nmtjs/common": "0.15.0-beta.1",
+    "@nmtjs/contract": "0.15.0-beta.1",
+    "@nmtjs/type": "0.15.0-beta.1"
+  },
+  "devDependencies": {
+    "@nmtjs/core": "0.15.0-beta.1"
   },
   "peerDependencies": {
-    "@nmtjs/common": "0.14.5",
-    "@nmtjs/type": "0.14.5",
-    "@nmtjs/core": "0.14.5"
+    "@nmtjs/common": "0.15.0-beta.1",
+    "@nmtjs/core": "0.15.0-beta.1",
+    "@nmtjs/type": "0.15.0-beta.1",
+    "@nmtjs/contract": "0.15.0-beta.1"
   },
   "files": [
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.14.5",
+  "version": "0.15.0-beta.1",
   "scripts": {
+    "clean-build": "rm -rf ./dist",
     "build": "tsc",
+    "dev": "tsc --watch",
     "type-check": "tsc --noEmit"
   }
 }

package/dist/client/events.d.ts

@@ -1,15 +0,0 @@
-import type { Callback } from '@nmtjs/common';
-export type EventMap = {
-    [K: string]: any[];
-};
-/**
- * Very simple node-like event emitter wrapper around EventTarget
- */
-export declare class EventEmitter<Events extends EventMap = EventMap, EventName extends Extract<keyof Events, string> = Extract<keyof Events, string>> {
-    #private;
-    static once<T extends EventEmitter, E extends T extends EventEmitter<any, infer Event> ? Event : never>(ee: T, event: E): Promise<unknown>;
-    on<E extends EventName>(event: E | (Object & string), listener: (...args: Events[E]) => void, options?: AddEventListenerOptions): () => void;
-    once<E extends EventName>(event: E | (Object & string), listener: (...args: Events[E]) => void, options?: AddEventListenerOptions): () => void;
-    off(event: EventName | (Object & string), listener: Callback): void;
-    emit<E extends EventName | (Object & string)>(event: E, ...args: E extends EventName ? Events[E] : any[]): boolean;
-}

package/dist/client/events.js

@@ -1,28 +0,0 @@
-// TODO: add errors and promise rejections handling
-/**
- * Very simple node-like event emitter wrapper around EventTarget
- */
-export class EventEmitter {
-    static once(ee, event) {
-        return new Promise((resolve) => ee.once(event, resolve));
-    }
-    #target = new EventTarget();
-    #listeners = new Map();
-    on(event, listener, options) {
-        const wrapper = (event) => listener(...event.detail);
-        this.#listeners.set(listener, wrapper);
-        this.#target.addEventListener(event, wrapper, { ...options, once: false });
-        return () => this.#target.removeEventListener(event, wrapper);
-    }
-    once(event, listener, options) {
-        return this.on(event, listener, { ...options, once: true });
-    }
-    off(event, listener) {
-        const wrapper = this.#listeners.get(listener);
-        if (wrapper)
-            this.#target.removeEventListener(event, wrapper);
-    }
-    emit(event, ...args) {
-        return this.#target.dispatchEvent(new CustomEvent(event, { detail: args }));
-    }
-}

package/dist/client/format.d.ts

@@ -1,21 +0,0 @@
-import type { DecodeRPCContext, EncodeRPCContext, ProtocolRPC, ProtocolRPCResponse } from '../common/types.ts';
-import type { ProtocolClientBlobStream, ProtocolServerBlobStream } from './stream.ts';
-export type ProtocolRPCEncode = {
-    buffer: ArrayBuffer;
-    streams: Record<number, ProtocolClientBlobStream>;
-};
-export interface BaseClientDecoder {
-    decode(buffer: ArrayBuffer): any;
-    decodeRPC(buffer: ArrayBuffer, context: DecodeRPCContext<ProtocolServerBlobStream>): ProtocolRPCResponse<ProtocolServerBlobStream>;
-}
-export interface BaseClientEncoder {
-    encode(data: any): ArrayBuffer;
-    encodeRPC(rpc: ProtocolRPC, context: EncodeRPCContext<ProtocolClientBlobStream>): ProtocolRPCEncode;
-}
-export declare abstract class BaseClientFormat implements BaseClientDecoder, BaseClientEncoder {
-    abstract contentType: string;
-    abstract encode(data: any): ArrayBuffer;
-    abstract encodeRPC(rpc: ProtocolRPC, context: EncodeRPCContext<ProtocolClientBlobStream>): ProtocolRPCEncode;
-    abstract decode(buffer: ArrayBuffer): any;
-    abstract decodeRPC(buffer: ArrayBuffer, context: DecodeRPCContext<ProtocolServerBlobStream>): ProtocolRPCResponse<ProtocolServerBlobStream>;
-}

package/dist/client/format.js

@@ -1,2 +0,0 @@
-export class BaseClientFormat {
-}

package/dist/client/index.d.ts

@@ -1,4 +0,0 @@
-export * from './events.ts';
-export * from './format.ts';
-export * from './protocol.ts';
-export * from './stream.ts';

package/dist/client/index.js

@@ -1,4 +0,0 @@
-export * from "./events.js";
-export * from "./format.js";
-export * from "./protocol.js";
-export * from "./stream.js";

package/dist/client/protocol.d.ts

@@ -1,150 +0,0 @@
-import type { InteractivePromise, OneOf } from '@nmtjs/common';
-import type { ProtocolBlobMetadata } from '../common/blob.ts';
-import type { BaseProtocolError, ProtocolRPCResponse } from '../common/types.ts';
-import type { BaseClientFormat } from './format.ts';
-import { ClientMessageType, ServerMessageType } from '../common/enums.ts';
-import { EventEmitter } from './events.ts';
-import { ProtocolClientBlobStream, ProtocolServerBlobStream, ProtocolServerStream } from './stream.ts';
-export declare class ProtocolError extends Error implements BaseProtocolError {
-    code: string;
-    data?: any;
-    constructor(code: string, message?: string, data?: any);
-    get message(): string;
-    toString(): string;
-    toJSON(): {
-        code: string;
-        message: string;
-        data: any;
-    };
-}
-export declare class ProtocolClientStreams {
-    #private;
-    get(streamId: number): ProtocolClientBlobStream;
-    add(source: ReadableStream, streamId: number, metadata: ProtocolBlobMetadata): ProtocolClientBlobStream;
-    remove(streamId: number): void;
-    abort(streamId: number, error?: Error): void;
-    pull(streamId: number, size: number): Promise<ArrayBuffer | null>;
-    end(streamId: number): void;
-    clear(error?: Error): void;
-}
-export declare class ProtocolServerStreams<T extends ProtocolServerStream = ProtocolServerStream> {
-    #private;
-    has(streamId: number): boolean;
-    get(streamId: number): T;
-    add(streamId: number, stream: T): T;
-    remove(streamId: number): void;
-    abort(streamId: number): void;
-    push(streamId: number, chunk: ArrayBuffer): Promise<void>;
-    end(streamId: number): void;
-    clear(error?: Error): void;
-}
-export type ProtocolTransportEventMap = {
-    connected: [];
-    disconnected: [reason: 'server' | 'client' | 'error'];
-};
-export interface ProtocolSendMetadata {
-    callId?: number;
-    streamId?: number;
-}
-export declare enum ProtocolTransportStatus {
-    CONNECTED = "CONNECTED",
-    DISCONNECTED = "DISCONNECTED",
-    CONNECTING = "CONNECTING"
-}
-export declare abstract class ProtocolTransport<Options = unknown> extends EventEmitter<ProtocolTransportEventMap> {
-    protected options?: Options | undefined;
-    status: ProtocolTransportStatus;
-    constructor(options?: Options | undefined);
-    abstract connect(auth: any, transformer: ProtocolBaseTransformer): Promise<void>;
-    abstract disconnect(): Promise<void>;
-    abstract call(procedure: string, payload: any, options: ProtocolBaseClientCallOptions, transformer: ProtocolBaseTransformer): Promise<ProtocolClientCall>;
-    abstract send(messageType: ClientMessageType, buffer: ArrayBuffer, metadata: ProtocolSendMetadata): Promise<void>;
-}
-export declare class ProtocolBaseTransformer {
-    encodeRPC(_procedure: string, payload: any): any;
-    decodeRPC(_procedure: string, payload: any): any;
-    decodeRPCChunk(_procedure: string, payload: any): any;
-    decodeEvent(_event: string, payload: any): any;
-}
-export type ProtocolClientCall = InteractivePromise<any> & {
-    procedure: string;
-    signal: AbortSignal;
-};
-export type ProtocolBaseClientOptions = {
-    transport: ProtocolTransport;
-    format: BaseClientFormat;
-    transformer?: ProtocolBaseTransformer;
-    timeout?: number;
-};
-export type ProtocolBaseClientCallOptions = {
-    signal?: AbortSignal;
-    timeout: number;
-};
-export declare class BaseProtocol<T extends Record<string, Record<string, any>> = Record<string, Record<string, any>>> extends EventEmitter<{
-    [N in keyof T]: {
-        [E in keyof T[N] as `${Extract<N, string>}/${Extract<E, string>}`]: [
-            payload: T[N][E]
-        ];
-    };
-}[keyof T]> {
-    readonly format: BaseClientFormat;
-    protected readonly clientStreams: ProtocolClientStreams;
-    protected readonly serverStreams: ProtocolServerStreams<ProtocolServerBlobStream>;
-    protected readonly rpcStreams: ProtocolServerStreams;
-    protected readonly calls: Map<number, ProtocolClientCall>;
-    protected callId: number;
-    protected streamId: number;
-    constructor(format: BaseClientFormat);
-    get contentType(): string;
-    handleCallResponse(callId: number, call: ProtocolClientCall, response: OneOf<[
-        {
-            error: BaseProtocolError;
-        },
-        {
-            result: any;
-            stream?: any;
-        }
-    ]>, transformer: ProtocolBaseTransformer): void;
-    handleRpcResponse({ callId, error, result, streams }: ProtocolRPCResponse, transformer: ProtocolBaseTransformer, stream?: ProtocolServerStream): ProtocolClientCall;
-    handleRpcStreamResponse(response: ProtocolRPCResponse, stream: ProtocolServerStream, transformer: ProtocolBaseTransformer): ProtocolClientCall;
-    createCall(procedure: string, options: ProtocolBaseClientCallOptions): InteractivePromise<unknown> & {
-        procedure: string;
-        signal: AbortSignal;
-    };
-    createRpc(procedure: string, payload: any, options: ProtocolBaseClientCallOptions, transformer: ProtocolBaseTransformer): {
-        callId: number;
-        call: InteractivePromise<unknown> & {
-            procedure: string;
-            signal: AbortSignal;
-        };
-        streams: Record<number, ProtocolClientBlobStream>;
-        buffer: ArrayBuffer;
-    };
-    pushRpcStream(callId: number, chunk: any): void;
-    endRpcStream(callId: number): void;
-    abortRpcStream(callId: number): void;
-    removeClientStream(streamId: number): void;
-    pullClientStream(streamId: number, size: number): Promise<ArrayBuffer | null>;
-    endClientStream(streamId: number): void;
-    abortClientStream(streamId: number, error?: Error): void;
-    addServerStream(stream: ProtocolServerBlobStream): void;
-    removeServerStream(streamId: number): void;
-    pushServerStream(streamId: number, chunk: ArrayBuffer): Promise<void>;
-    endServerStream(streamId: number): void;
-    abortServerStream(streamId: number, _error?: Error): void;
-    emitEvent(event: string, payload: string, transformer: ProtocolBaseTransformer): void;
-}
-export declare class Protocol<T extends Record<string, Record<string, any>> = Record<string, Record<string, any>>> extends BaseProtocol<T> {
-    handleServerMessage(buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
-    protected [ServerMessageType.Event](buffer: ArrayBuffer, _transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
-    protected [ServerMessageType.RpcResponse](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
-    protected [ServerMessageType.RpcStreamResponse](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
-    protected [ServerMessageType.RpcStreamChunk](buffer: ArrayBuffer, _transport: ProtocolTransport, _transformer: ProtocolBaseTransformer): void;
-    protected [ServerMessageType.RpcStreamEnd](buffer: ArrayBuffer, _transport: ProtocolTransport, _transformer: ProtocolBaseTransformer): void;
-    protected [ServerMessageType.RpcStreamAbort](buffer: ArrayBuffer, _transport: ProtocolTransport, _transformer: ProtocolBaseTransformer): void;
-    protected [ServerMessageType.ServerStreamPush](buffer: ArrayBuffer, transport: ProtocolTransport, _transformer: ProtocolBaseTransformer): void;
-    protected [ServerMessageType.ServerStreamEnd](buffer: ArrayBuffer, _transport: ProtocolTransport, _transformer: ProtocolBaseTransformer): void;
-    protected [ServerMessageType.ServerStreamAbort](buffer: ArrayBuffer, _transport: ProtocolTransport, _transformer: ProtocolBaseTransformer): void;
-    protected [ServerMessageType.ClientStreamPull](buffer: ArrayBuffer, transport: ProtocolTransport, _transformer: ProtocolBaseTransformer): void;
-    protected [ServerMessageType.ClientStreamAbort](buffer: ArrayBuffer, _transport: ProtocolTransport, _transformer: ProtocolBaseTransformer): void;
-}

package/dist/client/protocol.js

@@ -1,354 +0,0 @@
-import { createPromise } from '@nmtjs/common';
-import { concat, decodeNumber, encodeNumber } from "../common/binary.js";
-import { ClientMessageType, ErrorCode, ServerMessageType, } from "../common/enums.js";
-import { EventEmitter } from "./events.js";
-import { ProtocolClientBlobStream, ProtocolServerBlobStream, ProtocolServerStream, } from "./stream.js";
-export class ProtocolError extends Error {
-    code;
-    data;
-    constructor(code, message, data) {
-        super(message);
-        this.code = code;
-        this.data = data;
-    }
-    get message() {
-        return `${this.code} ${super.message}`;
-    }
-    toString() {
-        return `${this.code} ${this.message}`;
-    }
-    toJSON() {
-        return { code: this.code, message: this.message, data: this.data };
-    }
-}
-export class ProtocolClientStreams {
-    #collection = new Map();
-    get(streamId) {
-        const stream = this.#collection.get(streamId);
-        if (!stream)
-            throw new Error('Stream not found');
-        return stream;
-    }
-    add(source, streamId, metadata) {
-        const stream = new ProtocolClientBlobStream(source, streamId, metadata);
-        this.#collection.set(streamId, stream);
-        return stream;
-    }
-    remove(streamId) {
-        this.#collection.delete(streamId);
-    }
-    abort(streamId, error) {
-        const stream = this.get(streamId);
-        stream.abort(error);
-        this.remove(streamId);
-    }
-    pull(streamId, size) {
-        const stream = this.get(streamId);
-        return stream.read(size);
-    }
-    end(streamId) {
-        this.get(streamId).end();
-        this.remove(streamId);
-    }
-    clear(error) {
-        if (error) {
-            for (const stream of this.#collection.values()) {
-                stream.abort(error);
-            }
-        }
-        this.#collection.clear();
-    }
-}
-export class ProtocolServerStreams {
-    #collection = new Map();
-    has(streamId) {
-        return this.#collection.has(streamId);
-    }
-    get(streamId) {
-        const stream = this.#collection.get(streamId);
-        if (!stream)
-            throw new Error('Stream not found');
-        return stream;
-    }
-    add(streamId, stream) {
-        this.#collection.set(streamId, stream);
-        return stream;
-    }
-    remove(streamId) {
-        this.#collection.delete(streamId);
-    }
-    abort(streamId) {
-        if (this.has(streamId)) {
-            const stream = this.get(streamId);
-            stream.abort();
-            this.remove(streamId);
-        }
-    }
-    async push(streamId, chunk) {
-        const stream = this.get(streamId);
-        return await stream.push(chunk);
-    }
-    end(streamId) {
-        const stream = this.get(streamId);
-        stream.end();
-        this.remove(streamId);
-    }
-    clear(error) {
-        if (error) {
-            for (const stream of this.#collection.values()) {
-                stream.abort(error);
-            }
-        }
-        this.#collection.clear();
-    }
-}
-export var ProtocolTransportStatus;
-(function (ProtocolTransportStatus) {
-    ProtocolTransportStatus["CONNECTED"] = "CONNECTED";
-    ProtocolTransportStatus["DISCONNECTED"] = "DISCONNECTED";
-    ProtocolTransportStatus["CONNECTING"] = "CONNECTING";
-})(ProtocolTransportStatus || (ProtocolTransportStatus = {}));
-export class ProtocolTransport extends EventEmitter {
-    options;
-    status = ProtocolTransportStatus.DISCONNECTED;
-    constructor(options) {
-        super();
-        this.options = options;
-    }
-}
-export class ProtocolBaseTransformer {
-    encodeRPC(_procedure, payload) {
-        return payload;
-    }
-    decodeRPC(_procedure, payload) {
-        return payload;
-    }
-    decodeRPCChunk(_procedure, payload) {
-        return payload;
-    }
-    decodeEvent(_event, payload) {
-        return payload;
-    }
-}
-export class BaseProtocol extends EventEmitter {
-    format;
-    clientStreams = new ProtocolClientStreams();
-    serverStreams = new ProtocolServerStreams();
-    rpcStreams = new ProtocolServerStreams();
-    calls = new Map();
-    callId = 0;
-    streamId = 0;
-    constructor(format) {
-        super();
-        this.format = format;
-    }
-    get contentType() {
-        return this.format.contentType;
-    }
-    handleCallResponse(callId, call, response, transformer) {
-        if (response.error) {
-            call.reject(new ProtocolError(response.error.code, response.error.message, response.error.data));
-        }
-        else {
-            try {
-                const transformed = transformer.decodeRPC(call.procedure, response.result);
-                if (response.stream)
-                    call.resolve({ result: transformed, stream: response.stream });
-                else
-                    call.resolve(transformed);
-            }
-            catch (error) {
-                call.reject(new ProtocolError(ErrorCode.ClientRequestError, 'Unable to decode response', error));
-            }
-        }
-        this.calls.delete(callId);
-    }
-    handleRpcResponse({ callId, error, result, streams }, transformer, stream) {
-        const call = this.calls.get(callId);
-        if (!call)
-            throw new Error('Call not found');
-        for (const key in streams) {
-            const stream = streams[key];
-            this.serverStreams.add(stream.id, stream);
-        }
-        this.handleCallResponse(callId, call, error ? { error } : { result, stream }, transformer);
-        return call;
-    }
-    handleRpcStreamResponse(response, stream, transformer) {
-        const call = this.handleRpcResponse(response, transformer, stream);
-        this.rpcStreams.add(response.callId, stream);
-        return call;
-    }
-    createCall(procedure, options) {
-        const timeoutSignal = AbortSignal.timeout(options.timeout);
-        const signal = options.signal
-            ? AbortSignal.any([options.signal, timeoutSignal])
-            : timeoutSignal;
-        const call = Object.assign(createPromise(), { procedure, signal });
-        timeoutSignal.addEventListener('abort', () => {
-            const error = new ProtocolError(ErrorCode.RequestTimeout, 'Request timeout');
-            call.reject(error);
-        }, { once: true });
-        return call;
-    }
-    createRpc(procedure, payload, options, transformer) {
-        const callId = ++this.callId;
-        const call = this.createCall(procedure, options);
-        const { buffer, streams } = this.format.encodeRPC({ callId, procedure, payload: transformer.encodeRPC(procedure, payload) }, {
-            addStream: (blob) => {
-                const streamId = ++this.streamId;
-                return this.clientStreams.add(blob.source, streamId, blob.metadata);
-            },
-            getStream: (id) => {
-                const stream = this.clientStreams.get(id);
-                return stream;
-            },
-        });
-        this.calls.set(callId, call);
-        return { callId, call, streams, buffer };
-    }
-    pushRpcStream(callId, chunk) {
-        this.rpcStreams.push(callId, chunk);
-    }
-    endRpcStream(callId) {
-        this.rpcStreams.end(callId);
-    }
-    abortRpcStream(callId) {
-        this.rpcStreams.abort(callId);
-    }
-    removeClientStream(streamId) {
-        this.clientStreams.remove(streamId);
-    }
-    pullClientStream(streamId, size) {
-        return this.clientStreams.pull(streamId, size);
-    }
-    endClientStream(streamId) {
-        this.clientStreams.end(streamId);
-    }
-    abortClientStream(streamId, error) {
-        this.clientStreams.abort(streamId, error);
-    }
-    addServerStream(stream) {
-        this.serverStreams.add(stream.id, stream);
-    }
-    removeServerStream(streamId) {
-        this.serverStreams.remove(streamId);
-    }
-    pushServerStream(streamId, chunk) {
-        return this.serverStreams.push(streamId, chunk);
-    }
-    endServerStream(streamId) {
-        this.serverStreams.end(streamId);
-    }
-    abortServerStream(streamId, _error) {
-        this.serverStreams.abort(streamId);
-    }
-    emitEvent(event, payload, transformer) {
-        const transformed = transformer.decodeEvent(event, payload);
-        this.emit(event, 
-        //@ts-expect-error
-        transformed);
-    }
-}
-export class Protocol extends BaseProtocol {
-    handleServerMessage(buffer, transport, transformer) {
-        const type = decodeNumber(buffer, 'Uint8');
-        const messageBuffer = buffer.slice(Uint8Array.BYTES_PER_ELEMENT);
-        if (type in ServerMessageType) {
-            const messageType = type;
-            if (typeof ServerMessageType[messageType] !== 'undefined') {
-                this[messageType](messageBuffer, transport, transformer);
-            }
-            else {
-                throw new Error(`Unknown message type: ${messageType}`);
-            }
-        }
-    }
-    [ServerMessageType.Event](buffer, _transport, transformer) {
-        const [event, payload] = this.format.decode(buffer);
-        this.emitEvent(event, payload, transformer);
-    }
-    [ServerMessageType.RpcResponse](buffer, transport, transformer) {
-        const response = this.format.decodeRPC(buffer, {
-            addStream: (id, callId, metadata) => {
-                return new ProtocolServerBlobStream(id, metadata, {
-                    start: () => {
-                        transport.send(ClientMessageType.ServerStreamPull, encodeNumber(id, 'Uint32'), { callId, streamId: id });
-                    },
-                });
-            },
-            getStream: (id) => {
-                return this.serverStreams.get(id);
-            },
-        });
-        this.handleRpcResponse(response, transformer);
-    }
-    [ServerMessageType.RpcStreamResponse](buffer, transport, transformer) {
-        const response = this.format.decodeRPC(buffer, {
-            addStream: (id, callId, metadata) => {
-                return new ProtocolServerBlobStream(id, metadata, {
-                    start: () => {
-                        transport.send(ClientMessageType.ServerStreamPull, encodeNumber(id, 'Uint32'), { callId, streamId: id });
-                    },
-                });
-            },
-            getStream: (id) => {
-                return this.serverStreams.get(id);
-            },
-        });
-        const stream = new ProtocolServerStream({
-            transform: (chunk, controller) => {
-                const transformed = transformer.decodeRPCChunk(call.procedure, chunk);
-                controller.enqueue(transformed);
-            },
-        });
-        const call = this.handleRpcStreamResponse(response, stream, transformer);
-    }
-    [ServerMessageType.RpcStreamChunk](buffer, _transport, _transformer) {
-        const callId = decodeNumber(buffer, 'Uint32');
-        const chunk = buffer.slice(Uint32Array.BYTES_PER_ELEMENT);
-        const payload = this.format.decode(chunk);
-        this.pushRpcStream(callId, payload);
-    }
-    [ServerMessageType.RpcStreamEnd](buffer, _transport, _transformer) {
-        const callId = decodeNumber(buffer, 'Uint32');
-        this.endRpcStream(callId);
-    }
-    [ServerMessageType.RpcStreamAbort](buffer, _transport, _transformer) {
-        const callId = decodeNumber(buffer, 'Uint32');
-        this.abortRpcStream(callId);
-    }
-    [ServerMessageType.ServerStreamPush](buffer, transport, _transformer) {
-        const streamId = decodeNumber(buffer, 'Uint32');
-        const chunk = buffer.slice(Uint32Array.BYTES_PER_ELEMENT);
-        this.pushServerStream(streamId, chunk);
-        transport.send(ClientMessageType.ServerStreamPull, encodeNumber(streamId, 'Uint32'), { streamId });
-    }
-    [ServerMessageType.ServerStreamEnd](buffer, _transport, _transformer) {
-        const streamId = decodeNumber(buffer, 'Uint32');
-        this.endServerStream(streamId);
-    }
-    [ServerMessageType.ServerStreamAbort](buffer, _transport, _transformer) {
-        const streamId = decodeNumber(buffer, 'Uint32');
-        this.abortServerStream(streamId);
-    }
-    [ServerMessageType.ClientStreamPull](buffer, transport, _transformer) {
-        const streamId = decodeNumber(buffer, 'Uint32');
-        const size = decodeNumber(buffer, 'Uint32', Uint32Array.BYTES_PER_ELEMENT);
-        this.pullClientStream(streamId, size).then((chunk) => {
-            if (chunk) {
-                transport.send(ClientMessageType.ClientStreamPush, concat(encodeNumber(streamId, 'Uint32'), chunk), { streamId });
-            }
-            else {
-                transport.send(ClientMessageType.ClientStreamEnd, encodeNumber(streamId, 'Uint32'), { streamId });
-                this.endClientStream(streamId);
-            }
-        }, () => {
-            transport.send(ClientMessageType.ClientStreamAbort, encodeNumber(streamId, 'Uint32'), { streamId });
-        });
-    }
-    [ServerMessageType.ClientStreamAbort](buffer, _transport, _transformer) {
-        const streamId = decodeNumber(buffer, 'Uint32');
-        this.abortClientStream(streamId);
-    }
-}