alchemy 2.0.0-beta.57 → 2.0.0-beta.58

package/src/Cloudflare/Workers/Assets.ts

@@ -86,7 +86,7 @@ const getContentType = (name: string) => {
   return "application/octet-stream";
 };
 
-const maybeReadString = Effect.fnUntraced(function* (file: string) {
+const maybeReadString = Effect.fn(function* (file: string) {
   const fs = yield* FileSystem.FileSystem;
   return yield* fs.readFileString(file).pipe(
     Effect.catchIf(
@@ -102,7 +102,7 @@ const createIgnoreMatcher = (patterns: string[]) => {
   return (file: string) => matcher.ignores(file);
 };
 
-export const readAssets = Effect.fnUntraced(function* ({
+export const readAssets = Effect.fn(function* ({
   directory,
   ...config
 }: AssetsProps) {
@@ -128,7 +128,7 @@ export const readAssets = Effect.fnUntraced(function* ({
   let count = 0;
   yield* Effect.forEach(
     files,
-    Effect.fnUntraced(function* (name) {
+    Effect.fn(function* (name) {
       if (ignores(name)) {
         return;
       }
@@ -193,7 +193,7 @@ export const readAssets = Effect.fnUntraced(function* ({
   };
 });
 
-export const uploadAssets = Effect.fnUntraced(function* (
+export const uploadAssets = Effect.fn(function* (
   accountId: string,
   workerName: string,
   assets: AssetReadResult,
@@ -228,11 +228,11 @@ export const uploadAssets = Effect.fnUntraced(function* (
   const directory = path.resolve(assets.directory);
   yield* Effect.forEach(
     session.buckets,
-    Effect.fnUntraced(function* (bucket) {
+    Effect.fn(function* (bucket) {
       const body: Record<string, File> = {};
       yield* Effect.forEach(
         bucket,
-        Effect.fnUntraced(function* (hash) {
+        Effect.fn(function* (hash) {
           const name = assetsByHash.get(hash);
           if (!name) {
             return yield* new AssetNotFoundError({

package/src/Cloudflare/Workers/CronEventSource.ts

@@ -7,6 +7,7 @@ import type { ResourceLike } from "../../Resource.ts";
 import { RuntimeContext } from "../../RuntimeContext.ts";
 import type { FunctionContext } from "../../Serverless/Function.ts";
 import { isWorker, isWorkerEvent } from "./Worker.ts";
+import type { Providers } from "../Providers.ts";
 
 /**
  * Subscribe to Cloudflare Cron Triggers with an Effect handler.
@@ -47,11 +48,12 @@ export class CronEventSource extends Context.Service<
 
 export class CronEventSourcePolicy extends Binding.Policy<
   CronEventSourcePolicy,
-  (expression: string) => Effect.Effect<void>
+  (expression: string) => Effect.Effect<void>,
+  Providers
 >()("Cloudflare.Workers.CronEventSource") {}
 
 export const CronEventSourcePolicyLive = CronEventSourcePolicy.layer.succeed(
-  Effect.fnUntraced(function* (host: ResourceLike, expression: string) {
+  Effect.fn(function* (host: ResourceLike, expression: string) {
     if (isWorker(host)) {
       yield* host.bind(`Cron(${expression})`, {
         crons: [expression],

package/src/Cloudflare/Workers/DurableObjectBridge.ts

@@ -64,17 +64,19 @@ export const makeDurableObjectBridge =
 
         this.#instance = state.blockConcurrencyWhile(() =>
           this.#exported.pipe(
-            Effect.flatMap(({ constructor, services }) =>
-              constructor.pipe(
-                Effect.provide(
-                  Layer.succeed(
-                    DurableObjectState,
-                    fromDurableObjectState(this.#state),
-                  ).pipe(Layer.provideMerge(Layer.succeedContext(services))),
+            Effect.flatMap(({ constructor, services }) => {
+              const context = Layer.succeed(
+                DurableObjectState,
+                fromDurableObjectState(this.#state),
+              ).pipe(Layer.provideMerge(Layer.succeedContext(services)));
+              return constructor.pipe(
+                Effect.provide(context),
+                Effect.flatMap((instance) =>
+                  instance.pipe(Effect.provide(context)),
                 ),
                 Effect.map((instance) => ({ instance, services })),
-              ),
-            ),
+              );
+            }),
             Effect.provide(this.#globalContext),
             Effect.runPromise,
           ),
@@ -91,14 +93,17 @@ export const makeDurableObjectBridge =
                 const method = instance[prop as keyof DurableObjectShape];
                 if (typeof method === "function") {
                   const result = (method as any)(...args);
-                  // A streaming RPC method returns a `Stream` directly rather
-                  // than an `Effect`. Lift it into the success channel so the
-                  // resulting `Exit.value` is the `Stream` and `handleRpcExit`
-                  // can encode it as a stream envelope instead of trying to run
-                  // it as an effect.
-                  return Stream.isStream(result)
-                    ? Effect.succeed(result)
-                    : result;
+                  // Effects (including nested-RPC values built by
+                  // `asEffectOrStream`, which are Effects *branded* as Streams)
+                  // must be run as effects — their resolved value may itself be
+                  // a `Stream`, which `handleRpcExit` then encodes. Only a
+                  // *genuine* `Stream` (not an Effect) is lifted into the
+                  // success channel so `handleRpcExit` encodes it directly.
+                  return Effect.isEffect(result)
+                    ? result
+                    : Stream.isStream(result)
+                      ? Effect.succeed(result)
+                      : result;
                 } else if (Effect.isEffect(method)) {
                   return method;
                 } else {

package/src/Cloudflare/Workers/DurableObjectChatPersistence.ts

@@ -6,6 +6,7 @@ import {
   PersistenceError,
   type BackingPersistenceStore,
 } from "effect/unstable/persistence/Persistence";
+import { RuntimeContext } from "../../RuntimeContext.ts";
 import { DurableObjectState } from "./DurableObjectState.ts";
 
 /**
@@ -93,7 +94,10 @@ export const DurableObjectChatPersistence = Layer.effect(BackingPersistence)(
             get: (key) =>
               storage
                 .get<object>(prefixed(key))
-                .pipe(Effect.mapError(wrapErr("get", key))),
+                .pipe(
+                  Effect.mapError(wrapErr("get", key)),
+                  Effect.provide(RuntimeContext.phantom),
+                ),
             getMany: (keys) =>
               storage.get<object>(keys.map(prefixed)).pipe(
                 Effect.mapError(wrapErr("getMany")),
@@ -103,21 +107,32 @@ export const DurableObjectChatPersistence = Layer.effect(BackingPersistence)(
                       object | undefined
                     >,
                 ),
+                Effect.provide(RuntimeContext.phantom),
               ),
             set: (key, value, _ttl) =>
               storage
                 .put(prefixed(key), value)
-                .pipe(Effect.mapError(wrapErr("set", key))),
+                .pipe(
+                  Effect.mapError(wrapErr("set", key)),
+                  Effect.provide(RuntimeContext.phantom),
+                ),
             setMany: (entries) =>
               storage
                 .put(
                   Object.fromEntries(entries.map(([k, v]) => [prefixed(k), v])),
                 )
-                .pipe(Effect.mapError(wrapErr("setMany"))),
+                .pipe(
+                  Effect.mapError(wrapErr("setMany")),
+                  Effect.provide(RuntimeContext.phantom),
+                ),
             remove: (key) =>
               storage
                 .delete(prefixed(key))
-                .pipe(Effect.asVoid, Effect.mapError(wrapErr("remove", key))),
+                .pipe(
+                  Effect.asVoid,
+                  Effect.mapError(wrapErr("remove", key)),
+                  Effect.provide(RuntimeContext.phantom),
+                ),
             clear: storage.list({ prefix: `${storeId}:` }).pipe(
               Effect.flatMap((map) => {
                 const ks = [...map.keys()];
@@ -125,6 +140,7 @@ export const DurableObjectChatPersistence = Layer.effect(BackingPersistence)(
                 return Effect.asVoid(storage.delete(ks));
               }),
               Effect.mapError(wrapErr("clear")),
+              Effect.provide(RuntimeContext.phantom),
             ),
           } satisfies BackingPersistenceStore;
         }),

package/src/Cloudflare/Workers/DurableObjectNamespace.ts

@@ -2,6 +2,7 @@ import type * as cf from "@cloudflare/workers-types";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import type { Scope } from "effect/Scope";
 import type { HttpServerError } from "effect/unstable/http/HttpServerError";
 import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
 import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
@@ -10,10 +11,15 @@ import type { HttpEffect } from "../../Http.ts";
 import type { Input } from "../../Input.ts";
 import * as Output from "../../Output.ts";
 import { ALCHEMY_PHASE } from "../../Phase.ts";
-import type { PlatformServices } from "../../Platform.ts";
+import type { MainRpc, PlatformServices } from "../../Platform.ts";
+import type { RuntimeContext } from "../../RuntimeContext.ts";
 import { effectClass, taggedFunction } from "../../Util/effect.ts";
 import { asEffect } from "../../Util/types.ts";
-import { DurableObjectState } from "./DurableObjectState.ts";
+import type { Container } from "../Container/Container.ts";
+import {
+  DurableObjectState,
+  fromDurableObjectState,
+} from "./DurableObjectState.ts";
 import { makeRpcStub } from "./Rpc.ts";
 import { type DurableWebSocket } from "./WebSocket.ts";
 import { Worker, WorkerEnvironment, type WorkerServices } from "./Worker.ts";
@@ -21,7 +27,7 @@ import { Worker, WorkerEnvironment, type WorkerServices } from "./Worker.ts";
 export interface DurableObjectExport {
   readonly kind: "durableObject";
   readonly constructor: Effect.Effect<
-    DurableObjectShape,
+    Effect.Effect<DurableObjectShape, never, RuntimeContext>,
     never,
     DurableObjectState
   >;
@@ -79,7 +85,7 @@ export interface DurableObjectNamespace<
 }
 
 export interface DurableObjectShape {
-  fetch?: HttpEffect<DurableObjectState>;
+  fetch?: HttpEffect<DurableObjectState | RuntimeContext>;
   alarm?: (
     alarmInfo?: AlarmInvocationInfo,
   ) => Effect.Effect<void, never, never>;
@@ -140,31 +146,38 @@ export interface DurableObjectNamespaceClass extends Effect.Effect<
           | Dependencies<Self>
           | Effect.Effect<Dependencies<Self>, never, Req>,
       ): Effect.Effect<DurableObjectNamespace<Self>, never, Worker | Req>;
-      make<InitReq = never>(
+      make<Req = never>(
         impl: Effect.Effect<
-          Effect.Effect<Shape, never, DurableObjectServices>,
+          Effect.Effect<
+            Shape,
+            never,
+            RuntimeContext | DurableObjectState | Scope
+          >,
           never,
-          InitReq
+          DurableObjectServices | Req
         >,
-      ): Layer.Layer<
-        Self,
-        never,
-        Worker | Exclude<InitReq, DurableObjectServices>
-      >;
+      ): Layer.Layer<Self, never, Worker | Req>;
     };
   };
   <Self>(): {
-    <Shape, InitReq = never>(
+    <
+      Shape extends MainRpc<DurableObjectState>,
+      Req extends DurableObjectServices | Container.Application<any> = never,
+    >(
       name: string,
       impl: Effect.Effect<
-        Effect.Effect<Shape, never, DurableObjectServices>,
+        Effect.Effect<
+          Shape,
+          never,
+          RuntimeContext | DurableObjectState | Scope
+        >,
         never,
-        InitReq
+        Req
       >,
     ): Effect.Effect<
       DurableObjectNamespace<Self>,
       never,
-      Worker | Exclude<InitReq, DurableObjectServices>
+      Worker | Extract<Req, Container.Application<any>>
     > & {
       new (_: never): Shape;
     };
@@ -175,11 +188,7 @@ export interface DurableObjectNamespaceClass extends Effect.Effect<
   ): DurableObjectNamespaceLike<Shape>;
   <Shape, InitReq = never>(
     name: string,
-    impl: Effect.Effect<
-      Effect.Effect<Shape, never, DurableObjectServices>,
-      never,
-      InitReq
-    >,
+    impl: Effect.Effect<Shape, never, DurableObjectServices | InitReq>,
   ): Effect.Effect<
     DurableObjectNamespace<Shape>,
     never,
@@ -198,22 +207,26 @@ export class DurableObjectNamespaceScope extends Context.Service<
  *
  * A Durable Object uses a two-phase pattern with two nested `Effect.gen`
  * blocks. The outer Effect resolves shared dependencies (other DOs,
- * containers, etc.). The inner Effect runs once per instance and returns
- * the object's public methods and WebSocket handlers.
+ * containers, etc.) and the instance state *reference*
+ * (`Cloudflare.DurableObjectState`). The inner Effect returns the
+ * object's public methods and WebSocket handlers — and is the only
+ * place the state's `RuntimeContext`-colored methods (`storage.get`,
+ * `storage.put`, …) can actually run.
  *
  * ```typescript
  * Effect.gen(function* () {
- *   // Phase 1: resolve shared dependencies
+ *   // Phase 1: resolve shared dependencies + the instance state ref
  *   const db = yield* Cloudflare.D1Connection.bind(MyDB);
+ *   const state = yield* Cloudflare.DurableObjectState;
  *
  *   return Effect.gen(function* () {
- *     // Phase 2: per-instance setup and public API
- *     const state = yield* Cloudflare.DurableObjectState;
- *
+ *     // Phase 2: per-instance setup and public API. `state`'s methods
+ *     // (storage.get/put, …) are RuntimeContext-colored, so the actual
+ *     // I/O happens here, in the runtime closure.
  *     return {
  *       save: (data: string) => db.exec("INSERT ..."),
  *       fetch: Effect.gen(function* () { ... }),
- *       webSocketMessage: Effect.fnUntraced(function* (ws, msg) { ... }),
+ *       webSocketMessage: Effect.fn(function* (ws, msg) { ... }),
  *     };
  *   });
  * })
@@ -241,15 +254,16 @@ export class DurableObjectNamespaceScope extends Context.Service<
  * export default class Counter extends Cloudflare.DurableObjectNamespace<Counter>()(
  *   "Counter",
  *   Effect.gen(function* () {
- *     // init: bind resources
+ *     // init: bind resources + resolve the instance state ref
  *     const db = yield* Cloudflare.D1Connection.bind(MyDB);
+ *     const state = yield* Cloudflare.DurableObjectState;
  *
  *     return Effect.gen(function* () {
- *       const state = yield* Cloudflare.DurableObjectState;
+ *       // runtime: state's storage methods are RuntimeContext-colored,
+ *       // so the reads/writes live here
  *       const count = (yield* state.storage.get<number>("count")) ?? 0;
  *
  *       return {
- *         // runtime: use them
  *         increment: () =>
  *           Effect.gen(function* () {
  *             const next = count + 1;
@@ -283,15 +297,16 @@ export class DurableObjectNamespaceScope extends Context.Service<
  *
  * export default Counter.make(
  *   Effect.gen(function* () {
- *     // init: bind resources
+ *     // init: bind resources + resolve the instance state ref
  *     const db = yield* Cloudflare.D1Connection.bind(MyDB);
+ *     const state = yield* Cloudflare.DurableObjectState;
  *
  *     return Effect.gen(function* () {
- *       const state = yield* Cloudflare.DurableObjectState;
+ *       // runtime: state's storage methods are RuntimeContext-colored,
+ *       // so the reads/writes live here
  *       const count = (yield* state.storage.get<number>("count")) ?? 0;
  *
  *       return {
- *         // runtime: use them
  *         increment: () =>
  *           Effect.gen(function* () {
  *             const next = count + 1;
@@ -493,14 +508,15 @@ export class DurableObjectNamespaceScope extends Context.Service<
  *
  * @section Accessing Instance State
  * Each Durable Object instance has its own transactional key-value
- * storage via `Cloudflare.DurableObjectState`. Use `storage.get` and
- * `storage.put` inside the inner Effect to persist data across requests
- * and restarts.
+ * storage via `Cloudflare.DurableObjectState`. Resolve the `state`
+ * *reference* in the outer (init) Effect, but call its methods —
+ * `storage.get`, `storage.put`, … — only from the inner (runtime)
+ * Effect: those methods are `RuntimeContext`-colored, so the type
+ * system only allows them inside the runtime closure.
  *
  * @example Reading and writing durable storage
  * ```typescript
- * const state = yield* Cloudflare.DurableObjectState;
- *
+ * // inner (runtime) Effect — `state` was resolved in the outer Effect
  * yield* state.storage.put("counter", 42);
  * const value = yield* state.storage.get("counter");
  * ```
@@ -526,7 +542,7 @@ export class DurableObjectNamespaceScope extends Context.Service<
  * @example Handling messages and close events
  * ```typescript
  * return {
- *   webSocketMessage: Effect.fnUntraced(function* (
+ *   webSocketMessage: Effect.fn(function* (
  *     socket: Cloudflare.DurableWebSocket,
  *     message: string | Uint8Array,
  *   ) {
@@ -535,7 +551,7 @@ export class DurableObjectNamespaceScope extends Context.Service<
  *       : new TextDecoder().decode(message);
  *     // process the message
  *   }),
- *   webSocketClose: Effect.fnUntraced(function* (
+ *   webSocketClose: Effect.fn(function* (
  *     ws: Cloudflare.DurableWebSocket,
  *     code: number,
  *     reason: string,
@@ -546,37 +562,42 @@ 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).
+ * Resolve the `state` reference in the outer Effect, but place the
+ * rehydration loop (`state.getWebSockets()` is `RuntimeContext`-colored)
+ * **inside the inner `Effect.gen`** so it runs every time the DO
+ * instance is reconstructed (including after Cloudflare wakes the DO
+ * from hibernation).
  *
  * ```typescript
- * return Effect.gen(function* () {
+ * 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 Effect.gen(function* () {
+ *     const sessions = new Map<string, Cloudflare.DurableWebSocket>();
  *
- *   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);
- *       }
- *     }),
- *   };
+ *     // 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.fn(function* (socket, message) {
+ *         const text =
+ *           typeof message === "string" ? message : new TextDecoder().decode(message);
+ *         for (const peer of sessions.values()) {
+ *           yield* peer.send(text);
+ *         }
+ *       }),
+ *     };
+ *   });
  * });
  * ```
  *
@@ -834,9 +855,11 @@ export const DurableObjectNamespace: DurableObjectNamespaceClass =
           };
         });
 
-      const make = Effect.fnUntraced(function* (
+      const make = Effect.fn(function* (
         impl: Effect.Effect<
-          Effect.Effect<DurableObjectShape, never, DurableObjectState>
+          Effect.Effect<DurableObjectShape>,
+          never,
+          DurableObjectState
         >,
       ) {
         // Register the local DO binding (no `scriptName`) and obtain the
@@ -845,12 +868,29 @@ export const DurableObjectNamespace: DurableObjectNamespaceClass =
         // and also return it so a `Layer.effect(tag, make(impl))` Layer
         // resolves the tag to a concrete namespace value.
         const self = yield* binding();
+        const phase = yield* ALCHEMY_PHASE;
+        const constructor = impl.pipe(
+          Effect.provide(
+            Layer.succeed(DurableObjectNamespaceScope, self as any),
+          ),
+        );
+        if (phase === "plan") {
+          // during plan time, we evaluate the constructor with a mock DurableObjectState
+          // to trigger discovery of bindings
+          yield* constructor.pipe(
+            Effect.provide(
+              Layer.succeed(
+                DurableObjectState,
+                // mock during plan time
+                fromDurableObjectState({ storage: {} } as any),
+              ),
+            ),
+          );
+        }
         yield* (yield* Worker).export(namespace, {
           kind: "durableObject",
           // initialize the object's constructor (apply infra dependencies)
-          constructor: yield* impl.pipe(
-            Effect.provideService(DurableObjectNamespaceScope, self as any),
-          ),
+          constructor,
           // grab the object's infra dependencies so we can apply them when calling the instance's methods
           services: yield* Effect.context<Effect.Services<typeof impl>>(),
         } satisfies DurableObjectExport);
@@ -869,7 +909,19 @@ export const DurableObjectNamespace: DurableObjectNamespaceClass =
       } else if (Effect.isEffect(propsOrImpl)) {
         // inline Effect DO
         return effectClass(
-          Effect.tap(binding(), () => make(propsOrImpl as any)),
+          Effect.tap(binding(), () =>
+            make(propsOrImpl as any).pipe(
+              Effect.provideService(
+                DurableObjectState,
+                fromDurableObjectState(
+                  // everything is lazy, so this should build a proper mock
+                  {
+                    storage: {},
+                  } as any,
+                ),
+              ),
+            ),
+          ),
         );
       } else {
         // Tagged Effect DO. Yielding the class resolves the `tag`, which

package/src/Cloudflare/Workers/DurableObjectState.ts

@@ -1,6 +1,7 @@
 import type * as cf from "@cloudflare/workers-types";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
+import type { RuntimeContext } from "../../RuntimeContext.ts";
 import {
   fromDurableObjectStorage,
   type DurableObjectStorage,
@@ -14,23 +15,36 @@ export class DurableObjectState extends Context.Service<
     readonly storage: DurableObjectStorage;
     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[]>;
+      callback: () => Effect.Effect<T, never, RuntimeContext>,
+    ): Effect.Effect<T, never, RuntimeContext>;
+    acceptWebSocket(
+      ws: DurableWebSocket,
+      tags?: string[],
+    ): Effect.Effect<void, never, RuntimeContext>;
+    getWebSockets(
+      tag?: string,
+    ): Effect.Effect<DurableWebSocket[], never, RuntimeContext>;
     setWebSocketAutoResponse(
       maybeReqResp?: cf.WebSocketRequestResponsePair,
-    ): Effect.Effect<void>;
-    getWebSocketAutoResponse(): Effect.Effect<cf.WebSocketRequestResponsePair | null>;
+    ): Effect.Effect<void, never, RuntimeContext>;
+    getWebSocketAutoResponse(): Effect.Effect<
+      cf.WebSocketRequestResponsePair | null,
+      never,
+      RuntimeContext
+    >;
     getWebSocketAutoResponseTimestamp(
       ws: cf.WebSocket,
-    ): Effect.Effect<Date | null>;
+    ): Effect.Effect<Date | null, never, RuntimeContext>;
     setHibernatableWebSocketEventTimeout(
       timeoutMs?: number,
-    ): Effect.Effect<void>;
-    getHibernatableWebSocketEventTimeout(): Effect.Effect<number | null>;
-    getTags(ws: cf.WebSocket): Effect.Effect<string[]>;
-    abort(reason?: string): Effect.Effect<void>;
+    ): Effect.Effect<void, never, RuntimeContext>;
+    getHibernatableWebSocketEventTimeout(): Effect.Effect<
+      number | null,
+      never,
+      RuntimeContext
+    >;
+    getTags(ws: cf.WebSocket): Effect.Effect<string[], never, RuntimeContext>;
+    abort(reason?: string): Effect.Effect<void, never, RuntimeContext>;
   }
 >()("Cloudflare.DurableObjectState") {}