@nmtjs/client 0.6.5 → 0.7.1

package/dist/common.js

@@ -1,5 +1,4 @@
-import { ProtocolError } from '@nmtjs/protocol/client';
+import { ProtocolError } from "@nmtjs/protocol/client";
 export * from "./types.js";
-export class ClientError extends ProtocolError {
-}
-export { ErrorCode, ProtocolBlob, TransportType } from '@nmtjs/protocol/common';
+export class ClientError extends ProtocolError {}
+export { ErrorCode, ProtocolBlob, TransportType } from "@nmtjs/protocol/common";

package/dist/common.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../lib/common.ts"],"sourcesContent":["import { ProtocolError } from '@nmtjs/protocol/client'\n\nexport * from './types.ts'\n\nexport class ClientError extends ProtocolError {}\n\nexport {\n  ErrorCode,\n  ProtocolBlob,\n  type ProtocolBlobMetadata,\n  TransportType,\n} from '@nmtjs/protocol/common'\n"],"names":["ProtocolError","ClientError","ErrorCode","ProtocolBlob","TransportType"],"mappings":"AAAA,SAASA,aAAa,QAAQ,yBAAwB;AAEtD,cAAc,aAAY;AAE1B,OAAO,MAAMC,oBAAoBD;AAAe;AAEhD,SACEE,SAAS,EACTC,YAAY,EAEZC,aAAa,QACR,yBAAwB"}
+{"mappings":"AAAA,SAAS,qBAAqB,wBAAwB;AAEtD,cAAc;AAEd,OAAO,MAAM,oBAAoB,cAAc,CAAE;AAEjD,SACE,WACA,cAEA,qBACK","names":[],"sources":["src/common.ts"],"sourcesContent":["import { ProtocolError } from '@nmtjs/protocol/client'\n\nexport * from './types.ts'\n\nexport class ClientError extends ProtocolError {}\n\nexport {\n  ErrorCode,\n  ProtocolBlob,\n  type ProtocolBlobMetadata,\n  TransportType,\n} from '@nmtjs/protocol/common'\n"],"version":3}

package/dist/runtime.js

@@ -1,95 +1,62 @@
-import { ProtocolBaseClient, ProtocolBaseTransformer } from '@nmtjs/protocol/client';
-import { ErrorCode } from '@nmtjs/protocol/common';
-import { NeverType } from '@nmtjs/type';
-import { compile } from '@nmtjs/type/compiler';
+import { ProtocolBaseClient, ProtocolBaseTransformer } from "@nmtjs/protocol/client";
+import { ErrorCode } from "@nmtjs/protocol/common";
+import { NeemataTypeError, NeverType } from "@nmtjs/type";
 import { ClientError } from "./common.js";
 export class RuntimeContractTransformer extends ProtocolBaseTransformer {
-    #contract;
-    #types = new Set();
-    #compiled = new Map();
-    constructor(contract){
-        super();
-        this.#contract = contract;
-        for (const namespace of Object.values(contract.namespaces)){
-            for (const procedure of Object.values(namespace.procedures)){
-                const { input, output, stream } = procedure;
-                this.#registerType(input);
-                this.#registerType(output);
-                this.#registerType(stream);
-            }
-            for (const subscription of Object.values(namespace.subscriptions)){
-                const { input, output } = subscription;
-                this.#registerType(input);
-                this.#registerType(output);
-                for (const event of Object.values(subscription.events)){
-                    this.#registerType(event.payload);
-                }
-            }
-            for (const event of Object.values(namespace.events)){
-                this.#registerType(event.payload);
-            }
-        }
-        this.#compile();
-    }
-    decodeEvent(namespace, event, payload) {
-        const type = this.#contract.namespaces[namespace].events[event].payload;
-        if (type instanceof NeverType) return undefined;
-        const compiled = this.#compiled.get(type);
-        return compiled.decode(payload);
-    }
-    decodeRPC(namespace, procedure, payload) {
-        const type = this.#contract.namespaces[namespace].procedures[procedure].output;
-        if (type instanceof NeverType) return undefined;
-        const compiled = this.#compiled.get(type);
-        return compiled.decode(payload);
-    }
-    decodeRPCChunk(namespace, procedure, payload) {
-        const type = this.#contract.namespaces[namespace].procedures[procedure].stream;
-        if (type instanceof NeverType) return undefined;
-        const compiled = this.#compiled.get(type);
-        return compiled.decode(payload);
-    }
-    encodeRPC(namespace, procedure, payload) {
-        const type = this.#contract.namespaces[namespace].procedures[procedure].input;
-        if (type instanceof NeverType) return undefined;
-        const compiled = this.#compiled.get(type);
-        if (!compiled.check(payload)) {
-            const errors = compiled.errors(payload);
-            throw new ClientError(ErrorCode.ValidationError, 'Invalid RPC payload', errors);
-        }
-        return compiled.encode(payload);
-    }
-    #registerType(type) {
-        this.#types.add(type);
-    }
-    #compile() {
-        for (const type of this.#types){
-            this.#compiled.set(type, compile(type));
-        }
-    }
+	#contract;
+	constructor(contract) {
+		super();
+		this.#contract = contract;
+	}
+	decodeEvent(namespace, event, payload) {
+		const type = this.#contract.namespaces[namespace].events[event].payload;
+		return type.decode(payload);
+	}
+	decodeRPC(namespace, procedure, payload) {
+		const type = this.#contract.namespaces[namespace].procedures[procedure].output;
+		if (type instanceof NeverType) return undefined;
+		return type.decode(payload);
+	}
+	decodeRPCChunk(namespace, procedure, payload) {
+		const type = this.#contract.namespaces[namespace].procedures[procedure].stream;
+		if (type instanceof NeverType) return undefined;
+		return type.decode(payload);
+	}
+	encodeRPC(namespace, procedure, payload) {
+		const type = this.#contract.namespaces[namespace].procedures[procedure].input;
+		if (type instanceof NeverType) return undefined;
+		try {
+			return type.encode(payload);
+		} catch (error) {
+			if (error instanceof NeemataTypeError) {
+				throw new ClientError(ErrorCode.ValidationError, `Invalid payload for ${namespace}.${procedure}: ${error.message}`, error.issues);
+			}
+			throw error;
+		}
+	}
 }
 export class RuntimeClient extends ProtocolBaseClient {
-    _;
-    #callers = {};
-    constructor(contract, options){
-        super({
-            ...options,
-            transformer: new RuntimeContractTransformer(contract)
-        });
-        const callers = {};
-        for (const [namespaceKey, namespace] of Object.entries(contract.namespaces)){
-            namespace.procedures;
-            callers[namespaceKey] = {};
-            for (const [procedureKey, procedure] of Object.entries(namespace.procedures)){
-                callers[namespaceKey][procedureKey] = (payload, options)=>this._call(namespace.name, procedure.name, payload, {
-                        timeout: namespace.timeout,
-                        ...options
-                    });
-            }
-        }
-        this.#callers = callers;
-    }
-    get call() {
-        return this.#callers;
-    }
+	_;
+	#callers = {};
+	constructor(contract, options) {
+		super({
+			...options,
+			transformer: new RuntimeContractTransformer(contract)
+		});
+		const callers = {};
+		for (const [namespaceKey, namespace] of Object.entries(contract.namespaces)) {
+			namespace.procedures;
+			callers[namespaceKey] = {};
+			for (const [procedureKey, procedure] of Object.entries(namespace.procedures)) {
+				callers[namespaceKey][procedureKey] = (payload, options) => this._call(namespace.name, procedure.name, payload, {
+					timeout: namespace.timeout,
+					...options
+				});
+			}
+		}
+		this.#callers = callers;
+	}
+	get call() {
+		return this.#callers;
+	}
 }

package/dist/runtime.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../lib/runtime.ts"],"sourcesContent":["import type { TAnyAPIContract } from '@nmtjs/contract'\nimport type { BaseClientFormat } from '@nmtjs/protocol/client'\nimport {\n  ProtocolBaseClient,\n  ProtocolBaseTransformer,\n  type ProtocolTransport,\n} from '@nmtjs/protocol/client'\nimport { ErrorCode } from '@nmtjs/protocol/common'\nimport { type BaseTypeAny, NeverType } from '@nmtjs/type'\nimport { type Compiled, compile } from '@nmtjs/type/compiler'\nimport { ClientError } from './common.ts'\nimport type {\n  ClientCallers,\n  ResolveAPIContract,\n  ResolveClientEvents,\n  RuntimeContractTypeProvider,\n} from './types.ts'\n\nexport class RuntimeContractTransformer extends ProtocolBaseTransformer {\n  #contract: TAnyAPIContract\n  #types = new Set<BaseTypeAny>()\n  #compiled = new Map<BaseTypeAny, Compiled>()\n\n  constructor(contract: TAnyAPIContract) {\n    super()\n\n    this.#contract = contract\n\n    for (const namespace of Object.values(contract.namespaces)) {\n      for (const procedure of Object.values(namespace.procedures)) {\n        const { input, output, stream } = procedure\n        this.#registerType(input)\n        this.#registerType(output)\n        this.#registerType(stream)\n      }\n\n      for (const subscription of Object.values(namespace.subscriptions)) {\n        const { input, output } = subscription\n        this.#registerType(input)\n        this.#registerType(output)\n\n        for (const event of Object.values(subscription.events)) {\n          this.#registerType(event.payload)\n        }\n      }\n\n      for (const event of Object.values(namespace.events)) {\n        this.#registerType(event.payload)\n      }\n    }\n\n    this.#compile()\n  }\n\n  decodeEvent(namespace: string, event: string, payload: any) {\n    const type = this.#contract.namespaces[namespace].events[event].payload\n    if (type instanceof NeverType) return undefined\n    const compiled = this.#compiled.get(type)!\n    return compiled.decode(payload)\n  }\n\n  decodeRPC(namespace: string, procedure: string, payload: any) {\n    const type =\n      this.#contract.namespaces[namespace].procedures[procedure].output\n    if (type instanceof NeverType) return undefined\n    const compiled = this.#compiled.get(type)!\n    return compiled.decode(payload)\n  }\n\n  decodeRPCChunk(namespace: string, procedure: string, payload: any) {\n    const type =\n      this.#contract.namespaces[namespace].procedures[procedure].stream\n    if (type instanceof NeverType) return undefined\n\n    const compiled = this.#compiled.get(type)!\n    return compiled.decode(payload)\n  }\n\n  encodeRPC(namespace: string, procedure: string, payload: any) {\n    const type =\n      this.#contract.namespaces[namespace].procedures[procedure].input\n    if (type instanceof NeverType) return undefined\n\n    const compiled = this.#compiled.get(type)!\n    if (!compiled.check(payload)) {\n      const errors = compiled.errors(payload)\n      throw new ClientError(\n        ErrorCode.ValidationError,\n        'Invalid RPC payload',\n        errors,\n      )\n    }\n\n    return compiled.encode(payload)\n  }\n\n  #registerType(type: BaseTypeAny) {\n    this.#types.add(type)\n  }\n\n  #compile() {\n    for (const type of this.#types) {\n      this.#compiled.set(type, compile(type))\n    }\n  }\n}\n\nexport class RuntimeClient<\n  APIContract extends TAnyAPIContract,\n  ResolvedAPIContract extends ResolveAPIContract<\n    APIContract,\n    RuntimeContractTypeProvider\n  > = ResolveAPIContract<APIContract, RuntimeContractTypeProvider>,\n> extends ProtocolBaseClient<ResolveClientEvents<ResolvedAPIContract>> {\n  _!: ResolvedAPIContract\n  #callers = {} as ClientCallers<ResolvedAPIContract>\n\n  constructor(\n    contract: APIContract,\n    options: {\n      transport: ProtocolTransport\n      format: BaseClientFormat\n      timeout?: number\n    },\n  ) {\n    super({\n      ...options,\n      transformer: new RuntimeContractTransformer(contract),\n    })\n\n    const callers = {} as any\n\n    for (const [namespaceKey, namespace] of Object.entries(\n      contract.namespaces,\n    )) {\n      namespace.procedures\n\n      callers[namespaceKey] = {} as any\n\n      for (const [procedureKey, procedure] of Object.entries(\n        namespace.procedures,\n      )) {\n        callers[namespaceKey][procedureKey] = (payload, options) =>\n          this._call(namespace.name, procedure.name, payload, {\n            timeout: namespace.timeout,\n            ...options,\n          })\n      }\n    }\n    this.#callers = callers\n  }\n\n  get call() {\n    return this.#callers\n  }\n}\n"],"names":["ProtocolBaseClient","ProtocolBaseTransformer","ErrorCode","NeverType","compile","ClientError","RuntimeContractTransformer","Set","Map","constructor","contract","namespace","Object","values","namespaces","procedure","procedures","input","output","stream","subscription","subscriptions","event","events","payload","decodeEvent","type","undefined","compiled","get","decode","decodeRPC","decodeRPCChunk","encodeRPC","check","errors","ValidationError","encode","add","set","RuntimeClient","_","options","transformer","callers","namespaceKey","entries","procedureKey","_call","name","timeout","call"],"mappings":"AAEA,SACEA,kBAAkB,EAClBC,uBAAuB,QAElB,yBAAwB;AAC/B,SAASC,SAAS,QAAQ,yBAAwB;AAClD,SAA2BC,SAAS,QAAQ,cAAa;AACzD,SAAwBC,OAAO,QAAQ,uBAAsB;AAC7D,SAASC,WAAW,QAAQ,cAAa;AAQzC,OAAO,MAAMC,mCAAmCL;IAC9C,CAAA,QAAS,CAAiB;IAC1B,CAAA,KAAM,GAAG,IAAIM,MAAkB;IAC/B,CAAA,QAAS,GAAG,IAAIC,MAA4B;IAE5CC,YAAYC,QAAyB,CAAE;QACrC,KAAK;QAEL,IAAI,CAAC,CAAA,QAAS,GAAGA;QAEjB,KAAK,MAAMC,aAAaC,OAAOC,MAAM,CAACH,SAASI,UAAU,EAAG;YAC1D,KAAK,MAAMC,aAAaH,OAAOC,MAAM,CAACF,UAAUK,UAAU,EAAG;gBAC3D,MAAM,EAAEC,KAAK,EAAEC,MAAM,EAAEC,MAAM,EAAE,GAAGJ;gBAClC,IAAI,CAAC,CAAA,YAAa,CAACE;gBACnB,IAAI,CAAC,CAAA,YAAa,CAACC;gBACnB,IAAI,CAAC,CAAA,YAAa,CAACC;YACrB;YAEA,KAAK,MAAMC,gBAAgBR,OAAOC,MAAM,CAACF,UAAUU,aAAa,EAAG;gBACjE,MAAM,EAAEJ,KAAK,EAAEC,MAAM,EAAE,GAAGE;gBAC1B,IAAI,CAAC,CAAA,YAAa,CAACH;gBACnB,IAAI,CAAC,CAAA,YAAa,CAACC;gBAEnB,KAAK,MAAMI,SAASV,OAAOC,MAAM,CAACO,aAAaG,MAAM,EAAG;oBACtD,IAAI,CAAC,CAAA,YAAa,CAACD,MAAME,OAAO;gBAClC;YACF;YAEA,KAAK,MAAMF,SAASV,OAAOC,MAAM,CAACF,UAAUY,MAAM,EAAG;gBACnD,IAAI,CAAC,CAAA,YAAa,CAACD,MAAME,OAAO;YAClC;QACF;QAEA,IAAI,CAAC,CAAA,OAAQ;IACf;IAEAC,YAAYd,SAAiB,EAAEW,KAAa,EAAEE,OAAY,EAAE;QAC1D,MAAME,OAAO,IAAI,CAAC,CAAA,QAAS,CAACZ,UAAU,CAACH,UAAU,CAACY,MAAM,CAACD,MAAM,CAACE,OAAO;QACvE,IAAIE,gBAAgBvB,WAAW,OAAOwB;QACtC,MAAMC,WAAW,IAAI,CAAC,CAAA,QAAS,CAACC,GAAG,CAACH;QACpC,OAAOE,SAASE,MAAM,CAACN;IACzB;IAEAO,UAAUpB,SAAiB,EAAEI,SAAiB,EAAES,OAAY,EAAE;QAC5D,MAAME,OACJ,IAAI,CAAC,CAAA,QAAS,CAACZ,UAAU,CAACH,UAAU,CAACK,UAAU,CAACD,UAAU,CAACG,MAAM;QACnE,IAAIQ,gBAAgBvB,WAAW,OAAOwB;QACtC,MAAMC,WAAW,IAAI,CAAC,CAAA,QAAS,CAACC,GAAG,CAACH;QACpC,OAAOE,SAASE,MAAM,CAACN;IACzB;IAEAQ,eAAerB,SAAiB,EAAEI,SAAiB,EAAES,OAAY,EAAE;QACjE,MAAME,OACJ,IAAI,CAAC,CAAA,QAAS,CAACZ,UAAU,CAACH,UAAU,CAACK,UAAU,CAACD,UAAU,CAACI,MAAM;QACnE,IAAIO,gBAAgBvB,WAAW,OAAOwB;QAEtC,MAAMC,WAAW,IAAI,CAAC,CAAA,QAAS,CAACC,GAAG,CAACH;QACpC,OAAOE,SAASE,MAAM,CAACN;IACzB;IAEAS,UAAUtB,SAAiB,EAAEI,SAAiB,EAAES,OAAY,EAAE;QAC5D,MAAME,OACJ,IAAI,CAAC,CAAA,QAAS,CAACZ,UAAU,CAACH,UAAU,CAACK,UAAU,CAACD,UAAU,CAACE,KAAK;QAClE,IAAIS,gBAAgBvB,WAAW,OAAOwB;QAEtC,MAAMC,WAAW,IAAI,CAAC,CAAA,QAAS,CAACC,GAAG,CAACH;QACpC,IAAI,CAACE,SAASM,KAAK,CAACV,UAAU;YAC5B,MAAMW,SAASP,SAASO,MAAM,CAACX;YAC/B,MAAM,IAAInB,YACRH,UAAUkC,eAAe,EACzB,uBACAD;QAEJ;QAEA,OAAOP,SAASS,MAAM,CAACb;IACzB;IAEA,CAAA,YAAa,CAACE,IAAiB;QAC7B,IAAI,CAAC,CAAA,KAAM,CAACY,GAAG,CAACZ;IAClB;IAEA,CAAA,OAAQ;QACN,KAAK,MAAMA,QAAQ,IAAI,CAAC,CAAA,KAAM,CAAE;YAC9B,IAAI,CAAC,CAAA,QAAS,CAACa,GAAG,CAACb,MAAMtB,QAAQsB;QACnC;IACF;AACF;AAEA,OAAO,MAAMc,sBAMHxC;IACRyC,EAAuB;IACvB,CAAA,OAAQ,GAAG,CAAC,EAAuC;IAEnDhC,YACEC,QAAqB,EACrBgC,OAIC,CACD;QACA,KAAK,CAAC;YACJ,GAAGA,OAAO;YACVC,aAAa,IAAIrC,2BAA2BI;QAC9C;QAEA,MAAMkC,UAAU,CAAC;QAEjB,KAAK,MAAM,CAACC,cAAclC,UAAU,IAAIC,OAAOkC,OAAO,CACpDpC,SAASI,UAAU,EAClB;YACDH,UAAUK,UAAU;YAEpB4B,OAAO,CAACC,aAAa,GAAG,CAAC;YAEzB,KAAK,MAAM,CAACE,cAAchC,UAAU,IAAIH,OAAOkC,OAAO,CACpDnC,UAAUK,UAAU,EACnB;gBACD4B,OAAO,CAACC,aAAa,CAACE,aAAa,GAAG,CAACvB,SAASkB,UAC9C,IAAI,CAACM,KAAK,CAACrC,UAAUsC,IAAI,EAAElC,UAAUkC,IAAI,EAAEzB,SAAS;wBAClD0B,SAASvC,UAAUuC,OAAO;wBAC1B,GAAGR,OAAO;oBACZ;YACJ;QACF;QACA,IAAI,CAAC,CAAA,OAAQ,GAAGE;IAClB;IAEA,IAAIO,OAAO;QACT,OAAO,IAAI,CAAC,CAAA,OAAQ;IACtB;AACF"}
+{"mappings":"AAEA,SACE,oBACA,+BAEK,wBAAwB;AAC/B,SAAS,iBAAiB,wBAAwB;AAClD,SAA2B,kBAAkB,iBAAiB,aAAa;AAC3E,SAAS,mBAAmB,aAAa;AASzC,OAAO,MAAM,mCAAmC,wBAAwB;CACtE;CAEA,YAAYA,UAA2B;AACrC,SAAO;AAEP,OAAKC,YAAY;CAClB;CAED,YAAYC,WAAmBC,OAAeC,SAAc;EAC1D,MAAM,OAAO,KAAKH,UAAU,WAAW,WAAW,OAAO,OAAO;AAChE,SAAO,KAAK,OAAO,QAAQ;CAC5B;CAED,UAAUC,WAAmBG,WAAmBD,SAAc;EAC5D,MAAM,OACJ,KAAKH,UAAU,WAAW,WAAW,WAAW,WAAW;AAC7D,MAAI,gBAAgB,UAAW,QAAO;AACtC,SAAO,KAAK,OAAO,QAAQ;CAC5B;CAED,eAAeC,WAAmBG,WAAmBD,SAAc;EACjE,MAAM,OACJ,KAAKH,UAAU,WAAW,WAAW,WAAW,WAAW;AAC7D,MAAI,gBAAgB,UAAW,QAAO;AACtC,SAAO,KAAK,OAAO,QAAQ;CAC5B;CAED,UAAUC,WAAmBG,WAAmBD,SAAc;EAC5D,MAAM,OACJ,KAAKH,UAAU,WAAW,WAAW,WAAW,WAAW;AAC7D,MAAI,gBAAgB,UAAW,QAAO;AACtC,MAAI;AACF,UAAO,KAAK,OAAO,QAAQ;EAC5B,SAAQ,OAAO;AACd,OAAI,iBAAiB,kBAAkB;AACrC,UAAM,IAAI,YACR,UAAU,kBACT,sBAAsB,UAAU,GAAG,UAAU,IAAI,MAAM,QAAQ,GAChE,MAAM;GAET;AACD,SAAM;EACP;CACF;AACF;AAED,OAAO,MAAM,sBAWH,mBAA6D;CACrE;CACA,WAAW,CAAE;CAEb,YACEK,UACAC,SAKA;AACA,QAAM;GACJ,GAAG;GACH,aAAa,IAAI,2BAA2B;EAC7C,EAAC;EAEF,MAAM,UAAU,CAAE;AAElB,OAAK,MAAM,CAAC,cAAc,UAAU,IAAI,OAAO,QAC7C,SAAS,WACV,EAAE;AACD,aAAU;AAEV,WAAQ,gBAAgB,CAAE;AAE1B,QAAK,MAAM,CAAC,cAAc,UAAU,IAAI,OAAO,QAC7C,UAAU,WACX,EAAE;AACD,YAAQ,cAAc,gBAAgB,CAAC,SAAS,YAC9C,KAAK,MAAM,UAAU,MAAM,UAAU,MAAM,SAAS;KAClD,SAAS,UAAU;KACnB,GAAG;IACJ,EAAC;GACL;EACF;AACD,OAAKC,WAAW;CACjB;CAED,IAAI,OAAO;AACT,SAAO,KAAKA;CACb;AACF","names":["contract: TAnyAPIContract","#contract","namespace: string","event: string","payload: any","procedure: string","contract: APIContract","options: {\n      transport: ProtocolTransport\n      format: BaseClientFormat\n      timeout?: number\n    }","#callers"],"sources":["src/runtime.ts"],"sourcesContent":["import type { TAnyAPIContract } from '@nmtjs/contract'\nimport type { BaseClientFormat } from '@nmtjs/protocol/client'\nimport {\n  ProtocolBaseClient,\n  ProtocolBaseTransformer,\n  type ProtocolTransport,\n} from '@nmtjs/protocol/client'\nimport { ErrorCode } from '@nmtjs/protocol/common'\nimport { type BaseTypeAny, NeemataTypeError, NeverType } from '@nmtjs/type'\nimport { ClientError } from './common.ts'\nimport type {\n  ClientCallers,\n  ResolveAPIContract,\n  ResolveClientEvents,\n  RuntimeInputContractTypeProvider,\n  RuntimeOutputContractTypeProvider,\n} from './types.ts'\n\nexport class RuntimeContractTransformer extends ProtocolBaseTransformer {\n  #contract: TAnyAPIContract\n\n  constructor(contract: TAnyAPIContract) {\n    super()\n\n    this.#contract = contract\n  }\n\n  decodeEvent(namespace: string, event: string, payload: any) {\n    const type = this.#contract.namespaces[namespace].events[event].payload\n    return type.decode(payload)\n  }\n\n  decodeRPC(namespace: string, procedure: string, payload: any) {\n    const type =\n      this.#contract.namespaces[namespace].procedures[procedure].output\n    if (type instanceof NeverType) return undefined\n    return type.decode(payload)\n  }\n\n  decodeRPCChunk(namespace: string, procedure: string, payload: any) {\n    const type =\n      this.#contract.namespaces[namespace].procedures[procedure].stream\n    if (type instanceof NeverType) return undefined\n    return type.decode(payload)\n  }\n\n  encodeRPC(namespace: string, procedure: string, payload: any) {\n    const type =\n      this.#contract.namespaces[namespace].procedures[procedure].input\n    if (type instanceof NeverType) return undefined\n    try {\n      return type.encode(payload)\n    } catch (error) {\n      if (error instanceof NeemataTypeError) {\n        throw new ClientError(\n          ErrorCode.ValidationError,\n          `Invalid payload for ${namespace}.${procedure}: ${error.message}`,\n          error.issues,\n        )\n      }\n      throw error\n    }\n  }\n}\n\nexport class RuntimeClient<\n  APIContract extends TAnyAPIContract,\n  ResolvedAPIContract extends ResolveAPIContract<\n    APIContract,\n    RuntimeInputContractTypeProvider,\n    RuntimeOutputContractTypeProvider\n  > = ResolveAPIContract<\n    APIContract,\n    RuntimeInputContractTypeProvider,\n    RuntimeOutputContractTypeProvider\n  >,\n> extends ProtocolBaseClient<ResolveClientEvents<ResolvedAPIContract>> {\n  _!: ResolvedAPIContract\n  #callers = {} as ClientCallers<ResolvedAPIContract>\n\n  constructor(\n    contract: APIContract,\n    options: {\n      transport: ProtocolTransport\n      format: BaseClientFormat\n      timeout?: number\n    },\n  ) {\n    super({\n      ...options,\n      transformer: new RuntimeContractTransformer(contract),\n    })\n\n    const callers = {} as any\n\n    for (const [namespaceKey, namespace] of Object.entries(\n      contract.namespaces,\n    )) {\n      namespace.procedures\n\n      callers[namespaceKey] = {} as any\n\n      for (const [procedureKey, procedure] of Object.entries(\n        namespace.procedures,\n      )) {\n        callers[namespaceKey][procedureKey] = (payload, options) =>\n          this._call(namespace.name, procedure.name, payload, {\n            timeout: namespace.timeout,\n            ...options,\n          })\n      }\n    }\n    this.#callers = callers\n  }\n\n  get call() {\n    return this.#callers\n  }\n}\n"],"version":3}

package/dist/static.js

@@ -1,22 +1,18 @@
-import { ProtocolBaseClient } from '@nmtjs/protocol/client';
+import { ProtocolBaseClient } from "@nmtjs/protocol/client";
 export class StaticClient extends ProtocolBaseClient {
-    _;
-    #callers;
-    constructor(options){
-        super(options);
-        this.#callers = new Proxy(Object(), {
-            get: (target, namespace)=>{
-                if (namespace === 'then') return target;
-                return new Proxy(Object(), {
-                    get: (target, procedure)=>{
-                        if (procedure === 'then') return target;
-                        return (payload, options)=>this._call(namespace, procedure, payload, options);
-                    }
-                });
-            }
-        });
-    }
-    get call() {
-        return this.#callers;
-    }
+	_;
+	#callers;
+	constructor(options) {
+		super(options);
+		this.#callers = new Proxy(Object(), { get: (target, namespace) => {
+			if (namespace === "then") return target;
+			return new Proxy(Object(), { get: (target, procedure) => {
+				if (procedure === "then") return target;
+				return (payload, options) => this._call(namespace, procedure, payload, options);
+			} });
+		} });
+	}
+	get call() {
+		return this.#callers;
+	}
 }

package/dist/static.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../lib/static.ts"],"sourcesContent":["import type { TAnyAPIContract } from '@nmtjs/contract'\nimport {\n  type BaseClientFormat,\n  ProtocolBaseClient,\n  type ProtocolTransport,\n} from '@nmtjs/protocol/client'\n\nimport type {\n  ClientCallers,\n  ResolveAPIContract,\n  ResolveClientEvents,\n  StaticContractTypeProvider,\n} from './types.ts'\n\nexport class StaticClient<\n  APIContract extends TAnyAPIContract,\n  ResolvedAPIContract extends ResolveAPIContract<\n    APIContract,\n    StaticContractTypeProvider\n  > = ResolveAPIContract<APIContract, StaticContractTypeProvider>,\n> extends ProtocolBaseClient<ResolveClientEvents<ResolvedAPIContract>> {\n  _!: ResolvedAPIContract\n\n  #callers: ClientCallers<ResolvedAPIContract>\n\n  constructor(options: {\n    transport: ProtocolTransport\n    format: BaseClientFormat\n    timeout?: number\n  }) {\n    super(options)\n\n    this.#callers = new Proxy(Object(), {\n      get: (target, namespace) => {\n        // `await client.call.namespaceName` or `await client.call.namespaceName.procedureName`\n        // without explicitly calling a function implicitly calls .then() on target\n        // FIXME: this basically makes \"then\" a reserved word\n        if (namespace === 'then') return target\n        return new Proxy(Object(), {\n          get: (target, procedure) => {\n            // `await client.call.namespaceName` or `await client.call.namespaceName.procedureName`\n            // without explicitly calling a function implicitly calls .then() on target\n            // FIXME: this basically makes \"then\" a reserved word\n            if (procedure === 'then') return target\n            return (payload, options) =>\n              this._call(\n                namespace as string,\n                procedure as string,\n                payload,\n                options,\n              )\n          },\n        })\n      },\n    })\n  }\n\n  get call() {\n    return this.#callers\n  }\n}\n"],"names":["ProtocolBaseClient","StaticClient","_","constructor","options","Proxy","Object","get","target","namespace","procedure","payload","_call","call"],"mappings":"AACA,SAEEA,kBAAkB,QAEb,yBAAwB;AAS/B,OAAO,MAAMC,qBAMHD;IACRE,EAAuB;IAEvB,CAAA,OAAQ,CAAoC;IAE5CC,YAAYC,OAIX,CAAE;QACD,KAAK,CAACA;QAEN,IAAI,CAAC,CAAA,OAAQ,GAAG,IAAIC,MAAMC,UAAU;YAClCC,KAAK,CAACC,QAAQC;gBAIZ,IAAIA,cAAc,QAAQ,OAAOD;gBACjC,OAAO,IAAIH,MAAMC,UAAU;oBACzBC,KAAK,CAACC,QAAQE;wBAIZ,IAAIA,cAAc,QAAQ,OAAOF;wBACjC,OAAO,CAACG,SAASP,UACf,IAAI,CAACQ,KAAK,CACRH,WACAC,WACAC,SACAP;oBAEN;gBACF;YACF;QACF;IACF;IAEA,IAAIS,OAAO;QACT,OAAO,IAAI,CAAC,CAAA,OAAQ;IACtB;AACF"}
+{"mappings":"AACA,SAEE,0BAEK,wBAAwB;AAU/B,OAAO,MAAM,qBAWH,mBAA6D;CACrE;CAEA;CAEA,YAAYA,SAIT;AACD,QAAM,QAAQ;AAEd,OAAKC,WAAW,IAAI,MAAM,QAAQ,EAAE,EAClC,KAAK,CAAC,QAAQ,cAAc;AAI1B,OAAI,cAAc,OAAQ,QAAO;AACjC,UAAO,IAAI,MAAM,QAAQ,EAAE,EACzB,KAAK,CAAC,QAAQ,cAAc;AAI1B,QAAI,cAAc,OAAQ,QAAO;AACjC,WAAO,CAAC,SAAS,YACf,KAAK,MACH,WACA,WACA,SACA,QACD;GACJ,EACF;EACF,EACF;CACF;CAED,IAAI,OAAO;AACT,SAAO,KAAKA;CACb;AACF","names":["options: {\n    transport: ProtocolTransport\n    format: BaseClientFormat\n    timeout?: number\n  }","#callers"],"sources":["src/static.ts"],"sourcesContent":["import type { TAnyAPIContract } from '@nmtjs/contract'\nimport {\n  type BaseClientFormat,\n  ProtocolBaseClient,\n  type ProtocolTransport,\n} from '@nmtjs/protocol/client'\n\nimport type {\n  ClientCallers,\n  ResolveAPIContract,\n  ResolveClientEvents,\n  StaticInputContractTypeProvider,\n  StaticOutputContractTypeProvider,\n} from './types.ts'\n\nexport class StaticClient<\n  APIContract extends TAnyAPIContract,\n  ResolvedAPIContract extends ResolveAPIContract<\n    APIContract,\n    StaticInputContractTypeProvider,\n    StaticOutputContractTypeProvider\n  > = ResolveAPIContract<\n    APIContract,\n    StaticInputContractTypeProvider,\n    StaticOutputContractTypeProvider\n  >,\n> extends ProtocolBaseClient<ResolveClientEvents<ResolvedAPIContract>> {\n  _!: ResolvedAPIContract\n\n  #callers: ClientCallers<ResolvedAPIContract>\n\n  constructor(options: {\n    transport: ProtocolTransport\n    format: BaseClientFormat\n    timeout?: number\n  }) {\n    super(options)\n\n    this.#callers = new Proxy(Object(), {\n      get: (target, namespace) => {\n        // `await client.call.namespaceName` or `await client.call.namespaceName.procedureName`\n        // without explicitly calling a function implicitly calls .then() on target\n        // FIXME: this basically makes \"then\" a reserved word\n        if (namespace === 'then') return target\n        return new Proxy(Object(), {\n          get: (target, procedure) => {\n            // `await client.call.namespaceName` or `await client.call.namespaceName.procedureName`\n            // without explicitly calling a function implicitly calls .then() on target\n            // FIXME: this basically makes \"then\" a reserved word\n            if (procedure === 'then') return target\n            return (payload, options) =>\n              this._call(\n                namespace as string,\n                procedure as string,\n                payload,\n                options,\n              )\n          },\n        })\n      },\n    })\n  }\n\n  get call() {\n    return this.#callers\n  }\n}\n"],"version":3}

package/dist/types.js

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

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../lib/types.ts"],"sourcesContent":["import type { CallTypeProvider, TypeProvider } from '@nmtjs/common'\nimport type { TAnyAPIContract } from '@nmtjs/contract'\nimport type {\n  ProtocolBaseClientCallOptions,\n  ProtocolServerStreamInterface,\n} from '@nmtjs/protocol/client'\nimport type { InputType, OutputType } from '@nmtjs/protocol/common'\nimport type { BaseTypeAny, NeverType, t } from '@nmtjs/type'\n\nexport interface StaticContractTypeProvider extends TypeProvider {\n  output: this['input'] extends BaseTypeAny\n    ? t.infer.input.decoded<this['input']>\n    : never\n}\n\nexport interface RuntimeContractTypeProvider extends TypeProvider {\n  output: this['input'] extends BaseTypeAny\n    ? t.infer.decoded<this['input']>\n    : never\n}\n\nexport type ResolveAPIContract<\n  C extends TAnyAPIContract = TAnyAPIContract,\n  T extends TypeProvider = TypeProvider,\n> = {\n  [N in keyof C['namespaces'] as C['namespaces'][N]['name']]: {\n    procedures: {\n      [P in keyof C['namespaces'][N]['procedures'] as C['namespaces'][N]['procedures'][P]['name']]: {\n        contract: C['namespaces'][N]['procedures'][P]\n        input: InputType<\n          CallTypeProvider<T, C['namespaces'][N]['procedures'][P]['input']>\n        >\n        output: C['namespaces'][N]['procedures'][P]['stream'] extends NeverType\n          ? OutputType<\n              CallTypeProvider<T, C['namespaces'][N]['procedures'][P]['output']>\n            >\n          : {\n              response: OutputType<\n                CallTypeProvider<\n                  T,\n                  C['namespaces'][N]['procedures'][P]['output']\n                >\n              >\n              stream: ProtocolServerStreamInterface<\n                CallTypeProvider<\n                  T,\n                  C['namespaces'][N]['procedures'][P]['stream']\n                >\n              >\n            }\n      }\n    }\n    events: {\n      [KE in keyof C['namespaces'][N]['events'] as C['namespaces'][N]['events'][KE]['name']]: {\n        payload: OutputType<\n          CallTypeProvider<T, C['namespaces'][N]['events'][KE]['payload']>\n        >\n      }\n    }\n  }\n}\n\nexport type ResolveClientEvents<\n  C extends ResolveAPIContract = ResolveAPIContract,\n> = {\n  [N in keyof C]: {\n    [KE in keyof C[N]['events']]: C[N]['events'][KE]['payload']\n  }\n}\n\nexport type ClientCallers<Resolved extends ResolveAPIContract> = {\n  [N in keyof Resolved]: {\n    [P in keyof Resolved[N]['procedures']]: (\n      ...args: Resolved[N]['procedures'][P]['input'] extends NeverType\n        ? [options?: ProtocolBaseClientCallOptions]\n        : t.infer.input.encoded<\n              Resolved[N]['procedures'][P]['contract']['input']\n            > extends undefined\n          ? [\n              data?: Resolved[N]['procedures'][P]['input'],\n              options?: ProtocolBaseClientCallOptions,\n            ]\n          : [\n              data: Resolved[N]['procedures'][P]['input'],\n              options?: ProtocolBaseClientCallOptions,\n            ]\n    ) => Promise<Resolved[N]['procedures'][P]['output']>\n  }\n}\n"],"names":[],"mappings":"AAsEA,WAkBC"}
+{"mappings":"","names":[],"sources":["src/types.ts"],"sourcesContent":["import type { CallTypeProvider, TypeProvider } from '@nmtjs/common'\nimport type { TAnyAPIContract } from '@nmtjs/contract'\nimport type {\n  ProtocolBaseClientCallOptions,\n  ProtocolServerStreamInterface,\n} from '@nmtjs/protocol/client'\nimport type { InputType, OutputType } from '@nmtjs/protocol/common'\nimport type { BaseTypeAny, NeverType, t } from '@nmtjs/type'\n\nexport interface StaticInputContractTypeProvider extends TypeProvider {\n  output: this['input'] extends BaseTypeAny\n    ? t.infer.input.encoded<this['input']>\n    : never\n}\n\nexport interface RuntimeInputContractTypeProvider extends TypeProvider {\n  output: this['input'] extends BaseTypeAny\n    ? t.infer.input.decoded<this['input']>\n    : never\n}\n\nexport interface StaticOutputContractTypeProvider extends TypeProvider {\n  output: this['input'] extends BaseTypeAny\n    ? t.infer.decoded<this['input']>\n    : never\n}\n\nexport interface RuntimeOutputContractTypeProvider extends TypeProvider {\n  output: this['input'] extends BaseTypeAny\n    ? t.infer.decoded<this['input']>\n    : never\n}\n\nexport type ResolveAPIContract<\n  C extends TAnyAPIContract = TAnyAPIContract,\n  InputTypeProvider extends TypeProvider = TypeProvider,\n  OutputTypeProvider extends TypeProvider = TypeProvider,\n> = {\n  [N in keyof C['namespaces'] as C['namespaces'][N]['name']]: {\n    procedures: {\n      [P in keyof C['namespaces'][N]['procedures'] as C['namespaces'][N]['procedures'][P]['name']]: {\n        contract: C['namespaces'][N]['procedures'][P]\n        input: InputType<\n          CallTypeProvider<\n            InputTypeProvider,\n            C['namespaces'][N]['procedures'][P]['input']\n          >\n        >\n        output: C['namespaces'][N]['procedures'][P]['stream'] extends NeverType\n          ? OutputType<\n              CallTypeProvider<\n                OutputTypeProvider,\n                C['namespaces'][N]['procedures'][P]['output']\n              >\n            >\n          : {\n              response: OutputType<\n                CallTypeProvider<\n                  OutputTypeProvider,\n                  C['namespaces'][N]['procedures'][P]['output']\n                >\n              >\n              stream: ProtocolServerStreamInterface<\n                CallTypeProvider<\n                  OutputTypeProvider,\n                  C['namespaces'][N]['procedures'][P]['stream']\n                >\n              >\n            }\n      }\n    }\n    events: {\n      [KE in keyof C['namespaces'][N]['events'] as C['namespaces'][N]['events'][KE]['name']]: {\n        payload: OutputType<\n          CallTypeProvider<\n            OutputTypeProvider,\n            C['namespaces'][N]['events'][KE]['payload']\n          >\n        >\n      }\n    }\n  }\n}\n\nexport type ResolveClientEvents<\n  C extends ResolveAPIContract = ResolveAPIContract,\n> = {\n  [N in keyof C]: {\n    [KE in keyof C[N]['events']]: C[N]['events'][KE]['payload']\n  }\n}\n\nexport type ClientCallers<Resolved extends ResolveAPIContract> = {\n  [N in keyof Resolved]: {\n    [P in keyof Resolved[N]['procedures']]: (\n      ...args: Resolved[N]['procedures'][P]['input'] extends NeverType\n        ? [options?: ProtocolBaseClientCallOptions]\n        : t.infer.input.encoded<\n              Resolved[N]['procedures'][P]['contract']['input']\n            > extends undefined\n          ? [\n              data?: Resolved[N]['procedures'][P]['input'],\n              options?: ProtocolBaseClientCallOptions,\n            ]\n          : [\n              data: Resolved[N]['procedures'][P]['input'],\n              options?: ProtocolBaseClientCallOptions,\n            ]\n    ) => Promise<Resolved[N]['procedures'][P]['output']>\n  }\n}\n"],"version":3}

package/package.json

@@ -3,37 +3,33 @@
   "type": "module",
   "exports": {
     ".": {
-      "bun": "./lib/common.ts",
-      "default": "./dist/common.js",
-      "types": "./lib/common.ts"
+      "import": "./dist/common.js",
+      "types": "./src/common.ts"
     },
     "./runtime": {
-      "bun": "./lib/runtime.ts",
-      "default": "./dist/runtime.js",
-      "types": "./lib/runtime.ts"
+      "import": "./dist/runtime.js",
+      "types": "./src/runtime.ts"
     },
     "./static": {
-      "bun": "./lib/static.ts",
-      "default": "./dist/static.js",
-      "types": "./lib/static.ts"
+      "import": "./dist/static.js",
+      "types": "./src/static.ts"
     }
   },
   "dependencies": {
-    "@nmtjs/contract": "0.6.5",
-    "@nmtjs/protocol": "0.6.5",
-    "@nmtjs/type": "0.6.5",
-    "@nmtjs/common": "0.6.5"
+    "@nmtjs/type": "0.7.1",
+    "@nmtjs/contract": "0.7.1",
+    "@nmtjs/common": "0.7.1",
+    "@nmtjs/protocol": "0.7.1"
   },
   "files": [
-    "index.ts",
-    "lib",
+    "src",
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.6.5",
+  "version": "0.7.1",
   "scripts": {
-    "build": "neemata-build -p neutral --root=./lib './**/*.ts'",
+    "build": "neemata-build --root=./src './**/*.ts'",
     "type-check": "tsc --noEmit"
   }
 }

package/{lib → src}/runtime.ts

@@ -6,101 +6,59 @@ import {
   type ProtocolTransport,
 } from '@nmtjs/protocol/client'
 import { ErrorCode } from '@nmtjs/protocol/common'
-import { type BaseTypeAny, NeverType } from '@nmtjs/type'
-import { type Compiled, compile } from '@nmtjs/type/compiler'
+import { type BaseTypeAny, NeemataTypeError, NeverType } from '@nmtjs/type'
 import { ClientError } from './common.ts'
 import type {
   ClientCallers,
   ResolveAPIContract,
   ResolveClientEvents,
-  RuntimeContractTypeProvider,
+  RuntimeInputContractTypeProvider,
+  RuntimeOutputContractTypeProvider,
 } from './types.ts'
 
 export class RuntimeContractTransformer extends ProtocolBaseTransformer {
   #contract: TAnyAPIContract
-  #types = new Set<BaseTypeAny>()
-  #compiled = new Map<BaseTypeAny, Compiled>()
 
   constructor(contract: TAnyAPIContract) {
     super()
 
     this.#contract = contract
-
-    for (const namespace of Object.values(contract.namespaces)) {
-      for (const procedure of Object.values(namespace.procedures)) {
-        const { input, output, stream } = procedure
-        this.#registerType(input)
-        this.#registerType(output)
-        this.#registerType(stream)
-      }
-
-      for (const subscription of Object.values(namespace.subscriptions)) {
-        const { input, output } = subscription
-        this.#registerType(input)
-        this.#registerType(output)
-
-        for (const event of Object.values(subscription.events)) {
-          this.#registerType(event.payload)
-        }
-      }
-
-      for (const event of Object.values(namespace.events)) {
-        this.#registerType(event.payload)
-      }
-    }
-
-    this.#compile()
   }
 
   decodeEvent(namespace: string, event: string, payload: any) {
     const type = this.#contract.namespaces[namespace].events[event].payload
-    if (type instanceof NeverType) return undefined
-    const compiled = this.#compiled.get(type)!
-    return compiled.decode(payload)
+    return type.decode(payload)
   }
 
   decodeRPC(namespace: string, procedure: string, payload: any) {
     const type =
       this.#contract.namespaces[namespace].procedures[procedure].output
     if (type instanceof NeverType) return undefined
-    const compiled = this.#compiled.get(type)!
-    return compiled.decode(payload)
+    return type.decode(payload)
   }
 
   decodeRPCChunk(namespace: string, procedure: string, payload: any) {
     const type =
       this.#contract.namespaces[namespace].procedures[procedure].stream
     if (type instanceof NeverType) return undefined
-
-    const compiled = this.#compiled.get(type)!
-    return compiled.decode(payload)
+    return type.decode(payload)
   }
 
   encodeRPC(namespace: string, procedure: string, payload: any) {
     const type =
       this.#contract.namespaces[namespace].procedures[procedure].input
     if (type instanceof NeverType) return undefined
-
-    const compiled = this.#compiled.get(type)!
-    if (!compiled.check(payload)) {
-      const errors = compiled.errors(payload)
-      throw new ClientError(
-        ErrorCode.ValidationError,
-        'Invalid RPC payload',
-        errors,
-      )
-    }
-
-    return compiled.encode(payload)
-  }
-
-  #registerType(type: BaseTypeAny) {
-    this.#types.add(type)
-  }
-
-  #compile() {
-    for (const type of this.#types) {
-      this.#compiled.set(type, compile(type))
+    try {
+      return type.encode(payload)
+    } catch (error) {
+      if (error instanceof NeemataTypeError) {
+        throw new ClientError(
+          ErrorCode.ValidationError,
+          `Invalid payload for ${namespace}.${procedure}: ${error.message}`,
+          error.issues,
+        )
+      }
+      throw error
     }
   }
 }
@@ -109,8 +67,13 @@ export class RuntimeClient<
   APIContract extends TAnyAPIContract,
   ResolvedAPIContract extends ResolveAPIContract<
     APIContract,
-    RuntimeContractTypeProvider
-  > = ResolveAPIContract<APIContract, RuntimeContractTypeProvider>,
+    RuntimeInputContractTypeProvider,
+    RuntimeOutputContractTypeProvider
+  > = ResolveAPIContract<
+    APIContract,
+    RuntimeInputContractTypeProvider,
+    RuntimeOutputContractTypeProvider
+  >,
 > extends ProtocolBaseClient<ResolveClientEvents<ResolvedAPIContract>> {
   _!: ResolvedAPIContract
   #callers = {} as ClientCallers<ResolvedAPIContract>

package/{lib → src}/static.ts

@@ -9,15 +9,21 @@ import type {
   ClientCallers,
   ResolveAPIContract,
   ResolveClientEvents,
-  StaticContractTypeProvider,
+  StaticInputContractTypeProvider,
+  StaticOutputContractTypeProvider,
 } from './types.ts'
 
 export class StaticClient<
   APIContract extends TAnyAPIContract,
   ResolvedAPIContract extends ResolveAPIContract<
     APIContract,
-    StaticContractTypeProvider
-  > = ResolveAPIContract<APIContract, StaticContractTypeProvider>,
+    StaticInputContractTypeProvider,
+    StaticOutputContractTypeProvider
+  > = ResolveAPIContract<
+    APIContract,
+    StaticInputContractTypeProvider,
+    StaticOutputContractTypeProvider
+  >,
 > extends ProtocolBaseClient<ResolveClientEvents<ResolvedAPIContract>> {
   _!: ResolvedAPIContract
 

package/{lib → src}/types.ts

@@ -7,13 +7,25 @@ import type {
 import type { InputType, OutputType } from '@nmtjs/protocol/common'
 import type { BaseTypeAny, NeverType, t } from '@nmtjs/type'
 
-export interface StaticContractTypeProvider extends TypeProvider {
+export interface StaticInputContractTypeProvider extends TypeProvider {
+  output: this['input'] extends BaseTypeAny
+    ? t.infer.input.encoded<this['input']>
+    : never
+}
+
+export interface RuntimeInputContractTypeProvider extends TypeProvider {
   output: this['input'] extends BaseTypeAny
     ? t.infer.input.decoded<this['input']>
     : never
 }
 
-export interface RuntimeContractTypeProvider extends TypeProvider {
+export interface StaticOutputContractTypeProvider extends TypeProvider {
+  output: this['input'] extends BaseTypeAny
+    ? t.infer.decoded<this['input']>
+    : never
+}
+
+export interface RuntimeOutputContractTypeProvider extends TypeProvider {
   output: this['input'] extends BaseTypeAny
     ? t.infer.decoded<this['input']>
     : never
@@ -21,29 +33,36 @@ export interface RuntimeContractTypeProvider extends TypeProvider {
 
 export type ResolveAPIContract<
   C extends TAnyAPIContract = TAnyAPIContract,
-  T extends TypeProvider = TypeProvider,
+  InputTypeProvider extends TypeProvider = TypeProvider,
+  OutputTypeProvider extends TypeProvider = TypeProvider,
 > = {
   [N in keyof C['namespaces'] as C['namespaces'][N]['name']]: {
     procedures: {
       [P in keyof C['namespaces'][N]['procedures'] as C['namespaces'][N]['procedures'][P]['name']]: {
         contract: C['namespaces'][N]['procedures'][P]
         input: InputType<
-          CallTypeProvider<T, C['namespaces'][N]['procedures'][P]['input']>
+          CallTypeProvider<
+            InputTypeProvider,
+            C['namespaces'][N]['procedures'][P]['input']
+          >
         >
         output: C['namespaces'][N]['procedures'][P]['stream'] extends NeverType
           ? OutputType<
-              CallTypeProvider<T, C['namespaces'][N]['procedures'][P]['output']>
+              CallTypeProvider<
+                OutputTypeProvider,
+                C['namespaces'][N]['procedures'][P]['output']
+              >
             >
           : {
               response: OutputType<
                 CallTypeProvider<
-                  T,
+                  OutputTypeProvider,
                   C['namespaces'][N]['procedures'][P]['output']
                 >
               >
               stream: ProtocolServerStreamInterface<
                 CallTypeProvider<
-                  T,
+                  OutputTypeProvider,
                   C['namespaces'][N]['procedures'][P]['stream']
                 >
               >
@@ -53,7 +72,10 @@ export type ResolveAPIContract<
     events: {
       [KE in keyof C['namespaces'][N]['events'] as C['namespaces'][N]['events'][KE]['name']]: {
         payload: OutputType<
-          CallTypeProvider<T, C['namespaces'][N]['events'][KE]['payload']>
+          CallTypeProvider<
+            OutputTypeProvider,
+            C['namespaces'][N]['events'][KE]['payload']
+          >
         >
       }
     }