effect-cf 0.20.0 → 0.22.0

package/src/DurableObjectNamespace.ts

@@ -1,9 +1,11 @@
-import { Data, Effect, type Context, type Scope } from "effect";
+import { Data, Effect, type Context, type Layer, type Scope } from "effect";
 
 import * as Binding from "./Binding";
+import type { WorkerEnvironment } from "./Environment";
 import * as CloudflareRpc from "./Rpc";
 import type * as DurableObjectDefinition from "./DurableObjectDefinition";
 import * as RpcDefinition from "./RpcDefinition";
+import * as ErrorMessage from "./internal/ErrorMessage";
 import * as RpcInvocation from "./internal/RpcInvocation";
 
 const expectedDurableObjectNamespace =
@@ -86,7 +88,11 @@ export class DurableObjectRpcError extends Data.TaggedError("DurableObjectRpcErr
   readonly binding: string;
   readonly method: string;
   readonly cause: unknown;
-}> {}
+}> {
+  override get message(): string {
+    return `Durable Object RPC method "${this.method}" failed for binding "${this.binding}": ${ErrorMessage.causeMessage(this.cause)}`;
+  }
+}
 
 /**
  * Failure raised when forwarding a request to a Durable Object stub.
@@ -94,7 +100,11 @@ export class DurableObjectRpcError extends Data.TaggedError("DurableObjectRpcErr
 export class DurableObjectFetchError extends Data.TaggedError("DurableObjectFetchError")<{
   readonly binding: string;
   readonly cause: unknown;
-}> {}
+}> {
+  override get message(): string {
+    return `Durable Object fetch failed for binding "${this.binding}": ${ErrorMessage.causeMessage(this.cause)}`;
+  }
+}
 
 type StubMethodKey<Api> = RpcInvocation.AsyncMethodKey<Api>;
 type StubMethodArgs<Api, Method extends keyof Api> = RpcInvocation.AsyncMethodArgs<Api, Method>;
@@ -316,7 +326,7 @@ export type DurableObjectNamespaceEffectClient<
    * Prefer the typed helpers above unless Cloudflare exposes a platform feature
    * that is not wrapped by effect-cf yet.
    */
-  readonly unsafeRaw: Effect.Effect<DurableObjectNamespaceClient<Api>>;
+  readonly rawUnsafe: Effect.Effect<DurableObjectNamespaceClient<Api>>;
 };
 
 export type DurableObjectNamespaceStaticClient<
@@ -360,7 +370,7 @@ export type DurableObjectNamespaceStaticClient<
     method: Method,
     ...args: StubMethodArgs<Api, Method>
   ) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, unknown, Scope.Scope | R>;
-  readonly unsafeRaw: () => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
+  readonly rawUnsafe: () => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
 };
 
 const hasFunction = (value: object, key: string): boolean =>
@@ -416,104 +426,93 @@ export const makeClient = <
         catch: (cause) => new DurableObjectFetchError({ binding: definition.binding, cause }),
       });
 
-    const rpc = <Method extends StubMethodKey<Api>>(
-      stub: StubClient,
-      method: Method,
-      ...args: StubMethodArgs<Api, Method>
-    ) =>
-      Effect.gen(function* () {
-        const methodName = String(method);
-        const encodedArgs =
-          definition.definition === undefined
-            ? args
-            : yield* RpcDefinition.encodeArgs(
-                definition.definition,
-                methodName as RpcDefinition.Definition.MethodNames<NonNullable<Definition>>,
-                args as never,
-              ).pipe(
-                Effect.mapError(
-                  (cause) =>
-                    new DurableObjectRpcError({
-                      binding: definition.binding,
-                      method: methodName,
-                      cause,
-                    }),
-                ),
-              );
-
-        return yield* RpcInvocation.invokeRpcMethod(
-          stub,
-          method,
-          encodedArgs as StubMethodArgs<Api, Method>,
+    const rpc = Effect.fn("DurableObjectNamespace.rpc")(function* <
+      Method extends StubMethodKey<Api>,
+    >(stub: StubClient, method: Method, ...args: StubMethodArgs<Api, Method>) {
+      const methodName = String(method);
+      const encodedArgs =
+        definition.definition === undefined
+          ? args
+          : yield* RpcDefinition.encodeArgs(
+              definition.definition,
+              methodName as RpcDefinition.Definition.MethodNames<NonNullable<Definition>>,
+              args as never,
+            ).pipe(
+              Effect.mapError(
+                (cause) =>
+                  new DurableObjectRpcError({
+                    binding: definition.binding,
+                    method: methodName,
+                    cause,
+                  }),
+              ),
+            );
+
+      return yield* RpcInvocation.invokeRpcMethod(
+        stub,
+        method,
+        encodedArgs as StubMethodArgs<Api, Method>,
+        (cause) =>
+          new DurableObjectRpcError({
+            binding: definition.binding,
+            method: methodName,
+            cause,
+          }),
+      );
+    });
+
+    const decodeSuccess = Effect.fn("DurableObjectNamespace.decodeSuccess")(function* <
+      Method extends StubMethodKey<Api>,
+    >(methodName: string, value: Awaited<StubMethodCloudflareReturn<Api, Method>>) {
+      if (definition.definition === undefined) {
+        return value as StubMethodSuccess<Api, Method>;
+      }
+
+      const decoded = yield* RpcDefinition.decodeSuccess(
+        definition.definition,
+        methodName as RpcDefinition.Definition.MethodNames<NonNullable<Definition>>,
+        value,
+      ).pipe(
+        Effect.mapError(
           (cause) =>
             new DurableObjectRpcError({
               binding: definition.binding,
               method: methodName,
               cause,
             }),
-        );
-      });
+        ),
+      );
 
-    const decodeSuccess = <Method extends StubMethodKey<Api>>(
-      methodName: string,
-      value: Awaited<StubMethodCloudflareReturn<Api, Method>>,
-    ) =>
-      Effect.gen(function* () {
-        if (definition.definition === undefined) {
-          return value as StubMethodSuccess<Api, Method>;
-        }
-
-        const decoded = yield* RpcDefinition.decodeSuccess(
-          definition.definition,
-          methodName as RpcDefinition.Definition.MethodNames<NonNullable<Definition>>,
-          value,
-        ).pipe(
-          Effect.mapError(
-            (cause) =>
-              new DurableObjectRpcError({
-                binding: definition.binding,
-                method: methodName,
-                cause,
-              }),
-          ),
-        );
-
-        return decoded as StubMethodSuccess<Api, Method>;
-      });
+      return decoded as StubMethodSuccess<Api, Method>;
+    });
 
-    const call = <Method extends StubMethodKey<Api>>(
-      stub: StubClient,
-      method: Method,
-      ...args: StubMethodArgs<Api, Method>
-    ) =>
-      Effect.gen(function* () {
-        const methodName = String(method);
-        const value = yield* CloudflareRpc.resolve(yield* rpc(stub, method, ...args)).pipe(
-          Effect.mapError(
-            (cause) =>
-              new DurableObjectRpcError({
-                binding: definition.binding,
-                method: methodName,
-                cause,
-              }),
-          ),
-        );
-
-        return yield* decodeSuccess<Method>(methodName, value);
-      });
+    const call = Effect.fn("DurableObjectNamespace.call")(function* <
+      Method extends StubMethodKey<Api>,
+    >(stub: StubClient, method: Method, ...args: StubMethodArgs<Api, Method>) {
+      const methodName = String(method);
+      const value = yield* CloudflareRpc.resolve(yield* rpc(stub, method, ...args)).pipe(
+        Effect.mapError(
+          (cause) =>
+            new DurableObjectRpcError({
+              binding: definition.binding,
+              method: methodName,
+              cause,
+            }),
+        ),
+      );
 
-    const scopedCall = <Method extends StubMethodKey<Api>>(
-      stub: StubClient,
-      method: Method,
-      ...args: StubMethodArgs<Api, Method>
-    ) =>
-      Effect.gen(function* () {
-        const methodName = String(method);
-        const result = yield* rpc(stub, method, ...args);
-        const value = yield* CloudflareRpc.scoped(result);
-
-        return yield* decodeSuccess<Method>(methodName, value);
-      });
+      return yield* decodeSuccess<Method>(methodName, value);
+    });
+
+    const scopedCall = Effect.fn("DurableObjectNamespace.scopedCall")(function* <
+      Method extends StubMethodKey<Api>,
+    >(stub: StubClient, method: Method, ...args: StubMethodArgs<Api, Method>) {
+      const methodName = String(method);
+      const result = yield* rpc(stub, method, ...args);
+      const value = yield* CloudflareRpc.scoped(result);
+
+      return yield* decodeSuccess<Method>(methodName, value);
+    });
 
     const directMethods = makeDirectMethods<never, Api, Definition>(definition.definition, {
       call,
@@ -533,7 +532,7 @@ export const makeClient = <
       rpc,
       call,
       scopedCall,
-      unsafeRaw: Effect.succeed(namespace),
+      rawUnsafe: Effect.succeed(namespace),
     }) as DurableObjectNamespaceEffectClient<Api, Definition>;
   };
 };
@@ -545,7 +544,11 @@ export const layer = <
 >(
   tag: Context.Service<Self, DurableObjectNamespaceEffectClient<Api, Definition>>,
   definition: DurableObjectNamespaceBindingDefinition<Definition>,
-) =>
+): Layer.Layer<
+  Self,
+  Binding.BindingNotFoundError | Binding.BindingValidationError,
+  WorkerEnvironment
+> =>
   Binding.layer(
     tag,
     definition.binding,

package/src/DurableObjectRpcWebSocket.ts

@@ -1,4 +1,4 @@
-import { Context, Effect, Layer, Option, Queue } from "effect";
+import { Context, Effect, Layer, Predicate, Queue } from "effect";
 import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
 import * as RpcServer from "effect/unstable/rpc/RpcServer";
@@ -52,7 +52,13 @@ export class DurableObjectRpcWebSocket extends Context.Service<
 /**
  * Builds a layer that bridges Durable Object websocket events to `RpcServer.Protocol`.
  */
-export const layer = (options: LayerOptions = {}) =>
+export const layer = (
+  options: LayerOptions = {},
+): Layer.Layer<
+  RpcServer.Protocol | DurableObjectRpcWebSocket,
+  never,
+  DurableObjectState | RpcSerialization.RpcSerialization
+> =>
   Layer.effectContext(
     Effect.gen(function* () {
       const tag = options.tag ?? defaultTag;
@@ -156,7 +162,7 @@ export const layer = (options: LayerOptions = {}) =>
               connection?.socket.raw.close();
             }),
           clientIds: Effect.sync(() => clientIds),
-          initialMessage: Effect.succeed(Option.none()),
+          initialMessage: Effect.succeedNone,
           supportsAck: true,
           supportsTransferables: false,
           supportsSpanPropagation: true,
@@ -174,7 +180,7 @@ export const layer = (options: LayerOptions = {}) =>
             const connection = register(socket);
             const decoded = yield* Effect.try({
               try: () => connection.parser.decode(normalizeMessage(message)),
-              catch: RpcMessage.ResponseDefectEncoded,
+              catch: (cause) => cause,
             });
 
             const run = writeRequest;
@@ -189,10 +195,12 @@ export const layer = (options: LayerOptions = {}) =>
               yield* run(connection.id, current as RpcMessage.FromClientEncoded);
             }
           }).pipe(
-            Effect.catch((error) => {
+            Effect.catch((cause) => {
               const connection = register(socket);
 
-              return send(connection, error);
+              return Predicate.isTagged(cause, "MaxBufferSizeExceeded")
+                ? Effect.ignore(connection.socket.close(1009, String(cause)))
+                : send(connection, RpcMessage.ResponseDefectEncoded(cause));
             }),
           ),
         close: unregister,

package/src/DurableObjectSqlite.ts

@@ -1,10 +1,11 @@
 import { SqliteClient } from "@effect/sql-sqlite-do";
 import { Effect, Layer } from "effect";
+import type { SqlClient } from "effect/unstable/sql";
 
 import { DurableObjectState } from "./DurableObjectState";
 
 /** Options forwarded to `@effect/sql-sqlite-do` when building a SQL client layer. */
-export type SqliteLayerOptions = Omit<SqliteClient.SqliteClientConfig, "db">;
+export type SqliteLayerOptions = Omit<SqliteClient.SqliteClientConfig, "db" | "storage">;
 
 /**
  * Provides `effect/unstable/sql` from the current Durable Object SQLite storage.
@@ -17,11 +18,13 @@ export type SqliteLayerOptions = Omit<SqliteClient.SqliteClientConfig, "db">;
  * );
  * ```
  */
-export const layer = (options?: SqliteLayerOptions) =>
+export const layer = (
+  options?: SqliteLayerOptions,
+): Layer.Layer<SqliteClient.SqliteClient | SqlClient.SqlClient, never, DurableObjectState> =>
   Layer.unwrap(
     Effect.gen(function* () {
       const state = yield* DurableObjectState;
 
-      return SqliteClient.layer({ ...options, db: state.raw.storage.sql });
+      return SqliteClient.layer({ ...options, storage: state.raw.storage });
     }),
   );

package/src/DurableObjectState.ts

@@ -81,9 +81,7 @@ export const fromDurableObjectState = (
     Effect.context<R>().pipe(
       Effect.flatMap((context) =>
         Effect.promise(() =>
-          state.blockConcurrencyWhile(() =>
-            runPromiseExitPreservingTypedFailures(Effect.provideContext(effect, context)),
-          ),
+          state.blockConcurrencyWhile(() => runPromiseExitPreservingTypedFailures(context, effect)),
         ),
       ),
       Effect.flatten,
@@ -92,9 +90,7 @@ export const fromDurableObjectState = (
     Effect.context<R>().pipe(
       Effect.flatMap((context) =>
         Effect.promise(() =>
-          state.blockConcurrencyWhile(() =>
-            Effect.runPromise(Effect.provideContext(effect, context)),
-          ),
+          state.blockConcurrencyWhile(() => Effect.runPromiseWith(context)(effect)),
         ),
       ),
     ),
@@ -116,10 +112,11 @@ export const fromDurableObjectState = (
   abort: (reason?: string) => Effect.sync(() => state.abort(reason)),
 });
 
-const runPromiseExitPreservingTypedFailures = async <A, E>(
-  effect: Effect.Effect<A, E>,
+const runPromiseExitPreservingTypedFailures = async <A, E, R>(
+  context: Context.Context<R>,
+  effect: Effect.Effect<A, E, R>,
 ): Promise<Exit.Exit<A, E>> => {
-  const exit = await Effect.runPromiseExit(effect);
+  const exit = await Effect.runPromiseExitWith(context)(effect);
 
   if (Exit.isFailure(exit) && (Cause.hasDies(exit.cause) || Cause.hasInterrupts(exit.cause))) {
     throw Cause.squash(exit.cause);

package/src/DurableObjectStorage.ts

@@ -1,5 +1,7 @@
 import { Data, Effect, Exit, Option, Schema as S } from "effect";
 
+import * as ErrorMessage from "./internal/ErrorMessage";
+
 /** Supported primitive value types for Durable Object SQL APIs. */
 export type SqlStorageValue = globalThis.SqlStorageValue;
 
@@ -7,7 +9,11 @@ export type SqlStorageValue = globalThis.SqlStorageValue;
 export class StorageOperationError extends Data.TaggedError("StorageOperationError")<{
   readonly operation: string;
   readonly cause: unknown;
-}> {}
+}> {
+  override get message(): string {
+    return `Durable Object storage ${this.operation} failed: ${ErrorMessage.causeMessage(this.cause)}`;
+  }
+}
 
 type StorageEffect<A> = Effect.Effect<A, StorageOperationError>;
 

package/src/DurableObjectWebSocket.ts

@@ -1,6 +1,7 @@
-import { Data, Effect, Option, Schema as S } from "effect";
+import { Data, Effect, Option, Result, Schema as S } from "effect";
 
 import { DurableObjectState } from "./DurableObjectState";
+import * as ErrorMessage from "./internal/ErrorMessage";
 
 /** Data supported by Cloudflare websocket `send`. */
 export type DurableWebSocketSendData = string | ArrayBuffer | ArrayBufferView;
@@ -8,12 +9,20 @@ export type DurableWebSocketSendData = string | ArrayBuffer | ArrayBufferView;
 /** Error raised when sending on a Durable Object websocket fails. */
 export class DurableWebSocketSendError extends Data.TaggedError("DurableWebSocketSendError")<{
   readonly cause: unknown;
-}> {}
+}> {
+  override get message(): string {
+    return `Durable Object websocket send failed: ${ErrorMessage.causeMessage(this.cause)}`;
+  }
+}
 
 /** Error raised when closing a Durable Object websocket fails. */
 export class DurableWebSocketCloseError extends Data.TaggedError("DurableWebSocketCloseError")<{
   readonly cause: unknown;
-}> {}
+}> {
+  override get message(): string {
+    return `Durable Object websocket close failed: ${ErrorMessage.causeMessage(this.cause)}`;
+  }
+}
 
 /** Error raised when serializing or deserializing a websocket attachment fails. */
 export class DurableWebSocketAttachmentError extends Data.TaggedError(
@@ -21,7 +30,11 @@ export class DurableWebSocketAttachmentError extends Data.TaggedError(
 )<{
   readonly operation: "serialize" | "deserialize";
   readonly cause: unknown;
-}> {}
+}> {
+  override get message(): string {
+    return `Durable Object websocket attachment ${this.operation} failed: ${ErrorMessage.causeMessage(this.cause)}`;
+  }
+}
 
 /** Effect-native wrapper around a hibernatable Durable Object websocket. */
 export interface DurableWebSocket<Attachment = unknown> {
@@ -110,33 +123,35 @@ export interface AcceptedUpgrade<Attachment = unknown> {
  * return response.response;
  * ```
  */
-export const acceptUpgrade = <Attachment = unknown>(
+export const acceptUpgrade = Effect.fn("DurableObjectWebSocket.acceptUpgrade")(function* <
+  Attachment = unknown,
+>(
   options: AcceptUpgradeOptions<Attachment> = {},
-): Effect.Effect<AcceptedUpgrade<Attachment>, never, DurableObjectState> =>
-  Effect.gen(function* () {
-    const state = yield* DurableObjectState;
-    const pair = new WebSocketPair();
-    const client = pair[0];
-    const server = fromWebSocket<Attachment>(pair[1]);
-
-    if (options.attachment !== undefined) {
-      server.raw.serializeAttachment(options.attachment);
-    }
-
-    yield* state.acceptWebSocket(
-      server,
-      options.tags === undefined ? undefined : [...options.tags],
-    );
+): Effect.fn.Return<
+  AcceptedUpgrade<Attachment>,
+  DurableWebSocketAttachmentError,
+  DurableObjectState
+> {
+  const state = yield* DurableObjectState;
+  const pair = new WebSocketPair();
+  const client = pair[0];
+  const server = fromWebSocket<Attachment>(pair[1]);
+
+  if (options.attachment !== undefined) {
+    yield* server.serializeAttachment(options.attachment);
+  }
 
-    return {
-      client,
-      server,
-      response: new Response(null, {
-        status: 101,
-        webSocket: client,
-      }),
-    };
-  });
+  yield* state.acceptWebSocket(server, options.tags === undefined ? undefined : [...options.tags]);
+
+  return {
+    client,
+    server,
+    response: new Response(null, {
+      status: 101,
+      webSocket: client,
+    }),
+  };
+});
 
 export type AttachmentInvalidPolicy = "ignore" | "ignore-and-close" | "fail";
 
@@ -213,23 +228,18 @@ export const attachment = <const AttachmentSchema extends S.Codec<any, any, neve
       const onInvalid = options.onInvalid ?? "ignore";
 
       for (const socket of sockets) {
-        const decoded = yield* deserialize(socket).pipe(
-          Effect.match({
-            onFailure: (error) => ({ _tag: "Failure" as const, error }),
-            onSuccess: (value) => ({ _tag: "Success" as const, value }),
-          }),
-        );
-
-        if (decoded._tag === "Success" && Option.isSome(decoded.value)) {
-          restored.push({ socket, attachment: decoded.value.value });
+        const decoded = yield* Effect.result(deserialize(socket));
+
+        if (Result.isSuccess(decoded) && Option.isSome(decoded.success)) {
+          restored.push({ socket, attachment: decoded.success.value });
           continue;
         }
 
-        if (decoded._tag === "Failure" && onInvalid === "fail") {
-          return yield* Effect.fail(decoded.error);
+        if (Result.isFailure(decoded) && onInvalid === "fail") {
+          return yield* Effect.fail(decoded.failure);
         }
 
-        if (decoded._tag === "Failure" && onInvalid === "ignore-and-close") {
+        if (Result.isFailure(decoded) && onInvalid === "ignore-and-close") {
           yield* socket.close(1008, "invalid websocket attachment").pipe(Effect.ignore);
         }
       }

package/src/Email.ts

@@ -9,6 +9,7 @@ import { Context, Data, Effect, type Layer } from "effect";
 
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
+import * as ErrorMessage from "./internal/ErrorMessage";
 
 const expectedSendEmailBinding = "Send Email binding with send()";
 const textEncoder = new TextEncoder();
@@ -27,7 +28,14 @@ export const sendLimits = {
   maxAllowlistHeaders: 20,
 } as const;
 
-/** Error codes reported by Cloudflare Email Sending. */
+/**
+ * Error codes reported by Cloudflare Email Sending.
+ *
+ * Surfaced on {@link EmailOperationError} `code` on a best-effort basis: the
+ * runtime attaches them as a non-standard `code` property on thrown errors,
+ * which may be missing depending on the runtime or dev-time proxying
+ * (miniflare remote bindings serialize errors and can strip it).
+ */
 export const emailErrorCodes = [
   "E_VALIDATION_ERROR",
   "E_FIELD_MISSING",
@@ -59,9 +67,21 @@ export class EmailOperationError extends Data.TaggedError("EmailOperationError")
   readonly binding: string;
   readonly operation: string;
   readonly cause: unknown;
-  /** Cloudflare error code taken from the thrown error, when present. */
+  /**
+   * Cloudflare error code taken from the thrown error, when present.
+   *
+   * Best-effort: may be `undefined` depending on the runtime or dev-time
+   * proxying — miniflare remote bindings (`"remote": true`) serialize thrown
+   * errors and can strip the non-standard `code` property.
+   */
   readonly code?: EmailErrorCode | (string & {});
-}> {}
+}> {
+  override get message(): string {
+    const code = this.code === undefined ? "" : ` (${this.code})`;
+
+    return `Email ${this.operation} failed for binding "${this.binding}"${code}: ${ErrorMessage.causeMessage(this.cause)}`;
+  }
+}
 
 /** A single message field that violates a documented Email Sending limit. */
 export interface EmailViolation {
@@ -76,7 +96,11 @@ export class EmailValidationError extends Data.TaggedError("EmailValidationError
   readonly binding: string;
   readonly operation: string;
   readonly violations: ReadonlyArray<EmailViolation>;
-}> {}
+}> {
+  override get message(): string {
+    return `Email ${this.operation} for binding "${this.binding}" failed validation: ${ErrorMessage.violationsMessage(this.violations)}`;
+  }
+}
 
 /** Typed Cloudflare Send Email binding definition. */
 export interface EmailDefinition {
@@ -108,7 +132,7 @@ export interface EmailClient {
     (message: EmailMessage): Effect.Effect<EmailSendResult, EmailSendError>;
     (builder: EmailMessageBuilder): Effect.Effect<EmailSendResult, EmailSendError>;
   };
-  readonly unsafeRaw: Effect.Effect<EmailBinding>;
+  readonly rawUnsafe: Effect.Effect<EmailBinding>;
   readonly definition: EmailDefinition;
 }
 
@@ -141,6 +165,12 @@ export interface TagClass<Self, Id extends string> extends Context.ServiceClass<
   >;
 }
 
+/**
+ * Best-effort extraction of the Cloudflare error `code` from a thrown error.
+ * Returns `undefined` when the property is absent — e.g. when a dev-time
+ * proxy such as a miniflare remote binding (`"remote": true`) serializes the
+ * error and strips non-standard properties.
+ */
 const emailErrorCode = (cause: unknown): EmailOperationError["code"] => {
   if (typeof cause !== "object" || cause === null) {
     return undefined;
@@ -439,21 +469,18 @@ export const makeClient =
   (email: EmailBinding): EmailClient => {
     const runtime = email as EmailRuntimeBinding;
     const validate = options?.validate ?? true;
-    const send = ((message: EmailSendInput) => {
-      const dispatch = () =>
-        tryEmailPromise(definition.binding, "send", () => runtime.send(message));
-
-      if (!validate || !isEmailMessageBuilder(message)) {
-        return dispatch();
+    const send = Effect.fn("Email.send")(function* (message: EmailSendInput) {
+      if (validate && isEmailMessageBuilder(message)) {
+        yield* validateSendInput(definition.binding, "send", message);
       }
 
-      return validateSendInput(definition.binding, "send", message).pipe(Effect.flatMap(dispatch));
+      return yield* tryEmailPromise(definition.binding, "send", () => runtime.send(message));
     }) as EmailClient["send"];
 
     return {
       definition,
       send,
-      unsafeRaw: Effect.succeed(email),
+      rawUnsafe: Effect.succeed(email),
     };
   };