@nmtjs/protocol 0.15.0-beta.35 → 0.15.0-beta.37

package/dist/common/binary.js

@@ -2,39 +2,26 @@
 /// <reference lib="dom" />
 const utf8decoder = new TextDecoder();
 const utf8encoder = new TextEncoder();
-export const encodeNumber = (value, type, littleEndian = true) => {
+export const encodeNumber = (value, type, littleEndian = false) => {
     const bytesNeeded = globalThis[`${type}Array`].BYTES_PER_ELEMENT;
     const ab = new ArrayBuffer(bytesNeeded);
     const dv = new DataView(ab);
     dv[`set${type}`](0, value, littleEndian);
     return ab;
 };
-export const decodeNumber = (buffer, type, offset = 0, littleEndian = true) => {
-    const ab = buffer instanceof ArrayBuffer ? buffer : buffer.buffer;
-    const baseOffset = buffer instanceof ArrayBuffer ? 0 : buffer.byteOffset;
-    const view = new DataView(ab);
-    return view[`get${type}`](baseOffset + offset, littleEndian);
+export const decodeNumber = (buffer, type, offset = 0, littleEndian = false) => {
+    const view = new DataView(buffer);
+    return view[`get${type}`](offset, littleEndian);
 };
-export const encodeText = (text) => utf8encoder.encode(text);
+export const encodeText = (text) => new Uint8Array(utf8encoder.encode(text)).buffer;
 export const decodeText = (buffer) => utf8decoder.decode(buffer);
 export const concat = (...buffers) => {
-    let totalLength = 0;
-    for (const buffer of buffers)
-        totalLength += buffer.byteLength;
+    const totalLength = buffers.reduce((acc, buffer) => acc + buffer.byteLength, 0);
     const view = new Uint8Array(totalLength);
     let offset = 0;
     for (const buffer of buffers) {
-        const chunk = buffer instanceof ArrayBuffer
-            ? new Uint8Array(buffer)
-            : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-        view.set(chunk, offset);
-        offset += chunk.byteLength;
+        view.set(new Uint8Array(buffer), offset);
+        offset += buffer.byteLength;
     }
-    return view;
+    return view.buffer;
 };
-export const UTF8Transform = () => new TransformStream({
-    transform(chunk, controller) {
-        controller.enqueue(encodeText(chunk));
-    },
-});
-//# sourceMappingURL=binary.js.map

package/dist/common/blob.d.ts

@@ -1,4 +1,5 @@
-import { kBlobKey } from './constants.ts';
+export declare const BlobKey: unique symbol;
+export type BlobKey = typeof BlobKey;
 export type ProtocolBlobMetadata = {
     type: string;
     size?: number | undefined;
@@ -6,24 +7,16 @@ export type ProtocolBlobMetadata = {
 };
 export interface ProtocolBlobInterface {
     readonly metadata: ProtocolBlobMetadata;
-    readonly [kBlobKey]: any;
+    readonly [BlobKey]: true;
 }
 export declare class ProtocolBlob implements ProtocolBlobInterface {
-    [kBlobKey]: true;
-    readonly source: any;
+    readonly [BlobKey] = true;
     readonly metadata: ProtocolBlobMetadata;
-    readonly encode?: (metadata: ProtocolBlobMetadata) => unknown;
-    readonly toJSON?: () => unknown;
-    constructor({ source, encode, size, type, filename }: {
-        source: any;
-        encode?: () => unknown;
-        size?: number;
-        type?: string;
-        filename?: string;
-    });
-    static from(_source: any, _metadata?: {
+    readonly source: any;
+    constructor(source: any, size?: number, type?: string, filename?: string);
+    static from(source: any, metadata?: {
         size?: number;
         type?: string;
         filename?: string;
-    }, _encode?: (metadata: ProtocolBlobMetadata) => unknown): ProtocolBlob;
+    }): ProtocolBlob;
 }

package/dist/common/blob.js

@@ -1,67 +1,42 @@
-import { kBlobKey } from './constants.js';
+export const BlobKey = Symbol.for('neemata:BlobKey');
 export class ProtocolBlob {
-    [kBlobKey] = true;
-    source;
+    [BlobKey] = true;
     metadata;
-    encode;
-    toJSON;
-    constructor({ source, encode, size, type = 'application/octet-stream', filename, }) {
+    source;
+    constructor(source, size, type = 'application/octet-stream', filename) {
         if (typeof size !== 'undefined' && size <= 0)
             throw new Error('Blob size is invalid');
-        this.encode = encode;
         this.source = source;
         this.metadata = { size, type, filename };
-        if (encode) {
-            Object.defineProperty(this, 'toJSON', {
-                configurable: false,
-                enumerable: false,
-                writable: false,
-                value: encode,
-            });
-        }
     }
-    static from(_source, _metadata = {}, _encode) {
-        let source;
-        const metadata = { type: 'application/octet-stream', ..._metadata };
-        if (_source instanceof globalThis.ReadableStream) {
-            source = _source;
-        }
-        else if ('File' in globalThis && _source instanceof globalThis.File) {
-            source = _source.stream();
-            metadata.size ??= _source.size;
-            metadata.filename ??= _source.name;
-        }
-        else if (_source instanceof globalThis.Blob) {
-            source = _source.stream();
-            metadata.size ??= _source.size;
-            metadata.type ??= _source.type;
-        }
-        else if (typeof _source === 'string') {
-            const blob = new Blob([_source]);
-            source = blob.stream();
-            metadata.size ??= blob.size;
-            metadata.type ??= 'text/plain';
-        }
-        else if (globalThis.ArrayBuffer.isView(_source)) {
-            const blob = new Blob([_source]);
-            source = blob.stream();
-            metadata.size ??= blob.size;
-        }
-        else if (_source instanceof globalThis.ArrayBuffer) {
-            const blob = new Blob([_source]);
-            source = blob.stream();
-            metadata.size ??= blob.size;
+    static from(source, metadata = {}) {
+        let _source;
+        if (source instanceof globalThis.ReadableStream) {
+            _source = source;
+        }
+        else if ('File' in globalThis && source instanceof globalThis.File) {
+            _source = source.stream();
+            metadata.size = source.size;
+            metadata.filename = source.name;
+        }
+        else if (source instanceof globalThis.Blob) {
+            _source = source.stream();
+            metadata.size = source.size;
+        }
+        else if (typeof source === 'string') {
+            const blob = new Blob([source]);
+            _source = blob.stream();
+            metadata.size = blob.size;
+            metadata.type = metadata.type || 'text/plain';
+        }
+        else if (source instanceof globalThis.ArrayBuffer) {
+            const blob = new Blob([source]);
+            _source = blob.stream();
+            metadata.size = blob.size;
         }
         else {
-            source = _source;
+            _source = source;
         }
-        return new ProtocolBlob({
-            source,
-            encode: _encode?.bind(null, metadata),
-            size: metadata.size,
-            type: metadata.type,
-            filename: metadata.filename,
-        });
+        return new ProtocolBlob(_source, metadata.size, metadata.type, metadata.filename);
     }
 }
-//# sourceMappingURL=blob.js.map

package/dist/common/enums.d.ts

@@ -1,17 +1,15 @@
-export declare enum ProtocolVersion {
-    v1 = 1
-}
 export declare enum ClientMessageType {
     Rpc = 10,
     RpcAbort = 11,
-    RpcPull = 12,
+    RpcStreamAbort = 12,
     ClientStreamPush = 20,
     ClientStreamEnd = 21,
     ClientStreamAbort = 22,
-    ServerStreamAbort = 33,
-    ServerStreamPull = 34
+    ServerStreamAbort = 23,
+    ServerStreamPull = 24
 }
 export declare enum ServerMessageType {
+    Event = 1,
     RpcResponse = 10,
     RpcStreamResponse = 11,
     RpcStreamChunk = 12,
@@ -20,10 +18,10 @@ export declare enum ServerMessageType {
     ServerStreamPush = 20,
     ServerStreamEnd = 21,
     ServerStreamAbort = 22,
-    ClientStreamAbort = 33,
-    ClientStreamPull = 34
+    ClientStreamAbort = 23,
+    ClientStreamPull = 24
 }
-export declare enum ConnectionType {
+export declare enum TransportType {
     Bidirectional = "Bidirectional",
     Unidirectional = "Unidirectional"
 }
@@ -41,11 +39,3 @@ export declare enum ErrorCode {
     ClientRequestError = "ClientRequestError",
     ConnectionError = "ConnectionError"
 }
-export declare enum MessageByteLength {
-    MessageType = 1,
-    MessageError = 1,
-    ProcedureLength = 2,
-    CallId = 4,
-    StreamId = 4,
-    ChunkSize = 4
-}

package/dist/common/enums.js

@@ -1,24 +1,17 @@
-export { ProtocolVersion };
-var ProtocolVersion;
-(function (ProtocolVersion) {
-    ProtocolVersion[ProtocolVersion["v1"] = 1] = "v1";
-})(ProtocolVersion || (ProtocolVersion = {}));
-export { ClientMessageType };
-var ClientMessageType;
+export var ClientMessageType;
 (function (ClientMessageType) {
     ClientMessageType[ClientMessageType["Rpc"] = 10] = "Rpc";
     ClientMessageType[ClientMessageType["RpcAbort"] = 11] = "RpcAbort";
-    ClientMessageType[ClientMessageType["RpcPull"] = 12] = "RpcPull";
+    ClientMessageType[ClientMessageType["RpcStreamAbort"] = 12] = "RpcStreamAbort";
     ClientMessageType[ClientMessageType["ClientStreamPush"] = 20] = "ClientStreamPush";
     ClientMessageType[ClientMessageType["ClientStreamEnd"] = 21] = "ClientStreamEnd";
     ClientMessageType[ClientMessageType["ClientStreamAbort"] = 22] = "ClientStreamAbort";
-    ClientMessageType[ClientMessageType["ServerStreamAbort"] = 33] = "ServerStreamAbort";
-    ClientMessageType[ClientMessageType["ServerStreamPull"] = 34] = "ServerStreamPull";
+    ClientMessageType[ClientMessageType["ServerStreamAbort"] = 23] = "ServerStreamAbort";
+    ClientMessageType[ClientMessageType["ServerStreamPull"] = 24] = "ServerStreamPull";
 })(ClientMessageType || (ClientMessageType = {}));
-export { ServerMessageType };
-var ServerMessageType;
+export var ServerMessageType;
 (function (ServerMessageType) {
-    // Event = 1,
+    ServerMessageType[ServerMessageType["Event"] = 1] = "Event";
     ServerMessageType[ServerMessageType["RpcResponse"] = 10] = "RpcResponse";
     ServerMessageType[ServerMessageType["RpcStreamResponse"] = 11] = "RpcStreamResponse";
     ServerMessageType[ServerMessageType["RpcStreamChunk"] = 12] = "RpcStreamChunk";
@@ -27,17 +20,15 @@ var ServerMessageType;
     ServerMessageType[ServerMessageType["ServerStreamPush"] = 20] = "ServerStreamPush";
     ServerMessageType[ServerMessageType["ServerStreamEnd"] = 21] = "ServerStreamEnd";
     ServerMessageType[ServerMessageType["ServerStreamAbort"] = 22] = "ServerStreamAbort";
-    ServerMessageType[ServerMessageType["ClientStreamAbort"] = 33] = "ClientStreamAbort";
-    ServerMessageType[ServerMessageType["ClientStreamPull"] = 34] = "ClientStreamPull";
+    ServerMessageType[ServerMessageType["ClientStreamAbort"] = 23] = "ClientStreamAbort";
+    ServerMessageType[ServerMessageType["ClientStreamPull"] = 24] = "ClientStreamPull";
 })(ServerMessageType || (ServerMessageType = {}));
-export { ConnectionType };
-var ConnectionType;
-(function (ConnectionType) {
-    ConnectionType["Bidirectional"] = "Bidirectional";
-    ConnectionType["Unidirectional"] = "Unidirectional";
-})(ConnectionType || (ConnectionType = {}));
-export { ErrorCode };
-var ErrorCode;
+export var TransportType;
+(function (TransportType) {
+    TransportType["Bidirectional"] = "Bidirectional";
+    TransportType["Unidirectional"] = "Unidirectional";
+})(TransportType || (TransportType = {}));
+export var ErrorCode;
 (function (ErrorCode) {
     ErrorCode["ValidationError"] = "ValidationError";
     ErrorCode["BadRequest"] = "BadRequest";
@@ -52,14 +43,3 @@ var ErrorCode;
     ErrorCode["ClientRequestError"] = "ClientRequestError";
     ErrorCode["ConnectionError"] = "ConnectionError";
 })(ErrorCode || (ErrorCode = {}));
-export { MessageByteLength };
-var MessageByteLength;
-(function (MessageByteLength) {
-    MessageByteLength[MessageByteLength["MessageType"] = 1] = "MessageType";
-    MessageByteLength[MessageByteLength["MessageError"] = 1] = "MessageError";
-    MessageByteLength[MessageByteLength["ProcedureLength"] = 2] = "ProcedureLength";
-    MessageByteLength[MessageByteLength["CallId"] = 4] = "CallId";
-    MessageByteLength[MessageByteLength["StreamId"] = 4] = "StreamId";
-    MessageByteLength[MessageByteLength["ChunkSize"] = 4] = "ChunkSize";
-})(MessageByteLength || (MessageByteLength = {}));
-//# sourceMappingURL=enums.js.map

package/dist/common/index.d.ts

@@ -1,6 +1,4 @@
 export * from './binary.ts';
 export * from './blob.ts';
-export * from './constants.ts';
 export * from './enums.ts';
 export * from './types.ts';
-export * from './utils.ts';

package/dist/common/index.js

@@ -1,7 +1,4 @@
-export * from './binary.js';
-export * from './blob.js';
-export * from './constants.js';
-export * from './enums.js';
-export * from './types.js';
-export * from './utils.js';
-//# sourceMappingURL=index.js.map
+export * from "./binary.js";
+export * from "./blob.js";
+export * from "./enums.js";
+export * from "./types.js";

package/dist/common/types.d.ts

@@ -1,14 +1,33 @@
-import type { ProtocolBlobMetadata } from './blob.ts';
+import type { OneOf } from '@nmtjs/common';
+import type { ProtocolBlob, ProtocolBlobMetadata } from './blob.ts';
 type Stream = any;
 export interface BaseProtocolError {
     code: string;
     message: string;
     data?: any;
 }
-export type ProtocolRPCPayload = unknown;
-export type ProtocolRPCResponse = unknown;
-export type EncodeRPCStreams = Record<number, ProtocolBlobMetadata>;
+export type ProtocolRPC = {
+    callId: number;
+    procedure: string;
+    payload: any;
+};
+export type ProtocolRPCResponse<T = Stream> = OneOf<[
+    {
+        callId: number;
+        error: BaseProtocolError;
+    },
+    {
+        callId: number;
+        result: any;
+        streams: Record<number, T>;
+    }
+]>;
+export interface EncodeRPCContext<T = Stream> {
+    getStream: (id: number) => T;
+    addStream: (blob: ProtocolBlob) => T;
+}
 export interface DecodeRPCContext<T = Stream> {
-    addStream: (id: number, metadata: ProtocolBlobMetadata) => T;
+    getStream: (id: number, callId: number) => T;
+    addStream: (id: number, callId: number, metadata: ProtocolBlobMetadata) => T;
 }
 export {};

package/dist/common/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/server/api.d.ts

@@ -0,0 +1,33 @@
+import type { Async } from '@nmtjs/common';
+import type { Container, Hook, MetadataStore } from '@nmtjs/core';
+import type { Connection } from './connection.ts';
+import { kIterableResponse } from './constants.ts';
+export type ProtocolApiCallOptions = {
+    connection: Connection;
+    procedure: string;
+    container: Container;
+    payload: any;
+    signal: AbortSignal;
+    validateMetadata?: (metadata: MetadataStore) => void;
+};
+export type ProtocolAnyIterable<T> = ((signal: AbortSignal) => Async<AsyncIterable<T>>) | AsyncIterable<T>;
+export interface ProtocolApiCallBaseResult<T = unknown> {
+    output: T;
+}
+export interface ProtocolApiCallIterableResult<Y = unknown, O = unknown> extends ProtocolApiCallBaseResult<O> {
+    [kIterableResponse]: true;
+    iterable: ProtocolAnyIterable<Y>;
+    onFinish?: () => void;
+}
+export type ProtocolApiCallResult = ProtocolApiCallBaseResult | ProtocolApiCallIterableResult;
+export interface ProtocolApi {
+    call(options: ProtocolApiCallOptions): Promise<ProtocolApiCallResult>;
+}
+export declare function isIterableResult(value: ProtocolApiCallResult): value is ProtocolApiCallIterableResult;
+export declare function createStreamResponse<Y, O>(iterable: ProtocolAnyIterable<Y>, output?: O, onFinish?: () => void): ProtocolApiCallIterableResult<Y, O>;
+declare module '@nmtjs/core' {
+    interface HookType {
+        [Hook.OnConnect]: (connection: Connection) => any;
+        [Hook.OnDisconnect]: (connection: Connection) => any;
+    }
+}

package/dist/server/api.js

@@ -0,0 +1,7 @@
+import { kIterableResponse } from "./constants.js";
+export function isIterableResult(value) {
+    return value && value[kIterableResponse] === true;
+}
+export function createStreamResponse(iterable, output = undefined, onFinish) {
+    return { [kIterableResponse]: true, iterable, output, onFinish };
+}

package/dist/server/connection.d.ts

@@ -0,0 +1,25 @@
+import type { Container } from '@nmtjs/core';
+import type { BaseServerDecoder, BaseServerEncoder } from './format.ts';
+import type { ProtocolClientStream, ProtocolServerStream } from './stream.ts';
+export type ConnectionOptions<Data = unknown> = {
+    id?: string;
+    data: Data;
+};
+export declare class Connection<Data = unknown> {
+    readonly id: string;
+    readonly data: Data;
+    constructor(options: ConnectionOptions<Data>);
+}
+export declare class ConnectionContext {
+    streamId: number;
+    rpcs: Map<number, AbortController>;
+    clientStreams: Map<number, ProtocolClientStream>;
+    serverStreams: Map<number, ProtocolServerStream>;
+    rpcStreams: Map<number, AbortController>;
+    container: Container;
+    format: {
+        encoder: BaseServerEncoder;
+        decoder: BaseServerDecoder;
+    };
+    constructor(container: ConnectionContext['container'], format: ConnectionContext['format']);
+}

package/dist/server/connection.js

@@ -0,0 +1,22 @@
+import { randomUUID } from 'node:crypto';
+export class Connection {
+    id;
+    data;
+    constructor(options) {
+        this.id = options.id ?? randomUUID();
+        this.data = options.data;
+    }
+}
+export class ConnectionContext {
+    streamId = 1;
+    rpcs = new Map();
+    clientStreams = new Map();
+    serverStreams = new Map();
+    rpcStreams = new Map();
+    container;
+    format;
+    constructor(container, format) {
+        this.container = container;
+        this.format = format;
+    }
+}

package/dist/server/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const kTransportPlugin: unique symbol;
+export type kTransportPlugin = typeof kTransportPlugin;
+export declare const kIterableResponse: unique symbol;
+export type kIterableResponse = typeof kIterableResponse;

package/dist/server/constants.js

@@ -0,0 +1,2 @@
+export const kTransportPlugin = Symbol.for('neemata:TransportPluginKey');
+export const kIterableResponse = Symbol.for('neemata:IterableResponseKey');

package/dist/server/format.d.ts

@@ -1,33 +1,39 @@
-import type { Pattern } from '@nmtjs/common';
-import type { ProtocolBlobMetadata } from '../common/blob.ts';
-import type { DecodeRPCContext, EncodeRPCStreams, ProtocolRPCPayload } from '../common/types.ts';
-import type { ProtocolClientStream } from './stream.ts';
+import type { OneOf } from '@nmtjs/common';
+import type { Pattern } from '@nmtjs/core';
+import type { DecodeRPCContext, EncodeRPCContext, ProtocolRPC, ProtocolRPCResponse } from '../common/types.ts';
+import type { ProtocolClientStream, ProtocolServerStream } from './stream.ts';
 export interface BaseServerDecoder {
     accept: Pattern[];
-    decode(buffer: ArrayBufferView): unknown;
-    decodeRPC(buffer: ArrayBufferView, context: DecodeRPCContext<() => ProtocolClientStream>): ProtocolRPCPayload;
+    decode(buffer: ArrayBuffer): any;
+    decodeRPC(buffer: ArrayBuffer, context: DecodeRPCContext<ProtocolClientStream>): ProtocolRPC;
 }
 export interface BaseServerEncoder {
     contentType: string;
-    encode(data: unknown): ArrayBufferView;
-    encodeRPC(data: unknown, streams: EncodeRPCStreams): ArrayBufferView;
-    encodeBlob(streamId: number, metadata: ProtocolBlobMetadata): unknown;
+    encode(data: any): ArrayBuffer;
+    encodeRPC(rpc: OneOf<[
+        {
+            callId: number;
+            error: any;
+        },
+        {
+            callId: number;
+            result: any;
+        }
+    ]>, context: EncodeRPCContext<ProtocolServerStream>): ArrayBuffer;
 }
 export declare abstract class BaseServerFormat implements BaseServerDecoder, BaseServerEncoder {
     abstract accept: Pattern[];
     abstract contentType: string;
-    abstract encode(data: unknown): ArrayBufferView;
-    abstract encodeRPC(data: unknown, streams: EncodeRPCStreams): ArrayBufferView;
-    abstract encodeBlob(streamId: number, metadata: ProtocolBlobMetadata): unknown;
-    abstract decode(buffer: ArrayBufferView): any;
-    abstract decodeRPC(buffer: ArrayBufferView, context: DecodeRPCContext<() => ProtocolClientStream>): ProtocolRPCPayload;
+    abstract encode(data: any): ArrayBuffer;
+    abstract encodeRPC(rpc: ProtocolRPCResponse, context: EncodeRPCContext<ProtocolServerStream>): ArrayBuffer;
+    abstract decode(buffer: ArrayBuffer): any;
+    abstract decodeRPC(buffer: ArrayBuffer, context: DecodeRPCContext<ProtocolClientStream>): ProtocolRPC;
 }
 export declare const parseContentTypes: (types: string) => string[];
-export declare class ProtocolFormats {
+export declare class ProtocolFormat {
     decoders: Map<Pattern, BaseServerDecoder>;
     encoders: Map<Pattern, BaseServerEncoder>;
-    default: BaseServerFormat;
-    constructor(formats: [BaseServerFormat, ...BaseServerFormat[]]);
+    constructor(formats: BaseServerFormat[]);
     supportsDecoder(contentType: string, throwIfUnsupported?: boolean): BaseServerDecoder | null;
     supportsEncoder(contentType: string, throwIfUnsupported?: boolean): BaseServerEncoder | null;
     private supports;

package/dist/server/format.js

@@ -1,22 +1,20 @@
-import { match } from '@nmtjs/common';
+import { match } from '@nmtjs/core';
 export class BaseServerFormat {
 }
 export const parseContentTypes = (types) => {
-    const normalized = types.trim();
-    if (normalized === '*/*')
+    if (types === '*/*')
         return ['*/*'];
-    return normalized
+    return types
         .split(',')
-        .map((t) => t.trim())
         .map((t) => {
-        const [rawType, ...rest] = t.split(';');
+        const [type, ...rest] = t.split(';');
         const params = new Map(rest.map((p) => p
             .trim()
             .split('=')
             .slice(0, 2)
-            .map((part) => part.trim())));
+            .map((p) => p.trim())));
         return {
-            type: rawType.trim(),
+            type,
             q: params.has('q') ? Number.parseFloat(params.get('q')) : 1,
         };
     })
@@ -25,16 +23,14 @@ export const parseContentTypes = (types) => {
             return 1;
         if (b.type === '*/*')
             return -1;
-        return b.q - a.q;
+        return b.q - a.q ? -1 : 1;
     })
         .map((t) => t.type);
 };
-export class ProtocolFormats {
+export class ProtocolFormat {
     decoders = new Map();
     encoders = new Map();
-    default;
     constructor(formats) {
-        this.default = formats[0];
         for (const format of formats) {
             this.encoders.set(format.contentType, format);
             for (const acceptType of format.accept) {
@@ -62,4 +58,3 @@ export class ProtocolFormats {
         return null;
     }
 }
-//# sourceMappingURL=format.js.map

package/dist/server/index.d.ts

@@ -1,9 +1,11 @@
+export * from './api.ts';
+export * from './connection.ts';
+export * from './constants.ts';
 export * from './format.ts';
+export * from './injectables.ts';
 export * from './protocol.ts';
+export * from './registry.ts';
 export * from './stream.ts';
+export * from './transport.ts';
 export * from './types.ts';
 export * from './utils.ts';
-import { ProtocolVersion1 } from './versions/v1.ts';
-export declare const versions: {
-    1: ProtocolVersion1;
-};

package/dist/server/index.js

@@ -1,9 +1,11 @@
-export * from './format.js';
-export * from './protocol.js';
-export * from './stream.js';
-export * from './types.js';
-export * from './utils.js';
-import { ProtocolVersion } from '../common/enums.js';
-import { ProtocolVersion1 } from './versions/v1.js';
-export const versions = { [ProtocolVersion.v1]: new ProtocolVersion1() };
-//# sourceMappingURL=index.js.map
+export * from "./api.js";
+export * from "./connection.js";
+export * from "./constants.js";
+export * from "./format.js";
+export * from "./injectables.js";
+export * from "./protocol.js";
+export * from "./registry.js";
+export * from "./stream.js";
+export * from "./transport.js";
+export * from "./types.js";
+export * from "./utils.js";

package/dist/server/injectables.d.ts

@@ -0,0 +1,14 @@
+import { Scope } from '@nmtjs/core';
+import type { Connection } from './connection.ts';
+export declare const ProtocolInjectables: {
+    readonly connection: import("@nmtjs/core").LazyInjectable<Connection<unknown>, Scope.Connection>;
+    readonly connectionData: import("@nmtjs/core").LazyInjectable<any, Scope.Connection>;
+    readonly connectionAbortSignal: import("@nmtjs/core").LazyInjectable<AbortSignal, Scope.Connection>;
+    readonly rpcClientAbortSignal: import("@nmtjs/core").LazyInjectable<AbortSignal, Scope.Call>;
+    readonly rpcTimeoutSignal: import("@nmtjs/core").LazyInjectable<AbortSignal, Scope.Call>;
+    readonly rpcAbortSignal: import("@nmtjs/core").FactoryInjectable<AbortSignal, {
+        rpcTimeoutSignal: import("@nmtjs/core").LazyInjectable<AbortSignal, Scope.Call>;
+        rpcClientAbortSignal: import("@nmtjs/core").LazyInjectable<AbortSignal, Scope.Call>;
+        connectionAbortSignal: import("@nmtjs/core").LazyInjectable<AbortSignal, Scope.Connection>;
+    }, Scope.Global, AbortSignal>;
+};