effect-cf 0.41.1 → 0.42.0

package/dist/RpcDefinition.d.mts

@@ -2,7 +2,7 @@ import { Provider } from "./Rpc.mjs";
 import * as Effect from "effect/Effect";
 import * as S from "effect/Schema";
 declare namespace RpcDefinition_d_exports {
-  export { Definition, Method, Methods, NoReservedMethods, ReservedMethodName, RpcArgumentCountError, RpcArgumentDecodeError, RpcArgumentEncodeError, RpcReservedMethodNameError, RpcSuccessDecodeError, RpcSuccessEncodeError, ServiceFreeSchema, WireError, assertNoReservedMethods, decodeArgs, decodeSuccess, decodeWireError, encodeArgs, encodeSuccess, encodeWireError, isWireError, make, method, reservedMethodNames };
+  export { Definition, Method, Methods, NativeSchema, NativeSchemaTypeId, NoReservedMethods, ReservedMethodName, RpcArgumentCountError, RpcArgumentDecodeError, RpcArgumentEncodeError, RpcReservedMethodNameError, RpcSchema, RpcSuccessDecodeError, RpcSuccessEncodeError, SchemaType, ServiceFreeSchema, WireEncoded, WireError, assertNoReservedMethods, decodeArgs, decodeSuccess, decodeWireError, encodeArgs, encodeSuccess, encodeWireError, isWireError, make, method, native, reservedMethodNames };
 }
 declare const RpcReservedMethodNameError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "RpcReservedMethodNameError";
@@ -72,18 +72,32 @@ declare const reservedMethodNameValues: readonly ["constructor", "fetch", "conne
 declare const reservedMethodNames: Set<string>;
 type ReservedMethodName = (typeof reservedMethodNameValues)[number];
 type ServiceFreeSchema = S.Codec<any, any, never, never>;
-interface Method<Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema = ServiceFreeSchema> {
+declare const NativeSchemaTypeId: unique symbol;
+/** A schema whose encoded value is passed directly to Workers RPC. */
+interface NativeSchema<Schema extends ServiceFreeSchema = ServiceFreeSchema> {
+  readonly [NativeSchemaTypeId]: typeof NativeSchemaTypeId;
+  readonly schema: Schema;
+}
+type RpcSchema = ServiceFreeSchema | NativeSchema;
+type SchemaType<Schema extends RpcSchema> = Schema extends NativeSchema<infer Native extends ServiceFreeSchema> ? S.Schema.Type<Native> : Schema extends ServiceFreeSchema ? S.Schema.Type<Schema> : never;
+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.
+ */
+declare const native: <Schema extends ServiceFreeSchema>(schema: Schema) => NativeSchema<Schema>;
+interface Method<Args extends ReadonlyArray<RpcSchema> = ReadonlyArray<RpcSchema>, Success extends RpcSchema = RpcSchema> {
   readonly args: Args;
   readonly success: Success;
 }
 declare namespace Method {
-  export type Any = Method<ReadonlyArray<ServiceFreeSchema>, ServiceFreeSchema>;
-  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends ReadonlyArray<ServiceFreeSchema>] ? [S.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<S.Schema.Type<Args[number]>>;
-  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = { [Index in keyof Args]: S.Json; };
+  export type Any = Method<ReadonlyArray<RpcSchema>, RpcSchema>;
+  type ArgsFromSchemas<Args extends ReadonlyArray<RpcSchema>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends RpcSchema, ...infer Tail extends ReadonlyArray<RpcSchema>] ? [SchemaType<Head>, ...ArgsFromSchemas<Tail>] : Array<SchemaType<Args[number]>>;
+  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 EncodedSuccess<_Self extends Any> = S.Json;
+  export type Success<Self extends Any> = SchemaType<Self["success"]>;
+  export type EncodedSuccess<Self extends Any> = WireEncoded<Self["success"]>;
   export {};
 }
 type Methods = Record<string, Method.Any>;
@@ -100,17 +114,17 @@ declare namespace Definition {
 }
 type ReservedMethodValue = S.Schema.Type<typeof S.Unknown>;
 declare const assertNoReservedMethods: <MethodDefinitions extends Readonly<Record<string, ReservedMethodValue>>>(target: string, methods: MethodDefinitions, reserved: ReadonlySet<string>) => void;
-declare function method<Success extends ServiceFreeSchema>(definition: {
+declare function method<Success extends RpcSchema>(definition: {
   readonly success: Success;
 }): Method<readonly [], Success>;
-declare function method<const Args extends ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema>(definition: {
+declare function method<const Args extends ReadonlyArray<RpcSchema>, Success extends RpcSchema>(definition: {
   readonly args: Args;
   readonly success: Success;
 }): Method<Args, Success>;
-declare const decodeArgs: <const Self extends Definition.Any, MethodName extends Definition.MethodNames<Self>>(definition: Self, methodName: MethodName, args: readonly unknown[]) => Effect.Effect<Self["methods"][MethodName]["args"] extends (infer T) ? T extends Self["methods"][MethodName]["args"] ? T extends readonly [] ? [] : T extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ... /*elided*/ any] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<T[number]>[] : never : never, RpcArgumentCountError | RpcArgumentDecodeError, never>;
-declare const encodeArgs: <const Self extends Definition.Any, MethodName extends Definition.MethodNames<Self>>(definition: Self, methodName: MethodName, args: Self["methods"][MethodName]["args"] extends (infer T) ? T extends Self["methods"][MethodName]["args"] ? T extends readonly [] ? [] : T extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends readonly ServiceFreeSchema[]] ? [S.Schema.Type<Head>, ... /*elided*/ any] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<Tail[number]>[]] : S.Schema.Type<T[number]>[] : never : never) => Effect.Effect<Self["methods"][MethodName]["args"] extends (infer T_1 extends readonly ServiceFreeSchema[]) ? { [Index in keyof T_1]: S.Json; } : never, RpcArgumentCountError | RpcArgumentEncodeError, never>;
+declare const decodeArgs: <const Self extends Definition.Any, MethodName extends Definition.MethodNames<Self>>(definition: Self, methodName: MethodName, args: readonly unknown[]) => Effect.Effect<Self["methods"][MethodName]["args"] extends (infer T) ? T extends Self["methods"][MethodName]["args"] ? T extends readonly [] ? [] : T extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ... /*elided*/ any] : SchemaType<Tail[number]>[]] : SchemaType<Tail[number]>[]] : SchemaType<Tail[number]>[]] : SchemaType<Tail[number]>[]] : SchemaType<Tail[number]>[]] : SchemaType<Tail[number]>[]] : SchemaType<Tail[number]>[]] : SchemaType<Tail[number]>[]] : SchemaType<Tail[number]>[]] : SchemaType<Tail[number]>[]] : SchemaType<T[number]>[] : never : never, RpcArgumentCountError | RpcArgumentDecodeError, never>;
+declare const encodeArgs: <const Self extends Definition.Any, MethodName extends Definition.MethodNames<Self>>(definition: Self, methodName: MethodName, args: Self["methods"][MethodName]["args"] extends (infer T) ? T extends Self["methods"][MethodName]["args"] ? T extends readonly [] ? [] : T extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends RpcSchema, ...infer Tail extends readonly RpcSchema[]] ? [SchemaType<Head>, ... /*elided*/ any] : SchemaType<Tail[number]>[]] : SchemaType<Tail[number]>[]] : SchemaType<Tail[number]>[]] : SchemaType<Tail[number]>[]] : SchemaType<Tail[number]>[]] : SchemaType<Tail[number]>[]] : SchemaType<Tail[number]>[]] : SchemaType<Tail[number]>[]] : SchemaType<Tail[number]>[]] : SchemaType<Tail[number]>[]] : SchemaType<T[number]>[] : never : never) => Effect.Effect<Self["methods"][MethodName]["args"] extends (infer T_1 extends readonly RpcSchema[]) ? { [Index in keyof T_1]: WireEncoded<T_1[Index]>; } : never, RpcArgumentCountError | RpcArgumentEncodeError, never>;
 declare const encodeSuccess: <const Self extends Definition.Any, MethodName extends Definition.MethodNames<Self>>(definition: Self, methodName: MethodName, value: Method.Success<Self["methods"][MethodName]>) => Effect.Effect<Method.EncodedSuccess<Self["methods"][MethodName]>, RpcSuccessEncodeError>;
 declare const decodeSuccess: <const Self extends Definition.Any, MethodName extends Definition.MethodNames<Self>>(definition: Self, methodName: MethodName, value: WireValue) => Effect.Effect<Method.Success<Self["methods"][MethodName]>, RpcSuccessDecodeError>;
 declare const make: <Id extends string, const MethodDefinitions extends Methods>(id: Id, methods: MethodDefinitions) => Definition<Id, MethodDefinitions>;
 //#endregion
-export { Definition, Method, Methods, NoReservedMethods, ReservedMethodName, RpcArgumentCountError, RpcArgumentDecodeError, RpcArgumentEncodeError, RpcDefinition_d_exports, RpcReservedMethodNameError, RpcSuccessDecodeError, RpcSuccessEncodeError, ServiceFreeSchema, WireError, assertNoReservedMethods, decodeArgs, decodeSuccess, decodeWireError, encodeArgs, encodeSuccess, encodeWireError, isWireError, make, method, reservedMethodNames };
+export { Definition, Method, Methods, NativeSchema, NativeSchemaTypeId, NoReservedMethods, ReservedMethodName, RpcArgumentCountError, RpcArgumentDecodeError, RpcArgumentEncodeError, RpcDefinition_d_exports, RpcReservedMethodNameError, RpcSchema, RpcSuccessDecodeError, RpcSuccessEncodeError, SchemaType, ServiceFreeSchema, WireEncoded, WireError, assertNoReservedMethods, decodeArgs, decodeSuccess, decodeWireError, encodeArgs, encodeSuccess, encodeWireError, isWireError, make, method, native, reservedMethodNames };

package/dist/RpcDefinition.mjs

@@ -6,6 +6,7 @@ import * as S from "effect/Schema";
 import * as Predicate from "effect/Predicate";
 //#region src/RpcDefinition.ts
 var RpcDefinition_exports = /* @__PURE__ */ __exportAll({
+	NativeSchemaTypeId: () => NativeSchemaTypeId,
 	RpcArgumentCountError: () => RpcArgumentCountError,
 	RpcArgumentDecodeError: () => RpcArgumentDecodeError,
 	RpcArgumentEncodeError: () => RpcArgumentEncodeError,
@@ -22,6 +23,7 @@ var RpcDefinition_exports = /* @__PURE__ */ __exportAll({
 	isWireError: () => isWireError,
 	make: () => make,
 	method: () => method,
+	native: () => native,
 	reservedMethodNames: () => reservedMethodNames
 });
 var RpcReservedMethodNameError = class extends Data.TaggedError("RpcReservedMethodNameError") {
@@ -110,13 +112,26 @@ const reservedMethodNames = /* @__PURE__ */ new Set([
 	"serialize",
 	"deserialize"
 ]);
+const NativeSchemaTypeId = Symbol.for("effect-cf/RpcDefinition/NativeSchema");
+/**
+* Marks a schema to use its declared encoded form directly at the Workers RPC
+* boundary instead of lowering it to canonical JSON.
+*/
+const native = (schema) => {
+	return Object.freeze({
+		[NativeSchemaTypeId]: NativeSchemaTypeId,
+		schema
+	});
+};
+const isNativeSchema = (schema) => 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) => S.toCodecJson(schema);
+const wireCodec = (schema) => isNativeSchema(schema) ? schema.schema : S.toCodecJson(schema);
 const assertNoReservedMethods = (target, methods, reserved) => {
 	for (const method of Object.keys(methods)) if (reserved.has(method)) throw new RpcReservedMethodNameError({
 		definition: target,
@@ -137,7 +152,8 @@ const decodeArgs = Effect.fnUntraced(function* (definition, methodName, args) {
 		expected: methodDefinition.args.length,
 		actual: args.length
 	});
-	return yield* S.decodeUnknownEffect(wireCodec(S.Tuple(methodDefinition.args)))(args).pipe(Effect.mapError((cause) => new RpcArgumentDecodeError({
+	const codecs = methodDefinition.args.map((schema) => wireCodec(schema));
+	return yield* S.decodeUnknownEffect(S.Tuple(codecs))(args).pipe(Effect.mapError((cause) => new RpcArgumentDecodeError({
 		definition: definition.id,
 		method: methodName,
 		cause
@@ -151,7 +167,8 @@ const encodeArgs = Effect.fnUntraced(function* (definition, methodName, args) {
 		expected: methodDefinition.args.length,
 		actual: args.length
 	});
-	return yield* S.encodeUnknownEffect(wireCodec(S.Tuple(methodDefinition.args)))(args).pipe(Effect.mapError((cause) => new RpcArgumentEncodeError({
+	const codecs = methodDefinition.args.map((schema) => wireCodec(schema));
+	return yield* S.encodeUnknownEffect(S.Tuple(codecs))(args).pipe(Effect.mapError((cause) => new RpcArgumentEncodeError({
 		definition: definition.id,
 		method: methodName,
 		cause
@@ -181,4 +198,4 @@ const make = (id, methods) => {
 	};
 };
 //#endregion
-export { RpcArgumentCountError, RpcArgumentDecodeError, RpcArgumentEncodeError, RpcDefinition_exports, RpcReservedMethodNameError, RpcSuccessDecodeError, RpcSuccessEncodeError, assertNoReservedMethods, decodeArgs, decodeSuccess, decodeWireError, encodeArgs, encodeSuccess, encodeWireError, isWireError, make, method, reservedMethodNames };
+export { NativeSchemaTypeId, RpcArgumentCountError, RpcArgumentDecodeError, RpcArgumentEncodeError, RpcDefinition_exports, RpcReservedMethodNameError, RpcSuccessDecodeError, RpcSuccessEncodeError, assertNoReservedMethods, decodeArgs, decodeSuccess, decodeWireError, encodeArgs, encodeSuccess, encodeWireError, isWireError, make, method, native, reservedMethodNames };

package/dist/Sandbox.d.mts

@@ -194,4 +194,4 @@ declare const proxyToSandbox: (request: Request<unknown, CfProperties<unknown>>,
   readonly binding?: string;
 } | undefined) => Effect.Effect<Option.Option<Response>, SandboxOperationError, WorkerEnvironment>;
 //#endregion
-export { type BackupOptions, type CheckChangesOptions, type CheckChangesResult, type CreateTerminalOptions, DeleteFileResult, type DirectoryBackup, type ExecOptions, ExposePortOptions, ExposedPort, ExposedPortStatus, FileExistsResult, type FileWatchSSEEvent, type ISandbox, LayerOptions, type ListFilesOptions, ListFilesResult, MkdirResult, type MountBucketOptions, MoveFileResult, type ProcessExit, type ProcessLogEvent, type ProcessLogsOptions, type ProcessOutput, type ProcessOutputOptions, type ProcessStatus, ReadFileEncoding, ReadFileResult, RenameFileResult, type RestoreBackupResult, Sandbox, SandboxClientResource, type SandboxCommand, SandboxDefinition, SandboxInstanceClient, SandboxNamespaceClient, SandboxNamespaceResource, SandboxNamespaceService, SandboxOperationError, type SandboxOptions, type SandboxProcess, SandboxProcessHandle, SandboxTerminalHandle, SandboxTunnelsClient, SandboxTunnelsResource, Tag, TagClass, type Terminal, type TerminalOutputCursor, type TerminalOutputEvent, type TerminalOutputOptions, type TerminalSnapshot, type TunnelInfo, type TunnelOptions, type WaitForExitOptions, type WaitForLogOptions, type WaitForLogResult, type WaitForPortOptions, type WatchOptions, WriteFileResult, fromSandboxClient, isSandboxNamespaceResource, layer, make, makeClient, proxyToSandbox };
+export { type BackupOptions, type BindingNotFoundError, type BindingValidationError, type CheckChangesOptions, type CheckChangesResult, type CreateTerminalOptions, DeleteFileResult, type DirectoryBackup, type ExecOptions, ExposePortOptions, ExposedPort, ExposedPortStatus, FileExistsResult, type FileWatchSSEEvent, type ISandbox, LayerOptions, type ListFilesOptions, ListFilesResult, MkdirResult, type MountBucketOptions, MoveFileResult, type ProcessExit, type ProcessLogEvent, type ProcessLogsOptions, type ProcessOutput, type ProcessOutputOptions, type ProcessStatus, ReadFileEncoding, ReadFileResult, RenameFileResult, type RestoreBackupResult, Sandbox, SandboxClientResource, type SandboxCommand, SandboxDefinition, SandboxInstanceClient, SandboxNamespaceClient, SandboxNamespaceResource, SandboxNamespaceService, SandboxOperationError, type SandboxOptions, type SandboxProcess, SandboxProcessHandle, SandboxTerminalHandle, SandboxTunnelsClient, SandboxTunnelsResource, Tag, TagClass, type Terminal, type TerminalOutputCursor, type TerminalOutputEvent, type TerminalOutputOptions, type TerminalSnapshot, type TunnelInfo, type TunnelOptions, type WaitForExitOptions, type WaitForLogOptions, type WaitForLogResult, type WaitForPortOptions, type WatchOptions, WriteFileResult, fromSandboxClient, isSandboxNamespaceResource, layer, make, makeClient, proxyToSandbox };

package/dist/ServiceBinding.d.mts

@@ -1,14 +1,14 @@
 import { WorkerEnvironment } from "./Environment.mjs";
 import { BindingNotFoundError, BindingService, BindingValidationError } from "./Binding.mjs";
-import { Provider, Result } from "./Rpc.mjs";
+import { Provider } from "./Rpc.mjs";
 import { Definition, Method as Method$1 } from "./RpcDefinition.mjs";
-import { AsyncMethodArgs, AsyncMethodCloudflareReturn, AsyncMethodKey, AsyncMethodSuccess } from "./internal/RpcInvocation.mjs";
 import { Definition as Definition$1, ReservedMethodName as ReservedMethodName$1, ServerApi } from "./WorkerDefinition.mjs";
+import { AsyncMethodArgs, AsyncMethodCloudflareReturn, AsyncMethodKey, AsyncMethodSuccess } from "./internal/RpcInvocation.mjs";
 import * as Effect from "effect/Effect";
 import * as Schema$1 from "effect/Schema";
 import { Context, Scope } from "effect";
 declare namespace ServiceBinding_d_exports {
-  export { Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceFetcher, isServiceBindingClient, layer, makeClient, makeDirectMethods };
+  export { BindingNotFoundError, BindingValidationError, Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceCall, ServiceClass, ServiceFetcher, ServiceRpc, ServiceScopedCall, isServiceBindingClient, layer, makeClient, makeDirectMethods };
 }
 declare const TypeId: "effect-cf/ServiceBinding";
 interface ServiceFetcher {
@@ -58,6 +58,8 @@ type ServiceMethodArgs<Api, Method extends keyof Api> = AsyncMethodArgs<Api, Met
 type ServiceMethodSuccess<Api, Method extends keyof Api> = AsyncMethodSuccess<Api, Method>;
 type ServiceMethodCloudflareReturn<Api, Method extends keyof Api> = AsyncMethodCloudflareReturn<Api, Method>;
 type ServiceCall<R, Api> = <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError, R>;
+type ServiceRpc<R, Api> = <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodCloudflareReturn<Api, Method>, ServiceBindingRpcError, R>;
+type ServiceScopedCall<R, Api> = <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, ServiceBindingRpcError, Scope.Scope | R>;
 type DefinitionDirectMethods<R, Definition$2 extends Definition$1.Any> = { readonly [Method in Definition.MethodNames<Definition$2>]: (...args: Method$1.Args<Definition$2["methods"][Method]>) => Effect.Effect<Method$1.Success<Definition$2["methods"][Method]>, ServiceBindingRpcError, R>; };
 type DirectMethods<R, Definition> = Definition extends Definition$1.Any ? DefinitionDirectMethods<R, Definition> : {};
 type ServiceBindingEffectClient<Api extends object, Definition extends Definition$1.Any | undefined = undefined> = DirectMethods<never, Definition> & {
@@ -71,14 +73,14 @@ type ServiceBindingEffectClient<Api extends object, Definition extends Definitio
    *
    * Most application code should use {@link call} instead.
    */
-  readonly rpc: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodCloudflareReturn<Api, Method>, ServiceBindingRpcError>;
+  readonly rpc: ServiceRpc<never, Api>;
   /**
    * Invokes a Worker RPC method, resolves Cloudflare's RPC result, and decodes
    * the success value when the binding was created from a definition.
    *
    * This is the normal choice when application code wants the final typed value.
    */
-  readonly call: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError>;
+  readonly call: ServiceCall<never, Api>;
   /**
    * Invokes a Worker RPC method in the current `Scope`, resolves Cloudflare's RPC
    * result, decodes definition-backed success values, and disposes the resolved
@@ -87,26 +89,23 @@ type ServiceBindingEffectClient<Api extends object, Definition extends Definitio
    * 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 ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, ServiceBindingRpcError, Scope.Scope>;
+  readonly scopedCall: ServiceScopedCall<never, Api>;
 };
 type ServiceBindingStaticClient<R, Api extends object, Definition extends Definition$1.Any | undefined = undefined> = DirectMethods<R, Definition> & {
   readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, ServiceBindingFetchError, R>;
-  readonly rpc: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodCloudflareReturn<Api, Method>, ServiceBindingRpcError, R>;
-  readonly call: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError, R>;
-  readonly scopedCall: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, ServiceBindingRpcError, Scope.Scope | R>;
+  readonly rpc: ServiceRpc<R, Api>;
+  readonly call: ServiceCall<R, Api>;
+  readonly scopedCall: ServiceScopedCall<R, Api>;
+};
+type ServiceClass<Self, Id extends string, Api extends object = never, Definition extends Definition$1.Any | undefined = undefined> = BindingService<Self, Id, ServiceBindingEffectClient<ApiOrDefinition<Api, Definition>, Definition>> & ServiceBindingStaticClient<Self, ApiOrDefinition<Api, Definition>, Definition> & {
+  readonly [TypeId]: typeof TypeId;
+  readonly definition: ServiceBindingDefinition<Definition>;
 };
 type ServiceBindingValue = Schema$1.Schema.Type<typeof Schema$1.Unknown>;
 declare const isServiceBindingClient: <Api extends object>(value: ServiceBindingValue) => value is ServiceBindingClient<Api>;
 declare const makeClient: <Api extends object, const Definition extends Definition$1.Any | undefined = undefined>(definition: ServiceBindingDefinition<Definition>) => ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition>);
 declare const layer: <Self, Api extends object, const Definition extends Definition$1.Any | undefined = undefined>(tag: Context.Service<Self, ServiceBindingEffectClient<Api, Definition>>, definition: ServiceBindingDefinition<Definition>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const Service: <Self, Api extends object = never>() => <Id extends string, const Definition extends Definition$1.Any | undefined = undefined>(id: Id, definition: ServiceBindingDefinition<Definition>) => BindingService<Self, Id, ServiceBindingEffectClient<ApiOrDefinition<Api, Definition>, Definition>> & DirectMethods<Self, Definition> & {
-  readonly [TypeId]: typeof TypeId;
-  readonly definition: ServiceBindingDefinition<Definition>;
-  readonly fetch: (input: URL | RequestInfo<unknown, CfProperties<unknown>>, init?: RequestInit<CfProperties<unknown>> | undefined) => Effect.Effect<Response, ServiceBindingFetchError, Self>;
-  readonly rpc: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<Result<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>, ServiceBindingRpcError, Self>;
-  readonly call: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>, ServiceBindingRpcError, Self>;
-  readonly scopedCall: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<Awaited<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>, ServiceBindingRpcError, Self | Scope.Scope>;
-};
+declare const Service: <Self, Api extends object = never>() => <Id extends string, const Definition extends Definition$1.Any | undefined = undefined>(id: Id, definition: ServiceBindingDefinition<Definition>) => ServiceClass<Self, Id, Api, Definition>;
 declare const makeDirectMethods: <R, Api, Definition extends Definition$1.Any | undefined>(rpcDefinition: Definition | undefined, call: ServiceCall<R, Api>) => DirectMethods<R, Definition>;
 //#endregion
-export { Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceBinding_d_exports, ServiceFetcher, isServiceBindingClient, layer, makeClient, makeDirectMethods };
+export { type BindingNotFoundError, type BindingValidationError, Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceBinding_d_exports, ServiceCall, ServiceClass, ServiceFetcher, ServiceRpc, ServiceScopedCall, isServiceBindingClient, layer, makeClient, makeDirectMethods };

package/dist/Vectorize.d.mts

@@ -5,7 +5,7 @@ import * as Effect from "effect/Effect";
 import * as Schema$1 from "effect/Schema";
 import { Layer } from "effect";
 declare namespace Vectorize_d_exports {
-  export { LayerOptions, Tag, TagClass, VectorizeBinding, VectorizeClient, VectorizeDefinition, VectorizeIndexDetails, VectorizeIndexInfo, VectorizeMatch, VectorizeMatches, VectorizeMutation, VectorizeOperation, VectorizeOperationError, VectorizeQueryOptions, VectorizeService, VectorizeValues, VectorizeVector, VectorizeVectorMetadata, VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue, isVectorizeBinding, layer, make, makeClient };
+  export { BindingNotFoundError, BindingValidationError, LayerOptions, Tag, TagClass, VectorizeBinding, VectorizeClient, VectorizeDefinition, VectorizeIndexDetails, VectorizeIndexInfo, VectorizeMatch, VectorizeMatches, VectorizeMutation, VectorizeOperation, VectorizeOperationError, VectorizeQueryOptions, VectorizeService, VectorizeValues, VectorizeVector, VectorizeVectorMetadata, VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue, isVectorizeBinding, layer, make, makeClient };
 }
 type VectorizeOperation = "describe" | "query" | "queryById" | "insert" | "upsert" | "deleteByIds" | "getByIds";
 declare const VectorizeOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
@@ -65,4 +65,4 @@ declare const layer: <Self>(tag: Context$1.Service<Self, VectorizeClient>, defin
 declare const make: <Id extends string>(id: Id) => TagClass<VectorizeService<Id>, Id>;
 declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 //#endregion
-export { LayerOptions, Tag, TagClass, VectorizeBinding, VectorizeClient, VectorizeDefinition, VectorizeIndexDetails, VectorizeIndexInfo, VectorizeMatch, VectorizeMatches, VectorizeMutation, VectorizeOperation, VectorizeOperationError, VectorizeQueryOptions, VectorizeService, VectorizeValues, VectorizeVector, VectorizeVectorMetadata, VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue, Vectorize_d_exports, isVectorizeBinding, layer, make, makeClient };
+export { type BindingNotFoundError, type BindingValidationError, LayerOptions, Tag, TagClass, VectorizeBinding, VectorizeClient, VectorizeDefinition, VectorizeIndexDetails, VectorizeIndexInfo, VectorizeMatch, VectorizeMatches, VectorizeMutation, VectorizeOperation, VectorizeOperationError, VectorizeQueryOptions, VectorizeService, VectorizeValues, VectorizeVector, VectorizeVectorMetadata, VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue, Vectorize_d_exports, isVectorizeBinding, layer, make, makeClient };

package/dist/Worker.d.mts

@@ -1,8 +1,10 @@
 import { WorkerEnv, WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
 import { ReservedMethodName as ReservedMethodName$1 } from "./RpcDefinition.mjs";
 import { QueueHandler } from "./Queue.mjs";
 import { ReceiverOptions, RpcInvocationInfo } from "./RpcTracing.mjs";
-import { Api, Definition, HandlerEffect, Handlers, LayerOptions, Method, Methods, NoReservedMethods, Options, ServerApi, ServiceFreeSchema, Tag, TagClass, implement, method } from "./WorkerDefinition.mjs";
+import { Api, Definition, HandlerEffect, Handlers, LayerOptions, Method, Methods, NativeSchema, NoReservedMethods, Options, RpcSchema, ServerApi, ServiceFreeSchema, Tag, TagClass, implement, method, native } from "./WorkerDefinition.mjs";
+import { ServiceBindingFetchError, ServiceBindingRpcError, ServiceCall, ServiceRpc, ServiceScopedCall } from "./ServiceBinding.mjs";
 import * as Context$1 from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer$1 from "effect/Layer";
@@ -11,7 +13,7 @@ import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
 import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
 import { Cause, Scope } from "effect";
 declare namespace Worker_d_exports {
-  export { Api, Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect, Handlers, LayerOptions, Method, Methods, NativeRequest, NoReservedMethods, Options, ReservedMethodName, RpcHandlers, RunOptions, RunSymbol, ServerApi, ServiceFreeSchema, Tag, TagClass, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcContract, WorkerRpcHandler, WorkerRpcContract as WorkerRpcShape, implement, isWebSocketUpgrade, make, makeFetchHandler, method };
+  export { Api, BindingNotFoundError, BindingValidationError, Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect, Handlers, LayerOptions, Method, Methods, NativeRequest, NativeSchema, NoReservedMethods, Options, ReservedMethodName, RpcHandlers, RpcSchema, RunOptions, RunSymbol, ServerApi, ServiceBindingFetchError, ServiceBindingRpcError, ServiceCall, ServiceFreeSchema, ServiceRpc, ServiceScopedCall, Tag, TagClass, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcContract, WorkerRpcHandler, WorkerRpcContract as WorkerRpcShape, implement, isWebSocketUpgrade, make, makeFetchHandler, method, native };
 }
 declare const ExecutionContext_base: Context$1.ServiceClass<ExecutionContext, "effect-cf/ExecutionContext", globalThis.ExecutionContext<unknown>>;
 declare class ExecutionContext extends ExecutionContext_base {}
@@ -136,4 +138,4 @@ declare function make<ROut, LayerError, REvent extends never = never, EventLayer
 declare function makeFetchHandler<ROut, LayerError, REvent, EventLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer$1.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptionsWithEventLayer<ROut, REvent, EventLayerError>): FetchHandler<Env>;
 declare function makeFetchHandler<ROut, LayerError, REvent extends never = never, EventLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer$1.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptions<ROut, REvent, EventLayerError>): FetchHandler<Env>;
 //#endregion
-export { type Api, type Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, type HandlerEffect, type Handlers, type LayerOptions, type Method, type Methods, NativeRequest, type NoReservedMethods, type Options, ReservedMethodName, RpcHandlers, RunOptions, RunSymbol, type ServerApi, type ServiceFreeSchema, Tag, type TagClass, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcContract, type WorkerRpcContract as WorkerRpcShape, WorkerRpcHandler, Worker_d_exports, implement, isWebSocketUpgrade, make, makeFetchHandler, method };
+export { type Api, type BindingNotFoundError, type BindingValidationError, type Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, type HandlerEffect, type Handlers, type LayerOptions, type Method, type Methods, NativeRequest, type NativeSchema, type NoReservedMethods, type Options, ReservedMethodName, RpcHandlers, type RpcSchema, RunOptions, RunSymbol, type ServerApi, type ServiceBindingFetchError, type ServiceBindingRpcError, type ServiceCall, type ServiceFreeSchema, type ServiceRpc, type ServiceScopedCall, Tag, type TagClass, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcContract, type WorkerRpcContract as WorkerRpcShape, WorkerRpcHandler, Worker_d_exports, implement, isWebSocketUpgrade, make, makeFetchHandler, method, native };

package/dist/Worker.mjs

@@ -6,7 +6,7 @@ import { reservedMethodNames as reservedMethodNames$1 } from "./RpcDefinition.mj
 import { assumeEntrypointClass, defineEntrypointRpcMethods } from "./internal/Entrypoint.mjs";
 import { makeEntrypointRuntime, runEventPromise } from "./internal/Runtime.mjs";
 import { scheduleTelemetryFlush as scheduleTelemetryFlush$1 } from "./internal/Telemetry.mjs";
-import { Tag, implement, method } from "./WorkerDefinition.mjs";
+import { Tag, implement, method, native } from "./WorkerDefinition.mjs";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
@@ -28,7 +28,8 @@ var Worker_exports = /* @__PURE__ */ __exportAll({
 	isWebSocketUpgrade: () => isWebSocketUpgrade,
 	make: () => make,
 	makeFetchHandler: () => makeFetchHandler,
-	method: () => method
+	method: () => method,
+	native: () => native
 });
 var ExecutionContext = class extends Context.Service()("effect-cf/ExecutionContext") {};
 var WorkerContext = class extends Context.Service()("effect-cf/WorkerContext") {};
@@ -139,4 +140,4 @@ function makeFetchHandler(layer, options) {
 	} };
 }
 //#endregion
-export { ExecutionContext, NativeRequest, RunSymbol, Tag, WorkerContext, Worker_exports, implement, isWebSocketUpgrade, make, makeFetchHandler, method };
+export { ExecutionContext, NativeRequest, RunSymbol, Tag, WorkerContext, Worker_exports, implement, isWebSocketUpgrade, make, makeFetchHandler, method, native };

package/dist/WorkerDefinition.d.mts

@@ -1,26 +1,29 @@
 import { WorkerEnvironment } from "./Environment.mjs";
 import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
 import { Provider } from "./Rpc.mjs";
-import { ServiceBindingEffectClient, ServiceBindingStaticClient } from "./ServiceBinding.mjs";
+import { NativeSchema as NativeSchema$1, RpcSchema as RpcSchema$1, SchemaType, WireEncoded, native as native$1 } from "./RpcDefinition.mjs";
+import { ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceCall, ServiceRpc, ServiceScopedCall } from "./ServiceBinding.mjs";
 import { ExecutionContext, ReservedMethodName as ReservedMethodName$1, WorkerClass, WorkerContext, WorkerOptions, WorkerRpcHandler } from "./Worker.mjs";
 import * as Context$1 from "effect/Context";
 import { Layer, Schema } from "effect";
 declare namespace WorkerDefinition_d_exports {
-  export { Api, Definition, HandlerEffect, Handlers, LayerOptions, Method, Methods, NoReservedMethods, Options, ReservedMethodName, ServerApi, ServiceFreeSchema, Tag, TagClass, Worker, implement, make, method };
+  export { Api, BindingNotFoundError, BindingValidationError, Definition, HandlerEffect, Handlers, LayerOptions, Method, Methods, NativeSchema, NoReservedMethods, Options, ReservedMethodName, RpcSchema, ServerApi, ServiceBindingFetchError, ServiceBindingRpcError, ServiceCall, ServiceFreeSchema, ServiceRpc, ServiceScopedCall, Tag, TagClass, Worker, implement, make, method, native };
 }
 type ServiceFreeSchema = Schema.Codec<any, any, never, never>;
-interface Method<Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema = ServiceFreeSchema> {
+type NativeSchema<Schema extends ServiceFreeSchema = ServiceFreeSchema> = NativeSchema$1<Schema>;
+type RpcSchema = RpcSchema$1;
+interface Method<Args extends ReadonlyArray<RpcSchema> = ReadonlyArray<RpcSchema>, Success extends RpcSchema = RpcSchema> {
   readonly args: Args;
   readonly success: Success;
 }
 declare namespace Method {
-  export type Any = Method<ReadonlyArray<ServiceFreeSchema>, ServiceFreeSchema>;
-  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends ReadonlyArray<ServiceFreeSchema>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
-  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = { [Index in keyof Args]: Schema.Json; };
+  export type Any = Method<ReadonlyArray<RpcSchema>, RpcSchema>;
+  type ArgsFromSchemas<Args extends ReadonlyArray<RpcSchema>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends RpcSchema, ...infer Tail extends ReadonlyArray<RpcSchema>] ? [SchemaType<Head>, ...ArgsFromSchemas<Tail>] : Array<SchemaType<Args[number]>>;
+  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> = Schema.Schema.Type<Self["success"]>;
-  export type EncodedSuccess<_Self extends Any> = Schema.Json;
+  export type Success<Self extends Any> = SchemaType<Self["success"]>;
+  export type EncodedSuccess<Self extends Any> = WireEncoded<Self["success"]>;
   export {};
 }
 type Methods = Record<string, Method.Any>;
@@ -77,14 +80,15 @@ type TagClass<Self, Id extends string, MethodDefinitions extends Methods> = Cont
  * Defines a single RPC method schema in a worker definition.
  */
 declare const method: {
-  <Success extends ServiceFreeSchema>(definition: {
+  <Success extends RpcSchema>(definition: {
     readonly success: Success;
   }): Method<readonly [], Success>;
-  <const Args extends ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema>(definition: {
+  <const Args extends ReadonlyArray<RpcSchema>, Success extends RpcSchema>(definition: {
     readonly args: Args;
     readonly success: Success;
   }): Method<Args, Success>;
 };
+declare const native: typeof native$1;
 declare const make: <Id extends string, const MethodDefinitions extends Methods>(id: Id, methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>) => TagClass<Definition<Id, MethodDefinitions>, Id, MethodDefinitions>;
 declare const Tag: <Self>() => <Id extends string, const MethodDefinitions extends Methods>(id: Id, methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>) => TagClass<Self, Id, MethodDefinitions>;
 declare const Worker: typeof Tag;
@@ -97,4 +101,4 @@ declare const implement: <ROut, const Self extends Definition.Any>(_definition:
  */
 type HandlerEffect<ROut, Self extends Definition.Any, Key extends keyof Self["methods"]> = WorkerRpcHandler<ROut, Method.Success<Self["methods"][Key]>>;
 //#endregion
-export { Api, Definition, HandlerEffect, Handlers, LayerOptions, Method, Methods, NoReservedMethods, Options, ReservedMethodName, ServerApi, ServiceFreeSchema, Tag, TagClass, Worker, WorkerDefinition_d_exports, implement, make, method };
+export { Api, type BindingNotFoundError, type BindingValidationError, Definition, HandlerEffect, Handlers, LayerOptions, Method, Methods, NativeSchema, NoReservedMethods, Options, ReservedMethodName, RpcSchema, ServerApi, type ServiceBindingFetchError, type ServiceBindingRpcError, type ServiceCall, ServiceFreeSchema, type ServiceRpc, type ServiceScopedCall, Tag, TagClass, Worker, WorkerDefinition_d_exports, implement, make, method, native };

package/dist/WorkerDefinition.mjs

@@ -1,5 +1,5 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
-import { assertNoReservedMethods, decodeArgs, encodeSuccess, make as make$1, method as method$1 } from "./RpcDefinition.mjs";
+import { assertNoReservedMethods, decodeArgs, encodeSuccess, make as make$1, method as method$1, native as native$1 } from "./RpcDefinition.mjs";
 import { recordDecodedArgs } from "./internal/RpcInvocation.mjs";
 import { layer, makeDirectMethods } from "./ServiceBinding.mjs";
 import { make as make$2 } from "./Worker.mjs";
@@ -11,7 +11,8 @@ var WorkerDefinition_exports = /* @__PURE__ */ __exportAll({
 	Worker: () => Worker,
 	implement: () => implement,
 	make: () => make,
-	method: () => method
+	method: () => method,
+	native: () => native
 });
 const reservedMethodNames = /* @__PURE__ */ new Set([
 	"constructor",
@@ -36,6 +37,7 @@ const assumeTagClass = (value) => {
 * Defines a single RPC method schema in a worker definition.
 */
 const method = method$1;
+const native = native$1;
 const makeDefinition = (id, methods) => {
 	assertNoReservedMethods("Worker", methods, reservedMethodNames);
 	const definition = make$1(id, methods);
@@ -100,4 +102,4 @@ const wrapHandlers = (definition, handlers) => {
 */
 const implement = (_definition, handlers) => handlers;
 //#endregion
-export { Tag, Worker, WorkerDefinition_exports, implement, make, method };
+export { Tag, Worker, WorkerDefinition_exports, implement, make, method, native };

package/dist/WorkersAi.d.mts

@@ -5,7 +5,7 @@ import * as Effect from "effect/Effect";
 import * as S from "effect/Schema";
 import { Layer } from "effect";
 declare namespace WorkersAi_d_exports {
-  export { LayerOptions, Tag, TagClass, WorkersAiAsyncBatchResponse, WorkersAiBinding, WorkersAiClient, WorkersAiDefinition, WorkersAiEmbeddingInput, WorkersAiEmbeddingResponse, WorkersAiModelsSearchObject, WorkersAiModelsSearchParams, WorkersAiOperationError, WorkersAiOptions, WorkersAiService, embeddingResponse, isWorkersAiBinding, layer, make, makeClient };
+  export { BindingNotFoundError, BindingValidationError, LayerOptions, Tag, TagClass, WorkersAiAsyncBatchResponse, WorkersAiBinding, WorkersAiClient, WorkersAiDefinition, WorkersAiEmbeddingInput, WorkersAiEmbeddingResponse, WorkersAiModelsSearchObject, WorkersAiModelsSearchParams, WorkersAiOperationError, WorkersAiOptions, WorkersAiService, embeddingResponse, isWorkersAiBinding, layer, make, makeClient };
 }
 declare const WorkersAiOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "WorkersAiOperationError";
@@ -81,4 +81,4 @@ declare const layer: <Self, ModelList extends AiModelListType = AiModels>(tag: C
 declare const make: <Id extends string>(id: Id) => TagClass<WorkersAiService<Id>, Id, AiModels>;
 declare const Tag: <Self>() => <Id extends string, ModelList extends AiModelListType = AiModels>(id: Id) => TagClass<Self, Id, ModelList>;
 //#endregion
-export { LayerOptions, Tag, TagClass, WorkersAiAsyncBatchResponse, WorkersAiBinding, WorkersAiClient, WorkersAiDefinition, WorkersAiEmbeddingInput, WorkersAiEmbeddingResponse, WorkersAiModelsSearchObject, WorkersAiModelsSearchParams, WorkersAiOperationError, WorkersAiOptions, WorkersAiService, WorkersAi_d_exports, embeddingResponse, isWorkersAiBinding, layer, make, makeClient };
+export { type BindingNotFoundError, type BindingValidationError, LayerOptions, Tag, TagClass, WorkersAiAsyncBatchResponse, WorkersAiBinding, WorkersAiClient, WorkersAiDefinition, WorkersAiEmbeddingInput, WorkersAiEmbeddingResponse, WorkersAiModelsSearchObject, WorkersAiModelsSearchParams, WorkersAiOperationError, WorkersAiOptions, WorkersAiService, WorkersAi_d_exports, embeddingResponse, isWorkersAiBinding, layer, make, makeClient };

package/dist/Workflow.d.mts

@@ -1,6 +1,8 @@
 import { WorkerEnv, WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
 import { ExecutionContext, WorkerContext } from "./Worker.mjs";
-import { Definition as Definition$1, Handler as Handler$1, LayerOptions as LayerOptions$1, Options as Options$1, Tag, TagClass as TagClass$1, implement } from "./WorkflowDefinition.mjs";
+import { WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowOperationError } from "./WorkflowBinding.mjs";
+import { Definition as Definition$1, Handler as Handler$1, LayerOptions as LayerOptions$1, Options as Options$1, Tag, TagClass, implement } from "./WorkflowDefinition.mjs";
 import * as Context$1 from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer$1 from "effect/Layer";
@@ -8,7 +10,7 @@ import * as Cause$1 from "effect/Cause";
 import { WorkflowEntrypoint, WorkflowEvent, WorkflowSleepDuration, WorkflowStep, WorkflowStepConfig, WorkflowStepContext, WorkflowStepEvent, WorkflowTimeoutDuration } from "cloudflare:workers";
 import { Scope } from "effect";
 declare namespace Workflow_d_exports {
-  export { Definition, Handler, LayerOptions, Options, Tag, TagClass, WorkflowClass, WorkflowEvent$1 as WorkflowEvent, WorkflowEventService, WorkflowHandler, WorkflowOptions, WorkflowRunContext, WorkflowStep$1 as WorkflowStep, WorkflowStepContext$1 as WorkflowStepContext, WorkflowStepError, WorkflowStepNonRetryableError, WorkflowStepService, implement, make, sleep, sleepUntil, step, waitForEvent };
+  export { BindingNotFoundError, BindingValidationError, Definition, Handler, LayerOptions, Options, Tag, TagClass, WorkflowClass, WorkflowEvent$1 as WorkflowEvent, WorkflowEventService, WorkflowHandler, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowOperationError, WorkflowOptions, WorkflowRunContext, WorkflowStep$1 as WorkflowStep, WorkflowStepContext$1 as WorkflowStepContext, WorkflowStepError, WorkflowStepNonRetryableError, WorkflowStepService, implement, make, sleep, sleepUntil, step, waitForEvent };
 }
 interface WorkflowEventService<Payload = unknown> {
   readonly raw: WorkflowEvent<unknown>;
@@ -79,8 +81,7 @@ declare namespace Definition {
   type Any = Definition$1.Any;
 }
 type LayerOptions = LayerOptions$1;
-type TagClass<Self, Id extends string, Payload extends Definition$1.Any["payload"], Result extends Definition$1.Any["result"]> = TagClass$1<Self, Id, Payload, Result>;
 type Handler<ROut, Self extends Definition$1.Any> = Handler$1<ROut, Self>;
 type Options<ROut, Self extends Definition$1.Any> = Options$1<ROut, Self>;
 //#endregion
-export { Definition, Handler, LayerOptions, Options, Tag, TagClass, WorkflowClass, WorkflowEvent$1 as WorkflowEvent, WorkflowEventService, WorkflowHandler, WorkflowOptions, WorkflowRunContext, WorkflowStep$1 as WorkflowStep, WorkflowStepContext$1 as WorkflowStepContext, WorkflowStepError, WorkflowStepNonRetryableError, WorkflowStepService, Workflow_d_exports, implement, make, sleep, sleepUntil, step, waitForEvent };
+export { type BindingNotFoundError, type BindingValidationError, Definition, Handler, LayerOptions, Options, Tag, type TagClass, WorkflowClass, WorkflowEvent$1 as WorkflowEvent, WorkflowEventService, WorkflowHandler, type WorkflowInstance, type WorkflowInstanceCreateBatchOptions, type WorkflowInstanceCreateOptions, type WorkflowOperationError, WorkflowOptions, WorkflowRunContext, WorkflowStep$1 as WorkflowStep, WorkflowStepContext$1 as WorkflowStepContext, WorkflowStepError, WorkflowStepNonRetryableError, WorkflowStepService, Workflow_d_exports, implement, make, sleep, sleepUntil, step, waitForEvent };

package/dist/WorkflowDefinition.d.mts

@@ -9,7 +9,7 @@ import * as Effect from "effect/Effect";
 import * as S from "effect/Schema";
 import { Layer } from "effect";
 declare namespace WorkflowDefinition_d_exports {
-  export { Definition, Handler, LayerOptions, Options, Tag, TagClass, Workflow, implement, make };
+  export { BindingNotFoundError, BindingValidationError, Definition, Handler, LayerOptions, Options, Tag, TagClass, Workflow, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowOperationError, implement, make };
 }
 interface Definition<Id extends string = string, Payload extends ServiceFreeSchema = ServiceFreeSchema, Result extends ServiceFreeSchema = ServiceFreeSchema> {
   readonly id: Id;
@@ -26,7 +26,7 @@ interface Options<ROut, Self extends Definition.Any> {
 type LayerOptions = {
   readonly binding: string;
 };
-interface TagClass<Self, Id extends string, Payload extends ServiceFreeSchema, Result extends ServiceFreeSchema> extends Context$1.ServiceClass<Self, `effect-cf/Workflow/${Id}`, WorkflowBindingClient<Payload, Result>> {
+type TagClass<Self, Id extends string, Payload extends ServiceFreeSchema, Result extends ServiceFreeSchema> = Context$1.ServiceClass<Self, `effect-cf/Workflow/${Id}`, WorkflowBindingClient<Payload, Result>> & {
   readonly id: Id;
   readonly payload: Payload;
   readonly result: Result;
@@ -36,7 +36,7 @@ interface TagClass<Self, Id extends string, Payload extends ServiceFreeSchema, R
   readonly createBatch: (batch: WorkflowInstanceCreateBatchOptions<S.Schema.Type<Payload>, S.Codec.Encoded<Payload>>) => Effect.Effect<ReadonlyArray<WorkflowInstance<S.Schema.Type<Result>>>, WorkflowOperationError | S.SchemaError, Self>;
   readonly get: (instanceId: string) => Effect.Effect<WorkflowInstance<S.Schema.Type<Result>>, WorkflowOperationError, Self>;
   readonly rawUnsafe: Effect.Effect<globalThis.Workflow<S.Codec.Encoded<Payload>>, never, Self>;
-}
+};
 declare const make: <Id extends string, Payload extends ServiceFreeSchema, Result extends ServiceFreeSchema>(id: Id, definition: {
   readonly payload: Payload;
   readonly result: Result;
@@ -48,4 +48,4 @@ declare const Tag: <Self>() => <Id extends string, Payload extends ServiceFreeSc
 declare const Workflow: typeof Tag;
 declare const implement: <ROut, const Self extends Definition.Any>(_definition: Self, handler: Handler<ROut, Self>) => Handler<ROut, Self>;
 //#endregion
-export { Definition, Handler, LayerOptions, Options, Tag, TagClass, Workflow, WorkflowDefinition_d_exports, implement, make };
+export { type BindingNotFoundError, type BindingValidationError, Definition, Handler, LayerOptions, Options, Tag, TagClass, Workflow, WorkflowDefinition_d_exports, type WorkflowInstance, type WorkflowInstanceCreateBatchOptions, type WorkflowInstanceCreateOptions, type WorkflowOperationError, implement, make };

package/dist/index.d.mts

@@ -9,8 +9,8 @@ import { QueueBinding_d_exports } from "./QueueBinding.mjs";
 import { QueueDefinition_d_exports } from "./QueueDefinition.mjs";
 import { Queue_d_exports } from "./Queue.mjs";
 import { RpcTracing_d_exports } from "./RpcTracing.mjs";
-import { ServiceBinding_d_exports } from "./ServiceBinding.mjs";
 import { WorkerDefinition_d_exports } from "./WorkerDefinition.mjs";
+import { ServiceBinding_d_exports } from "./ServiceBinding.mjs";
 import { Worker_d_exports } from "./Worker.mjs";
 import { DurableObjectState_d_exports } from "./DurableObjectState.mjs";
 import { Hyperdrive_d_exports } from "./Hyperdrive.mjs";
@@ -25,8 +25,8 @@ import { CloudflareOtlp_d_exports } from "./CloudflareOtlp.mjs";
 import { CloudflareTracer_d_exports } from "./CloudflareTracer.mjs";
 import { D1_d_exports } from "./D1.mjs";
 import { DurableObjectAlarm_d_exports } from "./DurableObjectAlarm.mjs";
-import { DurableObjectNamespace_d_exports } from "./DurableObjectNamespace.mjs";
 import { DurableObjectDefinition_d_exports } from "./DurableObjectDefinition.mjs";
+import { DurableObjectNamespace_d_exports } from "./DurableObjectNamespace.mjs";
 import { DurableObject_d_exports } from "./DurableObject.mjs";
 import { DurableObjectRpcWebSocket_d_exports } from "./DurableObjectRpcWebSocket.mjs";
 import { DurableObjectSqlite_d_exports } from "./DurableObjectSqlite.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.41.1",
+  "version": "0.42.0",
   "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(