effect-cf 0.41.1 → 0.42.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.41.1",
+  "version": "0.42.1",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {

package/src/AiGateway.ts

@@ -10,6 +10,8 @@ import type { WorkerEnvironment } from "./Environment";
 import { isWorkersAiBinding, type WorkersAiBinding } from "./WorkersAi";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 const expectedAiGatewayBinding = "Workers AI binding with gateway()";
 
 export class AiGatewayOperationError extends Data.TaggedError("AiGatewayOperationError")<{

package/src/AnalyticsEngine.ts

@@ -21,6 +21,8 @@ import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 const expectedAnalyticsEngineDataset = "Analytics Engine dataset binding with writeDataPoint()";
 const defaultQueryApiBaseUrl = "https://api.cloudflare.com/client/v4";
 const textEncoder = new TextEncoder();

package/src/Artifacts.ts

@@ -17,6 +17,8 @@ import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 const expectedArtifactsBinding =
   "Artifacts binding with create(), get(), import(), list(), and delete()";
 

package/src/BrowserRendering.ts

@@ -8,6 +8,8 @@ import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 const expectedBrowserRenderingBinding = "Browser Rendering binding resource";
 
 export class BrowserRenderingOperationError extends Data.TaggedError(

package/src/ContainerNamespace.ts

@@ -10,6 +10,8 @@ import * as RpcTargets from "./RpcTargets";
 import type { WorkerEnvironment } from "./Environment";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 const expectedContainerNamespace = "Container namespace binding with getByName()";
 
 export type ContainerSignal = "SIGKILL" | "SIGINT" | "SIGTERM";

package/src/D1.ts

@@ -8,6 +8,8 @@ import type { SqlClient } from "effect/unstable/sql";
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 const TypeId = "~effect-cf/D1" as const;
 
 export type TypeId = typeof TypeId;
@@ -19,6 +21,18 @@ export interface D1Definition {
 
 export type D1SqlLayerOptions = Omit<D1Client.D1ClientConfig, "db">;
 
+export type ServiceClass<Self, Id extends string> = Binding.BindingService<Self, Id, D1Database> & {
+  [TypeId]: typeof TypeId;
+  definition: D1Definition;
+  sqlLayer: (
+    options?: D1SqlLayerOptions,
+  ) => Layer.Layer<
+    D1Client.D1Client | SqlClient.SqlClient,
+    Config.ConfigError | Binding.BindingNotFoundError | Binding.BindingValidationError,
+    WorkerEnvironment
+  >;
+};
+
 declare const D1ServiceTypeId: unique symbol;
 
 export interface D1Service<Id extends string> {
@@ -40,18 +54,12 @@ export const make = <Id extends string>(id: Id, definition: D1Definition) =>
 
 export const Service =
   <Self>() =>
-  <Id extends string>(id: Id, definition: D1Definition) => {
+  <Id extends string>(id: Id, definition: D1Definition): ServiceClass<Self, Id> => {
     const tag = Binding.Service<Self>()(id, definition.binding, isD1Database, undefined, {
       expected: expectedD1Database,
     });
 
-    const sqlLayer = (
-      options?: D1SqlLayerOptions,
-    ): Layer.Layer<
-      D1Client.D1Client | SqlClient.SqlClient,
-      Config.ConfigError | Binding.BindingNotFoundError | Binding.BindingValidationError,
-      WorkerEnvironment
-    > =>
+    const sqlLayer: ServiceClass<Self, Id>["sqlLayer"] = (options) =>
       Layer.unwrap(
         Effect.gen(function* () {
           const db = yield* tag;

package/src/DurableObject.ts

@@ -1,6 +1,7 @@
 import { DurableObject as CloudflareDurableObject } from "cloudflare:workers";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as Scheduler from "effect/Scheduler";
 import * as Tracer from "effect/Tracer";
 import type { ManagedRuntime, Scope } from "effect";
 
@@ -19,6 +20,17 @@ import * as Runtime from "./internal/Runtime";
 import * as Telemetry from "./internal/Telemetry";
 import type { ReceiverOptions, RpcInvocationInfo } from "./RpcTracing";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+export type {
+  DurableObjectFetchError,
+  DurableObjectNamespaceClient,
+  DurableObjectRpcError,
+  DurableObjectStubClient,
+  StubCall,
+  StubRpc,
+  StubScopedCall,
+} from "./DurableObjectNamespace";
+
 const reservedMethodNames: ReadonlySet<string> = RpcDefinition.reservedMethodNames;
 
 export type RuntimeContext<ROut> =
@@ -114,8 +126,10 @@ interface DurableObjectOptionsBase<
   /**
    * Effect run when Cloudflare loads this Durable Object instance into memory.
    *
-   * Use `DurableObjectState.blockConcurrencyWhile` inside this hook when
-   * incoming events should wait for setup to finish. Cloudflare may construct
+   * The base layer is acquired before incoming events are admitted. The hook
+   * itself runs in the background; start it with
+   * `DurableObjectState.blockConcurrencyWhile` when incoming events should
+   * wait for setup to finish. Cloudflare may construct
    * the same Durable Object id again after eviction or restart; use Durable
    * Object storage if work must happen only once per id.
    */
@@ -287,7 +301,17 @@ export function make<
       const initialize = options.initialize;
 
       if (initialize !== undefined) {
-        state.waitUntil(this[RunSymbol](initialize, { eventLayer: false }));
+        state.waitUntil(
+          state.blockConcurrencyWhile(async () => {
+            // Build services before admitting the first event, then let the
+            // hook synchronously install its own gate if it needs one. Its
+            // background work and failure reporting keep their waitUntil owner.
+            await Effect.runPromise(this.runtime.contextEffect, {
+              scheduler: new Scheduler.MixedScheduler("sync"),
+            });
+            state.waitUntil(this[RunSymbol](initialize, { eventLayer: false }));
+          }),
+        );
       }
     }
 
@@ -403,15 +427,17 @@ export type {
   LayerOptions,
   Method,
   Methods,
+  NativeSchema,
   NoReservedMethods,
   Options,
   ReservedMethodName,
+  RpcSchema,
   ServerApi,
   ServiceFreeSchema,
   TagClass,
 } from "./DurableObjectDefinition";
 
-export { implement, method, Tag } from "./DurableObjectDefinition";
+export { implement, method, native, Tag } from "./DurableObjectDefinition";
 
 // Preserve the original public type export while using a domain-role name internally.
 export type { DurableObjectRpcApi as "DurableObjectRpcShape" };

package/src/DurableObjectDefinition.ts

@@ -11,41 +11,55 @@ import * as RpcDefinition from "./RpcDefinition";
 import { recordDecodedArgs } from "./internal/RpcInvocation";
 import type { WorkerEnvironment } from "./Environment";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+export type {
+  DurableObjectFetchError,
+  DurableObjectNamespaceClient,
+  DurableObjectRpcError,
+  DurableObjectStubClient,
+  StubCall,
+  StubRpc,
+  StubScopedCall,
+} from "./DurableObjectNamespace";
+
 type ErasedInvoke<E> = (...args: ReadonlyArray<unknown>) => Effect.Effect<unknown, E>;
 
 export type ServiceFreeSchema = S.Codec<any, any, never, never>;
+export type NativeSchema<Schema extends ServiceFreeSchema = ServiceFreeSchema> =
+  RpcDefinition.NativeSchema<Schema>;
+export type RpcSchema = RpcDefinition.RpcSchema;
 
 export interface Method<
-  Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>,
-  Success extends ServiceFreeSchema = ServiceFreeSchema,
+  Args extends ReadonlyArray<RpcSchema> = ReadonlyArray<RpcSchema>,
+  Success extends RpcSchema = RpcSchema,
 > {
   readonly args: Args;
   readonly success: Success;
 }
 
 export namespace Method {
-  export type Any = Method<ReadonlyArray<ServiceFreeSchema>, ServiceFreeSchema>;
+  export type Any = Method<ReadonlyArray<RpcSchema>, RpcSchema>;
 
-  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = Args extends readonly []
+  type ArgsFromSchemas<Args extends ReadonlyArray<RpcSchema>> = Args extends readonly []
     ? []
     : Args extends readonly [
-          infer Head extends ServiceFreeSchema,
-          ...infer Tail extends ReadonlyArray<ServiceFreeSchema>,
+          infer Head extends RpcSchema,
+          ...infer Tail extends ReadonlyArray<RpcSchema>,
         ]
-      ? [S.Schema.Type<Head>, ...ArgsFromSchemas<Tail>]
-      : Array<S.Schema.Type<Args[number]>>;
+      ? [RpcDefinition.SchemaType<Head>, ...ArgsFromSchemas<Tail>]
+      : Array<RpcDefinition.SchemaType<Args[number]>>;
 
-  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = {
-    [Index in keyof Args]: S.Json;
+  type EncodedArgsFromSchemas<Args extends ReadonlyArray<RpcSchema>> = {
+    [Index in keyof Args]: RpcDefinition.WireEncoded<Args[Index]>;
   };
 
   export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
 
   export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
 
-  export type Success<Self extends Any> = S.Schema.Type<Self["success"]>;
+  export type Success<Self extends Any> = RpcDefinition.SchemaType<Self["success"]>;
 
-  export type EncodedSuccess<_Self extends Any> = S.Json;
+  export type EncodedSuccess<Self extends Any> = RpcDefinition.WireEncoded<Self["success"]>;
 }
 
 export type Methods = Record<string, Method.Any>;
@@ -178,20 +192,22 @@ export type TagClass<
 /**
  * Defines a single RPC method schema in a Durable Object definition.
  */
-export function method<Success extends ServiceFreeSchema>(definition: {
+export function method<Success extends RpcSchema>(definition: {
   readonly success: Success;
 }): Method<readonly [], Success>;
 export function method<
-  const Args extends ReadonlyArray<ServiceFreeSchema>,
-  Success extends ServiceFreeSchema,
+  const Args extends ReadonlyArray<RpcSchema>,
+  Success extends RpcSchema,
 >(definition: { readonly args: Args; readonly success: Success }): Method<Args, Success>;
 export function method(definition: {
-  readonly args?: ReadonlyArray<ServiceFreeSchema>;
-  readonly success: ServiceFreeSchema;
+  readonly args?: ReadonlyArray<RpcSchema>;
+  readonly success: RpcSchema;
 }): Method {
   return RpcDefinition.method(definition);
 }
 
+export const native = RpcDefinition.native;
+
 const makeDefinition = <Id extends string, const MethodDefinitions extends Methods>(
   id: Id,
   methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>,

package/src/DurableObjectNamespace.ts

@@ -120,12 +120,24 @@ type StubMethodCloudflareReturn<
   Method extends keyof Api,
 > = RpcInvocation.AsyncMethodCloudflareReturn<Api, Method>;
 
-type StubCall<R, Api extends object> = <Method extends StubMethodKey<Api>>(
+export type StubCall<R, Api extends object> = <Method extends StubMethodKey<Api>>(
   stub: DurableObjectStubClient<Api>,
   method: Method,
   ...args: StubMethodArgs<Api, Method>
 ) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError, R>;
 
+export type StubRpc<R, Api extends object> = <Method extends StubMethodKey<Api>>(
+  stub: DurableObjectStubClient<Api>,
+  method: Method,
+  ...args: StubMethodArgs<Api, Method>
+) => Effect.Effect<StubMethodCloudflareReturn<Api, Method>, DurableObjectRpcError, R>;
+
+export type StubScopedCall<R, Api extends object> = <Method extends StubMethodKey<Api>>(
+  stub: DurableObjectStubClient<Api>,
+  method: Method,
+  ...args: StubMethodArgs<Api, Method>
+) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, DurableObjectRpcError, Scope.Scope | R>;
+
 type DurableObjectDirectClient<R, Api extends object> = {
   readonly fetch: (
     input: RequestInfo | URL,
@@ -227,22 +239,14 @@ export type DurableObjectNamespaceEffectClient<
    *
    * Most application code should use {@link call} instead.
    */
-  readonly rpc: <Method extends StubMethodKey<Api>>(
-    stub: DurableObjectStubClient<Api>,
-    method: Method,
-    ...args: StubMethodArgs<Api, Method>
-  ) => Effect.Effect<StubMethodCloudflareReturn<Api, Method>, DurableObjectRpcError>;
+  readonly rpc: StubRpc<never, Api>;
   /**
    * Invokes a Durable Object RPC method, resolves Cloudflare's RPC result, and
    * decodes the success value when the namespace was created from a definition.
    *
    * This is the normal choice when application code wants the final typed value.
    */
-  readonly call: <Method extends StubMethodKey<Api>>(
-    stub: DurableObjectStubClient<Api>,
-    method: Method,
-    ...args: StubMethodArgs<Api, Method>
-  ) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError>;
+  readonly call: StubCall<never, Api>;
   /**
    * Invokes a Durable Object RPC method in the current `Scope`, resolves
    * Cloudflare's RPC result, decodes definition-backed success values, and
@@ -252,11 +256,7 @@ export type DurableObjectNamespaceEffectClient<
    * Use this for RPC methods that return Cloudflare RPC resources or other
    * disposable objects whose lifetime should be tied to an Effect scope.
    */
-  readonly scopedCall: <Method extends StubMethodKey<Api>>(
-    stub: DurableObjectStubClient<Api>,
-    method: Method,
-    ...args: StubMethodArgs<Api, Method>
-  ) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, DurableObjectRpcError, Scope.Scope>;
+  readonly scopedCall: StubScopedCall<never, Api>;
   /**
    * Exposes the underlying native Durable Object namespace binding.
    *
@@ -292,25 +292,9 @@ export type DurableObjectNamespaceStaticClient<
     input: RequestInfo | URL,
     init?: RequestInit,
   ) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
-  readonly rpc: <Method extends StubMethodKey<Api>>(
-    stub: DurableObjectStubClient<Api>,
-    method: Method,
-    ...args: StubMethodArgs<Api, Method>
-  ) => Effect.Effect<StubMethodCloudflareReturn<Api, Method>, DurableObjectRpcError, R>;
-  readonly call: <Method extends StubMethodKey<Api>>(
-    stub: DurableObjectStubClient<Api>,
-    method: Method,
-    ...args: StubMethodArgs<Api, Method>
-  ) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError, R>;
-  readonly scopedCall: <Method extends StubMethodKey<Api>>(
-    stub: DurableObjectStubClient<Api>,
-    method: Method,
-    ...args: StubMethodArgs<Api, Method>
-  ) => Effect.Effect<
-    Awaited<StubMethodSuccess<Api, Method>>,
-    DurableObjectRpcError,
-    Scope.Scope | R
-  >;
+  readonly rpc: StubRpc<R, Api>;
+  readonly call: StubCall<R, Api>;
+  readonly scopedCall: StubScopedCall<R, Api>;
   readonly rawUnsafe: () => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
 };
 

package/src/Email.ts

@@ -14,6 +14,8 @@ import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 const expectedSendEmailBinding = "Send Email binding with send()";
 const textEncoder = new TextEncoder();
 

package/src/Hyperdrive.ts

@@ -6,6 +6,8 @@ import type { Layer } from "effect";
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 const expectedHyperdrive = "Hyperdrive binding with connectionString";
 
 export interface HyperdriveDefinition {

package/src/Images.ts

@@ -33,6 +33,8 @@ import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 const TypeId = "~effect-cf/Images/Steps" as const;
 
 export type TypeId = typeof TypeId;

package/src/Kv.ts

@@ -14,6 +14,8 @@ import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 const expectedKvNamespace =
   "KV namespace binding with get(), put(), delete(), getWithMetadata(), and list()";
 

package/src/Queue.ts

@@ -7,6 +7,9 @@ import type { WorkerEnvironment } from "./Environment";
 import type * as QueueDefinition from "./QueueDefinition";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+export type { QueueOperationError, QueueProducer } from "./QueueBinding";
+
 export interface QueueMessage<Body> {
   readonly raw: globalThis.Message<unknown>;
   readonly id: string;
@@ -111,13 +114,7 @@ export namespace Definition {
 
 export type LayerOptions = QueueDefinition.LayerOptions;
 
-export type TagClass<
-  Self,
-  Id extends string,
-  Message extends QueueDefinition.Definition.Any["message"],
-> = QueueDefinition.TagClass<Self, Id, Message>;
-
-export { implement, Tag } from "./QueueDefinition";
+export { implement, Tag, type TagClass } from "./QueueDefinition";
 
 export type Handler<ROut, Self extends QueueDefinition.Definition.Any> = QueueDefinition.Handler<
   ROut,

package/src/QueueDefinition.ts

@@ -11,6 +11,9 @@ import type { ExecutionContext, WorkerContext } from "./Worker";
 import * as WorkerEntrypoint from "./Worker";
 import type * as RpcDefinition from "./RpcDefinition";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+export type { QueueOperationError, QueueProducer } from "./QueueBinding";
+
 export interface Definition<
   Id extends string = string,
   Message extends RpcDefinition.ServiceFreeSchema = RpcDefinition.ServiceFreeSchema,
@@ -43,15 +46,15 @@ export type LayerOptions = {
   readonly binding: string;
 };
 
-export interface TagClass<
+export type TagClass<
   Self,
   Id extends string,
   Message extends RpcDefinition.ServiceFreeSchema,
-> extends Context.ServiceClass<
+> = Context.ServiceClass<
   Self,
   `effect-cf/Queue/${Id}`,
   QueueBinding.QueueBindingClient<Message>
-> {
+> & {
   readonly id: Id;
   readonly message: Message;
   readonly make: <ROut, LayerError>(
@@ -83,7 +86,7 @@ export interface TagClass<
     never,
     Self
   >;
-}
+};
 
 const makeDefinition = <Id extends string, Message extends RpcDefinition.ServiceFreeSchema>(
   id: Id,

package/src/R2.ts

@@ -24,6 +24,8 @@ import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 const expectedR2Bucket =
   "R2 bucket binding with head(), get(), put(), createMultipartUpload(), resumeMultipartUpload(), delete(), and list()";
 

package/src/RpcDefinition.ts

@@ -148,45 +148,86 @@ export type ReservedMethodName = (typeof reservedMethodNameValues)[number];
 
 export type ServiceFreeSchema = S.Codec<any, any, never, never>;
 
+export const NativeSchemaTypeId: unique symbol = Symbol.for("effect-cf/RpcDefinition/NativeSchema");
+
+/** A schema whose encoded value is passed directly to Workers RPC. */
+export interface NativeSchema<Schema extends ServiceFreeSchema = ServiceFreeSchema> {
+  readonly [NativeSchemaTypeId]: typeof NativeSchemaTypeId;
+  readonly schema: Schema;
+}
+
+export type RpcSchema = ServiceFreeSchema | NativeSchema;
+
+export type SchemaType<Schema extends RpcSchema> =
+  Schema extends NativeSchema<infer Native extends ServiceFreeSchema>
+    ? S.Schema.Type<Native>
+    : Schema extends ServiceFreeSchema
+      ? S.Schema.Type<Schema>
+      : never;
+
+export type WireEncoded<Schema extends RpcSchema> =
+  Schema extends NativeSchema<infer Native extends ServiceFreeSchema>
+    ? S.Codec.Encoded<Native>
+    : S.Json;
+
+/**
+ * Marks a schema to use its declared encoded form directly at the Workers RPC
+ * boundary instead of lowering it to canonical JSON.
+ */
+export const native = <Schema extends ServiceFreeSchema>(schema: Schema): NativeSchema<Schema> => {
+  const nativeSchema: NativeSchema<Schema> = {
+    [NativeSchemaTypeId]: NativeSchemaTypeId,
+    schema,
+  };
+
+  return Object.freeze(nativeSchema);
+};
+
+const isNativeSchema = (schema: RpcSchema): schema is NativeSchema =>
+  Predicate.hasProperty(schema, NativeSchemaTypeId) &&
+  schema[NativeSchemaTypeId] === NativeSchemaTypeId;
+
 /**
  * Workers RPC structured-clones every value that crosses an isolate boundary
  * and rejects class instances. Declaration schemas such as `Schema.Result`
  * keep their container instance in their `Encoded` form, so the declared
- * schemas are lowered to their canonical JSON codec before touching the wire.
+ * schemas are lowered to their canonical JSON codec before touching the wire,
+ * unless explicitly wrapped with `native`.
  */
-const wireCodec = <Schema extends S.Constraint>(schema: Schema) => S.toCodecJson(schema);
+const wireCodec = (schema: RpcSchema): ServiceFreeSchema =>
+  isNativeSchema(schema) ? schema.schema : S.toCodecJson(schema);
 
 export interface Method<
-  Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>,
-  Success extends ServiceFreeSchema = ServiceFreeSchema,
+  Args extends ReadonlyArray<RpcSchema> = ReadonlyArray<RpcSchema>,
+  Success extends RpcSchema = RpcSchema,
 > {
   readonly args: Args;
   readonly success: Success;
 }
 
 export namespace Method {
-  export type Any = Method<ReadonlyArray<ServiceFreeSchema>, ServiceFreeSchema>;
+  export type Any = Method<ReadonlyArray<RpcSchema>, RpcSchema>;
 
-  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = Args extends readonly []
+  type ArgsFromSchemas<Args extends ReadonlyArray<RpcSchema>> = Args extends readonly []
     ? []
     : Args extends readonly [
-          infer Head extends ServiceFreeSchema,
-          ...infer Tail extends ReadonlyArray<ServiceFreeSchema>,
+          infer Head extends RpcSchema,
+          ...infer Tail extends ReadonlyArray<RpcSchema>,
         ]
-      ? [S.Schema.Type<Head>, ...ArgsFromSchemas<Tail>]
-      : Array<S.Schema.Type<Args[number]>>;
+      ? [SchemaType<Head>, ...ArgsFromSchemas<Tail>]
+      : Array<SchemaType<Args[number]>>;
 
-  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = {
-    [Index in keyof Args]: S.Json;
+  type EncodedArgsFromSchemas<Args extends ReadonlyArray<RpcSchema>> = {
+    [Index in keyof Args]: WireEncoded<Args[Index]>;
   };
 
   export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
 
   export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
 
-  export type Success<Self extends Any> = S.Schema.Type<Self["success"]>;
+  export type Success<Self extends Any> = SchemaType<Self["success"]>;
 
-  export type EncodedSuccess<_Self extends Any> = S.Json;
+  export type EncodedSuccess<Self extends Any> = WireEncoded<Self["success"]>;
 }
 
 export type Methods = Record<string, Method.Any>;
@@ -237,16 +278,16 @@ export const assertNoReservedMethods = <
   }
 };
 
-export function method<Success extends ServiceFreeSchema>(definition: {
+export function method<Success extends RpcSchema>(definition: {
   readonly success: Success;
 }): Method<readonly [], Success>;
 export function method<
-  const Args extends ReadonlyArray<ServiceFreeSchema>,
-  Success extends ServiceFreeSchema,
+  const Args extends ReadonlyArray<RpcSchema>,
+  Success extends RpcSchema,
 >(definition: { readonly args: Args; readonly success: Success }): Method<Args, Success>;
 export function method(definition: {
-  readonly args?: ReadonlyArray<ServiceFreeSchema>;
-  readonly success: ServiceFreeSchema;
+  readonly args?: ReadonlyArray<RpcSchema>;
+  readonly success: RpcSchema;
 }) {
   return {
     args: definition.args ?? [],
@@ -276,9 +317,8 @@ export const decodeArgs = Effect.fnUntraced(function* <
     });
   }
 
-  const decoded = yield* S.decodeUnknownEffect(wireCodec(S.Tuple(methodDefinition.args)))(
-    args,
-  ).pipe(
+  const codecs = methodDefinition.args.map((schema) => wireCodec(schema));
+  const decoded = yield* S.decodeUnknownEffect(S.Tuple(codecs))(args).pipe(
     Effect.mapError(
       (cause) =>
         new RpcArgumentDecodeError({
@@ -315,9 +355,8 @@ export const encodeArgs = Effect.fnUntraced(function* <
     });
   }
 
-  const encoded = yield* S.encodeUnknownEffect(wireCodec(S.Tuple(methodDefinition.args)))(
-    args,
-  ).pipe(
+  const codecs = methodDefinition.args.map((schema) => wireCodec(schema));
+  const encoded = yield* S.encodeUnknownEffect(S.Tuple(codecs))(args).pipe(
     Effect.mapError(
       (cause) =>
         new RpcArgumentEncodeError({

package/src/Sandbox.ts

@@ -47,6 +47,8 @@ import * as ErrorMessage from "./internal/ErrorMessage";
 import { CurrentTargets } from "./internal/RpcTargets";
 import * as RpcTargets from "./RpcTargets";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 export type {
   BackupOptions,
   CheckChangesOptions,