alchemy 2.0.0-beta.3 → 2.0.0-beta.31

package/src/Cloudflare/Workers/DurableObjectNamespace.ts

@@ -9,8 +9,12 @@ import type { HttpEffect } from "../../Http.ts";
 import * as Output from "../../Output.ts";
 import type { PlatformServices } from "../../Platform.ts";
 import { effectClass, taggedFunction } from "../../Util/effect.ts";
+import {
+  DurableObjectState,
+  fromDurableObjectState,
+} from "./DurableObjectState.ts";
 import { makeRpcStub } from "./Rpc.ts";
-import { fromWebSocket, type DurableWebSocket } from "./WebSocket.ts";
+import { type DurableWebSocket } from "./WebSocket.ts";
 import { Worker, WorkerEnvironment, type WorkerServices } from "./Worker.ts";
 
 export interface DurableObjectExport {
@@ -39,7 +43,26 @@ export type AlarmInvocationInfo = cf.AlarmInvocationInfo;
 type TypeId = "Cloudflare.DurableObjectNamespace";
 const TypeId = "Cloudflare.DurableObjectNamespace";
 
-export interface DurableObjectNamespace<Shape = unknown> {
+export const isDurableObjectNamespaceLike = (
+  value: unknown,
+): value is DurableObjectNamespaceLike =>
+  typeof value === "object" &&
+  value !== null &&
+  "kind" in value &&
+  value.kind === TypeId;
+
+export interface DurableObjectNamespaceLike<Shape = any> {
+  kind: TypeId;
+  name: string;
+  /** @internal phantom */
+  className?: string;
+  /** @internal phantom */
+  Shape?: Shape;
+}
+
+export interface DurableObjectNamespace<
+  Shape = unknown,
+> extends DurableObjectNamespaceLike<Shape> {
   Type: TypeId;
   name: string;
   namespaceId: Output.Output<string>;
@@ -63,7 +86,7 @@ export interface DurableObjectShape {
   ) => Effect.Effect<void, never, never>;
   webSocketMessage?: (
     socket: DurableWebSocket,
-    message: string | Uint8Array,
+    message: string | ArrayBuffer,
   ) => Effect.Effect<void>;
   webSocketClose?: (
     socket: DurableWebSocket,
@@ -77,8 +100,20 @@ export type DurableObjectServices =
   | DurableObjectNamespace
   | DurableObjectState
   | WorkerServices
+  | WorkerEnvironment
   | PlatformServices;
 
+export interface DurableObjectNamespaceProps {
+  /**
+   * @default name
+   */
+  className: string;
+  // scriptName?: string | undefined;
+  // environment?: string | undefined;
+  // sqlite?: boolean | undefined;
+  // namespaceId?: string | undefined;
+}
+
 export interface DurableObjectNamespaceClass extends Effect.Effect<
   DurableObjectNamespace,
   never,
@@ -100,6 +135,10 @@ export interface DurableObjectNamespaceClass extends Effect.Effect<
       new (_: never): Shape;
     };
   };
+  <Shape>(
+    name: string,
+    props?: DurableObjectNamespaceProps,
+  ): DurableObjectNamespaceLike<Shape>;
   <Shape, InitReq = never>(
     name: string,
     impl: Effect.Effect<
@@ -262,6 +301,51 @@ export class DurableObjectNamespaceScope extends Context.Service<
  * };
  * ```
  *
+ * @section Returning Streams from RPC
+ * RPC methods can return an Effect `Stream` and the caller will see
+ * the chunks as they're produced. Combine with `Stream.schedule` to
+ * pace emission, or with `Stream.fromQueue` to bridge an inbound
+ * subscription.
+ *
+ * @example Streaming sequential numbers
+ * ```typescript
+ * import * as Schedule from "effect/Schedule";
+ * import * as Stream from "effect/Stream";
+ *
+ * return {
+ *   tick: (n: number) =>
+ *     Stream.iterate(0, (i) => i + 1).pipe(
+ *       Stream.take(n),
+ *       Stream.schedule(Schedule.spaced("100 millis")),
+ *     ),
+ * };
+ * ```
+ *
+ * @example Forwarding the stream as a chunked HTTP response
+ * ```typescript
+ * // in a Worker fetch handler
+ * const counter = counters.getByName("tick");
+ * const stream = counter.tick(5).pipe(
+ *   Stream.map((i) => `${i}\n`),
+ *   Stream.encodeText,
+ * );
+ * return HttpServerResponse.stream(stream, {
+ *   headers: { "content-type": "text/plain" },
+ * });
+ * ```
+ *
+ * @section Worker → DO HTTP forwarding
+ * In addition to RPC methods, the typed stub exposes a `fetch`
+ * method that forwards an `HttpServerRequest` straight to the DO.
+ * The DO's own `fetch` Effect produces the response — useful for
+ * WebSocket upgrades and other request-shaped interactions.
+ *
+ * @example Forwarding an HTTP request to a DO
+ * ```typescript
+ * const room = rooms.getByName(roomId);
+ * return yield* room.fetch(request);
+ * ```
+ *
  * @section Accessing Instance State
  * Each Durable Object instance has its own transactional key-value
  * storage via `Cloudflare.DurableObjectState`. Use `storage.get` and
@@ -317,14 +401,66 @@ export class DurableObjectNamespaceScope extends Context.Service<
  * ```
  *
  * @example Recovering sessions after hibernation
+ * Place the rehydration loop **inside the inner `Effect.gen`** so
+ * it runs every time the DO instance is reconstructed (including
+ * after Cloudflare wakes the DO from hibernation).
+ *
  * ```typescript
- * const state = yield* Cloudflare.DurableObjectState;
- * const sockets = yield* state.getWebSockets();
+ * return Effect.gen(function* () {
+ *   const state = yield* Cloudflare.DurableObjectState;
+ *   const sessions = new Map<string, Cloudflare.DurableWebSocket>();
+ *
+ *   // Rehydrate the in-memory session map after hibernation.
+ *   for (const socket of yield* state.getWebSockets()) {
+ *     const data = socket.deserializeAttachment<{ id: string }>();
+ *     if (data) sessions.set(data.id, socket);
+ *   }
+ *
+ *   return {
+ *     fetch: Effect.gen(function* () {
+ *       const [response, socket] = yield* Cloudflare.upgrade();
+ *       const id = crypto.randomUUID();
+ *       socket.serializeAttachment({ id });
+ *       sessions.set(id, socket);
+ *       return response;
+ *     }),
+ *     webSocketMessage: Effect.fnUntraced(function* (socket, message) {
+ *       const text =
+ *         typeof message === "string" ? message : new TextDecoder().decode(message);
+ *       for (const peer of sessions.values()) {
+ *         yield* peer.send(text);
+ *       }
+ *     }),
+ *   };
+ * });
+ * ```
  *
- * for (const socket of sockets) {
- *   const data = socket.deserializeAttachment<{ id: string }>();
- *   // re-populate your session map
- * }
+ * @section Scheduled Alarms
+ * Each Durable Object can have a single alarm timestamp. Alchemy
+ * layers a small SQLite-backed scheduler on top via
+ * `Cloudflare.scheduleEvent` and `Cloudflare.processScheduledEvents`,
+ * so you can register many named events with arbitrary payloads and
+ * fire them from a single `alarm` handler.
+ *
+ * @example Scheduling and processing events
+ * ```typescript
+ * // schedule from a request or message handler
+ * yield* Cloudflare.scheduleEvent(
+ *   "reminder-1",
+ *   new Date(Date.now() + 60_000),
+ *   { message: "your meeting starts in a minute" },
+ * );
+ *
+ * return {
+ *   alarm: () =>
+ *     Effect.gen(function* () {
+ *       const fired = yield* Cloudflare.processScheduledEvents;
+ *       for (const event of fired) {
+ *         const payload = event.payload as { message: string };
+ *         // dispatch / broadcast / persist...
+ *       }
+ *     }),
+ * };
  * ```
  *
  * @section Using from a Worker
@@ -360,11 +496,59 @@ export class DurableObjectNamespaceScope extends Context.Service<
  *   }),
  * };
  * ```
+ *
+ * @section Binding in an Async Worker
+ * When using an Async Worker (plain `async fetch` handler, no Effect
+ * runtime), declare Durable Objects in the `bindings` prop of the
+ * Worker resource. Pass a `DurableObjectNamespace` reference with a
+ * `className` matching the exported `DurableObject` subclass in your
+ * worker source file. Use `Cloudflare.InferEnv` to get a fully typed
+ * `env` object that includes the namespace.
+ *
+ * @example Declaring a DO binding in the stack
+ * ```typescript
+ * // alchemy.run.ts
+ * import type { Counter } from "./src/worker.ts";
+ *
+ * export type WorkerEnv = Cloudflare.InferEnv<typeof Worker>;
+ *
+ * export const Worker = Cloudflare.Worker("Worker", {
+ *   main: "./src/worker.ts",
+ *   bindings: {
+ *     Counter: Cloudflare.DurableObjectNamespace<Counter>("Counter", {
+ *       className: "Counter",
+ *     }),
+ *   },
+ * });
+ * ```
+ *
+ * @example Using the DO from a plain async handler
+ * ```typescript
+ * // src/worker.ts
+ * import { DurableObject } from "cloudflare:workers";
+ * import type { WorkerEnv } from "../alchemy.run.ts";
+ *
+ * export default {
+ *   async fetch(request: Request, env: WorkerEnv) {
+ *     const counter = env.Counter.getByName("my-counter");
+ *     const count = await counter.increment();
+ *     return new Response(JSON.stringify({ count }));
+ *   },
+ * };
+ *
+ * export class Counter extends DurableObject {
+ *   private counter = 0;
+ *   async increment() {
+ *     return ++this.counter;
+ *   }
+ * }
+ * ```
  */
 export const DurableObjectNamespace: DurableObjectNamespaceClass =
   taggedFunction(DurableObjectNamespaceScope, ((
     ...args:
       | []
+      | [name: string, props?: DurableObjectNamespaceProps]
       | [
           name: string,
           impl: Effect.Effect<
@@ -378,137 +562,150 @@ export const DurableObjectNamespace: DurableObjectNamespaceClass =
   ) =>
     args.length === 0
       ? DurableObjectNamespace
-      : effectClass(
-          Effect.gen(function* () {
-            const [namespace, impl] = args;
-            const worker = yield* Worker;
+      : !Effect.isEffect(args[1])
+        ? ({
+            kind: TypeId,
+            name: args[0],
+            className: (args[1] as DurableObjectNamespaceProps | undefined)
+              ?.className,
+          } satisfies DurableObjectNamespaceLike<any>)
+        : effectClass(
+            Effect.gen(function* () {
+              const [namespace, impl] = args as any as [
+                name: string,
+                impl: Effect.Effect<
+                  Effect.Effect<
+                    DurableObjectNamespace<any>,
+                    never,
+                    DurableObjectState
+                  >
+                >,
+              ];
+              const worker = yield* Worker;
 
-            yield* worker.bind`${namespace}`({
-              // TODO(sam): automate class migrations, probably in the provider
-              bindings: [
-                {
-                  type: "durable_object_namespace",
-                  name: namespace,
-                  className: namespace,
-                  // scriptName:
-                  //   binding.scriptName === props.workerName
-                  //     ? undefined
-                  //     : binding.scriptName,
-                  // environment: binding.environment,
-                  // namespaceId: binding.namespaceId,
-                },
-              ],
-            });
+              yield* worker.bind`${namespace}`({
+                // TODO(sam): automate class migrations, probably in the provider
+                bindings: [
+                  {
+                    type: "durable_object_namespace",
+                    name: namespace,
+                    className: namespace,
+                    // scriptName:
+                    //   binding.scriptName === props.workerName
+                    //     ? undefined
+                    //     : binding.scriptName,
+                    // environment: binding.environment,
+                    // namespaceId: binding.namespaceId,
+                  },
+                ],
+              });
 
-            const services =
-              yield* Effect.context<Effect.Services<typeof impl>>();
+              const services =
+                yield* Effect.context<Effect.Services<typeof impl>>();
 
-            yield* worker.export(namespace, {
-              kind: "durableObject",
-              make: (state: cf.DurableObjectState, env: any) => {
-                const doState = fromDurableObjectState(state);
-                return constructor.pipe(
-                  Effect.provideContext(services),
-                  Effect.provideService(DurableObjectState, doState),
-                  Effect.provideService(WorkerEnvironment, env),
-                  Effect.map((methods: any) => {
-                    console.log(
-                      "[DurableObject] wrapping methods:",
-                      Object.keys(methods),
-                      "own:",
-                      Object.getOwnPropertyNames(methods),
-                    );
-                    const wrapped: Record<string, unknown> = {};
-                    for (const key of Object.getOwnPropertyNames(methods)) {
-                      const value = methods[key];
-                      if (Effect.isEffect(value)) {
-                        wrapped[key] = (
-                          value as Effect.Effect<any, any, any>
-                        ).pipe(
-                          Effect.provideService(DurableObjectState, doState),
-                        );
-                      } else if (typeof value === "function") {
-                        wrapped[key] = (...args: unknown[]) => {
-                          const result = (value as Function)(...args);
-                          if (Effect.isEffect(result)) {
-                            return (
-                              result as Effect.Effect<any, any, any>
-                            ).pipe(
-                              Effect.provideService(
-                                DurableObjectState,
-                                doState,
-                              ),
-                            );
-                          }
-                          return result;
-                        };
-                      } else {
-                        wrapped[key] = value;
+              yield* worker.export(namespace, {
+                kind: "durableObject",
+                make: (state: cf.DurableObjectState, env: any) => {
+                  const doState = fromDurableObjectState(state);
+                  return constructor.pipe(
+                    Effect.provideContext(services),
+                    Effect.provideService(DurableObjectState, doState),
+                    Effect.provideService(WorkerEnvironment, env),
+                    Effect.map((methods: any) => {
+                      const wrapped: Record<string, unknown> = {};
+                      for (const key of Object.getOwnPropertyNames(methods)) {
+                        const value = methods[key];
+                        if (Effect.isEffect(value)) {
+                          wrapped[key] = (
+                            value as Effect.Effect<any, any, any>
+                          ).pipe(
+                            Effect.provideService(DurableObjectState, doState),
+                          );
+                        } else if (typeof value === "function") {
+                          wrapped[key] = (...args: unknown[]) => {
+                            const result = (value as Function)(...args);
+                            if (Effect.isEffect(result)) {
+                              return (
+                                result as Effect.Effect<any, any, any>
+                              ).pipe(
+                                Effect.provideService(
+                                  DurableObjectState,
+                                  doState,
+                                ),
+                              );
+                            }
+                            return result;
+                          };
+                        } else {
+                          wrapped[key] = value;
+                        }
                       }
-                    }
-                    return wrapped;
-                  }),
-                );
-              },
-            } satisfies DurableObjectExport);
-
-            const binding = yield* Effect.serviceOption(WorkerEnvironment).pipe(
-              Effect.map(Option.getOrUndefined),
-              Effect.flatMap((env) => {
-                if (env === undefined) {
-                  // should be fine to return undefined here (it is only undefined at plantime)
-                  return Effect.succeed(undefined);
-                }
-                const ns = env[namespace];
-                if (!ns) {
-                  return Effect.die(
-                    new Error(
-                      `DurableObjectNamespace '${namespace}' not found`,
-                    ),
+                      return wrapped;
+                    }),
                   );
-                } else if (typeof ns.getByName === "function") {
-                  return Effect.succeed(ns);
-                } else {
-                  return Effect.die(
-                    new Error(
-                      `DurableObjectNamespace '${namespace}' is not a DurableObjectNamespace`,
-                    ),
-                  );
-                }
-              }),
-            );
+                },
+              } satisfies DurableObjectExport);
 
-            const namespaceId = worker.durableObjectNamespaces.pipe(
-              Output.map(
-                (durableObjectNamespaces) =>
-                  durableObjectNamespaces?.[namespace],
-              ),
-            );
+              const binding = yield* Effect.serviceOption(
+                WorkerEnvironment,
+              ).pipe(
+                Effect.map(Option.getOrUndefined),
+                Effect.flatMap((env) => {
+                  if (env === undefined) {
+                    // should be fine to return undefined here (it is only undefined at plantime)
+                    return Effect.succeed(undefined);
+                  }
+                  const ns = env[namespace];
+                  if (!ns) {
+                    return Effect.die(
+                      new Error(
+                        `DurableObjectNamespace '${namespace}' not found`,
+                      ),
+                    );
+                  } else if (typeof ns.getByName === "function") {
+                    return Effect.succeed(ns);
+                  } else {
+                    return Effect.die(
+                      new Error(
+                        `DurableObjectNamespace '${namespace}' is not a DurableObjectNamespace`,
+                      ),
+                    );
+                  }
+                }),
+              );
+
+              const namespaceId = worker.durableObjectNamespaces.pipe(
+                Output.map(
+                  (durableObjectNamespaces) =>
+                    durableObjectNamespaces?.[namespace],
+                ),
+              );
 
-            const self = {
-              Type: TypeId,
-              LogicalId: namespace,
-              name: namespace,
-              namespaceId,
-              getByName: (name: string) => makeRpcStub(binding.getByName(name)),
-              // newUniqueId: () => use((ns) => ns.newUniqueId()),
-              // idFromName: (name: string) => use((ns) => ns.idFromName(name)),
-              // idFromString: (id: string) => use((ns) => ns.idFromString(id)),
-              // get: (
-              //   id: cf.DurableObjectId,
-              //   options?: cf.DurableObjectNamespaceGetDurableObjectOptions,
-              // ) => use((ns) => makeRpcStub(ns.get(id, options))),
-              // jurisdiction: (jurisdiction: cf.DurableObjectJurisdiction) =>
-              //   use((ns) => ns.jurisdiction(jurisdiction) as any),
-            };
+              const self = {
+                Type: TypeId,
+                LogicalId: namespace,
+                name: namespace,
+                namespaceId,
+                getByName: (name: string) =>
+                  makeRpcStub(binding.getByName(name)),
+                // newUniqueId: () => use((ns) => ns.newUniqueId()),
+                // idFromName: (name: string) => use((ns) => ns.idFromName(name)),
+                // idFromString: (id: string) => use((ns) => ns.idFromString(id)),
+                // get: (
+                //   id: cf.DurableObjectId,
+                //   options?: cf.DurableObjectNamespaceGetDurableObjectOptions,
+                // ) => use((ns) => makeRpcStub(ns.get(id, options))),
+                // jurisdiction: (jurisdiction: cf.DurableObjectJurisdiction) =>
+                //   use((ns) => ns.jurisdiction(jurisdiction) as any),
+              };
 
-            const constructor = yield* impl.pipe(
-              Effect.provideService(DurableObjectNamespaceScope, self as any),
-            );
+              const constructor = yield* impl.pipe(
+                Effect.provideService(DurableObjectNamespaceScope, self as any),
+              );
 
-            return self;
-          }),
-        )) as any);
+              return self;
+            }),
+          )) as any);
 
 export type DurableObjectStub<Shape> = {
   // TODO(sam): do we need to transform? hopefully not
@@ -522,248 +719,3 @@ export type DurableObjectStub<Shape> = {
     never
   >;
 };
-
-export class DurableObjectState extends Context.Service<
-  DurableObjectState,
-  {
-    // TODO(sam): is this needed when we have Effect?
-    // waitUntil(promise: Promise<any>): Effect.Effect<void>;
-
-    // TODO(sam): what are these? Where do they come from?
-    // readonly props: Props;
-
-    readonly id: cf.DurableObjectId;
-    readonly storage: DurableObjectStorage;
-    // TODO(sam): effect-native interface for container
-    container?: cf.Container;
-    blockConcurrencyWhile<T>(
-      callback: () => Effect.Effect<T>,
-    ): Effect.Effect<T>;
-    acceptWebSocket(ws: DurableWebSocket, tags?: string[]): Effect.Effect<void>;
-    getWebSockets(tag?: string): Effect.Effect<DurableWebSocket[]>;
-    setWebSocketAutoResponse(
-      maybeReqResp?: cf.WebSocketRequestResponsePair,
-    ): Effect.Effect<void>;
-    getWebSocketAutoResponse(): Effect.Effect<cf.WebSocketRequestResponsePair | null>;
-    getWebSocketAutoResponseTimestamp(
-      ws: cf.WebSocket,
-    ): Effect.Effect<Date | null>;
-    setHibernatableWebSocketEventTimeout(
-      timeoutMs?: number,
-    ): Effect.Effect<void>;
-    getHibernatableWebSocketEventTimeout(): Effect.Effect<number | null>;
-    getTags(ws: cf.WebSocket): Effect.Effect<string[]>;
-    abort(reason?: string): Effect.Effect<void>;
-  }
->()("Cloudflare.DurableObjectState") {}
-
-export interface DurableObjectTransaction {
-  get<T = unknown>(
-    key: string,
-    options?: cf.DurableObjectGetOptions,
-  ): Effect.Effect<T | undefined>;
-  get<T = unknown>(
-    keys: string[],
-    options?: cf.DurableObjectGetOptions,
-  ): Effect.Effect<Map<string, T>>;
-  list<T = unknown>(
-    options?: cf.DurableObjectListOptions,
-  ): Effect.Effect<Map<string, T>>;
-  put<T>(
-    key: string,
-    value: T,
-    options?: cf.DurableObjectPutOptions,
-  ): Effect.Effect<void>;
-  put<T>(
-    entries: Record<string, T>,
-    options?: cf.DurableObjectPutOptions,
-  ): Effect.Effect<void>;
-  delete(
-    key: string,
-    options?: cf.DurableObjectPutOptions,
-  ): Effect.Effect<boolean>;
-  delete(
-    keys: string[],
-    options?: cf.DurableObjectPutOptions,
-  ): Effect.Effect<number>;
-  rollback(): Effect.Effect<void>;
-  getAlarm(
-    options?: cf.DurableObjectGetAlarmOptions,
-  ): Effect.Effect<number | null>;
-  setAlarm(
-    scheduledTime: number | Date,
-    options?: cf.DurableObjectSetAlarmOptions,
-  ): Effect.Effect<void>;
-  deleteAlarm(options?: cf.DurableObjectSetAlarmOptions): Effect.Effect<void>;
-}
-export interface DurableObjectStorage {
-  get<T = unknown>(
-    key: string,
-    options?: cf.DurableObjectGetOptions,
-  ): Effect.Effect<T | undefined>;
-  get<T = unknown>(
-    keys: string[],
-    options?: cf.DurableObjectGetOptions,
-  ): Effect.Effect<Map<string, T>>;
-  list<T = unknown>(
-    options?: cf.DurableObjectListOptions,
-  ): Effect.Effect<Map<string, T>>;
-  put<T>(
-    key: string,
-    value: T,
-    options?: cf.DurableObjectPutOptions,
-  ): Effect.Effect<void>;
-  put<T>(
-    entries: Record<string, T>,
-    options?: cf.DurableObjectPutOptions,
-  ): Effect.Effect<void>;
-  delete(
-    key: string,
-    options?: cf.DurableObjectPutOptions,
-  ): Effect.Effect<boolean>;
-  delete(
-    keys: string[],
-    options?: cf.DurableObjectPutOptions,
-  ): Effect.Effect<number>;
-  deleteAll(options?: cf.DurableObjectPutOptions): Effect.Effect<void>;
-  transaction<T>(
-    closure: (txn: DurableObjectTransaction) => Effect.Effect<T>,
-  ): Effect.Effect<T>;
-  getAlarm(
-    options?: cf.DurableObjectGetAlarmOptions,
-  ): Effect.Effect<number | null>;
-  setAlarm(
-    scheduledTime: number | Date,
-    options?: cf.DurableObjectSetAlarmOptions,
-  ): Effect.Effect<void>;
-  deleteAlarm(options?: cf.DurableObjectSetAlarmOptions): Effect.Effect<void>;
-  sync(): Effect.Effect<void>;
-  sql: cf.SqlStorage;
-  kv: cf.SyncKvStorage;
-  transactionSync<T>(closure: () => T): T;
-  getCurrentBookmark(): Effect.Effect<string>;
-  getBookmarkForTime(timestamp: number | Date): Effect.Effect<string>;
-  onNextSessionRestoreBookmark(bookmark: string): Effect.Effect<string>;
-}
-
-const fromDurableObjectState = (
-  state: cf.DurableObjectState,
-): DurableObjectState["Service"] => ({
-  id: state.id,
-  container: state.container,
-  storage: fromDurableObjectStorage(state.storage),
-  blockConcurrencyWhile: <T>(callback: () => Effect.Effect<T>) =>
-    Effect.tryPromise(() =>
-      state.blockConcurrencyWhile(() => Effect.runPromise(callback())),
-    ),
-  acceptWebSocket: (ws: DurableWebSocket, tags?: string[]) =>
-    Effect.sync(() => state.acceptWebSocket(ws.ws, tags)),
-  getWebSockets: (tag?: string) =>
-    Effect.sync(() => state.getWebSockets(tag).map(fromWebSocket)),
-  setWebSocketAutoResponse: (maybeReqResp?: cf.WebSocketRequestResponsePair) =>
-    Effect.sync(() => state.setWebSocketAutoResponse(maybeReqResp)),
-  getWebSocketAutoResponse: () =>
-    Effect.sync(() => state.getWebSocketAutoResponse()),
-  getWebSocketAutoResponseTimestamp: (ws: cf.WebSocket) =>
-    Effect.sync(() => state.getWebSocketAutoResponseTimestamp(ws)),
-  setHibernatableWebSocketEventTimeout: (timeoutMs?: number) =>
-    Effect.sync(() => state.setHibernatableWebSocketEventTimeout(timeoutMs)),
-  getHibernatableWebSocketEventTimeout: () =>
-    Effect.sync(() => state.getHibernatableWebSocketEventTimeout()),
-  getTags: (ws: cf.WebSocket) => Effect.sync(() => state.getTags(ws)),
-  abort: (reason?: string) => Effect.sync(() => state.abort(reason)),
-});
-
-const fromDurableObjectTransaction = (
-  txn: cf.DurableObjectTransaction,
-): DurableObjectTransaction => ({
-  get: ((keyOrKeys: string | string[], options?: cf.DurableObjectGetOptions) =>
-    Effect.tryPromise(() => txn.get(keyOrKeys as any, options))) as any,
-  list: (options?: cf.DurableObjectListOptions) =>
-    Effect.tryPromise(() => txn.list(options)),
-  put: ((
-    keyOrEntries: string | Record<string, unknown>,
-    valueOrOptions?: unknown,
-    maybeOptions?: cf.DurableObjectPutOptions,
-  ) =>
-    typeof keyOrEntries === "string"
-      ? Effect.tryPromise(() =>
-          txn.put(keyOrEntries, valueOrOptions, maybeOptions),
-        )
-      : Effect.tryPromise(() =>
-          txn.put(
-            keyOrEntries,
-            valueOrOptions as cf.DurableObjectPutOptions | undefined,
-          ),
-        )) as any,
-  delete: ((
-    keyOrKeys: string | string[],
-    options?: cf.DurableObjectPutOptions,
-  ) => Effect.tryPromise(() => txn.delete(keyOrKeys as any, options))) as any,
-  rollback: () => Effect.sync(() => txn.rollback()),
-  getAlarm: (options?: cf.DurableObjectGetAlarmOptions) =>
-    Effect.tryPromise(() => txn.getAlarm(options)),
-  setAlarm: (
-    scheduledTime: number | Date,
-    options?: cf.DurableObjectSetAlarmOptions,
-  ) => Effect.tryPromise(() => txn.setAlarm(scheduledTime, options)),
-  deleteAlarm: (options?: cf.DurableObjectSetAlarmOptions) =>
-    Effect.tryPromise(() => txn.deleteAlarm(options)),
-});
-
-const fromDurableObjectStorage = (
-  storage: cf.DurableObjectStorage,
-): DurableObjectStorage => ({
-  get: ((keyOrKeys: string | string[], options?: cf.DurableObjectGetOptions) =>
-    Effect.tryPromise(() => storage.get(keyOrKeys as any, options))) as any,
-  list: (options?: cf.DurableObjectListOptions) =>
-    Effect.tryPromise(() => storage.list(options)),
-  put: ((
-    keyOrEntries: string | Record<string, unknown>,
-    valueOrOptions?: unknown,
-    maybeOptions?: cf.DurableObjectPutOptions,
-  ) =>
-    typeof keyOrEntries === "string"
-      ? Effect.tryPromise(() =>
-          storage.put(keyOrEntries, valueOrOptions, maybeOptions),
-        )
-      : Effect.tryPromise(() =>
-          storage.put(
-            keyOrEntries,
-            valueOrOptions as cf.DurableObjectPutOptions | undefined,
-          ),
-        )) as any,
-  delete: ((
-    keyOrKeys: string | string[],
-    options?: cf.DurableObjectPutOptions,
-  ) =>
-    Effect.tryPromise(() => storage.delete(keyOrKeys as any, options))) as any,
-  deleteAll: (options?: cf.DurableObjectPutOptions) =>
-    Effect.tryPromise(() => storage.deleteAll(options)),
-  transaction: <T>(
-    closure: (txn: DurableObjectTransaction) => Effect.Effect<T>,
-  ) =>
-    Effect.tryPromise(() =>
-      storage.transaction((txn) =>
-        Effect.runPromise(closure(fromDurableObjectTransaction(txn))),
-      ),
-    ),
-  getAlarm: (options?: cf.DurableObjectGetAlarmOptions) =>
-    Effect.tryPromise(() => storage.getAlarm(options)),
-  setAlarm: (
-    scheduledTime: number | Date,
-    options?: cf.DurableObjectSetAlarmOptions,
-  ) => Effect.tryPromise(() => storage.setAlarm(scheduledTime, options)),
-  deleteAlarm: (options?: cf.DurableObjectSetAlarmOptions) =>
-    Effect.tryPromise(() => storage.deleteAlarm(options)),
-  sync: () => Effect.tryPromise(() => storage.sync()),
-  sql: storage.sql,
-  kv: storage.kv,
-  transactionSync: <T>(closure: () => T) => storage.transactionSync(closure),
-  getCurrentBookmark: () =>
-    Effect.tryPromise(() => storage.getCurrentBookmark()),
-  getBookmarkForTime: (timestamp: number | Date) =>
-    Effect.tryPromise(() => storage.getBookmarkForTime(timestamp)),
-  onNextSessionRestoreBookmark: (bookmark: string) =>
-    Effect.tryPromise(() => storage.onNextSessionRestoreBookmark(bookmark)),
-});