@nmtjs/protocol 0.14.5 → 0.15.0-beta.2

package/dist/client/protocol.d.ts

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

package/dist/client/stream.d.ts

@@ -1,31 +0,0 @@
-import type { ProtocolBlobInterface, ProtocolBlobMetadata } from '../common/blob.ts';
-import { BlobKey } from '../common/blob.ts';
-export declare class ProtocolClientBlobStream extends TransformStream<any, ArrayBuffer> implements ProtocolBlobInterface {
-    #private;
-    readonly source: ReadableStream;
-    readonly id: number;
-    readonly metadata: ProtocolBlobMetadata;
-    readonly [BlobKey] = true;
-    constructor(source: ReadableStream, id: number, metadata: ProtocolBlobMetadata);
-    read(size: number): Promise<ArrayBuffer | null>;
-    abort(error?: Error): void;
-    end(): Promise<void>;
-}
-export interface ProtocolServerStreamInterface<T = any> {
-    [Symbol.asyncIterator](): AsyncGenerator<T>;
-    abort(error?: Error): void;
-}
-export declare class ProtocolServerStream<T = any> extends TransformStream<any, T> implements ProtocolServerStreamInterface<T> {
-    #private;
-    constructor(options?: Transformer<any, T>);
-    [Symbol.asyncIterator](): AsyncGenerator<Awaited<T>, void, unknown>;
-    push(chunk: T): Promise<void>;
-    end(): Promise<void>;
-    abort(error?: Error): Promise<void>;
-}
-export declare class ProtocolServerBlobStream extends ProtocolServerStream<ArrayBuffer> implements ProtocolBlobInterface {
-    readonly id: number;
-    readonly metadata: ProtocolBlobMetadata;
-    readonly [BlobKey] = true;
-    constructor(id: number, metadata: ProtocolBlobMetadata, options?: Transformer<any, ArrayBuffer>);
-}

package/dist/common/binary.d.ts

@@ -1,19 +0,0 @@
-declare const utf8decoder: TextDecoder;
-export type BinaryTypes = {
-    Int8: number;
-    Int16: number;
-    Int32: number;
-    Uint8: number;
-    Uint16: number;
-    Uint32: number;
-    Float32: number;
-    Float64: number;
-    BigInt64: bigint;
-    BigUint64: bigint;
-};
-export declare const encodeNumber: <T extends keyof BinaryTypes>(value: BinaryTypes[T], type: T, littleEndian?: boolean) => ArrayBuffer;
-export declare const decodeNumber: <T extends keyof BinaryTypes>(buffer: ArrayBuffer, type: T, offset?: number, littleEndian?: boolean) => BinaryTypes[T];
-export declare const encodeText: (text: string) => ArrayBuffer;
-export declare const decodeText: (buffer: Parameters<typeof utf8decoder.decode>[0]) => string;
-export declare const concat: (...buffers: ArrayBuffer[]) => ArrayBuffer;
-export {};

package/dist/common/blob.d.ts

@@ -1,22 +0,0 @@
-export declare const BlobKey: unique symbol;
-export type BlobKey = typeof BlobKey;
-export type ProtocolBlobMetadata = {
-    type: string;
-    size?: number | undefined;
-    filename?: string | undefined;
-};
-export interface ProtocolBlobInterface {
-    readonly metadata: ProtocolBlobMetadata;
-    readonly [BlobKey]: true;
-}
-export declare class ProtocolBlob implements ProtocolBlobInterface {
-    readonly [BlobKey] = true;
-    readonly metadata: ProtocolBlobMetadata;
-    readonly source: any;
-    constructor(source: any, size?: number, type?: string, filename?: string);
-    static from(source: any, metadata?: {
-        size?: number;
-        type?: string;
-        filename?: string;
-    }): ProtocolBlob;
-}

package/dist/common/enums.d.ts

@@ -1,41 +0,0 @@
-export declare enum ClientMessageType {
-    Rpc = 10,
-    RpcAbort = 11,
-    RpcStreamAbort = 12,
-    ClientStreamPush = 20,
-    ClientStreamEnd = 21,
-    ClientStreamAbort = 22,
-    ServerStreamAbort = 23,
-    ServerStreamPull = 24
-}
-export declare enum ServerMessageType {
-    Event = 1,
-    RpcResponse = 10,
-    RpcStreamResponse = 11,
-    RpcStreamChunk = 12,
-    RpcStreamEnd = 13,
-    RpcStreamAbort = 14,
-    ServerStreamPush = 20,
-    ServerStreamEnd = 21,
-    ServerStreamAbort = 22,
-    ClientStreamAbort = 23,
-    ClientStreamPull = 24
-}
-export declare enum TransportType {
-    Bidirectional = "Bidirectional",
-    Unidirectional = "Unidirectional"
-}
-export declare enum ErrorCode {
-    ValidationError = "ValidationError",
-    BadRequest = "BadRequest",
-    NotFound = "NotFound",
-    Forbidden = "Forbidden",
-    Unauthorized = "Unauthorized",
-    InternalServerError = "InternalServerError",
-    NotAcceptable = "NotAcceptable",
-    RequestTimeout = "RequestTimeout",
-    GatewayTimeout = "GatewayTimeout",
-    ServiceUnavailable = "ServiceUnavailable",
-    ClientRequestError = "ClientRequestError",
-    ConnectionError = "ConnectionError"
-}

package/dist/common/index.d.ts

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

package/dist/common/types.d.ts

@@ -1,33 +0,0 @@
-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 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> {
-    getStream: (id: number, callId: number) => T;
-    addStream: (id: number, callId: number, metadata: ProtocolBlobMetadata) => T;
-}
-export {};

package/dist/server/api.d.ts

@@ -1,33 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

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

package/dist/server/format.d.ts

@@ -1,40 +0,0 @@
-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: ArrayBuffer): any;
-    decodeRPC(buffer: ArrayBuffer, context: DecodeRPCContext<ProtocolClientStream>): ProtocolRPC;
-}
-export interface BaseServerEncoder {
-    contentType: string;
-    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: 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 ProtocolFormat {
-    decoders: Map<Pattern, BaseServerDecoder>;
-    encoders: Map<Pattern, BaseServerEncoder>;
-    constructor(formats: BaseServerFormat[]);
-    supportsDecoder(contentType: string, throwIfUnsupported?: boolean): BaseServerDecoder | null;
-    supportsEncoder(contentType: string, throwIfUnsupported?: boolean): BaseServerEncoder | null;
-    private supports;
-}

package/dist/server/index.d.ts

@@ -1,11 +0,0 @@
-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';

package/dist/server/injectables.d.ts

@@ -1,14 +0,0 @@
-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>;
-};

package/dist/server/injectables.js

@@ -1,22 +0,0 @@
-import { createFactoryInjectable, createLazyInjectable, Scope, } from '@nmtjs/core';
-const connection = createLazyInjectable(Scope.Connection, 'RPC connection');
-const connectionData = createLazyInjectable(Scope.Connection, "RPC connection's data");
-const connectionAbortSignal = createLazyInjectable(Scope.Connection, 'Connection abort signal');
-const rpcClientAbortSignal = createLazyInjectable(Scope.Call, 'RPC client abort signal');
-const rpcTimeoutSignal = createLazyInjectable(Scope.Call, 'RPC timeout signal');
-const rpcAbortSignal = createFactoryInjectable({
-    dependencies: {
-        rpcTimeoutSignal,
-        rpcClientAbortSignal,
-        connectionAbortSignal,
-    },
-    factory: (ctx) => AbortSignal.any(Object.values(ctx)),
-}, 'Any RPC abort signal');
-export const ProtocolInjectables = {
-    connection,
-    connectionData,
-    connectionAbortSignal,
-    rpcClientAbortSignal,
-    rpcTimeoutSignal,
-    rpcAbortSignal,
-};

package/dist/server/protocol.d.ts

@@ -1,128 +0,0 @@
-import type { Callback } from '@nmtjs/common';
-import type { AnyInjectable, Container, Logger } from '@nmtjs/core';
-import type { ProtocolBlob, ProtocolBlobMetadata } from '../common/blob.ts';
-import type { ProtocolRPC } from '../common/types.ts';
-import type { ProtocolApi, ProtocolApiCallOptions } from './api.ts';
-import type { ConnectionOptions } from './connection.ts';
-import type { ProtocolFormat } from './format.ts';
-import type { ProtocolRegistry } from './registry.ts';
-import type { Transport } from './transport.ts';
-import type { ResolveFormatParams } from './utils.ts';
-import { Connection, ConnectionContext } from './connection.ts';
-import { ProtocolClientStream, ProtocolServerStream } from './stream.ts';
-export declare class ProtocolError extends Error {
-    code: string;
-    data?: any;
-    constructor(code: string, message?: string, data?: any);
-    get message(): string;
-    toString(): string;
-    toJSON(): {
-        code: string;
-        message: string;
-        data: any;
-    };
-}
-export type ProtocolConnectionTransport = {
-    send: Transport<any>['send'];
-};
-export declare class ProtocolConnections {
-    #private;
-    private readonly application;
-    constructor(application: {
-        logger: Logger;
-        registry: ProtocolRegistry;
-        format: ProtocolFormat;
-        container: Container;
-    });
-    get(connectionId: string): {
-        connection: Connection;
-        context: ConnectionContext;
-        transport: ProtocolConnectionTransport;
-    };
-    add<T>(transport: ProtocolConnectionTransport, options: ConnectionOptions<T>, params: ResolveFormatParams): Promise<{
-        connection: Connection<T>;
-        context: ConnectionContext;
-    }>;
-    remove(connectionId: string): Promise<void>;
-    initialize(connection: Connection): Promise<void>;
-}
-export declare class ProtocolClientStreams {
-    private readonly connections;
-    constructor(connections: ProtocolConnections);
-    get(connectionId: string, streamId: number): ProtocolClientStream;
-    remove(connectionId: string, streamId: number): void;
-    add(connectionId: string, streamId: number, metadata: ProtocolBlobMetadata, read: Callback): ProtocolClientStream;
-    push(connectionId: string, streamId: number, chunk: ArrayBuffer): void;
-    end(connectionId: string, streamId: number): void;
-    abort(connectionId: string, streamId: number, error?: Error): void;
-}
-export declare class ProtocolServerStreams {
-    private readonly connections;
-    constructor(connections: ProtocolConnections);
-    get(connectionId: string, streamId: number): ProtocolServerStream;
-    add(connectionId: string, streamId: number, blob: ProtocolBlob): ProtocolServerStream;
-    remove(connectionId: string, streamId: number): void;
-    pull(connectionId: string, streamId: number): void;
-    abort(connectionId: string, streamId: number, error?: Error): void;
-}
-export type ProtocolRPCOptions = {
-    signal?: AbortSignal;
-    provides?: [AnyInjectable, any][];
-    validateMetadata?: ProtocolApiCallOptions['validateMetadata'];
-};
-export declare class Protocol {
-    #private;
-    protected readonly application: {
-        logger: Logger;
-        format: ProtocolFormat;
-        container: Container;
-        registry: ProtocolRegistry;
-        api: ProtocolApi;
-    };
-    protected readonly options?: {
-        persistConnections?: {
-            timeout: number;
-        };
-    } | undefined;
-    constructor(application: {
-        logger: Logger;
-        format: ProtocolFormat;
-        container: Container;
-        registry: ProtocolRegistry;
-        api: ProtocolApi;
-    }, options?: {
-        persistConnections?: {
-            timeout: number;
-        };
-    } | undefined);
-    call(options: ProtocolApiCallOptions): Promise<import("./api.ts").ProtocolApiCallResult>;
-    rpc(connectionId: string, rpc: ProtocolRPC, params?: ProtocolRPCOptions): Promise<void>;
-    rpcRaw(connectionId: string, buffer: ArrayBuffer, params?: ProtocolRPCOptions): Promise<void>;
-    rpcAbort(connectionId: string, callId: number): void;
-    rpcAbortRaw(connectionId: string, buffer: ArrayBuffer): void;
-    rpcStreamAbort(connectionId: string, callId: number): void;
-    rpcStreamAbortRaw(connectionId: string, buffer: ArrayBuffer): void;
-    notify(): void;
-    addConnection(transport: ProtocolConnectionTransport, options: ConnectionOptions, params: ResolveFormatParams): Promise<{
-        connection: Connection<unknown>;
-        context: ConnectionContext;
-    }>;
-    removeConnection(connectionId: string): Promise<void>;
-    getConnection(connectionId: string): {
-        connection: Connection;
-        context: ConnectionContext;
-        transport: ProtocolConnectionTransport;
-    };
-    initializeConnection(connection: Connection): Promise<void>;
-    getClientStream(connectionId: string, streamId: number): ProtocolClientStream;
-    addClientStream(connectionId: string, streamId: number, metadata: ProtocolBlobMetadata, read: Callback): ProtocolClientStream;
-    removeClientStream(connectionId: string, streamId: number): void;
-    pushClientStream(connectionId: string, streamId: number, chunk: ArrayBuffer): void;
-    endClientStream(connectionId: string, streamId: number): void;
-    abortClientStream(connectionId: string, streamId: number, error?: Error): void;
-    getServerStream(connectionId: string, streamId: number): ProtocolServerStream;
-    addServerStream(connectionId: string, streamId: number, blob: ProtocolBlob): ProtocolServerStream;
-    removeServerStream(connectionId: string, streamId: number): void;
-    pullServerStream(connectionId: string, streamId: number): void;
-    abortServerStream(connectionId: string, streamId: number, error?: Error): void;
-}

package/dist/server/registry.d.ts

@@ -1,3 +0,0 @@
-import { Registry } from '@nmtjs/core';
-export declare class ProtocolRegistry extends Registry {
-}

package/dist/server/registry.js

@@ -1,3 +0,0 @@
-import { Registry } from '@nmtjs/core';
-export class ProtocolRegistry extends Registry {
-}

package/dist/server/stream.d.ts

@@ -1,13 +0,0 @@
-import type { ReadableOptions } from 'node:stream';
-import { PassThrough } from 'node:stream';
-import type { ProtocolBlob, ProtocolBlobMetadata } from '../common/blob.ts';
-export declare class ProtocolClientStream extends PassThrough {
-    readonly id: number;
-    readonly metadata: ProtocolBlobMetadata;
-    constructor(id: number, metadata: ProtocolBlobMetadata, options?: ReadableOptions);
-}
-export declare class ProtocolServerStream extends PassThrough {
-    readonly id: number;
-    readonly metadata: ProtocolBlobMetadata;
-    constructor(id: number, blob: ProtocolBlob);
-}