effect-cf 0.20.1 → 0.23.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

@@ -2,6 +2,8 @@ import { Cause, Context, Effect, Exit } from "effect";
 
 import { fromDurableObjectStorage, type DurableObjectStorage } from "./DurableObjectStorage";
 import { fromWebSocket, type DurableWebSocket } from "./DurableObjectWebSocket";
+import type { WorkerContextWaitUntilOptions } from "./Worker";
+import { makeWaitUntilScheduler } from "./internal/WorkerContext";
 
 /**
  * Effect-friendly wrapper around Cloudflare `DurableObjectState`.
@@ -15,6 +17,16 @@ export interface DurableObjectStateService {
   readonly storage: DurableObjectStorage;
   /** Registers background work with Cloudflare's lifecycle. */
   waitUntil(promise: Promise<unknown>): Effect.Effect<void>;
+  /**
+   * Runs a background Effect via Cloudflare's `waitUntil` with the caller's
+   * Effect context, mirroring `WorkerContext.waitUntil` failure modes:
+   * `"observe"` (default) logs or routes failures to `onFailure`, while
+   * `"propagate"` also rejects the native `waitUntil` promise.
+   */
+  waitUntil<A, E, R, R2 = never>(
+    effect: Effect.Effect<A, E, R>,
+    options?: WorkerContextWaitUntilOptions<E, R2>,
+  ): Effect.Effect<void, never, R | R2>;
   /**
    * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate.
    *
@@ -72,54 +84,66 @@ export class DurableObjectState extends Context.Service<
  */
 export const fromDurableObjectState = (
   state: globalThis.DurableObjectState,
-): DurableObjectStateService => ({
-  raw: state,
-  id: state.id,
-  storage: fromDurableObjectStorage(state.storage),
-  waitUntil: (promise: Promise<unknown>) => Effect.sync(() => state.waitUntil(promise)),
-  blockConcurrencyWhile: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-    Effect.context<R>().pipe(
-      Effect.flatMap((context) =>
-        Effect.promise(() =>
-          state.blockConcurrencyWhile(() =>
-            runPromiseExitPreservingTypedFailures(Effect.provideContext(effect, context)),
+): DurableObjectStateService => {
+  const scheduleWaitUntil = makeWaitUntilScheduler("DurableObjectState.waitUntil", (promise) =>
+    state.waitUntil(promise),
+  );
+  const waitUntil = (<A, E, R, R2 = never>(
+    input: Promise<unknown> | Effect.Effect<A, E, R>,
+    options?: WorkerContextWaitUntilOptions<E, R2>,
+  ) =>
+    Effect.isEffect(input)
+      ? scheduleWaitUntil(input, options, options?.mode ?? "observe")
+      : Effect.sync(() => state.waitUntil(input))) as DurableObjectStateService["waitUntil"];
+
+  return {
+    raw: state,
+    id: state.id,
+    storage: fromDurableObjectStorage(state.storage),
+    waitUntil,
+    blockConcurrencyWhile: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+      Effect.context<R>().pipe(
+        Effect.flatMap((context) =>
+          Effect.promise(() =>
+            state.blockConcurrencyWhile(() =>
+              runPromiseExitPreservingTypedFailures(context, effect),
+            ),
           ),
         ),
+        Effect.flatten,
       ),
-      Effect.flatten,
-    ),
-  blockConcurrencyWhileOrReset: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-    Effect.context<R>().pipe(
-      Effect.flatMap((context) =>
-        Effect.promise(() =>
-          state.blockConcurrencyWhile(() =>
-            Effect.runPromise(Effect.provideContext(effect, context)),
+    blockConcurrencyWhileOrReset: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+      Effect.context<R>().pipe(
+        Effect.flatMap((context) =>
+          Effect.promise(() =>
+            state.blockConcurrencyWhile(() => Effect.runPromiseWith(context)(effect)),
           ),
         ),
       ),
+    acceptWebSocket: (ws: DurableWebSocket, tags?: Array<string>) =>
+      Effect.sync(() => state.acceptWebSocket(ws.raw, tags)),
+    getWebSockets: (tag?: string) =>
+      Effect.sync(() => state.getWebSockets(tag).map((socket) => fromWebSocket(socket))),
+    setWebSocketAutoResponse: (pair?: WebSocketRequestResponsePair) =>
+      Effect.sync(() => state.setWebSocketAutoResponse(pair)),
+    getWebSocketAutoResponse: Effect.sync(() => state.getWebSocketAutoResponse()),
+    getWebSocketAutoResponseTimestamp: (ws: DurableWebSocket) =>
+      Effect.sync(() => state.getWebSocketAutoResponseTimestamp(ws.raw)),
+    setHibernatableWebSocketEventTimeout: (timeoutMs?: number) =>
+      Effect.sync(() => state.setHibernatableWebSocketEventTimeout(timeoutMs)),
+    getHibernatableWebSocketEventTimeout: Effect.sync(() =>
+      state.getHibernatableWebSocketEventTimeout(),
     ),
-  acceptWebSocket: (ws: DurableWebSocket, tags?: Array<string>) =>
-    Effect.sync(() => state.acceptWebSocket(ws.raw, tags)),
-  getWebSockets: (tag?: string) =>
-    Effect.sync(() => state.getWebSockets(tag).map((socket) => fromWebSocket(socket))),
-  setWebSocketAutoResponse: (pair?: WebSocketRequestResponsePair) =>
-    Effect.sync(() => state.setWebSocketAutoResponse(pair)),
-  getWebSocketAutoResponse: Effect.sync(() => state.getWebSocketAutoResponse()),
-  getWebSocketAutoResponseTimestamp: (ws: DurableWebSocket) =>
-    Effect.sync(() => state.getWebSocketAutoResponseTimestamp(ws.raw)),
-  setHibernatableWebSocketEventTimeout: (timeoutMs?: number) =>
-    Effect.sync(() => state.setHibernatableWebSocketEventTimeout(timeoutMs)),
-  getHibernatableWebSocketEventTimeout: Effect.sync(() =>
-    state.getHibernatableWebSocketEventTimeout(),
-  ),
-  getTags: (ws: DurableWebSocket) => Effect.sync(() => state.getTags(ws.raw)),
-  abort: (reason?: string) => Effect.sync(() => state.abort(reason)),
-});
+    getTags: (ws: DurableWebSocket) => Effect.sync(() => state.getTags(ws.raw)),
+    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);
         }
       }