@nmtjs/client 0.14.5 → 0.15.0-beta.2

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/dist/clients/runtime.js

@@ -0,0 +1,80 @@
+import { IsProcedureContract, IsRouterContract } from '@nmtjs/contract';
+import { BaseClient } from "../core.js";
+export class RuntimeContractTransformer {
+    #procedures = new Map();
+    constructor(router) {
+        const registerProcedures = (r, path = []) => {
+            if (IsRouterContract(r)) {
+                for (const [key, route] of Object.entries(r.routes)) {
+                    registerProcedures(route, [...path, key]);
+                }
+            }
+            else if (IsProcedureContract(r)) {
+                const fullName = [...path].join('/');
+                this.#procedures.set(fullName, r);
+            }
+        };
+        registerProcedures(router);
+    }
+    encode(_procedure, payload) {
+        const procedure = this.#procedures.get(_procedure);
+        if (!procedure)
+            throw new Error(`Procedure not found: ${_procedure}`);
+        return procedure.input.encode(payload);
+    }
+    decode(_procedure, payload) {
+        const procedure = this.#procedures.get(_procedure);
+        if (!procedure)
+            throw new Error(`Procedure not found: ${_procedure}`);
+        return procedure.output.decode(payload);
+    }
+}
+export class RuntimeClient extends BaseClient {
+    transformer;
+    #procedures = new Map();
+    #callers;
+    constructor(options, transport, transportOptions) {
+        super(options, transport, transportOptions);
+        this.resolveProcedures(this.options.contract);
+        this.transformer = new RuntimeContractTransformer(this.options.contract);
+        this.#callers = this.buildCallers();
+    }
+    get call() {
+        return this.#callers;
+    }
+    get stream() {
+        return this.#callers;
+    }
+    resolveProcedures(router, path = []) {
+        for (const [key, route] of Object.entries(router.routes)) {
+            if (IsRouterContract(route)) {
+                this.resolveProcedures(route, [...path, key]);
+            }
+            else if (IsProcedureContract(route)) {
+                const fullName = [...path, key].join('/');
+                this.#procedures.set(fullName, route);
+            }
+        }
+    }
+    buildCallers() {
+        const callers = Object.create(null);
+        for (const [name, { stream }] of this.#procedures) {
+            const parts = name.split('/');
+            let current = callers;
+            for (let i = 0; i < parts.length; i++) {
+                const part = parts[i];
+                if (i === parts.length - 1) {
+                    current[part] = (payload, options) => this._call(name, payload, {
+                        ...options,
+                        _stream_response: !!stream,
+                    });
+                }
+                else {
+                    current[part] = current[part] ?? Object.create(null);
+                    current = current[part];
+                }
+            }
+        }
+        return callers;
+    }
+}

package/dist/clients/static.js

@@ -0,0 +1,26 @@
+import { BaseClient } from "../core.js";
+import { BaseClientTransformer } from "../transformers.js";
+export class StaticClient extends BaseClient {
+    transformer;
+    constructor(options, transport, transportOptions) {
+        super(options, transport, transportOptions);
+        this.transformer = new BaseClientTransformer();
+    }
+    get call() {
+        return this.createProxy(Object.create(null), false);
+    }
+    get stream() {
+        return this.createProxy(Object.create(null), true);
+    }
+    createProxy(target, isStream, path = []) {
+        return new Proxy(target, {
+            get: (obj, prop) => {
+                if (prop === 'then')
+                    return obj;
+                const newPath = [...path, String(prop)];
+                const caller = (payload, options) => this._call(newPath.join('/'), payload, options);
+                return this.createProxy(caller, isStream, newPath);
+            },
+        });
+    }
+}

package/dist/core.js

@@ -0,0 +1,410 @@
+import { anyAbortSignal, createFuture, MAX_UINT32, noopFn } 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";
+export { ErrorCode, ProtocolBlob, } from '@nmtjs/protocol';
+export * from "./types.js";
+export class ClientError extends ProtocolError {
+}
+const DEFAULT_RECONNECT_TIMEOUT = 1000;
+const DEFAULT_MAX_RECONNECT_TIMEOUT = 60000;
+/**
+ * @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
+ */
+export class BaseClient extends EventEmitter {
+    options;
+    transportFactory;
+    transportOptions;
+    _;
+    calls = new Map();
+    transport;
+    protocol;
+    messageContext;
+    clientStreams = new ClientStreams();
+    serverStreams = new ServerStreams();
+    rpcStreams = new ServerStreams();
+    callId = 0;
+    streamId = 0;
+    cab = null;
+    reconnectTimeout = DEFAULT_RECONNECT_TIMEOUT;
+    #auth;
+    constructor(options, transportFactory, transportOptions) {
+        super();
+        this.options = options;
+        this.transportFactory = transportFactory;
+        this.transportOptions = transportOptions;
+        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) => {
+                if (reason === 'server') {
+                    this.connect();
+                }
+                else if (reason === 'error') {
+                    const timeout = new Promise((resolve) => setTimeout(resolve, this.reconnectTimeout));
+                    const connected = new Promise((_, reject) => this.once('connected', reject));
+                    this.reconnectTimeout = Math.min(this.reconnectTimeout * 2, DEFAULT_MAX_RECONNECT_TIMEOUT);
+                    await Promise.race([timeout, connected]).then(this.connect.bind(this), noopFn);
+                }
+            });
+            this.on('connected', () => {
+                this.reconnectTimeout = DEFAULT_RECONNECT_TIMEOUT;
+            });
+            if (globalThis.window) {
+                globalThis.window.addEventListener('pageshow', () => {
+                    if (!this.cab)
+                        this.connect();
+                });
+            }
+        }
+    }
+    get auth() {
+        return this.#auth;
+    }
+    set auth(value) {
+        this.#auth = value;
+    }
+    async connect() {
+        if (this.transport.type === ConnectionType.Bidirectional) {
+            this.cab = new AbortController();
+            const protocol = this.protocol;
+            const serverStreams = this.serverStreams;
+            const transport = {
+                send: (buffer) => {
+                    this.#send(buffer).catch(noopFn);
+                },
+            };
+            this.messageContext = {
+                transport,
+                encoder: this.options.format,
+                decoder: this.options.format,
+                addClientStream: (blob) => {
+                    const streamId = this.#getStreamId();
+                    return this.clientStreams.add(blob.source, streamId, blob.metadata);
+                },
+                addServerStream(streamId, metadata) {
+                    const stream = new ProtocolServerBlobStream(metadata, {
+                        pull: (controller) => {
+                            transport.send(protocol.encodeMessage(this, ClientMessageType.ServerStreamPull, { streamId, size: 65535 /* 64kb by default */ }));
+                        },
+                        close: () => {
+                            serverStreams.remove(streamId);
+                        },
+                        readableStrategy: { highWaterMark: 0 },
+                    });
+                    serverStreams.add(streamId, stream);
+                    return ({ signal } = {}) => {
+                        if (signal)
+                            signal.addEventListener('abort', () => {
+                                transport.send(protocol.encodeMessage(this, ClientMessageType.ServerStreamAbort, { streamId }));
+                                serverStreams.abort(streamId);
+                            }, { once: true });
+                        return stream;
+                    };
+                },
+                streamId: this.#getStreamId.bind(this),
+            };
+            return this.transport.connect({
+                auth: this.auth,
+                application: this.options.application,
+                onMessage: this.onMessage.bind(this),
+                onConnect: this.onConnect.bind(this),
+                onDisconnect: this.onDisconnect.bind(this),
+            });
+        }
+    }
+    async disconnect() {
+        if (this.transport.type === ConnectionType.Bidirectional) {
+            this.cab.abort();
+            await this.transport.disconnect();
+            this.messageContext = null;
+            this.cab = null;
+        }
+    }
+    blob(source, metadata) {
+        return ProtocolBlob.from(source, metadata);
+    }
+    async _call(procedure, payload, options = {}) {
+        const timeout = options.timeout ?? this.options.timeout;
+        const controller = new AbortController();
+        // attach all abort signals
+        const signals = [controller.signal];
+        if (timeout)
+            signals.push(AbortSignal.timeout(timeout));
+        if (options.signal)
+            signals.push(options.signal);
+        if (this.cab?.signal)
+            signals.push(this.cab.signal);
+        const signal = signals.length ? anyAbortSignal(...signals) : undefined;
+        const callId = this.#getCallId();
+        const call = createFuture();
+        call.procedure = procedure;
+        call.signal = signal;
+        this.calls.set(callId, call);
+        // Check if signal is already aborted before proceeding
+        if (signal?.aborted) {
+            this.calls.delete(callId);
+            const error = new ProtocolError(ErrorCode.ClientRequestError, signal.reason);
+            call.reject(error);
+        }
+        else {
+            if (signal) {
+                signal.addEventListener('abort', () => {
+                    call.reject(new ProtocolError(ErrorCode.ClientRequestError, signal.reason));
+                    if (this.transport.type === ConnectionType.Bidirectional &&
+                        this.messageContext) {
+                        const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.RpcAbort, { callId });
+                        this.#send(buffer).catch(noopFn);
+                    }
+                }, { once: true });
+            }
+            try {
+                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);
+                }
+                else {
+                    const response = await this.transport.call({
+                        application: this.options.application,
+                        format: this.options.format,
+                        auth: this.auth,
+                    }, { callId, procedure, payload: transformedPayload }, { signal, _stream_response: options._stream_response });
+                    this.#handleCallResponse(callId, response);
+                }
+            }
+            catch (error) {
+                call.reject(error);
+            }
+        }
+        const result = call.promise.then((value) => {
+            if (value instanceof ProtocolServerRPCStream) {
+                return value.createAsyncIterable(() => {
+                    controller.abort();
+                });
+            }
+            controller.abort();
+            return value;
+        }, (err) => {
+            controller.abort();
+            throw err;
+        });
+        if (this.options.safe) {
+            return await result
+                .then((result) => ({ result }))
+                .catch((error) => ({ error }))
+                .finally(() => {
+                this.calls.delete(callId);
+            });
+        }
+        else {
+            return await result.finally(() => {
+                this.calls.delete(callId);
+            });
+        }
+    }
+    async onConnect() {
+        this.emit('connected');
+    }
+    async onDisconnect(reason) {
+        this.emit('disconnected', reason);
+        this.clientStreams.clear(reason);
+        this.serverStreams.clear(reason);
+        this.rpcStreams.clear(reason);
+    }
+    async onMessage(buffer) {
+        if (!this.messageContext)
+            return;
+        const message = this.protocol.decodeMessage(this.messageContext, buffer);
+        switch (message.type) {
+            case ServerMessageType.RpcResponse:
+                this.#handleRPCResponseMessage(message);
+                break;
+            case ServerMessageType.RpcStreamResponse:
+                this.#handleRPCStreamResponseMessage(message);
+                break;
+            case ServerMessageType.RpcStreamChunk:
+                this.rpcStreams.push(message.callId, message.chunk);
+                break;
+            case ServerMessageType.RpcStreamEnd:
+                this.rpcStreams.end(message.callId);
+                this.calls.delete(message.callId);
+                break;
+            case ServerMessageType.RpcStreamAbort:
+                this.rpcStreams.abort(message.callId);
+                this.calls.delete(message.callId);
+                break;
+            case ServerMessageType.ServerStreamPush:
+                this.serverStreams.push(message.streamId, message.chunk);
+                break;
+            case ServerMessageType.ServerStreamEnd:
+                this.serverStreams.end(message.streamId);
+                break;
+            case ServerMessageType.ServerStreamAbort:
+                this.serverStreams.abort(message.streamId);
+                break;
+            case ServerMessageType.ClientStreamPull:
+                this.clientStreams.pull(message.streamId, message.size).then((chunk) => {
+                    if (chunk) {
+                        const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.ClientStreamPush, { streamId: message.streamId, chunk });
+                        this.#send(buffer).catch(noopFn);
+                    }
+                    else {
+                        const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.ClientStreamEnd, { streamId: message.streamId });
+                        this.#send(buffer).catch(noopFn);
+                        this.clientStreams.end(message.streamId);
+                    }
+                }, () => {
+                    const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.ClientStreamAbort, { streamId: message.streamId });
+                    this.#send(buffer).catch(noopFn);
+                    this.clientStreams.remove(message.streamId);
+                });
+                break;
+            case ServerMessageType.ClientStreamAbort:
+                this.clientStreams.abort(message.streamId);
+                break;
+        }
+    }
+    #handleRPCResponseMessage(message) {
+        const { callId, result, error } = message;
+        const call = this.calls.get(callId);
+        if (!call)
+            return;
+        if (error) {
+            call.reject(new ProtocolError(error.code, error.message, error.data));
+        }
+        else {
+            try {
+                const transformed = this.transformer.decode(call.procedure, result);
+                call.resolve(transformed);
+            }
+            catch (error) {
+                call.reject(new ProtocolError(ErrorCode.ClientRequestError, 'Unable to decode response', error));
+            }
+        }
+    }
+    #handleRPCStreamResponseMessage(message) {
+        const call = this.calls.get(message.callId);
+        if (message.error) {
+            if (!call)
+                return;
+            call.reject(new ProtocolError(message.error.code, message.error.message, message.error.data));
+        }
+        else {
+            if (call) {
+                const { procedure, signal } = call;
+                const stream = new ProtocolServerRPCStream({
+                    start: (controller) => {
+                        if (signal) {
+                            if (signal.aborted)
+                                controller.error(signal.reason);
+                            else
+                                signal.addEventListener('abort', () => {
+                                    controller.error(signal.reason);
+                                    if (this.rpcStreams.has(message.callId)) {
+                                        this.rpcStreams.remove(message.callId);
+                                        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);
+                                        }
+                                    }
+                                }, { once: true });
+                        }
+                    },
+                    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);
+                call.resolve(stream);
+            }
+            else {
+                // Call not found, but stream response received
+                // This can happen if the call was aborted or timed out
+                // 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);
+                }
+            }
+        }
+    }
+    #handleCallResponse(callId, response) {
+        const call = this.calls.get(callId);
+        if (response.type === 'rpc_stream') {
+            if (call) {
+                const stream = new ProtocolServerStream({
+                    transform: (chunk) => {
+                        return this.transformer.decode(call.procedure, this.options.format.decode(chunk));
+                    },
+                });
+                this.rpcStreams.add(callId, stream);
+                call.resolve(({ signal }) => {
+                    response.stream.pipeTo(stream.writable, { signal }).catch(noopFn);
+                    return stream;
+                });
+            }
+            else {
+                // Call not found, but stream response received
+                // This can happen if the call was aborted or timed out
+                // Need to cancel the stream to avoid resource leaks from server side
+                response.stream.cancel().catch(noopFn);
+            }
+        }
+        else if (response.type === 'blob') {
+            if (call) {
+                const { metadata, source } = response;
+                const stream = new ProtocolServerBlobStream(metadata);
+                this.serverStreams.add(this.#getStreamId(), stream);
+                call.resolve(({ signal }) => {
+                    source.pipeTo(stream.writable, { signal }).catch(noopFn);
+                    return stream;
+                });
+            }
+            else {
+                // Call not found, but blob response received
+                // This can happen if the call was aborted or timed out
+                // Need to cancel the stream to avoid resource leaks from server side
+                response.source.cancel().catch(noopFn);
+            }
+        }
+        else if (response.type === 'rpc') {
+            if (!call)
+                return;
+            try {
+                const transformed = this.transformer.decode(call.procedure, response.result);
+                call.resolve(transformed);
+            }
+            catch (error) {
+                call.reject(new ProtocolError(ErrorCode.ClientRequestError, 'Unable to decode response', error));
+            }
+        }
+    }
+    #send(buffer, signal) {
+        if (this.transport.type === ConnectionType.Unidirectional)
+            throw new Error('Invalid transport type for send');
+        return this.transport.send(buffer, { signal });
+    }
+    #getStreamId() {
+        if (this.streamId >= MAX_UINT32) {
+            this.streamId = 0;
+        }
+        return this.streamId++;
+    }
+    #getCallId() {
+        if (this.callId >= MAX_UINT32) {
+            this.callId = 0;
+        }
+        return this.callId++;
+    }
+}

package/dist/events.js

@@ -0,0 +1,33 @@
+// TODO: add errors and promise rejections handling
+/**
+ * Thin 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 }));
+    }
+}
+export const once = (ee, event, signal) => {
+    return new Promise((resolve) => {
+        ee.once(event, resolve, { signal });
+    });
+};

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./core.js";
+export * from "./events.js";
+export * from "./transformers.js";
+export * from "./transport.js";
+export * from "./types.js";

package/dist/streams.js

@@ -0,0 +1,100 @@
+import { ProtocolClientBlobStream } from '@nmtjs/protocol/client';
+export class ClientStreams {
+    #collection = new Map();
+    get size() {
+        return this.#collection.size;
+    }
+    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);
+    }
+    async abort(streamId, reason) {
+        const stream = this.#collection.get(streamId);
+        if (!stream)
+            return; // Stream already cleaned up
+        await stream.abort(reason);
+        this.remove(streamId);
+    }
+    pull(streamId, size) {
+        const stream = this.get(streamId);
+        return stream.read(size);
+    }
+    async end(streamId) {
+        await this.get(streamId).end();
+        this.remove(streamId);
+    }
+    async clear(reason) {
+        if (reason) {
+            const abortPromises = [...this.#collection.values()].map((stream) => stream.abort(reason));
+            await Promise.all(abortPromises);
+        }
+        this.#collection.clear();
+    }
+}
+export class ServerStreams {
+    #collection = new Map();
+    #writers = new Map();
+    get size() {
+        return this.#collection.size;
+    }
+    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);
+        this.#writers.set(streamId, stream.writable.getWriter());
+        return stream;
+    }
+    remove(streamId) {
+        this.#collection.delete(streamId);
+        this.#writers.delete(streamId);
+    }
+    async abort(streamId) {
+        if (this.has(streamId)) {
+            const writer = this.#writers.get(streamId);
+            if (writer) {
+                await writer.abort();
+                writer.releaseLock();
+            }
+            this.remove(streamId);
+        }
+    }
+    async push(streamId, chunk) {
+        const writer = this.#writers.get(streamId);
+        if (writer) {
+            return await writer.write(chunk);
+        }
+    }
+    async end(streamId) {
+        const writer = this.#writers.get(streamId);
+        if (writer) {
+            await writer.close();
+            writer.releaseLock();
+        }
+        this.remove(streamId);
+    }
+    async clear(reason) {
+        if (reason) {
+            const abortPromises = [...this.#writers.values()].map((writer) => writer.abort(reason).finally(() => writer.releaseLock()));
+            await Promise.allSettled(abortPromises);
+        }
+        this.#collection.clear();
+        this.#writers.clear();
+    }
+}

package/dist/transformers.js

@@ -0,0 +1,8 @@
+export class BaseClientTransformer {
+    encode(_procedure, payload) {
+        return payload;
+    }
+    decode(_procedure, payload) {
+        return payload;
+    }
+}

package/dist/transport.js

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

package/dist/types.js

@@ -1 +1 @@
-export {};
+export const ResolvedType = Symbol('ResolvedType');

package/package.json

@@ -2,42 +2,33 @@
   "name": "@nmtjs/client",
   "type": "module",
   "exports": {
-    ".": {
-      "types": "./dist/common.d.ts",
-      "import": "./dist/common.js",
-      "module-sync": "./dist/common.js"
-    },
-    "./runtime": {
-      "types": "./dist/runtime.d.ts",
-      "import": "./dist/runtime.js",
-      "module-sync": "./dist/runtime.js"
-    },
-    "./static": {
-      "types": "./dist/static.d.ts",
-      "import": "./dist/static.js",
-      "module-sync": "./dist/static.js"
-    }
+    ".": "./dist/index.js",
+    "./runtime": "./dist/clients/runtime.js",
+    "./static": "./dist/clients/static.js"
   },
   "peerDependencies": {
-    "@nmtjs/type": "0.14.5",
-    "@nmtjs/common": "0.14.5",
-    "@nmtjs/protocol": "0.14.5",
-    "@nmtjs/contract": "0.14.5"
+    "@nmtjs/type": "0.15.0-beta.2",
+    "@nmtjs/contract": "0.15.0-beta.2",
+    "@nmtjs/protocol": "0.15.0-beta.2",
+    "@nmtjs/common": "0.15.0-beta.2"
   },
   "devDependencies": {
-    "@nmtjs/type": "0.14.5",
-    "@nmtjs/contract": "0.14.5",
-    "@nmtjs/common": "0.14.5",
-    "@nmtjs/protocol": "0.14.5"
+    "@nmtjs/_tests": "0.15.0-beta.2",
+    "@nmtjs/contract": "0.15.0-beta.2",
+    "@nmtjs/common": "0.15.0-beta.2",
+    "@nmtjs/type": "0.15.0-beta.2",
+    "@nmtjs/protocol": "0.15.0-beta.2"
   },
   "files": [
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.14.5",
+  "version": "0.15.0-beta.2",
   "scripts": {
+    "clean-build": "rm -rf ./dist",
     "build": "tsc",
+    "dev": "tsc --watch",
     "type-check": "tsc --noEmit"
   }
 }

package/dist/common.d.ts

@@ -1,38 +0,0 @@
-import type { TypeProvider } from '@nmtjs/common';
-import type { TAnyAPIContract } from '@nmtjs/contract';
-import type { ProtocolBaseClientCallOptions, ProtocolBaseTransformer, ProtocolTransport } from '@nmtjs/protocol/client';
-import { ProtocolError } from '@nmtjs/protocol/client';
-import type { ClientCallers, ResolveAPIRouterRoutes } from './types.ts';
-export { ErrorCode, ProtocolBlob, type ProtocolBlobMetadata, TransportType, } from '@nmtjs/protocol';
-export * from './types.ts';
-export declare class ClientError extends ProtocolError {
-}
-export interface BaseClientOptions<SafeCall extends boolean = false> {
-    timeout: number;
-    autoreconnect?: boolean;
-    safe?: SafeCall;
-}
-export declare abstract class BaseClient<APIContract extends TAnyAPIContract = TAnyAPIContract, SafeCall extends boolean = false, InputTypeProvider extends TypeProvider = TypeProvider, OutputTypeProvider extends TypeProvider = TypeProvider, Routes extends {
-    contract: APIContract['router'];
-    routes: ResolveAPIRouterRoutes<APIContract['router'], InputTypeProvider, OutputTypeProvider>;
-} = {
-    contract: APIContract['router'];
-    routes: ResolveAPIRouterRoutes<APIContract['router'], InputTypeProvider, OutputTypeProvider>;
-}> {
-    readonly transport: ProtocolTransport;
-    readonly options: BaseClientOptions<SafeCall>;
-    _: {
-        api: Routes;
-        safe: SafeCall;
-    };
-    protected abstract transformer: ProtocolBaseTransformer;
-    protected callers: ClientCallers<Routes, SafeCall>;
-    auth: any;
-    protected reconnectTimeout: number;
-    constructor(transport: ProtocolTransport, options: BaseClientOptions<SafeCall>);
-    protected _call(procedure: string, payload: any, options: ProtocolBaseClientCallOptions): Promise<any>;
-    get call(): ClientCallers<Routes, SafeCall>;
-    setAuth(auth: any): void;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-}

package/dist/common.js

@@ -1,60 +0,0 @@
-import { noopFn } from '@nmtjs/common';
-import { ProtocolError } from '@nmtjs/protocol/client';
-export { ErrorCode, ProtocolBlob, TransportType, } from '@nmtjs/protocol';
-export * from "./types.js";
-export class ClientError extends ProtocolError {
-}
-const DEFAULT_RECONNECT_TIMEOUT = 1000;
-export class BaseClient {
-    transport;
-    options;
-    _;
-    callers;
-    auth;
-    reconnectTimeout = DEFAULT_RECONNECT_TIMEOUT;
-    constructor(transport, options) {
-        this.transport = transport;
-        this.options = options;
-        if (this.options.autoreconnect) {
-            this.transport.on('disconnected', async (reason) => {
-                if (reason === 'server') {
-                    this.connect();
-                }
-                else if (reason === 'error') {
-                    const timeout = new Promise((resolve) => setTimeout(resolve, this.reconnectTimeout));
-                    const connected = new Promise((_, reject) => this.transport.once('connected', reject));
-                    this.reconnectTimeout += DEFAULT_RECONNECT_TIMEOUT;
-                    await Promise.race([timeout, connected]).then(this.connect.bind(this), noopFn);
-                }
-            });
-            this.transport.on('connected', () => {
-                this.reconnectTimeout = DEFAULT_RECONNECT_TIMEOUT;
-            });
-        }
-    }
-    async _call(procedure, payload, options) {
-        const call = await this.transport.call(procedure, payload, options, this.transformer);
-        if (this.options.safe) {
-            return await call.promise
-                .then((result) => ({ result }))
-                .catch((error) => ({ error }));
-        }
-        else {
-            return await call.promise.catch((error) => {
-                throw error;
-            });
-        }
-    }
-    get call() {
-        return this.callers;
-    }
-    setAuth(auth) {
-        this.auth = auth;
-    }
-    connect() {
-        return this.transport.connect(this.auth, this.transformer);
-    }
-    disconnect() {
-        return this.transport.disconnect();
-    }
-}

package/dist/runtime.d.ts

@@ -1,21 +0,0 @@
-import type { TAnyAPIContract, TAnyProcedureContract, TAnyRouterContract } from '@nmtjs/contract';
-import { ProtocolBaseTransformer } from '@nmtjs/protocol/client';
-import type { RuntimeInputContractTypeProvider, RuntimeOutputContractTypeProvider } from './common.ts';
-import { BaseClient } from './common.ts';
-export declare class RuntimeContractTransformer extends ProtocolBaseTransformer {
-    protected procedures: Map<string, TAnyProcedureContract>;
-    constructor(procedures: Map<string, TAnyProcedureContract>);
-    decodeRPC(procedure: string, payload: any): any;
-    decodeRPCChunk(procedure: string, payload: any): unknown;
-    encodeRPC(procedure: string, payload: any): unknown;
-    protected getProcedureContract(procedure: string): TAnyProcedureContract;
-    protected build(router: TAnyRouterContract): void;
-}
-export declare class RuntimeClient<APIContract extends TAnyAPIContract, SafeCall extends boolean = false> extends BaseClient<APIContract, SafeCall, RuntimeInputContractTypeProvider, RuntimeOutputContractTypeProvider> {
-    contract: APIContract;
-    protected transformer: RuntimeContractTransformer;
-    protected procedures: Map<string, TAnyProcedureContract>;
-    constructor(contract: APIContract, ...args: ConstructorParameters<typeof BaseClient<APIContract, SafeCall>>);
-    protected resolveProcedures(router: TAnyRouterContract): void;
-    protected buildCallers(): any;
-}

package/dist/runtime.js

@@ -1,105 +0,0 @@
-import { IsProcedureContract, IsRouterContract } from '@nmtjs/contract';
-import { ErrorCode } from '@nmtjs/protocol';
-import { ProtocolBaseTransformer } from '@nmtjs/protocol/client';
-import { NeemataTypeError, t } from '@nmtjs/type';
-import { BaseClient, ClientError } from "./common.js";
-export class RuntimeContractTransformer extends ProtocolBaseTransformer {
-    procedures;
-    constructor(procedures) {
-        super();
-        this.procedures = procedures;
-    }
-    decodeRPC(procedure, payload) {
-        const contract = this.getProcedureContract(procedure);
-        const type = contract.output;
-        if (type instanceof t.NeverType)
-            return undefined;
-        return payload;
-    }
-    decodeRPCChunk(procedure, payload) {
-        const contract = this.getProcedureContract(procedure);
-        const type = contract.stream;
-        if (!type || type instanceof t.NeverType)
-            return undefined;
-        return type.decode(payload);
-    }
-    encodeRPC(procedure, payload) {
-        const contract = this.getProcedureContract(procedure);
-        const type = contract.input;
-        if (type instanceof t.NeverType)
-            return undefined;
-        try {
-            return type.encode(payload);
-        }
-        catch (error) {
-            if (error instanceof NeemataTypeError) {
-                throw new ClientError(ErrorCode.ValidationError, `Invalid payload for ${procedure}: ${error.message}`, error.issues);
-            }
-            throw error;
-        }
-    }
-    getProcedureContract(procedure) {
-        const proc = this.procedures.get(procedure);
-        if (!proc) {
-            throw new ClientError(ErrorCode.NotFound, `Procedure contract not found for procedure: ${procedure}`);
-        }
-        return proc;
-    }
-    build(router) {
-        const routes = Object.values(router.routes);
-        for (const route of routes) {
-            if (IsRouterContract(route)) {
-                this.build(route);
-            }
-            else if (IsProcedureContract(route)) {
-                this.procedures.set(route.name, route);
-            }
-        }
-    }
-}
-export class RuntimeClient extends BaseClient {
-    contract;
-    transformer;
-    procedures = new Map();
-    constructor(contract, ...args) {
-        super(...args);
-        this.contract = contract;
-        this.resolveProcedures(this.contract.router);
-        this.transformer = new RuntimeContractTransformer(this.procedures);
-        this.callers = this.buildCallers();
-    }
-    resolveProcedures(router) {
-        const routes = Object.values(router.routes);
-        for (const route of routes) {
-            if (IsRouterContract(route)) {
-                this.resolveProcedures(route);
-            }
-            else if (IsProcedureContract(route)) {
-                this.procedures.set(route.name, route);
-            }
-        }
-    }
-    buildCallers() {
-        const callers = Object.create(null);
-        for (const [name, procedure] of this.procedures) {
-            const parts = name.split('/');
-            let current = callers;
-            for (let i = 0; i < parts.length; i++) {
-                const part = parts[i];
-                if (i === parts.length - 1) {
-                    current[part] = (payload, options = {}) => this._call(name, payload, {
-                        timeout: procedure.timeout || options.timeout || this.options.timeout,
-                        ...options,
-                    });
-                }
-                else {
-                    if (!current[part]) {
-                        current[part] = {};
-                    }
-                    current = current[part];
-                }
-            }
-        }
-        return callers;
-    }
-}

package/dist/static.d.ts

@@ -1,9 +0,0 @@
-import type { TAnyAPIContract } from '@nmtjs/contract';
-import { ProtocolBaseTransformer } from '@nmtjs/protocol/client';
-import type { StaticInputContractTypeProvider, StaticOutputContractTypeProvider } from './common.ts';
-import { BaseClient } from './common.ts';
-export declare class StaticClient<APIContract extends TAnyAPIContract, SafeCall extends boolean = false> extends BaseClient<APIContract, SafeCall, StaticInputContractTypeProvider, StaticOutputContractTypeProvider> {
-    protected transformer: ProtocolBaseTransformer;
-    constructor(...args: ConstructorParameters<typeof BaseClient<APIContract, SafeCall>>);
-    protected createProxy(target: any, path?: string[]): any;
-}

package/dist/static.js

@@ -1,27 +0,0 @@
-import { ProtocolBaseTransformer } from '@nmtjs/protocol/client';
-import { BaseClient } from "./common.js";
-export class StaticClient extends BaseClient {
-    transformer;
-    constructor(...args) {
-        super(...args);
-        this.transformer = new ProtocolBaseTransformer();
-        this.callers = this.createProxy(Object.create(null));
-    }
-    createProxy(target, path = []) {
-        return new Proxy(target, {
-            get: (obj, prop) => {
-                // `await client.call.something` or `await client.call.something.nested`
-                // without explicitly calling a function implicitly calls .then() on a target
-                // FIXME: this basically makes "then" a reserved word for static Client
-                if (prop === 'then')
-                    return obj;
-                const newPath = [...path, String(prop)];
-                const caller = (payload, options) => this._call(newPath.join('/'), payload, {
-                    ...options,
-                    timeout: options?.timeout ?? this.options.timeout,
-                });
-                return this.createProxy(caller, newPath);
-            },
-        });
-    }
-}

package/dist/types.d.ts

@@ -1,61 +0,0 @@
-import type { CallTypeProvider, OneOf, TypeProvider } from '@nmtjs/common';
-import type { TAnyAPIContract, TAnyProcedureContract, TAnyRouterContract } from '@nmtjs/contract';
-import type { ProtocolBlobInterface } from '@nmtjs/protocol';
-import type { ProtocolBaseClientCallOptions, ProtocolError, ProtocolServerBlobStream, ProtocolServerStreamInterface } from '@nmtjs/protocol/client';
-import type { BaseTypeAny, t } from '@nmtjs/type';
-import type { PlainType } from '@nmtjs/type/_plain';
-export type ClientOutputType<T> = T extends ProtocolBlobInterface ? ProtocolServerBlobStream : T extends {
-    [PlainType]?: true;
-} ? {
-    [K in keyof Omit<T, PlainType>]: ClientOutputType<T[K]>;
-} : T;
-export interface StaticInputContractTypeProvider extends TypeProvider {
-    output: this['input'] extends BaseTypeAny ? t.infer.decode.input<this['input']> : never;
-}
-export interface RuntimeInputContractTypeProvider extends TypeProvider {
-    output: this['input'] extends BaseTypeAny ? t.infer.encode.input<this['input']> : never;
-}
-export interface StaticOutputContractTypeProvider extends TypeProvider {
-    output: this['input'] extends BaseTypeAny ? ClientOutputType<t.infer.encodeRaw.output<this['input']>> : never;
-}
-export interface RuntimeOutputContractTypeProvider extends TypeProvider {
-    output: this['input'] extends BaseTypeAny ? ClientOutputType<t.infer.decodeRaw.output<this['input']>> : never;
-}
-export type AnyResolvedAPIContractProcedure = {
-    contract: TAnyProcedureContract;
-    input: any;
-    output: any;
-};
-export type AnyResolvedAPIContractRouter = {
-    contract: TAnyRouterContract;
-    routes: Record<string, AnyResolvedAPIContractRouter | AnyResolvedAPIContractProcedure>;
-};
-export type AnyResolvedAPIContract = Record<string, Record<string, AnyResolvedAPIContractProcedure | AnyResolvedAPIContractRouter>>;
-export type ResolveAPIRouterRoutes<T extends TAnyRouterContract, InputTypeProvider extends TypeProvider = TypeProvider, OutputTypeProvider extends TypeProvider = TypeProvider> = {
-    [K in keyof T['routes']]: T['routes'][K] extends TAnyRouterContract ? {
-        contract: T['routes'][K];
-        routes: ResolveAPIRouterRoutes<T['routes'][K], InputTypeProvider, OutputTypeProvider>;
-    } : T['routes'][K] extends TAnyProcedureContract ? {
-        contract: T['routes'][K];
-        input: CallTypeProvider<InputTypeProvider, T['routes'][K]['input']>;
-        output: T['routes'][K]['stream'] extends undefined | t.NeverType ? CallTypeProvider<OutputTypeProvider, T['routes'][K]['output']> : {
-            result: CallTypeProvider<OutputTypeProvider, T['routes'][K]['output']>;
-            stream: ProtocolServerStreamInterface<CallTypeProvider<OutputTypeProvider, T['routes'][K]['stream']>>;
-        };
-    } : never;
-};
-export type ResolveAPIContract<C extends TAnyAPIContract = TAnyAPIContract, InputTypeProvider extends TypeProvider = TypeProvider, OutputTypeProvider extends TypeProvider = TypeProvider> = ResolveAPIRouterRoutes<C['router'], InputTypeProvider, OutputTypeProvider>;
-export type ClientCaller<Procedure extends AnyResolvedAPIContractProcedure, SafeCall extends boolean> = (...args: Procedure['input'] extends t.NeverType ? [data?: undefined, options?: Partial<ProtocolBaseClientCallOptions>] : undefined extends t.infer.encode.input<Procedure['contract']['input']> ? [
-    data?: Procedure['input'],
-    options?: Partial<ProtocolBaseClientCallOptions>
-] : [
-    data: Procedure['input'],
-    options?: Partial<ProtocolBaseClientCallOptions>
-]) => SafeCall extends true ? Promise<OneOf<[{
-    output: Procedure['output'];
-}, {
-    error: ProtocolError;
-}]>> : Promise<Procedure['output']>;
-export type ClientCallers<Resolved extends AnyResolvedAPIContractRouter, SafeCall extends boolean> = {
-    [K in keyof Resolved['routes']]: Resolved['routes'][K] extends AnyResolvedAPIContractProcedure ? ClientCaller<Resolved['routes'][K], SafeCall> : Resolved['routes'][K] extends AnyResolvedAPIContractRouter ? ClientCallers<Resolved['routes'][K], SafeCall> : never;
-};