effect-cf 0.33.0 → 0.35.0

package/src/DurableObjectNamespace.ts

@@ -7,6 +7,7 @@ import type * as DurableObjectDefinition from "./DurableObjectDefinition";
 import * as RpcDefinition from "./RpcDefinition";
 import * as ErrorMessage from "./internal/ErrorMessage";
 import * as RpcInvocation from "./internal/RpcInvocation";
+import * as RpcTracing from "./RpcTracing";
 
 const expectedDurableObjectNamespace =
   "Durable Object namespace binding with getByName(), get(), idFromName(), idFromString(), newUniqueId(), and jurisdiction()";
@@ -39,29 +40,20 @@ export type DurableObjectStubClient<Api extends object> = DurableObjectFetcher &
     readonly name?: string;
   };
 
-/**
- * Native Durable Object namespace binding shape.
- */
 export interface DurableObjectNamespaceClient<Api extends object> {
-  /** Creates a globally unique Durable Object id. */
   newUniqueId(
     options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions,
   ): globalThis.DurableObjectId;
-  /** Deterministically maps a name to a Durable Object id. */
   idFromName(name: string): globalThis.DurableObjectId;
-  /** Rehydrates a Durable Object id from its string form. */
   idFromString(id: string): globalThis.DurableObjectId;
-  /** Returns a stub for an existing Durable Object id. */
   get(
     id: globalThis.DurableObjectId,
     options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
   ): DurableObjectStubClient<Api>;
-  /** Returns a stub by deterministic name. */
   getByName(
     name: string,
     options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
   ): DurableObjectStubClient<Api>;
-  /** Selects a namespace pinned to a specific jurisdiction. */
   jurisdiction(
     jurisdiction: globalThis.DurableObjectJurisdiction,
   ): DurableObjectNamespaceClient<Api>;
@@ -80,10 +72,10 @@ export interface DurableObjectNamespaceDefinition {
 export interface DurableObjectNamespaceBindingDefinition<
   Definition extends DurableObjectDefinition.Definition.Any | undefined = undefined,
 > {
-  /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
-  /** Optional RPC schema used for argument/result encoding. */
   readonly definition?: Definition;
+  /** Append live trace context only when the receiver also enables rpcTracing. */
+  readonly rpcTracing?: boolean;
 }
 
 /**
@@ -199,46 +191,22 @@ export type DurableObjectNamespaceEffectClient<
   Api extends object,
   Definition extends DurableObjectDefinition.Definition.Any | undefined = undefined,
 > = DirectMethods<never, Api, Definition> & {
-  /** Creates a globally unique Durable Object id. */
   readonly newUniqueId: (
     options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions,
   ) => Effect.Effect<globalThis.DurableObjectId>;
-  /** Deterministically maps a name to a Durable Object id. */
   readonly idFromName: (name: string) => Effect.Effect<globalThis.DurableObjectId>;
-  /** Rehydrates a Durable Object id from its string form. */
   readonly idFromString: (id: string) => Effect.Effect<globalThis.DurableObjectId>;
-  /** Returns a stub for an existing Durable Object id. */
   readonly get: (
     id: globalThis.DurableObjectId,
     options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
   ) => Effect.Effect<DurableObjectStubClient<Api>>;
-  /** Returns a stub by deterministic name. */
   readonly getByName: (
     name: string,
     options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
   ) => Effect.Effect<DurableObjectStubClient<Api>>;
-  /** Selects a namespace pinned to a specific jurisdiction. */
   readonly jurisdiction: (
     jurisdiction: globalThis.DurableObjectJurisdiction,
   ) => Effect.Effect<DurableObjectNamespaceClient<Api>>;
-  /**
-   * Forwards an HTTP request to a Durable Object stub.
-   *
-   * Use this for fetch-based Durable Object APIs, including WebSocket upgrade
-   * forwarding where the native response must be preserved.
-   *
-   * @example
-   * ```ts
-   * import { Effect } from "effect";
-   *
-   * const program = Effect.gen(function* () {
-   *   const rooms = yield* ChatRooms;
-   *   const room = yield* rooms.getByName("general");
-   *
-   *   return yield* rooms.fetch(room, new Request("https://worker.example/room"));
-   * });
-   * ```
-   */
   readonly fetch: (
     stub: DurableObjectStubClient<Api>,
     input: RequestInfo | URL,
@@ -252,21 +220,6 @@ export type DurableObjectNamespaceEffectClient<
    * promise-like value and it does not decode definition-backed success schemas.
    *
    * Most application code should use {@link call} instead.
-   *
-   * @example
-   * ```ts
-   * import { Effect } from "effect";
-   *
-   * const program = Effect.gen(function* () {
-   *   const counters = yield* Counters;
-   *   const counter = yield* counters.getByName("main");
-   *
-   *   const result = yield* counters.rpc(counter, "get");
-   *   const value = yield* Effect.promise(() => result);
-   *
-   *   return value;
-   * });
-   * ```
    */
   readonly rpc: <Method extends StubMethodKey<Api>>(
     stub: DurableObjectStubClient<Api>,
@@ -278,18 +231,6 @@ export type DurableObjectNamespaceEffectClient<
    * decodes the success value when the namespace was created from a definition.
    *
    * This is the normal choice when application code wants the final typed value.
-   *
-   * @example
-   * ```ts
-   * import { Effect } from "effect";
-   *
-   * const program = Effect.gen(function* () {
-   *   const counters = yield* Counters;
-   *   const counter = yield* counters.getByName("main");
-   *
-   *   return yield* counters.call(counter, "increment", 1);
-   * });
-   * ```
    */
   readonly call: <Method extends StubMethodKey<Api>>(
     stub: DurableObjectStubClient<Api>,
@@ -304,27 +245,12 @@ export type DurableObjectNamespaceEffectClient<
    *
    * Use this for RPC methods that return Cloudflare RPC resources or other
    * disposable objects whose lifetime should be tied to an Effect scope.
-   *
-   * @example
-   * ```ts
-   * import { Effect } from "effect";
-   *
-   * const program = Effect.scoped(
-   *   Effect.gen(function* () {
-   *     const rooms = yield* ChatRooms;
-   *     const room = yield* rooms.getByName("general");
-   *     const handle = yield* rooms.scopedCall(room, "openStream");
-   *
-   *     return yield* handle.read();
-   *   }),
-   * );
-   * ```
    */
   readonly scopedCall: <Method extends StubMethodKey<Api>>(
     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.
    *
@@ -374,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>;
 };
 
@@ -425,13 +355,30 @@ 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 }),
       });
 
-    const rpc = Effect.fn("DurableObjectNamespace.rpc")(function* <
-      Method extends StubMethodKey<Api>,
-    >(stub: StubClient, method: Method, ...args: StubMethodArgs<Api, Method>) {
+    const rpc = Effect.fnUntraced(function* <Method extends StubMethodKey<Api>>(
+      stub: StubClient,
+      method: Method,
+      ...args: StubMethodArgs<Api, Method>
+    ): Effect.fn.Return<StubMethodCloudflareReturn<Api, Method>, DurableObjectRpcError> {
       const methodName = String(method);
       // SAFETY: the runtime definition and method name select the same method schemas as Method.
       const encodedArgs =
@@ -452,11 +399,15 @@ export const makeClient = <
               ),
             );
 
-      // SAFETY: encodedArgs preserves the selected method's positional argument contract.
+      const nativeArgs = definition.rpcTracing
+        ? yield* RpcTracing.withRpcTraceContext(encodedArgs)
+        : encodedArgs;
+
+      // SAFETY: domain arguments retain their encoded order; an opted-in receiver strips only valid trace metadata.
       return yield* RpcInvocation.invokeRpcMethod(
         stub,
         method,
-        encodedArgs as StubMethodArgs<Api, Method>,
+        nativeArgs as StubMethodArgs<Api, Method>,
         (cause) =>
           new DurableObjectRpcError({
             binding: definition.binding,
@@ -466,9 +417,10 @@ export const makeClient = <
       );
     });
 
-    const decodeSuccess = Effect.fn("DurableObjectNamespace.decodeSuccess")(function* <
-      Method extends StubMethodKey<Api>,
-    >(methodName: string, value: Awaited<StubMethodCloudflareReturn<Api, Method>>) {
+    const decodeSuccess = Effect.fnUntraced(function* <Method extends StubMethodKey<Api>>(
+      methodName: string,
+      value: Awaited<StubMethodCloudflareReturn<Api, Method>>,
+    ): Effect.fn.Return<StubMethodSuccess<Api, Method>, DurableObjectRpcError> {
       if (definition.definition === undefined) {
         // SAFETY: without a schema codec, the native RPC result is already the declared success type.
         return value as StubMethodSuccess<Api, Method>;
@@ -494,33 +446,54 @@ export const makeClient = <
       return decoded as StubMethodSuccess<Api, Method>;
     });
 
-    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,
-            }),
-        ),
-      );
-
-      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 call = Effect.fnUntraced(
+      function* <Method extends StubMethodKey<Api>>(
+        stub: StubClient,
+        method: Method,
+        ...args: StubMethodArgs<Api, Method>
+      ): Effect.fn.Return<StubMethodSuccess<Api, Method>, DurableObjectRpcError> {
+        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);
+      },
+      (effect, ...args) =>
+        RpcTracing.withRpcClientSpan(effect, definition.binding, String(args[1])),
+    );
+
+    const scopedCall = Effect.fnUntraced(
+      function* <Method extends StubMethodKey<Api>>(
+        stub: StubClient,
+        method: Method,
+        ...args: StubMethodArgs<Api, Method>
+      ): 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).pipe(
+          Effect.mapError(
+            (cause) =>
+              new DurableObjectRpcError({
+                binding: definition.binding,
+                method: methodName,
+                cause,
+              }),
+          ),
+        );
+
+        return yield* decodeSuccess<Method>(methodName, value);
+      },
+      (effect, ...args) =>
+        RpcTracing.withRpcClientSpan(effect, definition.binding, String(args[1])),
+    );
 
     const directMethods = makeDirectMethods<never, Api, Definition>(definition.definition, {
       call,

package/src/DurableObjectRpcWebSocket.ts

@@ -22,14 +22,12 @@ const serviceRestartReason = "Durable Object RPC activation reset";
 /** Heartbeat handling for Effect's application-level RPC Ping messages. */
 export type HeartbeatPolicy = "auto-response" | "passthrough";
 
-/** Object-shaped application attachment fields that can coexist with adapter metadata. */
 export type RpcWebSocketAttachment = object;
 
 /** A resumable RPC stream declaration understood by the websocket transport. */
 export interface ResumableStreamDeclaration<ResumeDescriptor = unknown, Checkpoint = unknown> {
   /** Stable declaration identifier. Change it when the persisted representation changes. */
   readonly id: string;
-  /** RPC tag matched against encoded client requests. */
   readonly rpcTag: string;
   /** Validates a resume descriptor restored from a websocket attachment. */
   readonly resumeDescriptorSchema: Schema.Decoder<ResumeDescriptor>;
@@ -45,7 +43,6 @@ export interface ResumableStreamDeclaration<ResumeDescriptor = unknown, Checkpoi
     readonly resumeDescriptor: ResumeDescriptor;
     readonly acknowledgedCheckpoint: Checkpoint;
   }>;
-  /** Rebuilds the encoded request fields used to restart a handler. */
   readonly rebuild: (options: {
     readonly subscriptionKey: string;
     readonly resumeDescriptor: ResumeDescriptor;
@@ -80,9 +77,7 @@ export const resumableStream = <ResumeDescriptor, Checkpoint>(
  * Configuration for {@link layer}.
  */
 export interface LayerOptions {
-  /** Tag used to select hibernated sockets. */
   readonly tag?: string | undefined;
-  /** Socket attachment namespace used to persist adapter metadata across hibernation. */
   readonly attachmentKey?: string | undefined;
   /**
    * Heartbeat behavior. `"auto-response"` (the default) installs Cloudflare's
@@ -95,24 +90,16 @@ export interface LayerOptions {
    * when RPC and unrelated websocket protocols share one object.
    */
   readonly heartbeat?: HeartbeatPolicy | undefined;
-  /** Explicit stream declarations that may be reconstructed after activation loss. */
   readonly resumableStreams?: ReadonlyArray<AnyResumableStreamDeclaration> | undefined;
 }
 
-/** Native websocket event payload accepted by Cloudflare Durable Objects. */
 export type NativeWebSocketMessage = string | ArrayBuffer;
 
-/**
- * Service API used to wire websocket lifecycle events to Effect RPC server protocol.
- */
 export interface DurableObjectRpcWebSocketService {
-  /** Accepts a new, not-yet-accepted socket with the RPC tag and any application tags. */
+  /** Accept a server socket that has not already been accepted. */
   readonly accept: (socket: DurableWebSocket, tags?: ReadonlyArray<string>) => Effect.Effect<void>;
-  /**
-   * Creates and accepts a websocket upgrade without double-accepting the server
-   * socket. Application attachment fields are shallow-merged with the adapter's
-   * metadata namespace.
-   */
+
+  /** Shallow-merges application attachment fields with the adapter's metadata namespace. */
   readonly acceptUpgrade: <Attachment extends RpcWebSocketAttachment = RpcWebSocketAttachment>(
     options?: AcceptUpgradeOptions<Attachment>,
   ) => Effect.Effect<AcceptedUpgrade<Attachment>, DurableWebSocketAttachmentError>;
@@ -211,9 +198,6 @@ const ResumableAttachmentMetadataSchema = Schema.Struct({
 
 const decodeResumableAttachment = Schema.decodeUnknownOption(ResumableAttachmentMetadataSchema);
 
-/**
- * Context tag for the Durable Object RPC websocket service.
- */
 export class DurableObjectRpcWebSocket extends Context.Service<
   DurableObjectRpcWebSocket,
   DurableObjectRpcWebSocketService
@@ -246,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>();
@@ -284,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,
@@ -393,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;
@@ -450,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();
@@ -863,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,
@@ -1157,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/DurableObjectSqlite.ts

@@ -4,20 +4,8 @@ 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" | "storage">;
 
-/**
- * Provides `effect/unstable/sql` from the current Durable Object SQLite storage.
- *
- * @example
- * ```ts
- * const RoomLayer = Layer.mergeAll(
- *   DurableObjectSqlite.layer(),
- *   OtherRoomServices,
- * );
- * ```
- */
 export const layer = (
   options?: SqliteLayerOptions,
 ): Layer.Layer<SqliteClient.SqliteClient | SqlClient.SqlClient, never, DurableObjectState> =>

package/src/DurableObjectState.ts

@@ -3,19 +3,16 @@ 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";
 
 /**
  * Effect-friendly wrapper around Cloudflare `DurableObjectState`.
  */
 export interface DurableObjectStateService {
-  /** Underlying Cloudflare state instance. */
   readonly raw: globalThis.DurableObjectState;
-  /** Durable Object id for the current instance. */
   readonly id: globalThis.DurableObjectId;
-  /** Wrapped storage API. */
   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
@@ -47,21 +44,13 @@ export interface DurableObjectStateService {
    * documented timeout (currently 30 seconds).
    */
   blockConcurrencyWhileOrReset<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
-  /** Accepts a websocket connection for hibernation-capable Durable Objects. */
   acceptWebSocket(ws: DurableWebSocket, tags?: Array<string>): Effect.Effect<void>;
-  /** Lists active sockets, optionally filtered by tag. */
   getWebSockets(tag?: string): Effect.Effect<Array<DurableWebSocket>>;
-  /** Configures automatic request/response handling for sockets. */
   setWebSocketAutoResponse(pair?: WebSocketRequestResponsePair): Effect.Effect<void>;
-  /** Gets the configured websocket auto-response pair. */
   getWebSocketAutoResponse: Effect.Effect<WebSocketRequestResponsePair | null>;
-  /** Timestamp of the last automatic websocket response for a socket. */
   getWebSocketAutoResponseTimestamp(ws: DurableWebSocket): Effect.Effect<Date | null>;
-  /** Sets the timeout for hibernatable websocket events. */
   setHibernatableWebSocketEventTimeout(timeoutMs?: number): Effect.Effect<void>;
-  /** Gets the timeout for hibernatable websocket events. */
   getHibernatableWebSocketEventTimeout: Effect.Effect<number | null>;
-  /** Reads tags attached to a websocket. */
   getTags(ws: DurableWebSocket): Effect.Effect<Array<string>>;
   /**
    * Forcibly resets the Durable Object. Cloudflare logs an uncaught Error using
@@ -73,17 +62,11 @@ export interface DurableObjectStateService {
   abort(reason?: string, options?: globalThis.DurableObjectAbortOptions): Effect.Effect<void>;
 }
 
-/**
- * Context tag for accessing the current Durable Object state service.
- */
 export class DurableObjectState extends Context.Service<
   DurableObjectState,
   DurableObjectStateService
 >()("effect-cf/DurableObjectState") {}
 
-/**
- * Wraps a native Cloudflare `DurableObjectState` as a {@link DurableObjectStateService}.
- */
 export const fromDurableObjectState = (
   state: globalThis.DurableObjectState,
 ): DurableObjectStateService => {
@@ -105,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) =>
@@ -143,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);