effect-cf 0.34.0 → 0.36.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.34.0",
+  "version": "0.36.0",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {
@@ -27,6 +27,11 @@
       "import": "./dist/HyperdrivePg.mjs",
       "default": "./dist/HyperdrivePg.mjs"
     },
+    "./mcp": {
+      "types": "./dist/Mcp.d.mts",
+      "import": "./dist/Mcp.mjs",
+      "default": "./dist/Mcp.mjs"
+    },
     "./computer-artifacts": {
       "types": "./dist/ComputerArtifacts.d.mts",
       "import": "./dist/ComputerArtifacts.mjs",
@@ -75,6 +80,8 @@
     "@effect/sql-pg": "catalog:",
     "@effect/sql-sqlite-do": "catalog:",
     "@effect/vitest": "catalog:",
+    "@modelcontextprotocol/client": "^2.0.0",
+    "@modelcontextprotocol/server": "^2.0.0",
     "@platformatic/vfs": "^0.4.0",
     "effect": "catalog:",
     "esbuild": "^0.28.1",
@@ -89,6 +96,7 @@
     "@effect/sql-d1": "^4.0.0-rc.110",
     "@effect/sql-pg": "^4.0.0-rc.110",
     "@effect/sql-sqlite-do": "^4.0.0-rc.110",
+    "@modelcontextprotocol/server": "^2.0.0",
     "effect": "^4.0.0-rc.110"
   },
   "peerDependenciesMeta": {
@@ -106,6 +114,9 @@
     },
     "@effect/sql-pg": {
       "optional": true
+    },
+    "@modelcontextprotocol/server": {
+      "optional": true
     }
   }
 }

package/src/AnalyticsEngine.ts

@@ -572,7 +572,14 @@ const executeQueryRequest = (
   options?: AnalyticsEngineQueryOptions,
 ) =>
   Effect.gen(function* () {
-    const response = yield* httpClient.execute(queryRequest(definition, sql, options)).pipe(
+    const request = yield* Effect.try({
+      try: () => queryRequest(definition, sql, options),
+      catch: (cause) =>
+        analyticsEngineQueryError(definition, "query", "Invalid Analytics Engine SQL API URL", {
+          cause,
+        }),
+    });
+    const response = yield* httpClient.execute(request).pipe(
       Effect.mapError((cause) =>
         analyticsEngineQueryError(definition, "query", "Analytics Engine SQL API request failed", {
           cause,

package/src/CloudflareOtlp.ts

@@ -1,7 +1,8 @@
 /**
- * Worker fetch/RPC and Durable Object alarm/RPC handlers schedule a best-effort
- * flusher. It settles within two seconds; queues and other lifecycles must
- * flush explicitly. Failures are ignored so telemetry cannot fail user events.
+ * Worker fetch/queue/RPC and Durable Object alarm/RPC handlers schedule a
+ * best-effort flusher. It settles within two seconds; other lifecycles must
+ * flush explicitly. Scheduled flush failures cannot fail user events. Exporter
+ * layer finalizers run separately and follow their configured shutdown timeout.
  */
 import { ConfigProvider, Effect, Layer, Option } from "effect";
 import type * as Tracer from "effect/Tracer";
@@ -207,6 +208,8 @@ export const layerProtobuf = (
  *
  * Provide this layer at runtime scope for long-lived metrics aggregation, or at
  * handler scope when traces/logs should flush as the Cloudflare event finishes.
+ * A handler-scoped exporter can delay scope closure while its own finalizer
+ * flushes; the two-second background flush limit does not bound layer shutdown.
  */
 export const layerWorker = (options: WorkerLayerOptions = {}): Layer.Layer<OtlpExporter.Flusher> =>
   makeLayer(options, {

package/src/ComputerWorkspace.ts

@@ -100,6 +100,17 @@ export class WorkspaceAssetsError extends Schema.TaggedError<WorkspaceAssetsErro
   },
 ) {}
 
+/** Schema-serializable error while acquiring the Computer workspace client. */
+export class WorkspaceAcquireError extends Schema.TaggedError<WorkspaceAcquireError>()(
+  "WorkspaceAcquireError",
+  {
+    operation: Schema.String,
+    message: Schema.String,
+    code: Schema.optionalKey(Schema.String),
+    cause: Schema.optionalKey(Schema.Defect({ includeStack: true })),
+  },
+) {}
+
 export type WorkspaceReadFileOptions = Omit<CloudflareReadFileOptions, "encoding">;
 export type ReadTextFileOptions = WorkspaceReadFileOptions;
 export type ListDirectoryOptions = CloudflareReaddirOptions;
@@ -469,6 +480,21 @@ const execError = (operation: string, cause: unknown) => {
   return WorkspaceExecError.make(properties);
 };
 
+const acquireError = (operation: string, cause: unknown) => {
+  const properties: WorkspaceOperationErrorProperties = {
+    operation,
+    message: errorMessage(cause),
+    cause,
+  };
+  const code = errorCode(cause);
+
+  if (code !== undefined) {
+    properties.code = code;
+  }
+
+  return WorkspaceAcquireError.make(properties);
+};
+
 const assetsError = (operation: string, path: string, cause: unknown) => {
   const properties: WorkspaceFsErrorProperties = {
     operation,
@@ -887,9 +913,6 @@ const wrapRun = <Encoding extends WorkspaceExecEncoding>(
   return { id: handle.id, backend: handle.backend, events, result, kill };
 };
 
-const releaseRun = (handle: CloudflareWorkspaceRuntimeExecHandle<"utf8" | undefined>) =>
-  Effect.sync(() => handle[Symbol.dispose]());
-
 const makeRuntime = (client: CloudflareWorkspaceClient): ComputerWorkspaceRuntime => {
   const execImplementation = Effect.fn("ComputerWorkspace.runtime.exec", {
     attributes: { family: "runtime", operation: "exec" },
@@ -905,7 +928,7 @@ const makeRuntime = (client: CloudflareWorkspaceClient): ComputerWorkspaceRuntim
       : undefined;
 
     yield* Effect.annotateCurrentSpan({ backend: options?.backend, runId: options?.id });
-    const handle = yield* Effect.acquireRelease(
+    const handle = yield* Effect.acquireDisposable(
       Effect.tryPromise({
         try: () => {
           if (Predicate.isString(source)) {
@@ -926,7 +949,6 @@ const makeRuntime = (client: CloudflareWorkspaceClient): ComputerWorkspaceRuntim
         },
         catch: (cause) => execError("exec", cause),
       }),
-      releaseRun,
     );
 
     // SAFETY: runtimeExecOptions carries Encoding to Cloudflare's corresponding handle overload.
@@ -945,12 +967,11 @@ const makeRuntime = (client: CloudflareWorkspaceClient): ComputerWorkspaceRuntim
     options?: WorkspaceGetExecOptions<Encoding>,
   ) {
     yield* Effect.annotateCurrentSpan({ backend: options?.backend, runId: id });
-    const handle = yield* Effect.acquireRelease(
+    const handle = yield* Effect.acquireDisposable(
       Effect.tryPromise({
         try: () => client.runtime.getExec(id, runtimeGetOptions(options)),
         catch: (cause) => execError("getExec", cause),
       }),
-      releaseRun,
     );
 
     // SAFETY: runtimeGetOptions carries Encoding to Cloudflare's corresponding handle overload.
@@ -1169,25 +1190,31 @@ export class ComputerWorkspace extends Context.Service<
    * Acquires the single workspace registered by `withComputerWorkspace` and
    * releases its RPC client when the layer scope closes.
    */
-  static readonly layer: Layer.Layer<ComputerWorkspace, never, DurableObjectState> = Layer.effect(
-    ComputerWorkspace,
-    Effect.gen(function* () {
-      const state = yield* DurableObjectState;
-      const host = HostRegistry.lookup(state.raw);
-
-      if (host === undefined) {
-        return yield* Effect.die(
-          "ComputerWorkspace.layer requires a Durable Object class built with withComputerWorkspace",
+  static readonly layer: Layer.Layer<ComputerWorkspace, WorkspaceAcquireError, DurableObjectState> =
+    Layer.effect(
+      ComputerWorkspace,
+      Effect.gen(function* () {
+        const state = yield* DurableObjectState;
+        const host = HostRegistry.lookup(state.raw);
+
+        if (host === undefined) {
+          return yield* Effect.die(
+            "ComputerWorkspace.layer requires a Durable Object class built with withComputerWorkspace",
+          );
+        }
+
+        const computer = yield* Effect.tryPromise({
+          try: () => import("@cloudflare/computer"),
+          catch: (cause) => acquireError("import", cause),
+        });
+        const client = yield* Effect.acquireDisposable(
+          Effect.tryPromise({
+            try: () => computer.getWorkspace(host),
+            catch: (cause) => acquireError("getWorkspace", cause),
+          }),
         );
-      }
-
-      const computer = yield* Effect.promise(() => import("@cloudflare/computer"));
-      const client = yield* Effect.acquireRelease(
-        Effect.promise(() => computer.getWorkspace(host)),
-        (workspace) => Effect.sync(() => workspace[Symbol.dispose]()),
-      );
 
-      return ComputerWorkspace.of(fromWorkspaceClient(client));
-    }),
-  );
+        return ComputerWorkspace.of(fromWorkspaceClient(client));
+      }),
+    );
 }

package/src/DurableObject.ts

@@ -5,20 +5,13 @@ import { NativeRequest } from "./Worker";
 import { WorkerEnvironment, type WorkerEnv } from "./Environment";
 import { DurableObjectState, fromDurableObjectState } from "./DurableObjectState";
 import { fromWebSocket, type DurableWebSocket } from "./DurableObjectWebSocket";
+import * as RpcDefinition from "./RpcDefinition";
 import * as Entrypoint from "./internal/Entrypoint";
 import * as Runtime from "./internal/Runtime";
 import * as Telemetry from "./internal/Telemetry";
 import type { ReceiverOptions, RpcInvocationInfo } from "./RpcTracing";
 
-const reservedMethodNames = new Set<string>([
-  "constructor",
-  "dup",
-  "fetch",
-  "alarm",
-  "webSocketMessage",
-  "webSocketClose",
-  "webSocketError",
-]);
+const reservedMethodNames: ReadonlySet<string> = RpcDefinition.reservedMethodNames;
 
 type RuntimeContext<ROut> = DurableObjectState | WorkerEnvironment | ROut;
 
@@ -167,6 +160,12 @@ export type DurableObjectClass<Rpc extends DurableObjectRpc<ROut>, ROut> = new (
     ): Promise<A>;
   };
 
+/**
+ * Builds a Durable Object whose base `layer` lives for the in-memory instance.
+ * Cloudflare does not expose an eviction or shutdown hook, so finalizers in
+ * that layer are not guaranteed to run. Put resources that require timely
+ * release in `eventLayer`, whose scope closes after each handled event.
+ */
 export const make = <
   ROut,
   LayerError,

package/src/DurableObjectNamespace.ts

@@ -250,7 +250,7 @@ export type DurableObjectNamespaceEffectClient<
     stub: DurableObjectStubClient<Api>,
     method: Method,
     ...args: StubMethodArgs<Api, Method>
-  ) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, unknown, Scope.Scope>;
+  ) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, DurableObjectRpcError, Scope.Scope>;
   /**
    * Exposes the underlying native Durable Object namespace binding.
    *
@@ -300,7 +300,11 @@ export type DurableObjectNamespaceStaticClient<
     stub: DurableObjectStubClient<Api>,
     method: Method,
     ...args: StubMethodArgs<Api, Method>
-  ) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, unknown, Scope.Scope | R>;
+  ) => Effect.Effect<
+    Awaited<StubMethodSuccess<Api, Method>>,
+    DurableObjectRpcError,
+    Scope.Scope | R
+  >;
   readonly rawUnsafe: () => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
 };
 
@@ -351,7 +355,22 @@ export const makeClient = <
 
     const fetch = (stub: StubClient, input: RequestInfo | URL, init?: RequestInit) =>
       Effect.tryPromise({
-        try: () => stub.fetch(input, init),
+        try: (signal) => {
+          const callerSignal =
+            init?.signal !== undefined
+              ? init.signal
+              : input instanceof Request
+                ? input.signal
+                : undefined;
+
+          return stub.fetch(input, {
+            ...init,
+            signal:
+              callerSignal === null || callerSignal === undefined
+                ? signal
+                : AbortSignal.any([callerSignal, signal]),
+          });
+        },
         catch: (cause) => new DurableObjectFetchError({ binding: definition.binding, cause }),
       });
 
@@ -456,10 +475,19 @@ export const makeClient = <
         stub: StubClient,
         method: Method,
         ...args: StubMethodArgs<Api, Method>
-      ): Effect.fn.Return<StubMethodSuccess<Api, Method>, unknown, Scope.Scope> {
+      ): Effect.fn.Return<StubMethodSuccess<Api, Method>, DurableObjectRpcError, Scope.Scope> {
         const methodName = String(method);
         const result = yield* rpc(stub, method, ...args);
-        const value = yield* CloudflareRpc.scoped(result);
+        const value = yield* CloudflareRpc.scoped(result).pipe(
+          Effect.mapError(
+            (cause) =>
+              new DurableObjectRpcError({
+                binding: definition.binding,
+                method: methodName,
+                cause,
+              }),
+          ),
+        );
 
         return yield* decodeSuccess<Method>(methodName, value);
       },

package/src/DurableObjectRpcWebSocket.ts

@@ -230,7 +230,6 @@ export const layer = (
       const disconnects = yield* Queue.make<number>();
       const connectionsBySocket = new Map<WebSocket, RpcConnection>();
       const connectionsById = new Map<number, RpcConnection>();
-      const clientIds = new Set<number>();
       const resetSockets = new WeakSet<WebSocket>();
       const declarationsById = new Map<string, AnyResumableStreamDeclaration>();
       const declarationsByTag = new Map<string, AnyResumableStreamDeclaration>();
@@ -268,21 +267,6 @@ export const layer = (
       }
 
       const reserveClientId = (socket: DurableWebSocket): AttachmentMetadata => {
-        const attachment = readAttachment(socket.raw, attachmentKey);
-
-        if (attachment._tag === "Invalid") {
-          throw new Error("Invalid Durable Object RPC websocket attachment metadata");
-        }
-
-        if (attachment._tag === "Valid") {
-          const metadata = attachment.metadata;
-
-          nextClientId = Math.max(nextClientId, metadata.clientId + 1);
-          writeAttachment(socket.raw, attachmentKey, metadata);
-
-          return metadata;
-        }
-
         const id = nextClientId++;
         const created: LegacyAttachmentMetadata = {
           version: legacyAttachmentVersion,
@@ -377,7 +361,6 @@ export const layer = (
 
         connectionsBySocket.set(socket.raw, connection);
         connectionsById.set(connection.id, connection);
-        clientIds.add(connection.id);
         nextClientId = Math.max(nextClientId, connection.id + 1);
 
         return connection;
@@ -434,7 +417,6 @@ export const layer = (
 
         connectionsBySocket.delete(socket.raw);
         connectionsById.delete(connection.id);
-        clientIds.delete(connection.id);
         activeNonResumableRequestCount -= connection.nonResumableRequestIds.size;
         connection.requestIds.clear();
         connection.nonResumableRequestIds.clear();
@@ -847,7 +829,7 @@ export const layer = (
 
               connection?.socket.raw.close();
             }),
-          clientIds: Effect.sync(() => clientIds),
+          clientIds: Effect.sync(() => new Set(connectionsById.keys())),
           initialMessage: Effect.succeedNone,
           supportsAck: true,
           supportsTransferables: false,
@@ -1141,17 +1123,10 @@ const writeAttachment = (socket: WebSocket, key: string, metadata: AttachmentMet
   }
 
   const attachment = Predicate.isObject(current) ? current : {};
-  const currentMetadata =
-    Predicate.hasProperty(attachment, key) && Predicate.isObject(attachment[key])
-      ? attachment[key]
-      : {};
 
   socket.serializeAttachment({
     ...attachment,
-    [key]: {
-      ...currentMetadata,
-      ...metadata,
-    },
+    [key]: metadata,
   });
 };
 

package/src/DurableObjectState.ts

@@ -3,6 +3,7 @@ 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 { runNativeCallback } from "./internal/NativeCallback";
 import { makeWaitUntilScheduler } from "./internal/WorkerContext";
 
 /**
@@ -87,24 +88,21 @@ export const fromDurableObjectState = (
     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,
-      ),
+      runNativeCallback<A, E, R, Exit.Exit<A, E>>((run) =>
+        state.blockConcurrencyWhile(() => runExitPreservingTypedFailures(run, effect)),
+      ).pipe(Effect.orDie, Effect.flatten),
     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)),
-          ),
-        ),
-      ),
+      runNativeCallback<A, E, R, A>((run) =>
+        state.blockConcurrencyWhile(async () => {
+          const exit = await run(effect);
+
+          if (Exit.isFailure(exit)) {
+            throw Cause.squash(exit.cause);
+          }
+
+          return exit.value;
+        }),
+      ).pipe(Effect.orDie),
     acceptWebSocket: (ws: DurableWebSocket, tags?: Array<string>) =>
       Effect.sync(() => state.acceptWebSocket(ws.raw, tags)),
     getWebSockets: (tag?: string) =>
@@ -125,11 +123,11 @@ export const fromDurableObjectState = (
   };
 };
 
-const runPromiseExitPreservingTypedFailures = async <A, E, R>(
-  context: Context.Context<R>,
+const runExitPreservingTypedFailures = async <A, E, R>(
+  run: (effect: Effect.Effect<A, E, R>) => Promise<Exit.Exit<A, E>>,
   effect: Effect.Effect<A, E, R>,
 ): Promise<Exit.Exit<A, E>> => {
-  const exit = await Effect.runPromiseExitWith(context)(effect);
+  const exit = await run(effect);
 
   if (Exit.isFailure(exit) && (Cause.hasDies(exit.cause) || Cause.hasInterrupts(exit.cause))) {
     throw Cause.squash(exit.cause);

package/src/DurableObjectStorage.ts

@@ -1,6 +1,19 @@
-import { Clock, Data, Duration, Effect, Exit, Option, Predicate, Schema as S } from "effect";
+import {
+  Cause,
+  Clock,
+  Data,
+  Duration,
+  Effect,
+  Exit,
+  Fiber,
+  Option,
+  Predicate,
+  Result,
+  Schema as S,
+} from "effect";
 
 import * as ErrorMessage from "./internal/ErrorMessage";
+import { runNativeCallback } from "./internal/NativeCallback";
 
 export type SqlStorageValue = globalThis.SqlStorageValue;
 
@@ -331,6 +344,7 @@ export const fromDurableObjectStorage = (
           // failed Exit is thrown to abort it. Keep a typed reference to that
           // Exit rather than recovering its type from the untyped catch binding.
           let aborted: Exit.Exit<A, E> | undefined;
+          let escapedFiber: Fiber.Fiber<unknown, unknown> | undefined;
 
           try {
             return Effect.succeed(
@@ -340,55 +354,59 @@ export const fromDurableObjectStorage = (
                 if (Exit.isSuccess(exit)) {
                   return exit.value;
                 }
+                const defect = Cause.findDefect(exit.cause);
+
+                if (Result.isSuccess(defect) && Cause.isAsyncFiberError(defect.success)) {
+                  escapedFiber = defect.success.fiber;
+                  escapedFiber.interruptUnsafe();
+                }
                 aborted = exit;
 
                 throw exit;
               }),
             );
           } catch (cause) {
-            if (aborted !== undefined && cause === aborted && Exit.isFailure(aborted)) {
-              return Effect.failCause(aborted.cause);
+            const failure: Effect.Effect<never, E | StorageOperationError> =
+              aborted !== undefined && cause === aborted && Exit.isFailure(aborted)
+                ? Effect.failCause(aborted.cause)
+                : Effect.fail(storageError("transactionSync", cause));
+            const fiber = escapedFiber;
+
+            if (fiber !== undefined) {
+              return Fiber.interrupt(fiber).pipe(Effect.andThen(failure));
             }
 
-            return Effect.fail(storageError("transactionSync", cause));
+            return failure;
           }
         }),
       ),
     ),
   transaction: <A, E, R>(closure: (txn: DurableObjectTransaction) => Effect.Effect<A, E, R>) =>
-    Effect.context<R>().pipe(
-      Effect.flatMap((context) =>
-        Effect.callback<A, E | StorageOperationError>((resume) => {
-          // See `transactionSync`: the thrown Exit aborts Cloudflare's
-          // transaction, and holding it here keeps its error type.
-          let aborted: Exit.Exit<A, E> | undefined;
+    Effect.suspend(() => {
+      // See `transactionSync`: the thrown Exit aborts Cloudflare's
+      // transaction, and holding it here keeps its error type.
+      let aborted: Exit.Exit<A, E> | undefined;
 
-          void storage
-            .transaction(async (txn) => {
-              const exit = await Effect.runPromiseExitWith(context)(
-                closure(fromDurableObjectTransaction(txn)),
-              );
-
-              if (Exit.isSuccess(exit)) {
-                return exit.value;
-              }
-              aborted = exit;
-
-              throw exit;
-            })
-            .then(
-              (value) => resume(Effect.succeed(value)),
-              (cause) => {
-                if (aborted !== undefined && cause === aborted && Exit.isFailure(aborted)) {
-                  resume(Effect.failCause(aborted.cause));
-                } else {
-                  resume(Effect.fail(storageError("transaction", cause)));
-                }
-              },
-            );
+      return runNativeCallback<A, E, R, A>((run) =>
+        storage.transaction(async (txn) => {
+          const exit = await run(Effect.suspend(() => closure(fromDurableObjectTransaction(txn))));
+
+          if (Exit.isSuccess(exit)) {
+            return exit.value;
+          }
+          aborted = exit;
+
+          throw exit;
         }),
-      ),
-    ),
+      ).pipe(
+        Effect.catch(
+          (cause): Effect.Effect<never, E | StorageOperationError> =>
+            aborted !== undefined && cause === aborted && Exit.isFailure(aborted)
+              ? Effect.failCause(aborted.cause)
+              : Effect.fail(storageError("transaction", cause)),
+        ),
+      );
+    }),
   sync: () => tryStoragePromise("sync", () => storage.sync()),
   getCurrentBookmark: () =>
     tryStoragePromise("getCurrentBookmark", () => storage.getCurrentBookmark()),

package/src/DurableObjectWebSocket.ts

@@ -38,53 +38,37 @@ export interface DurableWebSocket<Attachment = unknown> {
   send(data: DurableWebSocketSendData): Effect.Effect<void, DurableWebSocketSendError>;
   close(code?: number, reason?: string): Effect.Effect<void, DurableWebSocketCloseError>;
   /** Serializes hibernation attachment metadata onto the socket. */
-  serializeAttachment<A = Attachment>(
+  serializeAttachment<A extends Attachment = Attachment>(
     value: A,
   ): Effect.Effect<void, DurableWebSocketAttachmentError>;
   /** Deserializes hibernation attachment metadata from the socket. */
   readonly deserializeAttachment: Effect.Effect<unknown, DurableWebSocketAttachmentError>;
 }
 
-const wrappers = new WeakMap<WebSocket, DurableWebSocket<unknown>>();
-
 export const fromWebSocket = <Attachment = unknown>(
   raw: WebSocket,
-): DurableWebSocket<Attachment> => {
-  const existing = wrappers.get(raw);
-
-  if (existing !== undefined) {
-    // SAFETY: Attachment is phantom; a wrapper's runtime behavior is independent of that type.
-    return existing as DurableWebSocket<Attachment>;
-  }
-
-  const socket: DurableWebSocket<unknown> = {
-    raw,
-    send: (data) =>
-      Effect.try({
-        try: () => raw.send(data),
-        catch: (cause) => new DurableWebSocketSendError({ cause }),
-      }),
-    close: (code, reason) =>
-      Effect.try({
-        try: () => raw.close(code, reason),
-        catch: (cause) => new DurableWebSocketCloseError({ cause }),
-      }),
-    serializeAttachment: (value) =>
-      Effect.try({
-        try: () => raw.serializeAttachment(value),
-        catch: (cause) => new DurableWebSocketAttachmentError({ operation: "serialize", cause }),
-      }),
-    deserializeAttachment: Effect.try({
-      try: () => raw.deserializeAttachment(),
-      catch: (cause) => new DurableWebSocketAttachmentError({ operation: "deserialize", cause }),
+): DurableWebSocket<Attachment> => ({
+  raw,
+  send: (data) =>
+    Effect.try({
+      try: () => raw.send(data),
+      catch: (cause) => new DurableWebSocketSendError({ cause }),
     }),
-  };
-
-  wrappers.set(raw, socket);
-
-  // SAFETY: Attachment is phantom; the newly created wrapper supports values through its generic serializer.
-  return socket as DurableWebSocket<Attachment>;
-};
+  close: (code, reason) =>
+    Effect.try({
+      try: () => raw.close(code, reason),
+      catch: (cause) => new DurableWebSocketCloseError({ cause }),
+    }),
+  serializeAttachment: <A extends Attachment = Attachment>(value: A) =>
+    Effect.try({
+      try: () => raw.serializeAttachment(value),
+      catch: (cause) => new DurableWebSocketAttachmentError({ operation: "serialize", cause }),
+    }),
+  deserializeAttachment: Effect.try({
+    try: () => raw.deserializeAttachment(),
+    catch: (cause) => new DurableWebSocketAttachmentError({ operation: "deserialize", cause }),
+  }),
+});
 
 export interface AcceptUpgradeOptions<Attachment = unknown> {
   readonly tags?: ReadonlyArray<string> | undefined;
@@ -165,15 +149,13 @@ export const attachment = <const AttachmentSchema extends S.Codec<any, any, neve
   S.Codec.Encoded<AttachmentSchema>
 > => {
   type Attachment = S.Schema.Type<AttachmentSchema>;
-  type Encoded = S.Codec.Encoded<AttachmentSchema>;
 
   const serialize = (socket: DurableWebSocket<unknown>, value: Attachment) =>
     S.encodeEffect(schema)(value).pipe(
       Effect.mapError(
         (cause) => new DurableWebSocketAttachmentError({ operation: "serialize", cause }),
       ),
-      // SAFETY: S.encodeEffect returns this codec's declared Encoded representation.
-      Effect.flatMap((encoded) => socket.serializeAttachment(encoded as Encoded)),
+      Effect.flatMap((encoded) => socket.serializeAttachment(encoded)),
     );
 
   const deserialize = (socket: DurableWebSocket<unknown>) =>