@nmtjs/gateway 0.15.0-beta.1 → 0.15.0-beta.2

package/dist/api.js

@@ -0,0 +1,3 @@
+export function isAsyncIterable(value) {
+    return Boolean(value && typeof value === 'object' && Symbol.asyncIterator in value);
+}

package/dist/connections.js

@@ -0,0 +1,29 @@
+import { MAX_UINT32, throwError } from '@nmtjs/common';
+export class ConnectionManager {
+    connections = new Map();
+    streamIds = new Map();
+    add(connection) {
+        this.connections.set(connection.id, connection);
+        this.streamIds.set(connection.id, 0);
+    }
+    get(id) {
+        return this.connections.get(id) ?? throwError('Connection not found');
+    }
+    has(id) {
+        return this.connections.has(id);
+    }
+    remove(id) {
+        this.connections.delete(id);
+        this.streamIds.delete(id);
+    }
+    getAll() {
+        return this.connections.values();
+    }
+    getStreamId(connectionId) {
+        let streamId = this.streamIds.get(connectionId);
+        if (streamId >= MAX_UINT32)
+            streamId = 0;
+        this.streamIds.set(connectionId, streamId + 1);
+        return streamId;
+    }
+}

package/dist/enums.js

@@ -0,0 +1,16 @@
+export var GatewayHook;
+(function (GatewayHook) {
+    GatewayHook["Connect"] = "Connect";
+    GatewayHook["Disconnect"] = "Disconnect";
+})(GatewayHook || (GatewayHook = {}));
+export var ProxyableTransportType;
+(function (ProxyableTransportType) {
+    ProxyableTransportType["WebSocket"] = "WebSocket";
+    ProxyableTransportType["HTTP"] = "HTTP";
+})(ProxyableTransportType || (ProxyableTransportType = {}));
+export var StreamTimeout;
+(function (StreamTimeout) {
+    StreamTimeout["Pull"] = "Pull";
+    StreamTimeout["Consume"] = "Consume";
+    StreamTimeout["Finish"] = "Finish";
+})(StreamTimeout || (StreamTimeout = {}));

package/dist/gateway.js

@@ -0,0 +1,456 @@
+import { randomUUID } from 'node:crypto';
+import { isTypedArray } from 'node:util/types';
+import { anyAbortSignal, isAbortError } from '@nmtjs/common';
+import { createFactoryInjectable, provide, Scope } from '@nmtjs/core';
+import { ClientMessageType, isBlobInterface, kBlobKey, ProtocolBlob, ServerMessageType, } from '@nmtjs/protocol';
+import { getFormat, ProtocolError, versions } from '@nmtjs/protocol/server';
+import { ConnectionManager } from "./connections.js";
+import { StreamTimeout } from "./enums.js";
+import * as injectables from "./injectables.js";
+import { RpcManager } from "./rpcs.js";
+import { BlobStreamsManager } from "./streams.js";
+export class Gateway {
+    logger;
+    connections;
+    rpcs;
+    blobStreams;
+    options;
+    constructor(options) {
+        this.options = {
+            rpcStreamConsumeTimeout: 5000,
+            streamTimeouts: {
+                //@ts-expect-error
+                [StreamTimeout.Pull]: options.streamTimeouts?.[StreamTimeout.Pull] ?? 5000,
+                //@ts-expect-error
+                [StreamTimeout.Consume]: options.streamTimeouts?.[StreamTimeout.Consume] ?? 5000,
+                //@ts-expect-error
+                [StreamTimeout.Finish]: options.streamTimeouts?.[StreamTimeout.Finish] ?? 10000,
+            },
+            ...options,
+            identity: options.identity ??
+                createFactoryInjectable({
+                    dependencies: { connectionId: injectables.connectionId },
+                    factory: ({ connectionId }) => connectionId,
+                }),
+        };
+        this.logger = options.logger.child({}, gatewayLoggerOptions);
+        this.connections = new ConnectionManager();
+        this.rpcs = new RpcManager();
+        this.blobStreams = new BlobStreamsManager({
+            timeouts: this.options.streamTimeouts,
+        });
+    }
+    async start() {
+        const hosts = [];
+        for (const key in this.options.transports) {
+            const { transport, proxyable } = this.options.transports[key];
+            const url = await transport.start({
+                formats: this.options.formats,
+                onConnect: this.onConnect(key),
+                onDisconnect: this.onDisconnect(key),
+                onMessage: this.onMessage(key),
+                onRpc: this.onRpc(key),
+            });
+            this.logger.info(`Transport [${key}] started on [${url}]`);
+            if (proxyable)
+                hosts.push({ url, type: proxyable });
+        }
+        return hosts;
+    }
+    async stop() {
+        // Close all connections
+        for (const connection of this.connections.getAll()) {
+            await this.closeConnection(connection.id);
+        }
+        for (const key in this.options.transports) {
+            const { transport } = this.options.transports[key];
+            await transport.stop({ formats: this.options.formats });
+            this.logger.debug(`Transport [${key}] stopped`);
+        }
+    }
+    send(transport, connectionId, data) {
+        if (transport in this.options.transports) {
+            const transportInstance = this.options.transports[transport].transport;
+            if (transportInstance.send) {
+                return transportInstance.send(connectionId, data);
+            }
+        }
+    }
+    async reload() {
+        for (const connections of this.connections.connections.values()) {
+            await connections.container.dispose();
+        }
+    }
+    createRpcContext(connection, messageContext, logger, gatewayRpc, signal) {
+        const { callId, payload, procedure, metadata } = gatewayRpc;
+        const controller = new AbortController();
+        this.rpcs.set(connection.id, callId, controller);
+        signal = signal
+            ? anyAbortSignal(signal, controller.signal)
+            : controller.signal;
+        const container = connection.container.fork(Scope.Call);
+        const dispose = async () => {
+            const streamAbortReason = 'Stream is not consumed by a user';
+            // Abort streams related to this call
+            this.blobStreams.abortClientCallStreams(connection.id, callId, streamAbortReason);
+            this.rpcs.delete(connection.id, callId);
+            this.rpcs.releasePull(connection.id, callId);
+            await container.dispose();
+        };
+        return {
+            ...messageContext,
+            callId,
+            payload,
+            procedure,
+            metadata,
+            container,
+            signal,
+            logger: logger.child({ callId, procedure }),
+            [Symbol.asyncDispose]: dispose,
+        };
+    }
+    createMessageContext(connection, transportKey) {
+        const transport = this.options.transports[transportKey].transport;
+        const { id: connectionId, protocol, decoder, encoder } = connection;
+        const streamId = this.connections.getStreamId.bind(this.connections, connectionId);
+        return {
+            connectionId,
+            protocol,
+            encoder,
+            decoder,
+            transport,
+            streamId,
+            addClientStream: ({ streamId, callId, metadata }) => {
+                const stream = this.blobStreams.createClientStream(connectionId, callId, streamId, metadata, {
+                    read: (size) => {
+                        transport.send(connectionId, protocol.encodeMessage(this.createMessageContext(connection, transportKey), ServerMessageType.ClientStreamPull, { streamId, size: size || 65535 }));
+                    },
+                });
+                stream.once('error', () => {
+                    this.send(transportKey, connectionId, protocol.encodeMessage(this.createMessageContext(connection, transportKey), ServerMessageType.ClientStreamAbort, { streamId }));
+                });
+                const consume = () => {
+                    this.blobStreams.consumeClientStream(connectionId, callId, streamId);
+                    return stream;
+                };
+                const consumer = Object.defineProperties(consume, {
+                    [kBlobKey]: {
+                        enumerable: false,
+                        configurable: false,
+                        writable: false,
+                        value: true,
+                    },
+                    metadata: {
+                        value: metadata,
+                        enumerable: true,
+                        configurable: false,
+                        writable: false,
+                    },
+                });
+                return consumer;
+            },
+        };
+    }
+    onConnect(transport) {
+        const logger = this.logger.child({ transport });
+        return async (options, ...injections) => {
+            logger.debug('Initiating new connection');
+            const protocol = versions[options.protocolVersion];
+            if (!protocol)
+                throw new Error('Unsupported protocol version');
+            const id = randomUUID();
+            const container = this.options.container.fork(Scope.Connection);
+            try {
+                await container.provide([
+                    provide(injectables.connectionData, options.data),
+                    provide(injectables.connectionId, id),
+                ]);
+                await container.provide(injections);
+                const identity = await container.resolve(this.options.identity);
+                const { accept, contentType, type } = options;
+                const { decoder, encoder } = getFormat(this.options.formats, {
+                    accept,
+                    contentType,
+                });
+                const connection = {
+                    id,
+                    type,
+                    identity,
+                    transport,
+                    protocol,
+                    container,
+                    encoder,
+                    decoder,
+                    abortController: new AbortController(),
+                };
+                this.connections.add(connection);
+                await container.provide(injectables.connectionAbortSignal, connection.abortController.signal);
+                logger.debug({
+                    id,
+                    protocol: options.protocolVersion,
+                    type,
+                    accept,
+                    contentType,
+                    identity,
+                    transportData: options.data,
+                }, 'Connection established');
+                return Object.assign(connection, {
+                    [Symbol.asyncDispose]: async () => {
+                        await this.onDisconnect(transport)(connection.id);
+                    },
+                });
+            }
+            catch (error) {
+                logger.debug({ error }, 'Error establishing connection');
+                container.dispose();
+                throw error;
+            }
+        };
+    }
+    onDisconnect(transport) {
+        const logger = this.logger.child({ transport });
+        return async (connectionId) => {
+            logger.debug({ connectionId }, 'Disconnecting connection');
+            await this.closeConnection(connectionId);
+        };
+    }
+    onMessage(transport) {
+        const _logger = this.logger.child({ transport });
+        return async ({ connectionId, data }, ...injections) => {
+            const logger = _logger.child({ connectionId });
+            try {
+                const connection = this.connections.get(connectionId);
+                const messageContext = this.createMessageContext(connection, transport);
+                const message = connection.protocol.decodeMessage(messageContext, Buffer.from(data));
+                logger.trace(message, 'Received message');
+                switch (message.type) {
+                    case ClientMessageType.Rpc: {
+                        const rpcContext = this.createRpcContext(connection, messageContext, logger, message.rpc);
+                        try {
+                            await rpcContext.container.provide([
+                                ...injections,
+                                provide(injectables.createBlob, this.createBlobFunction(rpcContext)),
+                            ]);
+                            await this.handleRpcMessage(connection, rpcContext);
+                        }
+                        finally {
+                            await rpcContext[Symbol.asyncDispose]();
+                        }
+                        break;
+                    }
+                    case ClientMessageType.RpcPull: {
+                        this.rpcs.releasePull(connectionId, message.callId);
+                        break;
+                    }
+                    case ClientMessageType.RpcAbort: {
+                        this.rpcs.abort(connectionId, message.callId);
+                        break;
+                    }
+                    case ClientMessageType.ClientStreamAbort: {
+                        this.blobStreams.abortClientStream(connectionId, message.streamId, message.reason);
+                        break;
+                    }
+                    case ClientMessageType.ClientStreamPush: {
+                        this.blobStreams.pushToClientStream(connectionId, message.streamId, message.chunk);
+                        break;
+                    }
+                    case ClientMessageType.ClientStreamEnd: {
+                        this.blobStreams.endClientStream(connectionId, message.streamId);
+                        break;
+                    }
+                    case ClientMessageType.ServerStreamAbort: {
+                        this.blobStreams.abortServerStream(connectionId, message.streamId, message.reason);
+                        break;
+                    }
+                    case ClientMessageType.ServerStreamPull: {
+                        this.blobStreams.pullServerStream(connectionId, message.streamId);
+                        break;
+                    }
+                    default:
+                        throw new Error('Unknown message type');
+                }
+            }
+            catch (error) {
+                logger.trace({ error }, 'Error handling message');
+                throw error;
+            }
+        };
+    }
+    onRpc(transport) {
+        const _logger = this.logger.child({ transport });
+        return async (connection, rpc, signal, ...injections) => {
+            const logger = _logger.child({ connectionId: connection.id });
+            const messageContext = this.createMessageContext(connection, connection.transport);
+            const rpcContext = this.createRpcContext(connection, messageContext, logger, rpc, signal);
+            try {
+                await rpcContext.container.provide([
+                    ...injections,
+                    provide(injectables.rpcAbortSignal, signal),
+                    provide(injectables.createBlob, this.createBlobFunction(rpcContext)),
+                ]);
+                const result = await this.options.api.call({
+                    connection,
+                    payload: rpc.payload,
+                    procedure: rpc.procedure,
+                    metadata: rpc.metadata,
+                    container: rpcContext.container,
+                    signal: rpcContext.signal,
+                });
+                if (typeof result === 'function') {
+                    return result(async () => {
+                        await rpcContext[Symbol.asyncDispose]();
+                    });
+                }
+                else {
+                    await rpcContext[Symbol.asyncDispose]();
+                    return result;
+                }
+            }
+            catch (error) {
+                await rpcContext[Symbol.asyncDispose]();
+                throw error;
+            }
+        };
+    }
+    async handleRpcMessage(connection, context) {
+        const { container, connectionId, transport, protocol, signal, callId, procedure, payload, encoder, } = context;
+        try {
+            await container.provide(injectables.rpcAbortSignal, signal);
+            const response = await this.options.api.call({
+                connection: connection,
+                container,
+                payload,
+                procedure,
+                signal,
+            });
+            if (typeof response === 'function') {
+                transport.send(connectionId, protocol.encodeMessage(context, ServerMessageType.RpcStreamResponse, {
+                    callId,
+                }));
+                try {
+                    const consumeTimeoutSignal = this.options.rpcStreamConsumeTimeout
+                        ? AbortSignal.timeout(this.options.rpcStreamConsumeTimeout)
+                        : undefined;
+                    const streamSignal = consumeTimeoutSignal
+                        ? anyAbortSignal(signal, consumeTimeoutSignal)
+                        : signal;
+                    await this.rpcs.awaitPull(connectionId, callId, streamSignal);
+                    for await (const chunk of response()) {
+                        signal.throwIfAborted();
+                        const chunkEncoded = encoder.encode(chunk);
+                        transport.send(connectionId, protocol.encodeMessage(context, ServerMessageType.RpcStreamChunk, { callId, chunk: chunkEncoded }));
+                        await this.rpcs.awaitPull(connectionId, callId);
+                    }
+                    transport.send(connectionId, protocol.encodeMessage(context, ServerMessageType.RpcStreamEnd, {
+                        callId,
+                    }));
+                }
+                catch (error) {
+                    if (!isAbortError(error)) {
+                        this.logger.error(error);
+                    }
+                    transport.send(connectionId, protocol.encodeMessage(context, ServerMessageType.RpcStreamAbort, {
+                        callId,
+                    }));
+                }
+            }
+            else {
+                const streams = this.blobStreams.getServerStreamsMetadata(connectionId, callId);
+                transport.send(connectionId, protocol.encodeMessage(context, ServerMessageType.RpcResponse, {
+                    callId,
+                    result: response,
+                    streams,
+                    error: null,
+                }));
+            }
+        }
+        catch (error) {
+            transport.send(connectionId, protocol.encodeMessage(context, ServerMessageType.RpcResponse, {
+                callId,
+                result: null,
+                streams: {},
+                error,
+            }));
+            const level = error instanceof ProtocolError ? 'trace' : 'error';
+            this.logger[level](error);
+        }
+    }
+    async closeConnection(connectionId) {
+        if (this.connections.has(connectionId)) {
+            const connection = this.connections.get(connectionId);
+            connection.abortController.abort();
+            connection.container.dispose();
+        }
+        this.rpcs.close(connectionId);
+        this.blobStreams.cleanupConnection(connectionId);
+        this.connections.remove(connectionId);
+    }
+    createBlobFunction(context) {
+        const { streamId: getStreamId, transport, protocol, connectionId, callId, encoder, } = context;
+        return (source, metadata) => {
+            const streamId = getStreamId();
+            const blob = ProtocolBlob.from(source, metadata, () => {
+                return encoder.encodeBlob(streamId);
+            });
+            const stream = this.blobStreams.createServerStream(connectionId, callId, streamId, blob);
+            stream.on('data', (chunk) => {
+                transport.send(connectionId, protocol.encodeMessage(context, ServerMessageType.ServerStreamPush, {
+                    streamId: streamId,
+                    chunk: Buffer.from(chunk),
+                }));
+            });
+            stream.on('error', (error) => {
+                transport.send(connectionId, protocol.encodeMessage(context, ServerMessageType.ServerStreamAbort, {
+                    streamId: streamId,
+                    reason: error.message,
+                }));
+            });
+            stream.once('finish', () => {
+                transport.send(connectionId, protocol.encodeMessage(context, ServerMessageType.ServerStreamEnd, {
+                    streamId: streamId,
+                }));
+            });
+            stream.once('close', () => {
+                this.blobStreams.removeServerStream(connectionId, streamId);
+            });
+            return blob;
+        };
+    }
+}
+const gatewayLoggerOptions = {
+    serializers: {
+        chunk: (chunk) => isTypedArray(chunk) ? `<Buffer length=${chunk.byteLength}>` : chunk,
+        payload: (payload) => {
+            function traverseObject(obj) {
+                if (Array.isArray(obj)) {
+                    return obj.map(traverseObject);
+                }
+                else if (isTypedArray(obj)) {
+                    return `<${obj.constructor.name} length=${obj.byteLength}>`;
+                }
+                else if (typeof obj === 'object' && obj !== null) {
+                    const result = {};
+                    for (const [key, value] of Object.entries(obj)) {
+                        result[key] = traverseObject(value);
+                    }
+                    return result;
+                }
+                else if (isBlobInterface(obj)) {
+                    return `<ClientBlobStream metadata=${JSON.stringify(obj.metadata)}>`;
+                }
+                return obj;
+            }
+            return traverseObject(payload);
+        },
+        headers: (value) => {
+            if (value instanceof Headers) {
+                const obj = {};
+                value.forEach((v, k) => {
+                    obj[k] = v;
+                });
+                return obj;
+            }
+            return value;
+        },
+    },
+};

package/dist/index.js

@@ -0,0 +1,9 @@
+export * from "./api.js";
+export * from "./connections.js";
+export * from "./enums.js";
+export * from "./gateway.js";
+export * from "./injectables.js";
+export * from "./rpcs.js";
+export * from "./streams.js";
+export * from "./transport.js";
+export * from "./types.js";

package/dist/injectables.js

@@ -0,0 +1,27 @@
+import { anyAbortSignal } from '@nmtjs/common';
+import { createFactoryInjectable, createLazyInjectable, createOptionalInjectable, Scope, } from '@nmtjs/core';
+export const connection = createLazyInjectable(Scope.Connection, 'Gateway connection');
+export const connectionId = createLazyInjectable(Scope.Connection, 'Gateway connection id');
+export const connectionData = createLazyInjectable(Scope.Connection, "Gateway connection's data");
+export const connectionAbortSignal = createLazyInjectable(Scope.Connection, 'Connection abort signal');
+export const rpcClientAbortSignal = createLazyInjectable(Scope.Call, 'RPC client abort signal');
+export const rpcStreamAbortSignal = createLazyInjectable(Scope.Call, 'RPC stream abort signal');
+export const rpcAbortSignal = createFactoryInjectable({
+    dependencies: {
+        rpcClientAbortSignal,
+        connectionAbortSignal,
+        rpcStreamAbortSignal: createOptionalInjectable(rpcStreamAbortSignal),
+    },
+    factory: (ctx) => anyAbortSignal(ctx.rpcClientAbortSignal, ctx.connectionAbortSignal, ctx.rpcStreamAbortSignal),
+}, 'Any RPC abort signal');
+export const createBlob = createLazyInjectable(Scope.Call, 'Create RPC blob');
+export const GatewayInjectables = {
+    connection,
+    connectionId,
+    connectionData,
+    connectionAbortSignal,
+    rpcClientAbortSignal,
+    rpcStreamAbortSignal,
+    rpcAbortSignal,
+    createBlob,
+};

package/dist/rpcs.js

@@ -0,0 +1,78 @@
+import { createFuture } from '@nmtjs/common';
+export class RpcManager {
+    // connectionId:callId -> AbortController
+    rpcs = new Map();
+    // connectionId:callId -> Future<void>
+    streams = new Map();
+    set(connectionId, callId, controller) {
+        const key = this.getKey(connectionId, callId);
+        this.rpcs.set(key, controller);
+    }
+    get(connectionId, callId) {
+        const key = this.getKey(connectionId, callId);
+        return this.rpcs.get(key);
+    }
+    delete(connectionId, callId) {
+        const key = this.getKey(connectionId, callId);
+        this.rpcs.delete(key);
+    }
+    abort(connectionId, callId) {
+        const key = this.getKey(connectionId, callId);
+        const controller = this.rpcs.get(key);
+        if (controller) {
+            controller.abort();
+            this.rpcs.delete(key);
+            this.releasePull(connectionId, callId);
+        }
+    }
+    awaitPull(connectionId, callId, signal) {
+        const key = this.getKey(connectionId, callId);
+        const rpc = this.rpcs.get(key);
+        if (!rpc)
+            throw new Error(`RPC not found`);
+        const future = this.streams.get(key);
+        if (future) {
+            return future.promise;
+        }
+        else {
+            const newFuture = createFuture();
+            if (signal)
+                signal.addEventListener('abort', () => newFuture.resolve(), {
+                    once: true,
+                });
+            this.streams.set(key, newFuture);
+            return newFuture.promise;
+        }
+    }
+    releasePull(connectionId, callId) {
+        const key = this.getKey(connectionId, callId);
+        const future = this.streams.get(key);
+        if (future) {
+            future.resolve();
+            this.streams.delete(key);
+        }
+    }
+    close(connectionId) {
+        // Iterate all RPCs and abort those belonging to this connection
+        // Optimization: Maintain a Set<callId> per connectionId
+        for (const [key, controller] of this.rpcs) {
+            if (key.startsWith(`${connectionId}:`)) {
+                controller.abort();
+                this.rpcs.delete(key);
+            }
+        }
+        // Also release any pending pulls for this connection
+        for (const key of this.streams.keys()) {
+            if (key.startsWith(`${connectionId}:`)) {
+                const future = this.streams.get(key);
+                if (future) {
+                    future.resolve();
+                    this.streams.delete(key);
+                }
+            }
+        }
+    }
+    getKey(connectionId, callId) {
+        return `${connectionId}:${callId}`;
+    }
+}

package/dist/streams.js

@@ -0,0 +1,277 @@
+import { noopFn } from '@nmtjs/common';
+import { ProtocolClientStream, ProtocolServerStream, } from '@nmtjs/protocol/server';
+import { StreamTimeout } from "./enums.js";
+/**
+ * @todo Clarify Pull/Consume timeout semantics - currently ambiguous whether
+ *       Pull timeout means "client not pulling" or "server not producing" for server streams
+ */
+export class BlobStreamsManager {
+    clientStreams = new Map();
+    serverStreams = new Map();
+    // Index for quick lookup by callId (connectionId:callId -> Set<streamId>)
+    connectionClientStreams = new Map();
+    connectionServerStreams = new Map();
+    clientCallStreams = new Map();
+    serverCallStreams = new Map();
+    timeoutDurations;
+    constructor(config) {
+        this.timeoutDurations = {
+            [StreamTimeout.Pull]: config.timeouts[StreamTimeout.Pull],
+            [StreamTimeout.Consume]: config.timeouts[StreamTimeout.Consume],
+            [StreamTimeout.Finish]: config.timeouts[StreamTimeout.Finish],
+        };
+    }
+    // --- Client Streams (Upload) ---
+    createClientStream(connectionId, callId, streamId, metadata, options) {
+        const stream = new ProtocolClientStream(streamId, metadata, options);
+        stream.on('error', noopFn);
+        const key = this.getKey(connectionId, streamId);
+        const state = {
+            connectionId,
+            callId,
+            stream,
+            timeouts: {
+                [StreamTimeout.Pull]: undefined,
+                [StreamTimeout.Consume]: undefined,
+                [StreamTimeout.Finish]: undefined,
+            },
+        };
+        this.clientStreams.set(key, state);
+        this.trackClientCall(connectionId, callId, streamId);
+        this.trackConnectionClientStream(connectionId, streamId);
+        this.startTimeout(state, StreamTimeout.Consume);
+        return stream;
+    }
+    pushToClientStream(connectionId, streamId, chunk) {
+        const key = this.getKey(connectionId, streamId);
+        const state = this.clientStreams.get(key);
+        if (state) {
+            state.stream.write(chunk);
+            this.clearTimeout(state, StreamTimeout.Consume);
+            this.startTimeout(state, StreamTimeout.Pull);
+        }
+    }
+    endClientStream(connectionId, streamId) {
+        const key = this.getKey(connectionId, streamId);
+        const state = this.clientStreams.get(key);
+        if (state) {
+            state.stream.end(null);
+            this.removeClientStream(connectionId, streamId);
+        }
+    }
+    abortClientStream(connectionId, streamId, error = 'Aborted') {
+        const key = this.getKey(connectionId, streamId);
+        const state = this.clientStreams.get(key);
+        if (state) {
+            state.stream.destroy(new Error(error));
+            this.removeClientStream(connectionId, streamId);
+        }
+    }
+    consumeClientStream(connectionId, callId, streamId) {
+        this.untrackClientCall(connectionId, callId, streamId);
+    }
+    removeClientStream(connectionId, streamId) {
+        const key = this.getKey(connectionId, streamId);
+        const state = this.clientStreams.get(key);
+        if (state) {
+            this.clientStreams.delete(key);
+            this.clearTimeout(state, StreamTimeout.Finish);
+            this.clearTimeout(state, StreamTimeout.Pull);
+            this.clearTimeout(state, StreamTimeout.Consume);
+            this.untrackClientCall(connectionId, state.callId, streamId);
+            this.untrackConnectionClientStream(connectionId, streamId);
+        }
+    }
+    // --- Server Streams (Download) ---
+    getServerStreamsMetadata(connectionId, callId) {
+        const key = this.getCallKey(connectionId, callId);
+        const streamIds = this.serverCallStreams.get(key);
+        const streams = {};
+        if (streamIds) {
+            for (const streamId of streamIds) {
+                const streamKey = this.getKey(connectionId, streamId);
+                const state = this.serverStreams.get(streamKey);
+                if (state) {
+                    streams[streamId] = state.stream.metadata;
+                }
+            }
+        }
+        return streams;
+    }
+    createServerStream(connectionId, callId, streamId, blob) {
+        const stream = new ProtocolServerStream(streamId, blob);
+        const key = this.getKey(connectionId, streamId);
+        const state = {
+            connectionId,
+            callId,
+            stream,
+            timeouts: {
+                [StreamTimeout.Pull]: undefined,
+                [StreamTimeout.Consume]: undefined,
+                [StreamTimeout.Finish]: undefined,
+            },
+        };
+        // Prevent unhandled 'error' events, in case the user did not subscribe to them
+        stream.on('error', noopFn);
+        this.serverStreams.set(key, state);
+        this.trackServerCall(connectionId, callId, streamId);
+        this.trackConnectionServerStream(connectionId, streamId);
+        this.startTimeout(state, StreamTimeout.Finish);
+        this.startTimeout(state, StreamTimeout.Consume);
+        return stream;
+    }
+    pullServerStream(connectionId, streamId) {
+        const key = this.getKey(connectionId, streamId);
+        const state = this.serverStreams.get(key);
+        if (state) {
+            state.stream.resume();
+            this.clearTimeout(state, StreamTimeout.Consume);
+            this.startTimeout(state, StreamTimeout.Pull);
+        }
+    }
+    abortServerStream(connectionId, streamId, error = 'Aborted') {
+        const key = this.getKey(connectionId, streamId);
+        const state = this.serverStreams.get(key);
+        if (state) {
+            state.stream.destroy(new Error(error));
+            this.removeServerStream(connectionId, streamId);
+        }
+    }
+    removeServerStream(connectionId, streamId) {
+        const key = this.getKey(connectionId, streamId);
+        const state = this.serverStreams.get(key);
+        if (state) {
+            this.serverStreams.delete(key);
+            this.clearTimeout(state, StreamTimeout.Pull);
+            this.clearTimeout(state, StreamTimeout.Consume);
+            this.clearTimeout(state, StreamTimeout.Finish);
+            this.untrackServerCall(connectionId, state.callId, streamId);
+            this.untrackConnectionServerStream(connectionId, streamId);
+        }
+    }
+    // --- Timeouts ---
+    startTimeout(state, type) {
+        this.clearTimeout(state, type);
+        const duration = this.timeoutDurations[type];
+        const timeout = setTimeout(() => {
+            if (state.stream instanceof ProtocolClientStream) {
+                this.abortClientStream(state.connectionId, state.stream.id, `${type} timeout`);
+            }
+            else {
+                this.abortServerStream(state.connectionId, state.stream.id, `${type} timeout`);
+            }
+            state.timeouts[type] = undefined;
+        }, duration);
+        state.timeouts[type] = timeout;
+    }
+    clearTimeout(state, type) {
+        const timeout = state.timeouts[type];
+        if (timeout) {
+            clearTimeout(timeout);
+            state.timeouts[type] = undefined;
+        }
+    }
+    // --- Helpers ---
+    getKey(connectionId, streamId) {
+        return `${connectionId}:${streamId}`;
+    }
+    getCallKey(connectionId, callId) {
+        return `${connectionId}:${callId}`;
+    }
+    trackClientCall(connectionId, callId, streamId) {
+        const key = this.getCallKey(connectionId, callId);
+        let set = this.clientCallStreams.get(key);
+        if (!set) {
+            set = new Set();
+            this.clientCallStreams.set(key, set);
+        }
+        set.add(streamId);
+    }
+    untrackClientCall(connectionId, callId, streamId) {
+        const key = this.getCallKey(connectionId, callId);
+        const set = this.clientCallStreams.get(key);
+        if (set) {
+            set.delete(streamId);
+            if (set.size === 0) {
+                this.clientCallStreams.delete(key);
+            }
+        }
+    }
+    trackServerCall(connectionId, callId, streamId) {
+        const key = this.getCallKey(connectionId, callId);
+        let set = this.serverCallStreams.get(key);
+        if (!set) {
+            set = new Set();
+            this.serverCallStreams.set(key, set);
+        }
+        set.add(streamId);
+    }
+    untrackServerCall(connectionId, callId, streamId) {
+        const key = this.getCallKey(connectionId, callId);
+        const set = this.serverCallStreams.get(key);
+        if (set) {
+            set.delete(streamId);
+            if (set.size === 0) {
+                this.serverCallStreams.delete(key);
+            }
+        }
+    }
+    trackConnectionClientStream(connectionId, streamId) {
+        let set = this.connectionClientStreams.get(connectionId);
+        if (!set) {
+            set = new Set();
+            this.connectionClientStreams.set(connectionId, set);
+        }
+        set.add(streamId);
+    }
+    untrackConnectionClientStream(connectionId, streamId) {
+        const set = this.connectionClientStreams.get(connectionId);
+        if (set) {
+            set.delete(streamId);
+            if (set.size === 0) {
+                this.connectionClientStreams.delete(connectionId);
+            }
+        }
+    }
+    trackConnectionServerStream(connectionId, streamId) {
+        let set = this.connectionServerStreams.get(connectionId);
+        if (!set) {
+            set = new Set();
+            this.connectionServerStreams.set(connectionId, set);
+        }
+        set.add(streamId);
+    }
+    untrackConnectionServerStream(connectionId, streamId) {
+        const set = this.connectionServerStreams.get(connectionId);
+        if (set) {
+            set.delete(streamId);
+            if (set.size === 0) {
+                this.connectionServerStreams.delete(connectionId);
+            }
+        }
+    }
+    // --- Cleanup ---
+    abortClientCallStreams(connectionId, callId, reason = 'Call aborted') {
+        const key = this.getCallKey(connectionId, callId);
+        const clientStreamIds = this.clientCallStreams.get(key);
+        if (clientStreamIds) {
+            for (const streamId of [...clientStreamIds]) {
+                this.abortClientStream(connectionId, streamId, reason);
+            }
+        }
+    }
+    cleanupConnection(connectionId) {
+        const clientStreamIds = this.connectionClientStreams.get(connectionId);
+        if (clientStreamIds) {
+            for (const streamId of [...clientStreamIds]) {
+                this.abortClientStream(connectionId, streamId, 'Connection closed');
+            }
+        }
+        const serverStreamIds = this.connectionServerStreams.get(connectionId);
+        if (serverStreamIds) {
+            for (const streamId of [...serverStreamIds]) {
+                this.abortServerStream(connectionId, streamId, 'Connection closed');
+            }
+        }
+    }
+}

package/dist/transport.js

@@ -0,0 +1,3 @@
+export function createTransport(config) {
+    return config;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -6,26 +6,26 @@
   },
   "dependencies": {
     "hookable": "6.0.0-rc.1",
-    "@nmtjs/common": "0.15.0-beta.1",
-    "@nmtjs/core": "0.15.0-beta.1",
-    "@nmtjs/type": "0.15.0-beta.1",
-    "@nmtjs/protocol": "0.15.0-beta.1"
+    "@nmtjs/core": "0.15.0-beta.2",
+    "@nmtjs/type": "0.15.0-beta.2",
+    "@nmtjs/common": "0.15.0-beta.2",
+    "@nmtjs/protocol": "0.15.0-beta.2"
   },
   "peerDependencies": {
-    "@nmtjs/common": "0.15.0-beta.1",
-    "@nmtjs/core": "0.15.0-beta.1",
-    "@nmtjs/type": "0.15.0-beta.1",
-    "@nmtjs/protocol": "0.15.0-beta.1"
+    "@nmtjs/common": "0.15.0-beta.2",
+    "@nmtjs/type": "0.15.0-beta.2",
+    "@nmtjs/protocol": "0.15.0-beta.2",
+    "@nmtjs/core": "0.15.0-beta.2"
   },
   "devDependencies": {
-    "@nmtjs/_tests": "0.15.0-beta.1"
+    "@nmtjs/_tests": "0.15.0-beta.2"
   },
   "files": [
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.15.0-beta.1",
+  "version": "0.15.0-beta.2",
   "scripts": {
     "clean-build": "rm -rf ./dist",
     "build": "tsc",