effect-cf 0.41.0 → 0.42.0

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/RpcTargets.ts

@@ -1,21 +1,15 @@
-import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Data from "effect/Data";
 import type * as Scope from "effect/Scope";
 import * as Option from "effect/Option";
 
+import { CurrentTargets, type Targets } from "./internal/RpcTargets";
+
 /** A native RPC target could not be constructed. */
 export class RpcTargetError extends Data.TaggedError("RpcTargetError")<{
   readonly cause: unknown;
 }> {}
 
-interface Targets {
-  get<A extends object, Owner extends object>(owner: Owner, address: string, create: () => A): A;
-  invalidate<Target extends object>(target: Target): void;
-}
-
-class CurrentTargets extends Context.Service<CurrentTargets, Targets>()("effect-cf/RpcTargets") {}
-
 /**
  * Reuse a native RPC target within the current invocation. Native Durable Object
  * stubs capture the calling request's channel when created. Recreating a stub