@effect/rpc - npm Package Compare versions

Comparing version 0.15.0 to 0.16.0

Client/dist/effect-rpc-Client.cjs.dev.js

@@ -9,10 +9,9 @@ 'use strict';
 var Error_dist_effectRpcError = require('../../Error/dist/effect-rpc-Error.cjs.dev.js');
-var Resolver_dist_effectRpcResolver = require('../../dist/Resolver-abf5fc84.cjs.dev.js');
 var Schema_dist_effectRpcSchema = require('../../Schema/dist/effect-rpc-Schema.cjs.dev.js');
-var codec = require('../../dist/codec-1158e8e9.cjs.dev.js');
-var schema = require('../../dist/schema-8f24267c.cjs.dev.js');
+var codec = require('../../dist/codec-932c4bbb.cjs.dev.js');
+var resolver = require('../../dist/resolver-de407fac.cjs.dev.js');
+var schema = require('../../dist/schema-0d780b0f.cjs.dev.js');
 require('@effect/schema/Schema');
 require('../../SchemaC/dist/effect-rpc-SchemaC.cjs.dev.js');
 require('effect/Data');
-require('effect/Context');
 require('effect/Equal');
@@ -23,2 +22,4 @@ require('effect/Exit');
 require('effect/RequestResolver');
+require('@effect/schema/AST');
+require('effect/Option');
 
@@ -66,3 +67,3 @@ function _interopNamespace(e) {
 /** @internal */
-const makeWithResolver$1 = (schemas, resolver, initOrOptions, options) => {
+const make$1 = (schemas, resolver, initOrOptions, options) => {
   const hasSetup = ("__setup" in schemas);
@@ -80,6 +81,3 @@ const opts = hasSetup ? options : initOrOptions;
 };
-
-/** @internal */
-const make$1 = (schemas, initOrOptions, options) => makeWithResolver$1(schemas, Resolver_dist_effectRpcResolver.RpcResolver, initOrOptions, options);
-const makeRpc = (resolver, serviceErrors, schema$1, method, {
+const makeRpc = (resolver$1, serviceErrors, schema$1, method, {
   spanPrefix = "RpcClient"
@@ -93,4 +91,5 @@ }) => {
     return input => {
-      const hash = Resolver_dist_effectRpcResolver.requestHash(method, input, spanPrefix);
-      return Effect__namespace.useSpan(`${spanPrefix}.${method}`, span => Function.pipe(encodeInput(input), Effect__namespace.flatMap(input => Effect__namespace.request(Resolver_dist_effectRpcResolver.RpcRequest({
+      const inputHash = Schema_dist_effectRpcSchema.hash(schema$1.input, input);
+      const hash = resolver.requestHash(method, inputHash, spanPrefix);
+      return Effect__namespace.useSpan(`${spanPrefix}.${method}`, span => Function.pipe(encodeInput(input), Effect__namespace.flatMap(input => Effect__namespace.request(resolver.RpcRequest({
         payload: {
@@ -106,7 +105,7 @@ _tag: method,
         schema: schema$1
-      }), resolver)), Effect__namespace.flatMap(parseOutput), Effect__namespace.catchAll(e => Effect__namespace.flatMap(parseError(e), Effect__namespace.fail))));
+      }), resolver$1)), Effect__namespace.flatMap(parseOutput), Effect__namespace.catchAll(e => Effect__namespace.flatMap(parseError(e), Effect__namespace.fail))));
     };
   }
-  const hash = Resolver_dist_effectRpcResolver.requestHash(method, undefined, spanPrefix);
-  return Effect__namespace.useSpan(`${spanPrefix}.${method}`, span => Function.pipe(Effect__namespace.request(Resolver_dist_effectRpcResolver.RpcRequest({
+  const hash = resolver.requestHash(method, 0, spanPrefix);
+  return Effect__namespace.useSpan(`${spanPrefix}.${method}`, span => Function.pipe(Effect__namespace.request(resolver.RpcRequest({
     payload: {
@@ -121,3 +120,3 @@ _tag: method,
     schema: schema$1
-  }), resolver), Effect__namespace.flatMap(parseOutput), Effect__namespace.catchAll(e => Effect__namespace.flatMap(parseError(e), Effect__namespace.fail))));
+  }), resolver$1), Effect__namespace.flatMap(parseOutput), Effect__namespace.catchAll(e => Effect__namespace.flatMap(parseError(e), Effect__namespace.fail))));
 };
@@ -149,3 +148,3 @@
 /**
- * Creates an RPC client
+ * Creates an RPC client with the specified resolver
  *
@@ -157,11 +156,2 @@ * @category constructors
 
-/**
- * Creates an RPC client with the specified resolver
- *
- * @category constructors
- * @since 1.0.0
- */
-const makeWithResolver = makeWithResolver$1;
-
 exports.make = make;
-exports.makeWithResolver = makeWithResolver;

Client/dist/effect-rpc-Client.cjs.prod.js

@@ -9,10 +9,9 @@ 'use strict';
 var Error_dist_effectRpcError = require('../../Error/dist/effect-rpc-Error.cjs.prod.js');
-var Resolver_dist_effectRpcResolver = require('../../dist/Resolver-62104cf5.cjs.prod.js');
 var Schema_dist_effectRpcSchema = require('../../Schema/dist/effect-rpc-Schema.cjs.prod.js');
-var codec = require('../../dist/codec-be6f8f58.cjs.prod.js');
-var schema = require('../../dist/schema-cd157c05.cjs.prod.js');
+var codec = require('../../dist/codec-0eacd60b.cjs.prod.js');
+var resolver = require('../../dist/resolver-e8f0e538.cjs.prod.js');
+var schema = require('../../dist/schema-ca62c904.cjs.prod.js');
 require('@effect/schema/Schema');
 require('../../SchemaC/dist/effect-rpc-SchemaC.cjs.prod.js');
 require('effect/Data');
-require('effect/Context');
 require('effect/Equal');
@@ -23,2 +22,4 @@ require('effect/Exit');
 require('effect/RequestResolver');
+require('@effect/schema/AST');
+require('effect/Option');
 
@@ -66,3 +67,3 @@ function _interopNamespace(e) {
 /** @internal */
-const makeWithResolver$1 = (schemas, resolver, initOrOptions, options) => {
+const make$1 = (schemas, resolver, initOrOptions, options) => {
   const hasSetup = ("__setup" in schemas);
@@ -80,6 +81,3 @@ const opts = hasSetup ? options : initOrOptions;
 };
-
-/** @internal */
-const make$1 = (schemas, initOrOptions, options) => makeWithResolver$1(schemas, Resolver_dist_effectRpcResolver.RpcResolver, initOrOptions, options);
-const makeRpc = (resolver, serviceErrors, schema$1, method, {
+const makeRpc = (resolver$1, serviceErrors, schema$1, method, {
   spanPrefix = "RpcClient"
@@ -93,4 +91,5 @@ }) => {
     return input => {
-      const hash = Resolver_dist_effectRpcResolver.requestHash(method, input, spanPrefix);
-      return Effect__namespace.useSpan(`${spanPrefix}.${method}`, span => Function.pipe(encodeInput(input), Effect__namespace.flatMap(input => Effect__namespace.request(Resolver_dist_effectRpcResolver.RpcRequest({
+      const inputHash = Schema_dist_effectRpcSchema.hash(schema$1.input, input);
+      const hash = resolver.requestHash(method, inputHash, spanPrefix);
+      return Effect__namespace.useSpan(`${spanPrefix}.${method}`, span => Function.pipe(encodeInput(input), Effect__namespace.flatMap(input => Effect__namespace.request(resolver.RpcRequest({
         payload: {
@@ -106,7 +105,7 @@ _tag: method,
         schema: schema$1
-      }), resolver)), Effect__namespace.flatMap(parseOutput), Effect__namespace.catchAll(e => Effect__namespace.flatMap(parseError(e), Effect__namespace.fail))));
+      }), resolver$1)), Effect__namespace.flatMap(parseOutput), Effect__namespace.catchAll(e => Effect__namespace.flatMap(parseError(e), Effect__namespace.fail))));
     };
   }
-  const hash = Resolver_dist_effectRpcResolver.requestHash(method, undefined, spanPrefix);
-  return Effect__namespace.useSpan(`${spanPrefix}.${method}`, span => Function.pipe(Effect__namespace.request(Resolver_dist_effectRpcResolver.RpcRequest({
+  const hash = resolver.requestHash(method, 0, spanPrefix);
+  return Effect__namespace.useSpan(`${spanPrefix}.${method}`, span => Function.pipe(Effect__namespace.request(resolver.RpcRequest({
     payload: {
@@ -121,3 +120,3 @@ _tag: method,
     schema: schema$1
-  }), resolver), Effect__namespace.flatMap(parseOutput), Effect__namespace.catchAll(e => Effect__namespace.flatMap(parseError(e), Effect__namespace.fail))));
+  }), resolver$1), Effect__namespace.flatMap(parseOutput), Effect__namespace.catchAll(e => Effect__namespace.flatMap(parseError(e), Effect__namespace.fail))));
 };
@@ -149,3 +148,3 @@
 /**
- * Creates an RPC client
+ * Creates an RPC client with the specified resolver
  *
@@ -157,11 +156,2 @@ * @category constructors
 
-/**
- * Creates an RPC client with the specified resolver
- *
- * @category constructors
- * @since 1.0.0
- */
-const makeWithResolver = makeWithResolver$1;
-
 exports.make = make;
-exports.makeWithResolver = makeWithResolver;

Client/dist/effect-rpc-Client.esm.js

@@ -1,2 +0,2 @@
-import { make as make$1, makeWithResolver as makeWithResolver$1 } from '../../internal/client.esm.js';
+import { make as make$1 } from '../../internal/client.esm.js';
 
@@ -27,3 +27,3 @@ /**
 /**
- * Creates an RPC client
+ * Creates an RPC client with the specified resolver
  *
@@ -35,10 +35,2 @@ * @category constructors
 
-/**
- * Creates an RPC client with the specified resolver
- *
- * @category constructors
- * @since 1.0.0
- */
-const makeWithResolver = makeWithResolver$1;
-
-export { make, makeWithResolver };
+export { make };

dist/declarations/src/Client.d.ts

@@ -16,4 +16,4 @@ /**
 export type Rpc<C extends RpcSchema.Any, R, SE> = C extends RpcSchema.IO<infer _IE, infer E, infer _II, infer I, infer _IO, infer O> ? (input: I) => Effect<R, RpcError | SE | E, O> : C extends RpcSchema.NoError<infer _II, infer I, infer _IO, infer O> ? (input: I) => Effect<R, RpcError | SE, O> : C extends RpcSchema.NoOutput<infer _IE, infer E, infer _II, infer I> ? (input: I) => Effect<R, RpcError | SE | E, void> : C extends RpcSchema.NoErrorNoOutput<infer _II, infer I> ? (input: I) => Effect<R, RpcError | SE, void> : C extends RpcSchema.NoInput<infer _IE, infer E, infer _IO, infer O> ? Effect<R, RpcError | SE | E, O> : C extends RpcSchema.NoInputNoError<infer _IO, infer O> ? Effect<R, RpcError | SE, O> : never;
-type RpcClientRpcs<S extends RpcService.DefinitionWithId, R, SE = never> = {
-    readonly [K in Exclude<keyof S, "__setup">]: S[K] extends RpcService.DefinitionWithId ? RpcClientRpcs<S[K], R, SE | RpcService.Errors<S>> : S[K] extends RpcSchema.Any ? Rpc<S[K], R, SE | RpcService.Errors<S>> : never;
+type RpcClientRpcs<S extends RpcService.DefinitionWithId, R, SE = never, Depth extends ReadonlyArray<number> = []> = {
+    readonly [K in Exclude<keyof S, "__setup">]: S[K] extends RpcService.DefinitionWithId ? Depth["length"] extends 3 ? never : RpcClientRpcs<S[K], R, SE | RpcService.Errors<S>, [0, ...Depth]> : S[K] extends RpcSchema.Any ? Rpc<S[K], R, SE | RpcService.Errors<S>> : never;
 };
@@ -27,4 +27,4 @@ /**
 export type RpcClient<S extends RpcService.DefinitionWithId, R> = RpcClientRpcs<S, R> & {
-    _schemas: S;
-    _unsafeDecode: <M extends RpcService.Methods<S>, O extends UndecodedRpcResponse<M, any>>(method: M, output: O) => O extends UndecodedRpcResponse<M, infer O> ? O : never;
+    readonly _schemas: S;
+    readonly _unsafeDecode: <M extends RpcService.Methods<S>, O extends UndecodedRpcResponse<M, any>>(method: M, output: O) => O extends UndecodedRpcResponse<M, infer O> ? O : never;
 };
@@ -39,3 +39,3 @@ /**
 /**
- * Creates an RPC client
+ * Creates an RPC client with the specified resolver
  *
@@ -46,16 +46,6 @@ * @category constructors
 export declare const make: {
-    <S extends RpcService.DefinitionWithSetup>(schemas: S, init: RpcSchema.Input<S["__setup"]>, options?: RpcClientOptions): Effect<never, RpcError | RpcSchema.Error<S["__setup"]>, RpcClient<S, RpcResolver<never>>>;
-    <S extends RpcService.DefinitionWithoutSetup>(schemas: S, options?: RpcClientOptions): RpcClient<S, RpcResolver<never>>;
-};
-/**
- * Creates an RPC client with the specified resolver
- *
- * @category constructors
- * @since 1.0.0
- */
-export declare const makeWithResolver: {
-    <S extends RpcService.DefinitionWithSetup, Resolver extends RpcResolver<never> | Effect<any, never, RpcResolver<never>>>(schemas: S, resolver: Resolver, init: RpcSchema.Input<S["__setup"]>, options?: RpcClientOptions | undefined): Effect<never, RpcError | RpcSchema.Error<S["__setup"]>, RpcClient<S, [
+    <const S extends RpcService.DefinitionWithSetup, Resolver extends RpcResolver<never> | Effect<any, never, RpcResolver<never>>>(schemas: S, resolver: Resolver, init: RpcSchema.Input<S["__setup"]>, options?: RpcClientOptions | undefined): Effect<never, RpcError | RpcSchema.Error<S["__setup"]>, RpcClient<S, [
         Resolver
     ] extends [Effect<any, any, any>] ? Effect.Context<Resolver> : never>>;
-    <S extends RpcService.DefinitionWithoutSetup, Resolver extends RpcResolver<never> | Effect<any, never, RpcResolver<never>>>(schemas: S, resolver: Resolver, options?: RpcClientOptions | undefined): RpcClient<S, [
+    <const S extends RpcService.DefinitionWithoutSetup, Resolver extends RpcResolver<never> | Effect<any, never, RpcResolver<never>>>(schemas: S, resolver: Resolver, options?: RpcClientOptions | undefined): RpcClient<S, [
         Resolver
@@ -62,0 +52,0 @@ ] extends [Effect<any, any, any>] ? Effect.Context<Resolver> : never>;

dist/declarations/src/Resolver.d.ts

 /**
  * @since 1.0.0
  */
-import { Tag } from "effect/Context";
 import type * as Effect from "effect/Effect";
@@ -17,7 +16,2 @@ import type * as Request from "effect/Request";
 /**
- * @category tags
- * @since 1.0.0
- */
-export declare const RpcResolver: Tag<RpcResolver<never>, RpcResolver<never>>;
-/**
  * @category models
@@ -24,0 +18,0 @@ * @since 1.0.0

dist/declarations/src/Router.d.ts

@@ -63,3 +63,3 @@ /**
 export interface RpcHandlers extends Record<string, RpcHandler.Any | {
-    handlers: RpcHandlers;
+    readonly handlers: RpcHandlers;
 }> {
@@ -75,5 +75,5 @@ }
      */
-    type FromService<S extends RpcService.DefinitionWithId> = {
-        readonly [K in Extract<keyof S, string>]: S[K] extends RpcService.DefinitionWithId ? {
-            handlers: FromService<S[K]>;
+    type FromService<S extends RpcService.DefinitionWithId, Depth extends ReadonlyArray<number> = []> = {
+        readonly [K in Extract<keyof S, string>]: S[K] extends RpcService.DefinitionWithId ? Depth["length"] extends 3 ? never : {
+            readonly handlers: FromService<S[K], [0, ...Depth]>;
         } : K extends "__setup" ? RpcHandler.FromSetupSchema<S[K]> : S[K] extends RpcSchema.Any ? RpcHandler.FromSchema<S[K]> : never;
@@ -85,7 +85,5 @@ };
      */
-    type Services<H extends RpcHandlers> = {
-        [M in keyof H]: H[M] extends {
-            readonly handlers: RpcHandlers;
-        } ? Services<H[M]["handlers"]> : H[M] extends RpcHandler<infer R, infer _E, infer _I, infer _O> ? R : never;
-    }[keyof H];
+    type Services<H extends RpcHandlers, Depth extends ReadonlyArray<number> = []> = keyof H extends infer M ? M extends keyof H ? H[M] extends {
+        readonly handlers: RpcHandlers;
+    } ? Depth["length"] extends 3 ? never : Services<H[M]["handlers"], [0, ...Depth]> : H[M] extends RpcHandler<infer R, infer _E, infer _I, infer _O> ? R : never : never : never;
     /**
@@ -95,7 +93,5 @@ * @category handlers utils
      */
-    type Error<H extends RpcHandlers> = {
-        [M in keyof H]: H[M] extends {
-            readonly handlers: RpcHandlers;
-        } ? Services<H[M]["handlers"]> : H[M] extends RpcHandler<infer _R, infer E, infer _I, infer _O> ? E : never;
-    }[keyof H];
+    type Errors<H extends RpcHandlers, Depth extends ReadonlyArray<number> = []> = keyof H extends infer M ? M extends keyof H ? H[M] extends {
+        readonly handlers: RpcHandlers;
+    } ? Depth["length"] extends 3 ? never : Errors<H[M]["handlers"], [0, ...Depth]> : H[M] extends RpcHandler<infer _R, infer E, infer _I, infer _O> ? E : never : never : never;
     /**
@@ -105,7 +101,5 @@ * @category handlers utils
      */
-    type Map<H extends RpcHandlers, XR, E2, P extends string = ""> = {
-        readonly [K in keyof H]: K extends string ? H[K] extends {
-            handlers: RpcHandlers;
-        } ? Map<H[K]["handlers"], XR, E2, `${P}${K}.`> : H[K] extends RpcHandler.IO<infer R, infer E, infer _I, infer O> ? [`${P}${K}`, Effect<Exclude<R, XR>, E | E2, O>] : H[K] extends Effect<infer R, infer E, infer O> ? [`${P}${K}`, Effect<Exclude<R, XR>, E | E2, O>] : never : never;
-    }[keyof H];
+    type Map<H extends RpcHandlers, XR, E2, P extends string = "", Depth extends ReadonlyArray<number> = []> = Extract<keyof H, string> extends infer K ? K extends Extract<keyof H, string> ? H[K] extends {
+        readonly handlers: RpcHandlers;
+    } ? Depth["length"] extends 3 ? never : Map<H[K]["handlers"], XR, E2, `${P}${K}.`, [0, ...Depth]> : H[K] extends RpcHandler.IO<infer R, infer E, infer _I, infer O> ? [`${P}${K}`, Effect<Exclude<R, XR>, E | E2, O>] : H[K] extends Effect<infer R, infer E, infer O> ? [`${P}${K}`, Effect<Exclude<R, XR>, E | E2, O>] : never : never : never;
 }
@@ -132,3 +126,3 @@ /**
         readonly schema: RpcService.DefinitionWithId;
-        readonly undecoded: RpcUndecodedClient<RpcHandlers>;
+        readonly undecoded: any;
         readonly options: Options;
@@ -165,4 +159,4 @@ }
      */
-    type Provide<Router extends Base, XR, PR, PE> = RpcRouter<Router["schema"], {
-        readonly [M in keyof Router["handlers"]]: Router["handlers"][M] extends Base ? Provide<Router["handlers"][M], XR, PR, PE> : Router["handlers"][M] extends RpcHandler.IO<infer R, infer E, infer I, infer O> ? RpcHandler.IO<Exclude<R, XR> | PR, E | PE, I, O> : Router["handlers"][M] extends RpcHandler.IOLayer<infer R, infer E, infer I, infer O> ? RpcHandler.IOLayer<Exclude<R, XR> | PR, E | PE, I, O> : Router["handlers"][M] extends RpcHandler.NoInput<infer R, infer E, infer O> ? RpcHandler.NoInput<Exclude<R, XR> | PR, E | PE, O> : never;
+    type Provide<Router extends Base, XR, PR, PE, Depth extends ReadonlyArray<number> = []> = RpcRouter<Router["schema"], {
+        readonly [M in keyof Router["handlers"]]: Router["handlers"][M] extends Base ? Depth["length"] extends 3 ? never : Provide<Router["handlers"][M], XR, PR, PE, [0, ...Depth]> : Router["handlers"][M] extends RpcHandler.IO<infer R, infer E, infer I, infer O> ? RpcHandler.IO<Exclude<R, XR> | PR, E | PE, I, O> : Router["handlers"][M] extends RpcHandler.IOLayer<infer R, infer E, infer I, infer O> ? RpcHandler.IOLayer<Exclude<R, XR> | PR, E | PE, I, O> : Router["handlers"][M] extends RpcHandler.NoInput<infer R, infer E, infer O> ? RpcHandler.NoInput<Exclude<R, XR> | PR, E | PE, O> : never;
     }>;
@@ -174,2 +168,12 @@ /**
     type SetupServices<R extends WithSetup> = R["handlers"]["__setup"] extends RpcHandler.IOLayer<infer _R, infer _E, infer _I, infer O> ? O : R["handlers"]["__setup"] extends RpcHandler.IO<infer _R, infer _E, infer _I, infer O> ? O extends Context<infer Env> ? Env : never : never;
+    /**
+     * @category router utils
+     * @since 1.0.0
+     */
+    type Services<R extends Base> = RpcHandlers.Services<R["handlers"]>;
+    /**
+     * @category router utils
+     * @since 1.0.0
+     */
+    type Errors<R extends Base> = RpcHandlers.Errors<R["handlers"]>;
 }
@@ -180,3 +184,3 @@ /**
  */
-export declare const make: <S extends RpcService.DefinitionWithId, H extends RpcHandlers.FromService<S>>(schema: S, handlers: H, options?: Partial<RpcRouter.Options>) => RpcRouter<S, H>;
+export declare const make: <const S extends RpcService.DefinitionWithId, const H extends RpcHandlers.FromService<S>>(schema: S, handlers: H, options?: Partial<RpcRouter.Options>) => RpcRouter<S, H>;
 /**
@@ -187,4 +191,4 @@ * @category router combinators
 export declare const provideService: {
-    <T extends Tag<any, any>>(tag: T, service: Tag.Service<T>): <Router extends RpcRouter.Base>(self: Router) => RpcRouter.Provide<Router, Tag.Identifier<T>, never, never>;
-    <Router extends RpcRouter.Base, T extends Tag<any, any>>(self: Router, tag: T, service: Tag.Service<T>): RpcRouter.Provide<Router, Tag.Identifier<T>, never, never>;
+    <T extends Tag<any, any>>(tag: T, service: Tag.Service<T>): <const Router extends RpcRouter.Base>(self: Router) => RpcRouter.Provide<Router, Tag.Identifier<T>, never, never>;
+    <const Router extends RpcRouter.Base, T extends Tag<any, any>>(self: Router, tag: T, service: Tag.Service<T>): RpcRouter.Provide<Router, Tag.Identifier<T>, never, never>;
 };
@@ -196,4 +200,4 @@ /**
 export declare const provideServiceEffect: {
-    <Router extends RpcRouter.Base, T extends Tag<any, any>, R, E extends RpcService.Errors<Router["schema"]>>(tag: T, effect: Effect<R, E, Tag.Service<T>>): (self: Router) => RpcRouter.Provide<Router, Tag.Identifier<T>, R, E>;
-    <Router extends RpcRouter.Base, T extends Tag<any, any>, R, E extends RpcService.Errors<Router["schema"]>>(self: Router, tag: T, effect: Effect<R, E, Tag.Service<T>>): RpcRouter.Provide<Router, Tag.Identifier<T>, R, E>;
+    <const Router extends RpcRouter.Base, T extends Tag<any, any>, R, E extends RpcService.Errors<Router["schema"]>>(tag: T, effect: Effect<R, E, Tag.Service<T>>): (self: Router) => RpcRouter.Provide<Router, Tag.Identifier<T>, R, E>;
+    <const Router extends RpcRouter.Base, T extends Tag<any, any>, R, E extends RpcService.Errors<Router["schema"]>>(self: Router, tag: T, effect: Effect<R, E, Tag.Service<T>>): RpcRouter.Provide<Router, Tag.Identifier<T>, R, E>;
 };
@@ -205,5 +209,5 @@ /**
 export declare const provideServiceSync: {
-    <T extends Tag<any, any>>(tag: T, service: LazyArg<Tag.Service<T>>): <Router extends RpcRouter.Base>(self: Router) => RpcRouter.Provide<Router, Tag.Identifier<T>, never, never>;
+    <T extends Tag<any, any>>(tag: T, service: LazyArg<Tag.Service<T>>): <const Router extends RpcRouter.Base>(self: Router) => RpcRouter.Provide<Router, Tag.Identifier<T>, never, never>;
     <Router extends RpcRouter.Base, T extends Tag<any, any>>(self: Router, tag: T, service: LazyArg<Tag.Service<T>>): RpcRouter.Provide<Router, Tag.Identifier<T>, never, never>;
 };
 //# sourceMappingURL=Router.d.ts.map

dist/declarations/src/Schema.d.ts

@@ -17,5 +17,5 @@ /**
     interface IO<IE, E, II, I, IO, O> {
-        input: Schema.Schema<II, I>;
-        output: Schema.Schema<IO, O>;
-        error: Schema.Schema<IE, E>;
+        readonly input: Schema.Schema<II, I>;
+        readonly output: Schema.Schema<IO, O>;
+        readonly error: Schema.Schema<IE, E>;
     }
@@ -27,4 +27,4 @@ /**
     interface NoError<II, I, IO, O> {
-        input: Schema.Schema<II, I>;
-        output: Schema.Schema<IO, O>;
+        readonly input: Schema.Schema<II, I>;
+        readonly output: Schema.Schema<IO, O>;
     }
@@ -36,4 +36,4 @@ /**
     interface NoInput<IE, E, IO, O> {
-        output: Schema.Schema<IO, O>;
-        error: Schema.Schema<IE, E>;
+        readonly output: Schema.Schema<IO, O>;
+        readonly error: Schema.Schema<IE, E>;
     }
@@ -45,3 +45,3 @@ /**
     interface NoInputNoError<IO, O> {
-        output: Schema.Schema<IO, O>;
+        readonly output: Schema.Schema<IO, O>;
     }
@@ -53,4 +53,4 @@ /**
     interface NoOutput<IE, E, II, I> {
-        input: Schema.Schema<II, I>;
-        error: Schema.Schema<IE, E>;
+        readonly input: Schema.Schema<II, I>;
+        readonly error: Schema.Schema<IE, E>;
     }
@@ -62,3 +62,3 @@ /**
     interface NoErrorNoOutput<II, I> {
-        input: Schema.Schema<II, I>;
+        readonly input: Schema.Schema<II, I>;
     }
@@ -126,3 +126,6 @@ /**
     interface Definition extends Record<string, RpcSchema.Any | WithId<any, any, any>> {
-        __setup?: RpcSchema.NoErrorNoOutput<any, any> | RpcSchema.NoOutput<any, any, any, any>;
+        readonly __setup?: {
+            readonly input: Schema.Schema<any>;
+            readonly error?: Schema.Schema<any>;
+        };
     }
@@ -183,5 +186,3 @@ /**
      */
-    type Methods<S extends DefinitionWithId, P extends string = ``> = {
-        [M in keyof S]: M extends string ? S[M] extends DefinitionWithId ? Methods<S[M], `${P}${M}.`> : `${P}${M}` : never;
-    }[keyof S];
+    type Methods<S extends DefinitionWithId, P extends string = ``, Depth extends ReadonlyArray<number> = []> = Extract<keyof S, string> extends infer M ? M extends Extract<keyof S, string> ? S[M] extends DefinitionWithId ? Depth["length"] extends 3 ? never : Methods<S[M], `${P}${M}.`, [0, ...Depth]> : `${P}${M}` : never : never;
     /**
@@ -191,4 +192,4 @@ * @category utils
      */
-    type Validate<VL extends string, V, S extends RpcService.Definition> = {
-        readonly [K in keyof S]: K extends "__setup" ? S[K] : S[K] extends DefinitionWithId ? Validate<VL, V, S[K]> : S[K] extends RpcSchema.IO<infer IE, infer _E, infer II, infer _I, infer IO, infer _O> ? [IE | II | IO] extends [V] ? S[K] : `schema input does not extend ${VL}` : S[K] extends RpcSchema.NoError<infer II, infer _I, infer IO, infer _O> ? [II | IO] extends [V] ? S[K] : `schema input does not extend ${VL}` : S[K] extends RpcSchema.NoInput<infer IE, infer _E, infer IO, infer _O> ? [IE | IO] extends [V] ? S[K] : `schema input does not extend ${VL}` : S[K] extends RpcSchema.NoInputNoError<infer IO, infer _O> ? [IO] extends [V] ? S[K] : `schema input does not extend ${VL}` : S[K];
+    type Validate<VL extends string, V, S extends RpcService.Definition, Depth extends ReadonlyArray<number> = []> = {
+        readonly [K in keyof S]: K extends "__setup" ? S[K] : S[K] extends DefinitionWithId ? Depth["length"] extends 3 ? never : Validate<VL, V, S[K], [0, ...Depth]> : S[K] extends RpcSchema.IO<infer IE, infer _E, infer II, infer _I, infer IO, infer _O> ? [IE | II | IO] extends [V] ? S[K] : `schema input does not extend ${VL}` : S[K] extends RpcSchema.NoError<infer II, infer _I, infer IO, infer _O> ? [II | IO] extends [V] ? S[K] : `schema input does not extend ${VL}` : S[K] extends RpcSchema.NoInput<infer IE, infer _E, infer IO, infer _O> ? [IE | IO] extends [V] ? S[K] : `schema input does not extend ${VL}` : S[K] extends RpcSchema.NoInputNoError<infer IO, infer _O> ? [IO] extends [V] ? S[K] : `schema input does not extend ${VL}` : S[K];
     };
@@ -207,3 +208,3 @@ /**
  */
-export declare const makeWith: <VL extends string, V>() => <S extends RpcService.Definition>(schema: S) => RpcService.Simplify<RpcService.Validate<VL, V, S>, never, never>;
+export declare const makeWith: <VL extends string, V>() => <const S extends RpcService.Definition>(schema: S) => RpcService.Simplify<RpcService.Validate<VL, V, S, []>, never, never>;
 /**
@@ -215,3 +216,3 @@ * Make a RPC service schema that can be encoded and decoded from JSON.
  */
-export declare const make: <S extends RpcService.Definition>(schema: S) => RpcService.Simplify<RpcService.Validate<"Schema.Json", internal.Json, S>, never, never>;
+export declare const make: <const S extends RpcService.Definition>(schema: S) => RpcService.Simplify<RpcService.Validate<"Schema.Json", internal.Json, S, []>, never, never>;
 /**
@@ -235,15 +236,13 @@ * Add a service level error, which can then be used with `Router.provideServiceEffect`.
      */
-    type From<S extends RpcService.Definition, P extends string = ""> = {
-        readonly [K in keyof S]: K extends string ? S[K] extends RpcService.DefinitionWithId ? To<S[K], `${P}${K}.`> : S[K] extends RpcSchema.IO<infer _IE, infer _E, infer II, infer _I, infer _IO, infer _O> ? {
-            readonly _tag: `${P}${K}`;
-            readonly input: II;
-        } : S[K] extends RpcSchema.NoError<infer II, infer _I, infer _IO, infer _O> ? {
-            readonly _tag: `${P}${K}`;
-            readonly input: II;
-        } : S[K] extends RpcSchema.NoInput<infer _IE, infer _E, infer _IO, infer _O> ? {
-            readonly _tag: `${P}${K}`;
-        } : S[K] extends RpcSchema.NoInputNoError<infer _IO, infer _O> ? {
-            readonly _tag: `${P}${K}`;
-        } : never : never;
-    }[keyof S];
+    type From<S extends RpcService.Definition, P extends string = "", Depth extends ReadonlyArray<number> = []> = Extract<keyof S, string> extends infer K ? K extends Extract<keyof S, string> ? S[K] extends RpcService.DefinitionWithId ? Depth["length"] extends 3 ? never : From<S[K], `${P}${K}.`, [0, ...Depth]> : S[K] extends RpcSchema.IO<infer _IE, infer _E, infer II, infer _I, infer _IO, infer _O> ? {
+        readonly _tag: `${P}${K}`;
+        readonly input: II;
+    } : S[K] extends RpcSchema.NoError<infer II, infer _I, infer _IO, infer _O> ? {
+        readonly _tag: `${P}${K}`;
+        readonly input: II;
+    } : S[K] extends RpcSchema.NoInput<infer _IE, infer _E, infer _IO, infer _O> ? {
+        readonly _tag: `${P}${K}`;
+    } : S[K] extends RpcSchema.NoInputNoError<infer _IO, infer _O> ? {
+        readonly _tag: `${P}${K}`;
+    } : never : never : never;
     /**
@@ -253,5 +252,3 @@ * @category utils
      */
-    type To<S extends RpcService.Definition, P extends string = ""> = {
-        readonly [K in keyof S]: K extends string ? S[K] extends RpcService.DefinitionWithId ? To<S[K], `${P}${K}.`> : S[K] extends RpcSchema.IO<infer _IE, infer _E, infer _II, infer I, infer _IO, infer _O> ? RpcRequest.WithInput<`${P}${K}`, I> : S[K] extends RpcSchema.NoError<infer _II, infer I, infer _IO, infer _O> ? RpcRequest.WithInput<`${P}${K}`, I> : S[K] extends RpcSchema.NoInput<infer _IE, infer _E, infer _IO, infer _O> ? RpcRequest.NoInput<`${P}${K}`> : S[K] extends RpcSchema.NoInputNoError<infer _IO, infer _O> ? RpcRequest.NoInput<`${P}${K}`> : never : never;
-    }[keyof S];
+    type To<S extends RpcService.Definition, P extends string = "", Depth extends ReadonlyArray<number> = []> = Extract<keyof S, string> extends infer K ? K extends Extract<keyof S, string> ? S[K] extends RpcService.DefinitionWithId ? Depth["length"] extends 3 ? never : To<S[K], `${P}${K}.`, [0, ...Depth]> : S[K] extends RpcSchema.IO<infer _IE, infer _E, infer _II, infer I, infer _IO, infer _O> ? RpcRequest.WithInput<`${P}${K}`, I> : S[K] extends RpcSchema.NoError<infer _II, infer I, infer _IO, infer _O> ? RpcRequest.WithInput<`${P}${K}`, I> : S[K] extends RpcSchema.NoInput<infer _IE, infer _E, infer _IO, infer _O> ? RpcRequest.NoInput<`${P}${K}`> : S[K] extends RpcSchema.NoInputNoError<infer _IO, infer _O> ? RpcRequest.NoInput<`${P}${K}`> : never : never : never;
     /**
@@ -267,3 +264,34 @@ * @category models
  */
-export declare const makeRequestUnion: <S extends RpcService.Definition>(schema: S) => Schema.Schema<RpcRequestSchema.From<S, "">, RpcRequestSchema.To<S, "">>;
+export declare const makeRequestUnion: <S extends RpcService.Definition>(schema: S) => Schema.Schema<RpcRequestSchema.From<S, "", []>, RpcRequestSchema.To<S, "", []>>;
+/**
+ * @category type ids
+ * @since 1.0.0
+ */
+export declare const HashAnnotationId: unique symbol;
+/**
+ * @category type ids
+ * @since 1.0.0
+ */
+export type HashAnnotationId = typeof HashAnnotationId;
+/**
+ * @category annotations
+ * @since 1.0.0
+ */
+export declare const withHash: {
+    <A>(f: (a: A) => number): <I>(self: Schema.Schema<I, A>) => Schema.Schema<I, A>;
+    <I, A>(self: Schema.Schema<I, A>, f: (a: A) => number): Schema.Schema<I, A>;
+};
+/**
+ * @category annotations
+ * @since 1.0.0
+ */
+export declare const withHashString: {
+    <A>(f: (a: A) => string): <I>(self: Schema.Schema<I, A>) => Schema.Schema<I, A>;
+    <I, A>(self: Schema.Schema<I, A>, f: (a: A) => string): Schema.Schema<I, A>;
+};
+/**
+ * @category annotations
+ * @since 1.0.0
+ */
+export declare const hash: <I, A>(self: Schema.Schema<I, A>, value: A) => number;
 //# sourceMappingURL=Schema.d.ts.map

dist/declarations/src/Server.d.ts

@@ -7,3 +7,2 @@ /**
 import type { Scope } from "effect/Scope";
-import type { Span } from "effect/Tracer";
 import type { RpcDecodeFailure, RpcEncodeFailure } from "./Error.js";
@@ -18,4 +17,4 @@ import type { RpcResponse } from "./Resolver.js";
 export declare const handler: {
-    <R extends RpcRouter.WithSetup>(router: R): Effect<Scope, never, (request: unknown) => Effect<Exclude<RpcHandlers.Services<R["handlers"]>, RpcRouter.SetupServices<R> | Span>, never, ReadonlyArray<RpcResponse>>>;
-    <R extends RpcRouter.WithoutSetup>(router: R): (request: unknown) => Effect<Exclude<RpcHandlers.Services<R["handlers"]>, Span>, never, ReadonlyArray<RpcResponse>>;
+    <const R extends RpcRouter.WithSetup>(router: R): Effect<Scope, never, (request: unknown) => Effect<Exclude<RpcHandlers.Services<R["handlers"]>, RpcRouter.SetupServices<R>>, never, ReadonlyArray<RpcResponse>>>;
+    <const R extends RpcRouter.WithoutSetup>(router: R): (request: unknown) => Effect<RpcHandlers.Services<R["handlers"]>, never, ReadonlyArray<RpcResponse>>;
 };
@@ -26,5 +25,5 @@ /**
  */
-export declare const handlerRaw: <R extends RpcRouter.Base>(router: R) => <Req extends RpcRequestSchema.To<R["schema"], "">>(request: Req) => Req extends {
+export declare const handlerRaw: <const R extends RpcRouter.Base>(router: R) => <Req extends RpcRequestSchema.To<R["schema"], "">>(request: Req) => Req extends {
     _tag: infer M;
-} ? RpcHandler.FromMethod<R["handlers"], M, Span, RpcEncodeFailure> : never;
+} ? RpcHandler.FromMethod<R["handlers"], M, never, RpcEncodeFailure> : never;
 /**
@@ -35,4 +34,4 @@ * @category constructors
 export declare const handleSingle: {
-    <R extends RpcRouter.WithSetup>(router: R): Effect<Scope, never, (request: unknown) => Effect<Exclude<RpcHandlers.Services<R["handlers"]>, RpcRouter.SetupServices<R> | Span>, never, RpcResponse>>;
-    <R extends RpcRouter.WithoutSetup>(router: R): (request: unknown) => Effect<Exclude<RpcHandlers.Services<R["handlers"]>, Span>, never, RpcResponse>;
+    <const R extends RpcRouter.WithSetup>(router: R): Effect<Scope, never, (request: unknown) => Effect<Exclude<RpcHandlers.Services<R["handlers"]>, RpcRouter.SetupServices<R>>, never, RpcResponse>>;
+    <R extends RpcRouter.WithoutSetup>(router: R): (request: unknown) => Effect<RpcHandlers.Services<R["handlers"]>, never, RpcResponse>;
 };
@@ -44,4 +43,4 @@ /**
 export declare const handleSingleWithSchema: {
-    <R extends RpcRouter.WithSetup>(router: R): Effect<Scope, never, (request: unknown) => Effect<Exclude<RpcHandlers.Services<R["handlers"]>, RpcRouter.SetupServices<R> | Span>, never, readonly [RpcResponse, Option<RpcSchema.Base>]>>;
-    <R extends RpcRouter.WithoutSetup>(router: R): (request: unknown) => Effect<Exclude<RpcHandlers.Services<R["handlers"]>, Span>, never, readonly [RpcResponse, Option<RpcSchema.Base>]>;
+    <const R extends RpcRouter.WithSetup>(router: R): Effect<Scope, never, (request: unknown) => Effect<Exclude<RpcHandlers.Services<R["handlers"]>, RpcRouter.SetupServices<R>>, never, readonly [RpcResponse, Option<RpcSchema.Base>]>>;
+    <R extends RpcRouter.WithoutSetup>(router: R): (request: unknown) => Effect<RpcHandlers.Services<R["handlers"]>, never, readonly [RpcResponse, Option<RpcSchema.Base>]>;
 };
@@ -60,6 +59,6 @@ /**
  */
-export type RpcUndecodedClient<H extends RpcHandlers, P extends string = ""> = {
+export type RpcUndecodedClient<H extends RpcHandlers, P extends string = "", Depth extends ReadonlyArray<number> = []> = {
     readonly [K in Extract<keyof H, string>]: H[K] extends {
-        handlers: RpcHandlers;
-    } ? RpcUndecodedClient<H[K]["handlers"], `${P}${K}.`> : H[K] extends RpcHandler.IO<infer R, infer E, infer I, infer O> ? (input: I) => Effect<Exclude<R, Span>, E | RpcEncodeFailure | RpcDecodeFailure, UndecodedRpcResponse<`${P}${K}`, O>> : H[K] extends Effect<infer R, infer E, infer O> ? Effect<Exclude<R, Span>, E | RpcEncodeFailure | RpcDecodeFailure, UndecodedRpcResponse<`${P}${K}`, O>> : never;
+        readonly handlers: RpcHandlers;
+    } ? Depth["length"] extends 3 ? never : RpcUndecodedClient<H[K]["handlers"], `${P}${K}.`, [0, ...Depth]> : H[K] extends RpcHandler.IO<infer R, infer E, infer I, infer O> ? (input: I) => Effect<R, E | RpcEncodeFailure | RpcDecodeFailure, UndecodedRpcResponse<`${P}${K}`, O>> : H[K] extends Effect<infer R, infer E, infer O> ? Effect<R, E | RpcEncodeFailure | RpcDecodeFailure, UndecodedRpcResponse<`${P}${K}`, O>> : never;
 };
@@ -70,3 +69,3 @@ /**
  */
-export declare const makeUndecodedClient: <S extends RpcService.DefinitionWithId, H extends RpcHandlers.FromService<S>>(schemas: S, handlers: H, options: RpcRouter.Options) => RpcUndecodedClient<H>;
+export declare const makeUndecodedClient: <const S extends RpcService.DefinitionWithId, const H extends RpcHandlers.FromService<S>>(schemas: S, handlers: H, options: RpcRouter.Options) => RpcUndecodedClient<H>;
 /**
@@ -73,0 +72,0 @@ * @category utils

internal/client.esm.js

@@ -5,4 +5,3 @@ import * as Effect from 'effect/Effect';
 import { RpcError } from '../Error/dist/effect-rpc-Error.esm.js';
-import { RpcResolver } from '../Resolver/dist/effect-rpc-Resolver.esm.js';
-import { RpcServiceErrorId, RpcServiceId } from '../Schema/dist/effect-rpc-Schema.esm.js';
+import { RpcServiceErrorId, RpcServiceId, hash } from '../Schema/dist/effect-rpc-Schema.esm.js';
 import { decode, encode } from './codec.esm.js';
@@ -32,3 +31,3 @@ import { requestHash, RpcRequest } from './resolver.esm.js';
 /** @internal */
-const makeWithResolver = (schemas, resolver, initOrOptions, options) => {
+const make = (schemas, resolver, initOrOptions, options) => {
   const hasSetup = ("__setup" in schemas);
@@ -46,5 +45,2 @@ const opts = hasSetup ? options : initOrOptions;
 };
-
-/** @internal */
-const make = (schemas, initOrOptions, options) => makeWithResolver(schemas, RpcResolver, initOrOptions, options);
 const makeRpc = (resolver, serviceErrors, schema, method, {
@@ -59,3 +55,4 @@ spanPrefix = "RpcClient"
     return input => {
-      const hash = requestHash(method, input, spanPrefix);
+      const inputHash = hash(schema.input, input);
+      const hash$1 = requestHash(method, inputHash, spanPrefix);
       return Effect.useSpan(`${spanPrefix}.${method}`, span => pipe(encodeInput(input), Effect.flatMap(input => Effect.request(RpcRequest({
@@ -70,3 +67,3 @@ payload: {
         },
-        hash,
+        hash: hash$1,
         schema
@@ -76,3 +73,3 @@ }), resolver)), Effect.flatMap(parseOutput), Effect.catchAll(e => Effect.flatMap(parseError(e), Effect.fail))));
   }
-  const hash = requestHash(method, undefined, spanPrefix);
+  const hash$1 = requestHash(method, 0, spanPrefix);
   return Effect.useSpan(`${spanPrefix}.${method}`, span => pipe(Effect.request(RpcRequest({
@@ -86,3 +83,3 @@ payload: {
     },
-    hash,
+    hash: hash$1,
     schema
@@ -92,2 +89,2 @@ }), resolver), Effect.flatMap(parseOutput), Effect.catchAll(e => Effect.flatMap(parseError(e), Effect.fail))));
 
-export { make, makeWithResolver };
+export { make };

internal/codec.esm.js

@@ -9,3 +9,5 @@ import * as Schema from '@effect/schema/Schema';
   const decode = Schema.parseEither(schema);
-  return input => Either.mapLeft(decode(input), error => RpcDecodeFailure({
+  return input => Either.mapLeft(decode(input, {
+    errors: "all"
+  }), error => RpcDecodeFailure({
     errors: error.errors
@@ -18,3 +20,5 @@ }));
   const decode = Schema.parse(schema);
-  return input => Effect.mapError(decode(input), error => RpcDecodeFailure({
+  return input => Effect.mapError(decode(input, {
+    errors: "all"
+  }), error => RpcDecodeFailure({
     errors: error.errors
@@ -27,3 +31,5 @@ }));
   const encode = Schema.encode(schema);
-  return (input, options) => Effect.mapError(encode(input, options), error => RpcEncodeFailure({
+  return input => Effect.mapError(encode(input, {
+    errors: "all"
+  }), error => RpcEncodeFailure({
     errors: error.errors
@@ -36,3 +42,5 @@ }));
   const encode = Schema.encodeEither(schema);
-  return (input, options) => Either.mapLeft(encode(input, options), error => RpcEncodeFailure({
+  return input => Either.mapLeft(encode(input, {
+    errors: "all"
+  }), error => RpcEncodeFailure({
     errors: error.errors
@@ -39,0 +47,0 @@ }));

internal/resolver.esm.js

@@ -25,3 +25,3 @@ import * as Schema from '@effect/schema/Schema';
 /** @internal */
-const requestHash = (method, input, spanPrefix) => pipe(Hash.string(method), Hash.combine(Hash.string(spanPrefix)), Hash.combine(Hash.hash(input)), Hash.optimize);
+const requestHash = (method, inputHash, spanPrefix) => pipe(Hash.string(method), Hash.combine(Hash.string(spanPrefix)), Hash.combine(inputHash), Hash.optimize);
 
@@ -28,0 +28,0 @@ /** @internal */

internal/schema.esm.js

@@ -0,3 +1,6 @@
+import * as AST from '@effect/schema/AST';
 import * as Schema from '@effect/schema/Schema';
-import { dual, identity } from 'effect/Function';
+import { dual, pipe, identity } from 'effect/Function';
+import * as Hash from 'effect/Hash';
+import * as Option from 'effect/Option';
 import { encode, decode, encodeEither, decodeEither } from './codec.esm.js';
@@ -57,7 +60,7 @@
 /** @internal */
-const inputEncodeMap = (schemas, prefix = "") => Object.entries(schemas).reduce((acc, [method, schema]) => {
+const rawClientCodecs = (schemas, prefix = "") => Object.entries(schemas).reduce((acc, [method, schema]) => {
   if (RpcServiceId in schema) {
     return {
       ...acc,
-      ...inputEncodeMap(schema, `${prefix}${method}.`)
+      ...rawClientCodecs(schema, `${prefix}${method}.`)
     };
@@ -69,3 +72,6 @@ } else if (!("input" in schema)) {
     ...acc,
-    [`${prefix}${method}`]: encode(Schema.to(schema.input))
+    [`${prefix}${method}`]: {
+      input: encode(Schema.to(schema.input)),
+      output: encode(Schema.to(schema.output))
+    }
   };
@@ -80,2 +86,16 @@ }, {});
 
-export { RpcServiceErrorId, RpcServiceId, inputEncodeMap, methodClientCodecsEither, methodCodecs, methodSchemaTransform, methodSchemas, schemasToUnion, withServiceError };
+/** @internal */
+const HashAnnotationId = /*#__PURE__*/Symbol.for("@effect/rpc/Schema/HashAnnotation");
+
+/** @internal */
+const withHash = /*#__PURE__*/dual(2, (self, f) => Schema.annotations({
+  [HashAnnotationId]: f
+})(self));
+
+/** @internal */
+const withHashString = /*#__PURE__*/dual(2, (self, f) => withHash(self, _ => Hash.string(f(_))));
+
+/** @internal */
+const hash = (self, value) => pipe(AST.getAnnotation(HashAnnotationId)(self.ast), Option.map(f => f(value)), Option.getOrElse(() => Hash.hash(value)));
+
+export { HashAnnotationId, RpcServiceErrorId, RpcServiceId, hash, methodClientCodecsEither, methodCodecs, methodSchemaTransform, methodSchemas, rawClientCodecs, schemasToUnion, withHash, withHashString, withServiceError };

internal/server.esm.js

@@ -14,3 +14,3 @@ import * as Schema from '@effect/schema/Schema';
 import { encode, decode } from './codec.esm.js';
-import { methodCodecs, methodSchemas, inputEncodeMap } from './schema.esm.js';
+import { methodCodecs, methodSchemas, rawClientCodecs } from './schema.esm.js';
 
@@ -127,9 +127,10 @@ const schemaHandlersMap = (handlers, prefix = "") => Object.entries(handlers).reduce((acc, [method, definition]) => {
   const handlerMap = schemaHandlersMap(router.handlers);
-  const inputEncoders = inputEncodeMap(router.schema);
+  const encoders = rawClientCodecs(router.schema);
   return request => {
     const handler = handlerMap[request._tag];
+    const codecs = encoders[request._tag];
     if (Effect.isEffect(handler)) {
       return handler;
     }
-    return Effect.flatMap(inputEncoders[request._tag](request.input), handler);
+    return Effect.flatMap(Effect.flatMap(codecs.input(request.input), handler), codecs.output);
   };
@@ -136,0 +137,0 @@ };

package.json

 {
   "name": "@effect/rpc",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "",
@@ -5,0 +5,0 @@ "main": "dist/effect-rpc.cjs.js",

Resolver/dist/effect-rpc-Resolver.cjs.dev.js

@@ -5,4 +5,3 @@ 'use strict';
 
-require('effect/Context');
-var Resolver_dist_effectRpcResolver = require('../../dist/Resolver-abf5fc84.cjs.dev.js');
+var resolver = require('../../dist/resolver-de407fac.cjs.dev.js');
 require('@effect/schema/Schema');
@@ -16,3 +15,3 @@ require('effect/Effect');
 require('effect/RequestResolver');
-require('../../dist/codec-1158e8e9.cjs.dev.js');
+require('../../dist/codec-932c4bbb.cjs.dev.js');
 require('effect/Either');
@@ -23,10 +22,56 @@ require('../../Error/dist/effect-rpc-Error.cjs.dev.js');
 
+/**
+ * @since 1.0.0
+ */
 
+/**
+ * @category models
+ * @since 1.0.0
+ */
 
-exports.RpcRequest = Resolver_dist_effectRpcResolver.RpcRequest$1;
-exports.RpcResolver = Resolver_dist_effectRpcResolver.RpcResolver;
-exports.RpcResponse = Resolver_dist_effectRpcResolver.RpcResponse;
-exports.make = Resolver_dist_effectRpcResolver.make;
-exports.makeSingle = Resolver_dist_effectRpcResolver.makeSingle;
-exports.makeSingleWithSchema = Resolver_dist_effectRpcResolver.makeSingleWithSchema;
-exports.makeWithSchema = Resolver_dist_effectRpcResolver.makeWithSchema;
+/**
+ * @category models
+ * @since 1.0.0
+ */
+/**
+ * @since 1.0.0
+ */
+let RpcRequest;
+/**
+ * @category models
+ * @since 1.0.0
+ */
+/**
+ * @since 1.0.0
+ */
+let RpcResponse;
+/**
+ * @category constructors
+ * @since 1.0.0
+ */
+const make = resolver.make;
+
+/**
+ * @category constructors
+ * @since 1.0.0
+ */
+const makeWithSchema = resolver.makeWithSchema;
+
+/**
+ * @category constructors
+ * @since 1.0.0
+ */
+const makeSingle = resolver.makeSingle;
+
+/**
+ * @category constructors
+ * @since 1.0.0
+ */
+const makeSingleWithSchema = resolver.makeSingleWithSchema;
+
+exports.RpcRequest = RpcRequest;
+exports.RpcResponse = RpcResponse;
+exports.make = make;
+exports.makeSingle = makeSingle;
+exports.makeSingleWithSchema = makeSingleWithSchema;
+exports.makeWithSchema = makeWithSchema;

Resolver/dist/effect-rpc-Resolver.cjs.prod.js

@@ -5,4 +5,3 @@ 'use strict';
 
-require('effect/Context');
-var Resolver_dist_effectRpcResolver = require('../../dist/Resolver-62104cf5.cjs.prod.js');
+var resolver = require('../../dist/resolver-e8f0e538.cjs.prod.js');
 require('@effect/schema/Schema');
@@ -16,3 +15,3 @@ require('effect/Effect');
 require('effect/RequestResolver');
-require('../../dist/codec-be6f8f58.cjs.prod.js');
+require('../../dist/codec-0eacd60b.cjs.prod.js');
 require('effect/Either');
@@ -23,10 +22,56 @@ require('../../Error/dist/effect-rpc-Error.cjs.prod.js');
 
+/**
+ * @since 1.0.0
+ */
 
+/**
+ * @category models
+ * @since 1.0.0
+ */
 
-exports.RpcRequest = Resolver_dist_effectRpcResolver.RpcRequest$1;
-exports.RpcResolver = Resolver_dist_effectRpcResolver.RpcResolver;
-exports.RpcResponse = Resolver_dist_effectRpcResolver.RpcResponse;
-exports.make = Resolver_dist_effectRpcResolver.make;
-exports.makeSingle = Resolver_dist_effectRpcResolver.makeSingle;
-exports.makeSingleWithSchema = Resolver_dist_effectRpcResolver.makeSingleWithSchema;
-exports.makeWithSchema = Resolver_dist_effectRpcResolver.makeWithSchema;
+/**
+ * @category models
+ * @since 1.0.0
+ */
+/**
+ * @since 1.0.0
+ */
+let RpcRequest;
+/**
+ * @category models
+ * @since 1.0.0
+ */
+/**
+ * @since 1.0.0
+ */
+let RpcResponse;
+/**
+ * @category constructors
+ * @since 1.0.0
+ */
+const make = resolver.make;
+
+/**
+ * @category constructors
+ * @since 1.0.0
+ */
+const makeWithSchema = resolver.makeWithSchema;
+
+/**
+ * @category constructors
+ * @since 1.0.0
+ */
+const makeSingle = resolver.makeSingle;
+
+/**
+ * @category constructors
+ * @since 1.0.0
+ */
+const makeSingleWithSchema = resolver.makeSingleWithSchema;
+
+exports.RpcRequest = RpcRequest;
+exports.RpcResponse = RpcResponse;
+exports.make = make;
+exports.makeSingle = makeSingle;
+exports.makeSingleWithSchema = makeSingleWithSchema;
+exports.makeWithSchema = makeWithSchema;

Resolver/dist/effect-rpc-Resolver.esm.js

@@ -1,2 +0,1 @@
-import { Tag } from 'effect/Context';
 import { make as make$1, makeWithSchema as makeWithSchema$1, makeSingle as makeSingle$1, makeSingleWithSchema as makeSingleWithSchema$1 } from '../../internal/resolver.esm.js';
@@ -14,8 +13,2 @@
 /**
- * @category tags
- * @since 1.0.0
- */
-const RpcResolver = /*#__PURE__*/Tag( /*#__PURE__*/Symbol.for("@effect/rpc/RpcResolver"));
-
-/**
  * @category models
@@ -60,2 +53,2 @@ * @since 1.0.0
 
-export { RpcRequest, RpcResolver, RpcResponse, make, makeSingle, makeSingleWithSchema, makeWithSchema };
+export { RpcRequest, RpcResponse, make, makeSingle, makeSingleWithSchema, makeWithSchema };

Router/dist/effect-rpc-Router.cjs.dev.js

@@ -8,3 +8,3 @@ 'use strict';
 var Layer = require('effect/Layer');
-var server = require('../../dist/server-8b939413.cjs.dev.js');
+var server = require('../../dist/server-d251d2ee.cjs.dev.js');
 require('@effect/schema/Schema');
@@ -21,4 +21,6 @@ require('effect');
 require('effect/Data');
-require('../../dist/codec-1158e8e9.cjs.dev.js');
-require('../../dist/schema-8f24267c.cjs.dev.js');
+require('../../dist/codec-932c4bbb.cjs.dev.js');
+require('../../dist/schema-0d780b0f.cjs.dev.js');
+require('@effect/schema/AST');
+require('effect/Hash');
 
@@ -85,6 +87,7 @@ function _interopNamespace(e) {
  */
+
 /**
  * @since 1.0.0
  */
-let RpcHandler;
+
 /**
@@ -94,6 +97,7 @@ * @category handlers models
  */
+
 /**
  * @since 1.0.0
  */
-let RpcHandlers;
+
 /**
@@ -103,6 +107,7 @@ * @category router models
  */
+
 /**
  * @since 1.0.0
  */
-let RpcRouter;
+
 /**
@@ -132,5 +137,2 @@ * @category router constructors
 
-exports.RpcHandler = RpcHandler;
-exports.RpcHandlers = RpcHandlers;
-exports.RpcRouter = RpcRouter;
 exports.make = make;
@@ -137,0 +139,0 @@ exports.provideService = provideService;

Router/dist/effect-rpc-Router.cjs.prod.js

@@ -8,3 +8,3 @@ 'use strict';
 var Layer = require('effect/Layer');
-var server = require('../../dist/server-53da2064.cjs.prod.js');
+var server = require('../../dist/server-90827ca9.cjs.prod.js');
 require('@effect/schema/Schema');
@@ -21,4 +21,6 @@ require('effect');
 require('effect/Data');
-require('../../dist/codec-be6f8f58.cjs.prod.js');
-require('../../dist/schema-cd157c05.cjs.prod.js');
+require('../../dist/codec-0eacd60b.cjs.prod.js');
+require('../../dist/schema-ca62c904.cjs.prod.js');
+require('@effect/schema/AST');
+require('effect/Hash');
 
@@ -85,6 +87,7 @@ function _interopNamespace(e) {
  */
+
 /**
  * @since 1.0.0
  */
-let RpcHandler;
+
 /**
@@ -94,6 +97,7 @@ * @category handlers models
  */
+
 /**
  * @since 1.0.0
  */
-let RpcHandlers;
+
 /**
@@ -103,6 +107,7 @@ * @category router models
  */
+
 /**
  * @since 1.0.0
  */
-let RpcRouter;
+
 /**
@@ -132,5 +137,2 @@ * @category router constructors
 
-exports.RpcHandler = RpcHandler;
-exports.RpcHandlers = RpcHandlers;
-exports.RpcRouter = RpcRouter;
 exports.make = make;
@@ -137,0 +139,0 @@ exports.provideService = provideService;

Router/dist/effect-rpc-Router.esm.js

@@ -11,6 +11,7 @@ import { make as make$1, provideService as provideService$1, provideServiceEffect as provideServiceEffect$1, provideServiceSync as provideServiceSync$1 } from '../../internal/router.esm.js';
  */
+
 /**
  * @since 1.0.0
  */
-let RpcHandler;
+
 /**
@@ -20,6 +21,7 @@ * @category handlers models
  */
+
 /**
  * @since 1.0.0
  */
-let RpcHandlers;
+
 /**
@@ -29,6 +31,7 @@ * @category router models
  */
+
 /**
  * @since 1.0.0
  */
-let RpcRouter;
+
 /**
@@ -58,2 +61,2 @@ * @category router constructors
 
-export { RpcHandler, RpcHandlers, RpcRouter, make, provideService, provideServiceEffect, provideServiceSync };
+export { make, provideService, provideServiceEffect, provideServiceSync };

Schema/dist/effect-rpc-Schema.cjs.dev.js

@@ -6,5 +6,8 @@ 'use strict';
 var Schema = require('@effect/schema/Schema');
-var schema = require('../../dist/schema-8f24267c.cjs.dev.js');
+var schema = require('../../dist/schema-0d780b0f.cjs.dev.js');
+require('@effect/schema/AST');
 require('effect/Function');
-require('../../dist/codec-1158e8e9.cjs.dev.js');
+require('effect/Hash');
+require('effect/Option');
+require('../../dist/codec-932c4bbb.cjs.dev.js');
 require('effect/Effect');
@@ -105,2 +108,32 @@ require('effect/Either');
 
+/**
+ * @category type ids
+ * @since 1.0.0
+ */
+const HashAnnotationId = schema.HashAnnotationId;
+
+/**
+ * @category type ids
+ * @since 1.0.0
+ */
+
+/**
+ * @category annotations
+ * @since 1.0.0
+ */
+const withHash = schema.withHash;
+
+/**
+ * @category annotations
+ * @since 1.0.0
+ */
+const withHashString = schema.withHashString;
+
+/**
+ * @category annotations
+ * @since 1.0.0
+ */
+const hash = schema.hash;
+
+exports.HashAnnotationId = HashAnnotationId;
 exports.RpcRequestSchema = RpcRequestSchema;
@@ -111,5 +144,8 @@ exports.RpcSchema = RpcSchema;
 exports.RpcServiceId = RpcServiceId;
+exports.hash = hash;
 exports.make = make;
 exports.makeRequestUnion = makeRequestUnion;
 exports.makeWith = makeWith;
+exports.withHash = withHash;
+exports.withHashString = withHashString;
 exports.withServiceError = withServiceError;

Schema/dist/effect-rpc-Schema.cjs.prod.js

@@ -6,5 +6,8 @@ 'use strict';
 var Schema = require('@effect/schema/Schema');
-var schema = require('../../dist/schema-cd157c05.cjs.prod.js');
+var schema = require('../../dist/schema-ca62c904.cjs.prod.js');
+require('@effect/schema/AST');
 require('effect/Function');
-require('../../dist/codec-be6f8f58.cjs.prod.js');
+require('effect/Hash');
+require('effect/Option');
+require('../../dist/codec-0eacd60b.cjs.prod.js');
 require('effect/Effect');
@@ -105,2 +108,32 @@ require('effect/Either');
 
+/**
+ * @category type ids
+ * @since 1.0.0
+ */
+const HashAnnotationId = schema.HashAnnotationId;
+
+/**
+ * @category type ids
+ * @since 1.0.0
+ */
+
+/**
+ * @category annotations
+ * @since 1.0.0
+ */
+const withHash = schema.withHash;
+
+/**
+ * @category annotations
+ * @since 1.0.0
+ */
+const withHashString = schema.withHashString;
+
+/**
+ * @category annotations
+ * @since 1.0.0
+ */
+const hash = schema.hash;
+
+exports.HashAnnotationId = HashAnnotationId;
 exports.RpcRequestSchema = RpcRequestSchema;
@@ -111,5 +144,8 @@ exports.RpcSchema = RpcSchema;
 exports.RpcServiceId = RpcServiceId;
+exports.hash = hash;
 exports.make = make;
 exports.makeRequestUnion = makeRequestUnion;
 exports.makeWith = makeWith;
+exports.withHash = withHash;
+exports.withHashString = withHashString;
 exports.withServiceError = withServiceError;

Schema/dist/effect-rpc-Schema.esm.js

 import * as Schema from '@effect/schema/Schema';
-import { RpcServiceId as RpcServiceId$1, RpcServiceErrorId as RpcServiceErrorId$1, withServiceError as withServiceError$1 } from '../../internal/schema.esm.js';
+import { RpcServiceId as RpcServiceId$1, RpcServiceErrorId as RpcServiceErrorId$1, withServiceError as withServiceError$1, HashAnnotationId as HashAnnotationId$1, withHash as withHash$1, withHashString as withHashString$1, hash as hash$1 } from '../../internal/schema.esm.js';
 
@@ -73,2 +73,31 @@ /**
 
-export { RpcRequestSchema, RpcSchema, RpcService, RpcServiceErrorId, RpcServiceId, make, makeRequestUnion, makeWith, withServiceError };
+/**
+ * @category type ids
+ * @since 1.0.0
+ */
+const HashAnnotationId = HashAnnotationId$1;
+
+/**
+ * @category type ids
+ * @since 1.0.0
+ */
+
+/**
+ * @category annotations
+ * @since 1.0.0
+ */
+const withHash = withHash$1;
+
+/**
+ * @category annotations
+ * @since 1.0.0
+ */
+const withHashString = withHashString$1;
+
+/**
+ * @category annotations
+ * @since 1.0.0
+ */
+const hash = hash$1;
+
+export { HashAnnotationId, RpcRequestSchema, RpcSchema, RpcService, RpcServiceErrorId, RpcServiceId, hash, make, makeRequestUnion, makeWith, withHash, withHashString, withServiceError };

Server/dist/effect-rpc-Server.cjs.dev.js

@@ -5,3 +5,3 @@ 'use strict';
 
-var server = require('../../dist/server-8b939413.cjs.dev.js');
+var server = require('../../dist/server-d251d2ee.cjs.dev.js');
 require('@effect/schema/Schema');
@@ -21,4 +21,6 @@ require('effect');
 require('effect/Data');
-require('../../dist/codec-1158e8e9.cjs.dev.js');
-require('../../dist/schema-8f24267c.cjs.dev.js');
+require('../../dist/codec-932c4bbb.cjs.dev.js');
+require('../../dist/schema-0d780b0f.cjs.dev.js');
+require('@effect/schema/AST');
+require('effect/Hash');
 
@@ -25,0 +27,0 @@ /**

Server/dist/effect-rpc-Server.cjs.prod.js

@@ -5,3 +5,3 @@ 'use strict';
 
-var server = require('../../dist/server-53da2064.cjs.prod.js');
+var server = require('../../dist/server-90827ca9.cjs.prod.js');
 require('@effect/schema/Schema');
@@ -21,4 +21,6 @@ require('effect');
 require('effect/Data');
-require('../../dist/codec-be6f8f58.cjs.prod.js');
-require('../../dist/schema-cd157c05.cjs.prod.js');
+require('../../dist/codec-0eacd60b.cjs.prod.js');
+require('../../dist/schema-ca62c904.cjs.prod.js');
+require('@effect/schema/AST');
+require('effect/Hash');
 
@@ -25,0 +27,0 @@ /**

src/Client.ts

@@ -10,3 +10,2 @@ /**
 import type { UndecodedRpcResponse } from "./Server"
-
 /**
@@ -27,4 +26,4 @@ * Represents an RPC method signature.
   : C extends RpcSchema.NoError<infer _II, infer I, infer _IO, infer O> ? (input: I) => Effect<R, RpcError | SE, O>
-  : C extends RpcSchema.NoOutput<infer _IE, infer E, infer _II, infer I> ?
-    (input: I) => Effect<R, RpcError | SE | E, void>
+  : C extends RpcSchema.NoOutput<infer _IE, infer E, infer _II, infer I>
+    ? (input: I) => Effect<R, RpcError | SE | E, void>
   : C extends RpcSchema.NoErrorNoOutput<infer _II, infer I> ? (input: I) => Effect<R, RpcError | SE, void>
@@ -35,3 +34,3 @@ : C extends RpcSchema.NoInput<infer _IE, infer E, infer _IO, infer O> ? Effect<R, RpcError | SE | E, O>
 
-type RpcClientRpcs<S extends RpcService.DefinitionWithId, R, SE = never> = {
+type RpcClientRpcs<S extends RpcService.DefinitionWithId, R, SE = never, Depth extends ReadonlyArray<number> = []> = {
   readonly [
@@ -42,3 +41,4 @@ K in Exclude<
     >
-  ]: S[K] extends RpcService.DefinitionWithId ? RpcClientRpcs<S[K], R, SE | RpcService.Errors<S>>
+  ]: S[K] extends RpcService.DefinitionWithId ?
+    Depth["length"] extends 3 ? never : RpcClientRpcs<S[K], R, SE | RpcService.Errors<S>, [0, ...Depth]>
     : S[K] extends RpcSchema.Any ? Rpc<S[K], R, SE | RpcService.Errors<S>>
@@ -60,4 +60,4 @@ : never
   & {
-    _schemas: S
-    _unsafeDecode: <
+    readonly _schemas: S
+    readonly _unsafeDecode: <
       M extends RpcService.Methods<S>,
@@ -70,2 +70,3 @@ O extends UndecodedRpcResponse<M, any>
   }
+
 /**
@@ -80,3 +81,3 @@ * @category models
 /**
- * Creates an RPC client
+ * Creates an RPC client with the specified resolver
  *
@@ -87,26 +88,4 @@ * @category constructors
 export const make: {
-  <S extends RpcService.DefinitionWithSetup>(
-    schemas: S,
-    init: RpcSchema.Input<S["__setup"]>,
-    options?: RpcClientOptions
-  ): Effect<
-    never,
-    RpcError | RpcSchema.Error<S["__setup"]>,
-    RpcClient<S, RpcResolver<never>>
-  >
-  <S extends RpcService.DefinitionWithoutSetup>(
-    schemas: S,
-    options?: RpcClientOptions
-  ): RpcClient<S, RpcResolver<never>>
-} = internal.make
-
-/**
- * Creates an RPC client with the specified resolver
- *
- * @category constructors
- * @since 1.0.0
- */
-export const makeWithResolver: {
   <
-    S extends RpcService.DefinitionWithSetup,
+    const S extends RpcService.DefinitionWithSetup,
     Resolver extends
@@ -130,3 +109,3 @@ | RpcResolver<never>
   <
-    S extends RpcService.DefinitionWithoutSetup,
+    const S extends RpcService.DefinitionWithoutSetup,
     Resolver extends
@@ -144,2 +123,2 @@ | RpcResolver<never>
   >
-} = internal.makeWithResolver
+} = internal.make

src/internal/client.ts

@@ -7,5 +7,5 @@ import type * as Schema from "@effect/schema/Schema"
 import { RpcError } from "../Error"
-import { RpcResolver } from "../Resolver"
+import type { RpcResolver } from "../Resolver"
 import type { RpcSchema, RpcService } from "../Schema"
-import { RpcServiceErrorId, RpcServiceId } from "../Schema"
+import { hash as schemaHash, RpcServiceErrorId, RpcServiceId } from "../Schema"
 import * as codec from "./codec"
@@ -15,3 +15,3 @@ import * as resolverInternal from "./resolver"
 
-const unsafeDecode = <S extends RpcService.DefinitionWithId>(schemas: S) => {
+const unsafeDecode = <const S extends RpcService.DefinitionWithId>(schemas: S) => {
   const map = schemaInternal.methodClientCodecsEither(schemas)
@@ -30,3 +30,3 @@
 
-const makeRecursive = <S extends RpcService.DefinitionWithId>(
+const makeRecursive = <const S extends RpcService.DefinitionWithId>(
   schemas: S,
@@ -67,5 +67,5 @@ transport: RpcResolver<never>,
 /** @internal */
-export const makeWithResolver: {
+export const make: {
   <
-    S extends RpcService.DefinitionWithSetup,
+    const S extends RpcService.DefinitionWithSetup,
     Resolver extends
@@ -89,3 +89,3 @@ | RpcResolver<never>
   <
-    S extends RpcService.DefinitionWithoutSetup,
+    const S extends RpcService.DefinitionWithoutSetup,
     Resolver extends
@@ -124,24 +124,3 @@ | RpcResolver<never>
 
-/** @internal */
-export const make: {
-  <S extends RpcService.DefinitionWithSetup>(
-    schemas: S,
-    init: RpcService.SetupInput<S>,
-    options?: client.RpcClientOptions
-  ): Effect.Effect<
-    never,
-    RpcService.SetupError<S> | RpcError,
-    client.RpcClient<S, RpcResolver<never>>
-  >
-  <S extends RpcService.DefinitionWithoutSetup>(
-    schemas: S,
-    options?: client.RpcClientOptions
-  ): client.RpcClient<S, RpcResolver<never>>
-} = (
-  schemas: any,
-  initOrOptions?: unknown,
-  options?: client.RpcClientOptions
-) => makeWithResolver(schemas, RpcResolver, initOrOptions, options) as any
-
-const makeRpc = <S extends RpcSchema.Any>(
+const makeRpc = <const S extends RpcSchema.Any>(
   resolver: RpcResolver<never>,
@@ -165,3 +144,4 @@ serviceErrors: ReadonlyArray<Schema.Schema<any>>,
     return ((input: any) => {
-      const hash = resolverInternal.requestHash(method, input, spanPrefix)
+      const inputHash = schemaHash(schema.input, input)
+      const hash = resolverInternal.requestHash(method, inputHash, spanPrefix)
       return Effect.useSpan(`${spanPrefix}.${method}`, (span) =>
@@ -193,3 +173,3 @@ pipe(
 
-  const hash = resolverInternal.requestHash(method, undefined, spanPrefix)
+  const hash = resolverInternal.requestHash(method, 0, spanPrefix)
 
@@ -196,0 +176,0 @@ return Effect.useSpan(`${spanPrefix}.${method}`, (span) =>

src/internal/codec.ts

@@ -11,3 +11,3 @@ import type { ParseOptions } from "@effect/schema/AST"
   return (input: unknown): Either.Either<RpcDecodeFailure, A> =>
-    Either.mapLeft(decode(input), (error) => RpcDecodeFailure({ errors: error.errors }))
+    Either.mapLeft(decode(input, { errors: "all" }), (error) => RpcDecodeFailure({ errors: error.errors }))
 }
@@ -19,3 +19,3 @@
   return (input: unknown): Effect.Effect<never, RpcDecodeFailure, A> =>
-    Effect.mapError(decode(input), (error) => RpcDecodeFailure({ errors: error.errors }))
+    Effect.mapError(decode(input, { errors: "all" }), (error) => RpcDecodeFailure({ errors: error.errors }))
 }
@@ -30,4 +30,4 @@
   const encode = Schema.encode(schema)
-  return (input: A, options?: ParseOptions | undefined) =>
-    Effect.mapError(encode(input, options), (error) => RpcEncodeFailure({ errors: error.errors }))
+  return (input: A) =>
+    Effect.mapError(encode(input, { errors: "all" }), (error) => RpcEncodeFailure({ errors: error.errors }))
 }
@@ -42,4 +42,4 @@
   const encode = Schema.encodeEither(schema)
-  return (input: A, options?: ParseOptions | undefined) =>
-    Either.mapLeft(encode(input, options), (error) => RpcEncodeFailure({ errors: error.errors }))
+  return (input: A) =>
+    Either.mapLeft(encode(input, { errors: "all" }), (error) => RpcEncodeFailure({ errors: error.errors }))
 }

src/internal/resolver.ts

@@ -29,3 +29,3 @@ import * as Schema from "@effect/schema/Schema"
   method: string,
-  input: unknown,
+  inputHash: number,
   spanPrefix: string
@@ -36,3 +36,3 @@ ): number =>
     Hash.combine(Hash.string(spanPrefix)),
-    Hash.combine(Hash.hash(input)),
+    Hash.combine(inputHash),
     Hash.optimize
@@ -39,0 +39,0 @@ )

src/internal/router.ts

@@ -12,4 +12,4 @@ import type { Tag } from "effect/Context"
 export const make = <
-  S extends RpcService.DefinitionWithId,
-  H extends RpcHandlers.FromService<S>
+  const S extends RpcService.DefinitionWithId,
+  const H extends RpcHandlers.FromService<S>
 >(
@@ -52,3 +52,3 @@ schema: S,
   <
-    Router extends RpcRouter.Base,
+    const Router extends RpcRouter.Base,
     T extends Tag<any, any>,
@@ -62,3 +62,3 @@ R,
   <
-    Router extends RpcRouter.Base,
+    const Router extends RpcRouter.Base,
     T extends Tag<any, any>,
@@ -97,6 +97,6 @@ R,
     service: LazyArg<Tag.Service<T>>
-  ): <Router extends RpcRouter.Base>(
+  ): <const Router extends RpcRouter.Base>(
     self: Router
   ) => RpcRouter.Provide<Router, Tag.Identifier<T>, never, never>
-  <Router extends RpcRouter.Base, T extends Tag<any, any>>(
+  <const Router extends RpcRouter.Base, T extends Tag<any, any>>(
     self: Router,
@@ -120,6 +120,6 @@ tag: T,
     service: Tag.Service<T>
-  ): <Router extends RpcRouter.Base>(
+  ): <const Router extends RpcRouter.Base>(
     self: Router
   ) => RpcRouter.Provide<Router, Tag.Identifier<T>, never, never>
-  <Router extends RpcRouter.Base, T extends Tag<any, any>>(
+  <const Router extends RpcRouter.Base, T extends Tag<any, any>>(
     self: Router,
@@ -126,0 +126,0 @@ tag: T,

src/internal/schema.ts

@@ -0,4 +1,7 @@
+import * as AST from "@effect/schema/AST"
 import * as Schema from "@effect/schema/Schema"
 import type * as Effect from "effect/Effect"
-import { dual, identity } from "effect/Function"
+import { dual, identity, pipe } from "effect/Function"
+import * as Hash from "effect/Hash"
+import * as Option from "effect/Option"
 import type { RpcEncodeFailure } from "../Error"
@@ -105,3 +108,3 @@ import type * as schema from "../Schema"
 /** @internal */
-export const inputEncodeMap = <S extends schema.RpcService.DefinitionWithId>(
+export const rawClientCodecs = <S extends schema.RpcService.DefinitionWithId>(
   schemas: S,
@@ -111,3 +114,6 @@ prefix = ""
   string,
-  (input: unknown) => Effect.Effect<never, RpcEncodeFailure, unknown>
+  {
+    readonly input: (input: unknown) => Effect.Effect<never, RpcEncodeFailure, unknown>
+    readonly output: (output: unknown) => Effect.Effect<never, RpcEncodeFailure, unknown>
+  }
 > =>
@@ -118,3 +124,3 @@ Object.entries(schemas).reduce((acc, [method, schema]) => {
         ...acc,
-        ...inputEncodeMap(schema, `${prefix}${method}.`)
+        ...rawClientCodecs(schema, `${prefix}${method}.`)
       }
@@ -127,3 +133,6 @@ } else if (!("input" in schema)) {
       ...acc,
-      [`${prefix}${method}`]: Codec.encode(Schema.to(schema.input))
+      [`${prefix}${method}`]: {
+        input: Codec.encode(Schema.to(schema.input)),
+        output: Codec.encode(Schema.to(schema.output))
+      }
     }
@@ -168,1 +177,41 @@ }, {})
 )
+
+/** @internal */
+export const HashAnnotationId: schema.HashAnnotationId = Symbol.for(
+  "@effect/rpc/Schema/HashAnnotation"
+) as schema.HashAnnotationId
+
+/** @internal */
+export const withHash: {
+  <A>(f: (a: A) => number): <I>(self: Schema.Schema<I, A>) => Schema.Schema<I, A>
+  <I, A>(
+    self: Schema.Schema<I, A>,
+    f: (a: A) => number
+  ): Schema.Schema<I, A>
+} = dual(
+  2,
+  <I, A>(self: Schema.Schema<I, A>, f: (a: A) => number) => Schema.annotations({ [HashAnnotationId]: f })(self)
+)
+
+/** @internal */
+export const withHashString: {
+  <A>(f: (a: A) => string): <I>(self: Schema.Schema<I, A>) => Schema.Schema<I, A>
+  <I, A>(
+    self: Schema.Schema<I, A>,
+    f: (a: A) => string
+  ): Schema.Schema<I, A>
+} = dual(
+  2,
+  <I, A>(self: Schema.Schema<I, A>, f: (a: A) => string) => withHash(self, (_) => Hash.string(f(_)))
+)
+
+/** @internal */
+export const hash = <I, A>(
+  self: Schema.Schema<I, A>,
+  value: A
+): number =>
+  pipe(
+    AST.getAnnotation<(a: A) => number>(HashAnnotationId)(self.ast),
+    Option.map((f) => f(value)),
+    Option.getOrElse(() => Hash.hash(value))
+  )

src/internal/server.ts

@@ -20,3 +20,3 @@ import * as Schema from "@effect/schema/Schema"
 import * as codec from "./codec"
-import { inputEncodeMap, methodCodecs, methodSchemas } from "./schema"
+import { methodCodecs, methodSchemas, rawClientCodecs } from "./schema"
 
@@ -49,3 +49,3 @@ const schemaHandlersMap = <H extends RpcHandlers>(
         RpcHandlers.Services<R["handlers"]>,
-        RpcRouter.SetupServices<R> | Tracer.Span
+        RpcRouter.SetupServices<R>
       >,
@@ -61,3 +61,3 @@ never,
   ) => Effect.Effect<
-    Exclude<RpcHandlers.Services<R["handlers"]>, Tracer.Span> | Scope,
+    RpcHandlers.Services<R["handlers"]> | Scope,
     never,
@@ -200,3 +200,3 @@ RpcResponse
         RpcHandlers.Services<R["handlers"]>,
-        RpcRouter.SetupServices<R> | Tracer.Span
+        RpcRouter.SetupServices<R>
       >,
@@ -212,3 +212,3 @@ never,
   ) => Effect.Effect<
-    Exclude<RpcHandlers.Services<R["handlers"]>, Tracer.Span>,
+    RpcHandlers.Services<R["handlers"]>,
     never,
@@ -261,3 +261,3 @@ readonly [RpcResponse, Option.Option<RpcSchema.Base>]
 export const handler: {
-  <R extends RpcRouter.WithSetup>(
+  <const R extends RpcRouter.WithSetup>(
     router: R
@@ -272,3 +272,3 @@ ): Effect.Effect<
         RpcHandlers.Services<R["handlers"]>,
-        RpcRouter.SetupServices<R> | Tracer.Span
+        RpcRouter.SetupServices<R>
       >,
@@ -284,3 +284,3 @@ never,
   ) => Effect.Effect<
-    Exclude<RpcHandlers.Services<R["handlers"]>, Tracer.Span>,
+    RpcHandlers.Services<R["handlers"]>,
     never,
@@ -305,12 +305,13 @@ ReadonlyArray<RpcResponse>
 /** @internal */
-export const handlerRaw = <R extends RpcRouter.Base>(router: R) => {
+export const handlerRaw = <const R extends RpcRouter.Base>(router: R) => {
   const handlerMap = schemaHandlersMap(router.handlers)
-  const inputEncoders = inputEncodeMap(router.schema)
+  const encoders = rawClientCodecs(router.schema)
 
   return <Req extends RpcRequestSchema.To<R["schema"]>>(
     request: Req
-  ): Req extends { _tag: infer M } ? RpcHandler.FromMethod<R["handlers"], M, Tracer.Span, RpcEncodeFailure>
+  ): Req extends { _tag: infer M } ? RpcHandler.FromMethod<R["handlers"], M, never, RpcEncodeFailure>
     : never =>
   {
     const handler = handlerMap[(request as RpcRequest.Payload)._tag]
+    const codecs = encoders[(request as RpcRequest.Payload)._tag]
     if (Effect.isEffect(handler)) {
@@ -321,6 +322,7 @@ return handler as any
     return Effect.flatMap(
-      inputEncoders[(request as RpcRequest.Payload)._tag](
-        (request as RpcRequest.Payload).input
+      Effect.flatMap(
+        codecs.input((request as RpcRequest.Payload).input),
+        handler as any
       ),
-      handler as any
+      codecs.output
     ) as any
@@ -332,4 +334,4 @@ }
 export const makeUndecodedClient = <
-  S extends RpcService.DefinitionWithId,
-  H extends RpcHandlers.FromService<S>
+  const S extends RpcService.DefinitionWithId,
+  const H extends RpcHandlers.FromService<S>
 >(
@@ -336,0 +338,0 @@ schemas: S,

src/Resolver.ts

 /**
  * @since 1.0.0
  */
-import { Tag } from "effect/Context"
 import type * as Effect from "effect/Effect"
@@ -19,10 +18,2 @@ import type * as Request from "effect/Request"
 /**
- * @category tags
- * @since 1.0.0
- */
-export const RpcResolver = Tag<RpcResolver<never>>(
-  Symbol.for("@effect/rpc/RpcResolver")
-)
-
-/**
  * @category models
@@ -29,0 +20,0 @@ * @since 1.0.0

src/Router.ts

@@ -24,3 +24,3 @@ /**
  */
-export namespace RpcHandler {
+export declare namespace RpcHandler {
   /**
@@ -96,3 +96,3 @@ * @category handler models
  */
-export interface RpcHandlers extends Record<string, RpcHandler.Any | { handlers: RpcHandlers }> {}
+export interface RpcHandlers extends Record<string, RpcHandler.Any | { readonly handlers: RpcHandlers }> {}
 
@@ -102,3 +102,3 @@ /**
  */
-export namespace RpcHandlers {
+export declare namespace RpcHandlers {
   /**
@@ -108,3 +108,3 @@ * @category handlers utils
    */
-  export type FromService<S extends RpcService.DefinitionWithId> = {
+  export type FromService<S extends RpcService.DefinitionWithId, Depth extends ReadonlyArray<number> = []> = {
     readonly [
@@ -115,5 +115,6 @@ K in Extract<
       >
-    ]: S[K] extends RpcService.DefinitionWithId ? { handlers: FromService<S[K]> }
-      : K extends "__setup" ? RpcHandler.FromSetupSchema<S[K]> :
-      S[K] extends RpcSchema.Any ? RpcHandler.FromSchema<S[K]>
+    ]: S[K] extends RpcService.DefinitionWithId ?
+      Depth["length"] extends 3 ? never : { readonly handlers: FromService<S[K], [0, ...Depth]> }
+      : K extends "__setup" ? RpcHandler.FromSetupSchema<S[K]>
+      : S[K] extends RpcSchema.Any ? RpcHandler.FromSchema<S[K]>
       : never
@@ -126,7 +127,10 @@ }
    */
-  export type Services<H extends RpcHandlers> = {
-    [M in keyof H]: H[M] extends { readonly handlers: RpcHandlers } ? Services<H[M]["handlers"]>
+  export type Services<H extends RpcHandlers, Depth extends ReadonlyArray<number> = []> = keyof H extends infer M
+    ? M extends keyof H ?
+      H[M] extends { readonly handlers: RpcHandlers } ?
+        Depth["length"] extends 3 ? never : Services<H[M]["handlers"], [0, ...Depth]>
       : H[M] extends RpcHandler<infer R, infer _E, infer _I, infer _O> ? R
       : never
-  }[keyof H]
+    : never
+    : never
 
@@ -137,7 +141,10 @@ /**
    */
-  export type Error<H extends RpcHandlers> = {
-    [M in keyof H]: H[M] extends { readonly handlers: RpcHandlers } ? Services<H[M]["handlers"]>
+  export type Errors<H extends RpcHandlers, Depth extends ReadonlyArray<number> = []> = keyof H extends infer M
+    ? M extends keyof H ?
+      H[M] extends { readonly handlers: RpcHandlers } ?
+        Depth["length"] extends 3 ? never : Errors<H[M]["handlers"], [0, ...Depth]>
       : H[M] extends RpcHandler<infer _R, infer E, infer _I, infer _O> ? E
       : never
-  }[keyof H]
+    : never
+    : never
 
@@ -148,5 +155,12 @@ /**
    */
-  export type Map<H extends RpcHandlers, XR, E2, P extends string = ""> = {
-    readonly [K in keyof H]: K extends string
-      ? H[K] extends { handlers: RpcHandlers } ? Map<H[K]["handlers"], XR, E2, `${P}${K}.`>
+  export type Map<
+    H extends RpcHandlers,
+    XR,
+    E2,
+    P extends string = "",
+    Depth extends ReadonlyArray<number> = []
+  > = Extract<keyof H, string> extends infer K
+    ? K extends Extract<keyof H, string>
+      ? H[K] extends { readonly handlers: RpcHandlers } ?
+        Depth["length"] extends 3 ? never : Map<H[K]["handlers"], XR, E2, `${P}${K}.`, [0, ...Depth]>
       : H[K] extends RpcHandler.IO<infer R, infer E, infer _I, infer O>
@@ -156,4 +170,4 @@ ? [`${P}${K}`, Effect<Exclude<R, XR>, E | E2, O>]
       : never
-      : never
-  }[keyof H]
+    : never
+    : never
 }
@@ -177,3 +191,3 @@
  */
-export namespace RpcRouter {
+export declare namespace RpcRouter {
   /**
@@ -186,3 +200,3 @@ * @category router models
     readonly schema: RpcService.DefinitionWithId
-    readonly undecoded: RpcUndecodedClient<RpcHandlers>
+    readonly undecoded: any
     readonly options: Options
@@ -223,7 +237,7 @@ }
    */
-  export type Provide<Router extends Base, XR, PR, PE> = RpcRouter<
+  export type Provide<Router extends Base, XR, PR, PE, Depth extends ReadonlyArray<number> = []> = RpcRouter<
     Router["schema"],
     {
       readonly [M in keyof Router["handlers"]]: Router["handlers"][M] extends Base
-        ? Provide<Router["handlers"][M], XR, PR, PE>
+        ? Depth["length"] extends 3 ? never : Provide<Router["handlers"][M], XR, PR, PE, [0, ...Depth]>
         : Router["handlers"][M] extends RpcHandler.IO<
@@ -268,2 +282,14 @@ infer R,
     : never
+
+  /**
+   * @category router utils
+   * @since 1.0.0
+   */
+  export type Services<R extends Base> = RpcHandlers.Services<R["handlers"]>
+
+  /**
+   * @category router utils
+   * @since 1.0.0
+   */
+  export type Errors<R extends Base> = RpcHandlers.Errors<R["handlers"]>
 }
@@ -276,4 +302,4 @@
 export const make: <
-  S extends RpcService.DefinitionWithId,
-  H extends RpcHandlers.FromService<S>
+  const S extends RpcService.DefinitionWithId,
+  const H extends RpcHandlers.FromService<S>
 >(
@@ -293,6 +319,6 @@ schema: S,
     service: Tag.Service<T>
-  ): <Router extends RpcRouter.Base>(
+  ): <const Router extends RpcRouter.Base>(
     self: Router
   ) => RpcRouter.Provide<Router, Tag.Identifier<T>, never, never>
-  <Router extends RpcRouter.Base, T extends Tag<any, any>>(
+  <const Router extends RpcRouter.Base, T extends Tag<any, any>>(
     self: Router,
@@ -310,3 +336,3 @@ tag: T,
   <
-    Router extends RpcRouter.Base,
+    const Router extends RpcRouter.Base,
     T extends Tag<any, any>,
@@ -320,3 +346,3 @@ R,
   <
-    Router extends RpcRouter.Base,
+    const Router extends RpcRouter.Base,
     T extends Tag<any, any>,
@@ -340,3 +366,3 @@ R,
     service: LazyArg<Tag.Service<T>>
-  ): <Router extends RpcRouter.Base>(
+  ): <const Router extends RpcRouter.Base>(
     self: Router
@@ -343,0 +369,0 @@ ) => RpcRouter.Provide<Router, Tag.Identifier<T>, never, never>

src/Schema.ts

@@ -18,5 +18,5 @@ /**
   export interface IO<IE, E, II, I, IO, O> {
-    input: Schema.Schema<II, I>
-    output: Schema.Schema<IO, O>
-    error: Schema.Schema<IE, E>
+    readonly input: Schema.Schema<II, I>
+    readonly output: Schema.Schema<IO, O>
+    readonly error: Schema.Schema<IE, E>
   }
@@ -29,4 +29,4 @@
   export interface NoError<II, I, IO, O> {
-    input: Schema.Schema<II, I>
-    output: Schema.Schema<IO, O>
+    readonly input: Schema.Schema<II, I>
+    readonly output: Schema.Schema<IO, O>
   }
@@ -39,4 +39,4 @@
   export interface NoInput<IE, E, IO, O> {
-    output: Schema.Schema<IO, O>
-    error: Schema.Schema<IE, E>
+    readonly output: Schema.Schema<IO, O>
+    readonly error: Schema.Schema<IE, E>
   }
@@ -49,3 +49,3 @@
   export interface NoInputNoError<IO, O> {
-    output: Schema.Schema<IO, O>
+    readonly output: Schema.Schema<IO, O>
   }
@@ -58,4 +58,4 @@
   export interface NoOutput<IE, E, II, I> {
-    input: Schema.Schema<II, I>
-    error: Schema.Schema<IE, E>
+    readonly input: Schema.Schema<II, I>
+    readonly error: Schema.Schema<IE, E>
   }
@@ -68,3 +68,3 @@
   export interface NoErrorNoOutput<II, I> {
-    input: Schema.Schema<II, I>
+    readonly input: Schema.Schema<II, I>
   }
@@ -151,5 +151,6 @@
   export interface Definition extends Record<string, RpcSchema.Any | WithId<any, any, any>> {
-    __setup?:
-      | RpcSchema.NoErrorNoOutput<any, any>
-      | RpcSchema.NoOutput<any, any, any, any>
+    readonly __setup?: {
+      readonly input: Schema.Schema<any>
+      readonly error?: Schema.Schema<any>
+    }
   }
@@ -229,7 +230,12 @@
    */
-  export type Methods<S extends DefinitionWithId, P extends string = ``> = {
-    [M in keyof S]: M extends string ? S[M] extends DefinitionWithId ? Methods<S[M], `${P}${M}.`>
+  export type Methods<
+    S extends DefinitionWithId,
+    P extends string = ``,
+    Depth extends ReadonlyArray<number> = []
+  > = Extract<keyof S, string> extends infer M
+    ? M extends Extract<keyof S, string> ?
+      S[M] extends DefinitionWithId ? Depth["length"] extends 3 ? never : Methods<S[M], `${P}${M}.`, [0, ...Depth]>
       : `${P}${M}`
-      : never
-  }[keyof S]
+    : never
+    : never
 
@@ -243,6 +249,7 @@ /**
     V,
-    S extends RpcService.Definition
+    S extends RpcService.Definition,
+    Depth extends ReadonlyArray<number> = []
   > = {
     readonly [K in keyof S]: K extends "__setup" ? S[K]
-      : S[K] extends DefinitionWithId ? Validate<VL, V, S[K]>
+      : S[K] extends DefinitionWithId ? Depth["length"] extends 3 ? never : Validate<VL, V, S[K], [0, ...Depth]>
       : S[K] extends RpcSchema.IO<
@@ -287,3 +294,3 @@ infer IE,
 export const makeWith = <VL extends string, V>() =>
-<S extends RpcService.Definition>(
+<const S extends RpcService.Definition>(
   schema: S
@@ -338,4 +345,10 @@ ): RpcService.Simplify<RpcService.Validate<VL, V, S>, never, never> => ({
    */
-  export type From<S extends RpcService.Definition, P extends string = ""> = {
-    readonly [K in keyof S]: K extends string ? S[K] extends RpcService.DefinitionWithId ? To<S[K], `${P}${K}.`>
+  export type From<
+    S extends RpcService.Definition,
+    P extends string = "",
+    Depth extends ReadonlyArray<number> = []
+  > = Extract<keyof S, string> extends infer K
+    ? K extends Extract<keyof S, string> ?
+      S[K] extends RpcService.DefinitionWithId ?
+        Depth["length"] extends 3 ? never : From<S[K], `${P}${K}.`, [0, ...Depth]>
       : S[K] extends RpcSchema.IO<
@@ -363,4 +376,4 @@ infer _IE,
       : never
-      : never
-  }[keyof S]
+    : never
+    : never
 
@@ -371,4 +384,10 @@ /**
    */
-  export type To<S extends RpcService.Definition, P extends string = ""> = {
-    readonly [K in keyof S]: K extends string ? S[K] extends RpcService.DefinitionWithId ? To<S[K], `${P}${K}.`>
+  export type To<
+    S extends RpcService.Definition,
+    P extends string = "",
+    Depth extends ReadonlyArray<number> = []
+  > = Extract<keyof S, string> extends infer K
+    ? K extends Extract<keyof S, string> ?
+      S[K] extends RpcService.DefinitionWithId ?
+        Depth["length"] extends 3 ? never : To<S[K], `${P}${K}.`, [0, ...Depth]>
       : S[K] extends RpcSchema.IO<
@@ -396,4 +415,4 @@ infer _IE,
       : never
-      : never
-  }[keyof S]
+    : never
+    : never
 
@@ -430,1 +449,37 @@ /**
   )
+
+/**
+ * @category type ids
+ * @since 1.0.0
+ */
+export const HashAnnotationId: unique symbol = internal.HashAnnotationId
+
+/**
+ * @category type ids
+ * @since 1.0.0
+ */
+export type HashAnnotationId = typeof HashAnnotationId
+
+/**
+ * @category annotations
+ * @since 1.0.0
+ */
+export const withHash: {
+  <A>(f: (a: A) => number): <I>(self: Schema.Schema<I, A>) => Schema.Schema<I, A>
+  <I, A>(self: Schema.Schema<I, A>, f: (a: A) => number): Schema.Schema<I, A>
+} = internal.withHash
+
+/**
+ * @category annotations
+ * @since 1.0.0
+ */
+export const withHashString: {
+  <A>(f: (a: A) => string): <I>(self: Schema.Schema<I, A>) => Schema.Schema<I, A>
+  <I, A>(self: Schema.Schema<I, A>, f: (a: A) => string): Schema.Schema<I, A>
+} = internal.withHashString
+
+/**
+ * @category annotations
+ * @since 1.0.0
+ */
+export const hash: <I, A>(self: Schema.Schema<I, A>, value: A) => number = internal.hash

src/Server.ts

@@ -7,3 +7,2 @@ /**
 import type { Scope } from "effect/Scope"
-import type { Span } from "effect/Tracer"
 import type { RpcDecodeFailure, RpcEncodeFailure } from "./Error"
@@ -20,3 +19,3 @@ import * as internal from "./internal/server"
 export const handler: {
-  <R extends RpcRouter.WithSetup>(
+  <const R extends RpcRouter.WithSetup>(
     router: R
@@ -31,3 +30,3 @@ ): Effect<
         RpcHandlers.Services<R["handlers"]>,
-        RpcRouter.SetupServices<R> | Span
+        RpcRouter.SetupServices<R>
       >,
@@ -38,3 +37,3 @@ never,
   >
-  <R extends RpcRouter.WithoutSetup>(
+  <const R extends RpcRouter.WithoutSetup>(
     router: R
@@ -44,7 +43,7 @@ ): (
   ) => Effect<
-    Exclude<RpcHandlers.Services<R["handlers"]>, Span>,
+    RpcHandlers.Services<R["handlers"]>,
     never,
     ReadonlyArray<RpcResponse>
   >
-} = internal.handler as any
+} = internal.handler
 
@@ -55,7 +54,7 @@ /**
  */
-export const handlerRaw: <R extends RpcRouter.Base>(
+export const handlerRaw: <const R extends RpcRouter.Base>(
   router: R
 ) => <Req extends RpcRequestSchema.To<R["schema"], "">>(
   request: Req
-) => Req extends { _tag: infer M } ? RpcHandler.FromMethod<R["handlers"], M, Span, RpcEncodeFailure>
+) => Req extends { _tag: infer M } ? RpcHandler.FromMethod<R["handlers"], M, never, RpcEncodeFailure>
   : never = internal.handlerRaw as any
@@ -68,3 +67,3 @@
 export const handleSingle: {
-  <R extends RpcRouter.WithSetup>(
+  <const R extends RpcRouter.WithSetup>(
     router: R
@@ -79,3 +78,3 @@ ): Effect<
         RpcHandlers.Services<R["handlers"]>,
-        RpcRouter.SetupServices<R> | Span
+        RpcRouter.SetupServices<R>
       >,
@@ -91,3 +90,3 @@ never,
   ) => Effect<
-    Exclude<RpcHandlers.Services<R["handlers"]>, Span>,
+    RpcHandlers.Services<R["handlers"]>,
     never,
@@ -103,3 +102,3 @@ RpcResponse
 export const handleSingleWithSchema: {
-  <R extends RpcRouter.WithSetup>(
+  <const R extends RpcRouter.WithSetup>(
     router: R
@@ -114,3 +113,3 @@ ): Effect<
         RpcHandlers.Services<R["handlers"]>,
-        RpcRouter.SetupServices<R> | Span
+        RpcRouter.SetupServices<R>
       >,
@@ -126,3 +125,3 @@ never,
   ) => Effect<
-    Exclude<RpcHandlers.Services<R["handlers"]>, Span>,
+    RpcHandlers.Services<R["handlers"]>,
     never,
@@ -146,20 +145,21 @@ readonly [RpcResponse, Option<RpcSchema.Base>]
  */
-export type RpcUndecodedClient<H extends RpcHandlers, P extends string = ""> = {
-  readonly [K in Extract<keyof H, string>]: H[K] extends {
-    handlers: RpcHandlers
-  } ? RpcUndecodedClient<H[K]["handlers"], `${P}${K}.`>
-    : H[K] extends RpcHandler.IO<infer R, infer E, infer I, infer O> ? (
-        input: I
-      ) => Effect<
-        Exclude<R, Span>,
-        E | RpcEncodeFailure | RpcDecodeFailure,
-        UndecodedRpcResponse<`${P}${K}`, O>
-      >
-    : H[K] extends Effect<infer R, infer E, infer O> ? Effect<
-        Exclude<R, Span>,
-        E | RpcEncodeFailure | RpcDecodeFailure,
-        UndecodedRpcResponse<`${P}${K}`, O>
-      >
-    : never
-}
+export type RpcUndecodedClient<H extends RpcHandlers, P extends string = "", Depth extends ReadonlyArray<number> = []> =
+  {
+    readonly [K in Extract<keyof H, string>]: H[K] extends {
+      readonly handlers: RpcHandlers
+    } ? Depth["length"] extends 3 ? never : RpcUndecodedClient<H[K]["handlers"], `${P}${K}.`, [0, ...Depth]>
+      : H[K] extends RpcHandler.IO<infer R, infer E, infer I, infer O> ? (
+          input: I
+        ) => Effect<
+          R,
+          E | RpcEncodeFailure | RpcDecodeFailure,
+          UndecodedRpcResponse<`${P}${K}`, O>
+        >
+      : H[K] extends Effect<infer R, infer E, infer O> ? Effect<
+          R,
+          E | RpcEncodeFailure | RpcDecodeFailure,
+          UndecodedRpcResponse<`${P}${K}`, O>
+        >
+      : never
+  }
 
@@ -171,4 +171,4 @@ /**
 export const makeUndecodedClient: <
-  S extends RpcService.DefinitionWithId,
-  H extends RpcHandlers.FromService<S>
+  const S extends RpcService.DefinitionWithId,
+  const H extends RpcHandlers.FromService<S>
 >(
@@ -175,0 +175,0 @@ schemas: S,

src/tsconfig.json

@@ -11,3 +11,3 @@ {
     "preserveSymlinks": true,
-    "moduleResolution": "Bundler",
+    "moduleResolution": "NodeNext",
     "lib": [
@@ -34,3 +34,3 @@ "ES2021",
     "target": "ES2021",
-    "module": "ESNext",
+    "module": "NodeNext",
     "incremental": true,
@@ -37,0 +37,0 @@ "removeComments": false,

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

256615

increased by3.92%

Number of package files

130

increased by0.78%

Lines of code

6696

increased by3.19%

No dependency changes