effect-cf 0.5.0 → 0.7.0

package/src/DurableObjectNamespace.ts

@@ -1,4 +1,4 @@
-import { Data, Effect } from "effect";
+import { Context, Data, Effect, type Scope } from "effect";
 
 import * as Binding from "./Binding";
 import * as CloudflareRpc from "./Rpc";
@@ -6,8 +6,6 @@ import type * as DurableObjectDefinition from "./DurableObjectDefinition";
 import * as RpcDefinition from "./RpcDefinition";
 import * as RpcInvocation from "./internal/RpcInvocation";
 
-const TypeId = "effect-cf/DurableObjectNamespace" as const;
-
 interface DurableObjectFetcher {
   fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
 }
@@ -66,14 +64,6 @@ export interface DurableObjectNamespaceDefinition {
   readonly binding: string;
 }
 
-type ApiFromDefinition<Definition> = Definition extends DurableObjectDefinition.Definition.Any
-  ? DurableObjectDefinition.ServerApi<Definition>
-  : never;
-
-type ApiOrDefinition<Api extends object, Definition> = [Api] extends [never]
-  ? ApiFromDefinition<Definition>
-  : Api;
-
 /**
  * Namespace binding metadata with optional RPC schema.
  */
@@ -109,25 +99,30 @@ type StubMethodSuccess<Api, Method extends keyof Api> = RpcInvocation.AsyncMetho
   Api,
   Method
 >;
+type StubMethodCloudflareReturn<
+  Api,
+  Method extends keyof Api,
+> = RpcInvocation.AsyncMethodCloudflareReturn<Api, Method>;
 
-type StubCall<Api extends object> = <Method extends StubMethodKey<Api>>(
+type StubCall<R, Api extends object> = <Method extends StubMethodKey<Api>>(
   stub: DurableObjectStubClient<Api>,
   method: Method,
   ...args: StubMethodArgs<Api, Method>
-) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError>;
+) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError, R>;
 
-type DurableObjectDirectClient<Self, Api extends object> = {
+type DurableObjectDirectClient<R, Api extends object> = {
   readonly fetch: (
     input: RequestInfo | URL,
     init?: RequestInit,
-  ) => Effect.Effect<globalThis.Response, DurableObjectFetchError, Self>;
+  ) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
 } & {
   readonly [Method in StubMethodKey<Api>]: (
     ...args: StubMethodArgs<Api, Method>
-  ) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError, Self>;
+  ) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError, R>;
 };
 
 type DefinitionNamespaceDirectMethods<
+  R,
   Api extends object,
   Definition extends DurableObjectDefinition.Definition.Any,
 > = {
@@ -136,141 +131,281 @@ type DefinitionNamespaceDirectMethods<
     ...args: RpcDefinition.Method.Args<Definition["methods"][Method]>
   ) => Effect.Effect<
     RpcDefinition.Method.Success<Definition["methods"][Method]>,
-    DurableObjectRpcError
+    DurableObjectRpcError,
+    R
   >;
 };
 
 type DefinitionDurableObjectDirectClient<
-  Self,
+  R,
   Definition extends DurableObjectDefinition.Definition.Any,
 > = {
   readonly fetch: (
     input: RequestInfo | URL,
     init?: RequestInit,
-  ) => Effect.Effect<globalThis.Response, DurableObjectFetchError, Self>;
+  ) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
 } & {
   readonly [Method in RpcDefinition.Definition.MethodNames<Definition>]: (
     ...args: RpcDefinition.Method.Args<Definition["methods"][Method]>
   ) => Effect.Effect<
     RpcDefinition.Method.Success<Definition["methods"][Method]>,
     DurableObjectRpcError,
-    Self
+    R
   >;
 };
 
 type DefinitionNamespaceDirectClientMethods<
-  Self,
+  R,
   Definition extends DurableObjectDefinition.Definition.Any,
 > = {
   readonly byName: (
     name: string,
     options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
-  ) => DefinitionDurableObjectDirectClient<Self, Definition>;
+  ) => DefinitionDurableObjectDirectClient<R, Definition>;
   readonly byId: (
     id: globalThis.DurableObjectId,
     options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
-  ) => DefinitionDurableObjectDirectClient<Self, Definition>;
+  ) => DefinitionDurableObjectDirectClient<R, Definition>;
 };
 
 type DirectMethods<
-  Self,
+  R,
   Api extends object,
   Definition,
 > = Definition extends DurableObjectDefinition.Definition.Any
-  ? DefinitionNamespaceDirectMethods<Api, Definition> &
-      DefinitionNamespaceDirectClientMethods<Self, Definition>
+  ? DefinitionNamespaceDirectMethods<R, Api, Definition> &
+      DefinitionNamespaceDirectClientMethods<R, Definition>
   : {};
 
-/**
- * Creates a typed Effect service for a Durable Object namespace binding.
- *
- * Returned value includes namespace helpers (`get`, `getByName`, `newUniqueId`),
- * raw `fetch` / `call` helpers, and direct RPC helpers when `definition` is provided.
- *
- * @example
- * ```ts
- * const ChatRoom = DurableObjectDefinition.make("ChatRoom", {
- *   postMessage: DurableObjectDefinition.method({
- *     args: [Schema.String],
- *     success: Schema.Void,
- *   }),
- * });
- *
- * const ChatRooms = ChatRoom.namespace("CHAT_ROOMS", { binding: "CHAT_ROOMS" });
- *
- * const program = Effect.gen(function* () {
- *   const room = ChatRooms.byName("general");
- *   yield* room.postMessage("hello");
- * });
- * ```
- */
-export const Service =
-  <Self, Api extends object = never>() =>
-  <
-    Id extends string,
-    const Definition extends DurableObjectDefinition.Definition.Any | undefined = undefined,
-  >(
-    id: Id,
-    definition: DurableObjectNamespaceBindingDefinition<Definition>,
-  ) => {
-    type NamespaceApi = ApiOrDefinition<Api, Definition>;
-    type NamespaceClient = DurableObjectNamespaceClient<NamespaceApi>;
-    type StubClient = DurableObjectStubClient<NamespaceApi>;
-
-    const hasFunction = (value: object, key: string): boolean =>
-      typeof Reflect.get(value, key) === "function";
-
-    const isDurableObjectNamespaceClient = (value: unknown): value is NamespaceClient =>
-      typeof value === "object" &&
-      value !== null &&
-      hasFunction(value, "getByName") &&
-      hasFunction(value, "get") &&
-      hasFunction(value, "idFromName") &&
-      hasFunction(value, "idFromString") &&
-      hasFunction(value, "newUniqueId") &&
-      hasFunction(value, "jurisdiction");
-
-    const tag = Binding.Service<Self>()(id, definition.binding, (value): value is NamespaceClient =>
-      isDurableObjectNamespaceClient(value),
-    );
-
-    const newUniqueId = Effect.fnUntraced(function* (
-      options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions,
-    ) {
-      const namespace = yield* tag;
-      return namespace.newUniqueId(options);
-    });
+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,
+    init?: RequestInit,
+  ) => Effect.Effect<globalThis.Response, DurableObjectFetchError>;
+  /**
+   * Invokes a Durable Object RPC method and returns Cloudflare's raw RPC result.
+   *
+   * This preserves Cloudflare RPC behavior such as promise-like pipelining and
+   * transferable / disposable result objects. It does not resolve the returned
+   * 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>,
+    method: Method,
+    ...args: StubMethodArgs<Api, Method>
+  ) => Effect.Effect<StubMethodCloudflareReturn<Api, Method>, DurableObjectRpcError>;
+  /**
+   * Invokes a Durable Object RPC method, resolves Cloudflare's RPC result, and
+   * 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>,
+    method: Method,
+    ...args: StubMethodArgs<Api, Method>
+  ) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError>;
+  /**
+   * Invokes a Durable Object RPC method in the current `Scope`, resolves
+   * Cloudflare's RPC result, decodes definition-backed success values, and
+   * disposes the resolved result when the scope closes if it implements
+   * `Symbol.dispose`.
+   *
+   * 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>;
+  /**
+   * Exposes the underlying native Durable Object namespace binding.
+   *
+   * Prefer the typed helpers above unless Cloudflare exposes a platform feature
+   * that is not wrapped by effect-cf yet.
+   */
+  readonly unsafeRaw: Effect.Effect<DurableObjectNamespaceClient<Api>>;
+};
 
-    const idFromName = Effect.fnUntraced(function* (name: string) {
-      const namespace = yield* tag;
-      return namespace.idFromName(name);
-    });
+export type DurableObjectNamespaceStaticClient<
+  R,
+  Api extends object,
+  Definition extends DurableObjectDefinition.Definition.Any | undefined = undefined,
+> = DirectMethods<R, Api, Definition> & {
+  readonly newUniqueId: (
+    options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions,
+  ) => Effect.Effect<globalThis.DurableObjectId, never, R>;
+  readonly idFromName: (name: string) => Effect.Effect<globalThis.DurableObjectId, never, R>;
+  readonly idFromString: (id: string) => Effect.Effect<globalThis.DurableObjectId, never, R>;
+  readonly get: (
+    id: globalThis.DurableObjectId,
+    options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
+  ) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
+  readonly getByName: (
+    name: string,
+    options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
+  ) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
+  readonly jurisdiction: (
+    jurisdiction: globalThis.DurableObjectJurisdiction,
+  ) => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
+  readonly fetch: (
+    stub: DurableObjectStubClient<Api>,
+    input: RequestInfo | URL,
+    init?: RequestInit,
+  ) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
+  readonly rpc: <Method extends StubMethodKey<Api>>(
+    stub: DurableObjectStubClient<Api>,
+    method: Method,
+    ...args: StubMethodArgs<Api, Method>
+  ) => Effect.Effect<StubMethodCloudflareReturn<Api, Method>, DurableObjectRpcError, R>;
+  readonly call: <Method extends StubMethodKey<Api>>(
+    stub: DurableObjectStubClient<Api>,
+    method: Method,
+    ...args: StubMethodArgs<Api, Method>
+  ) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError, R>;
+  readonly scopedCall: <Method extends StubMethodKey<Api>>(
+    stub: DurableObjectStubClient<Api>,
+    method: Method,
+    ...args: StubMethodArgs<Api, Method>
+  ) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, unknown, Scope.Scope | R>;
+  readonly unsafeRaw: () => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
+};
 
-    const idFromString = Effect.fnUntraced(function* (id: string) {
-      const namespace = yield* tag;
-      return namespace.idFromString(id);
-    });
+const hasFunction = (value: object, key: string): boolean =>
+  typeof Reflect.get(value, key) === "function";
+
+export const isDurableObjectNamespaceClient = <Api extends object>(
+  value: unknown,
+): value is DurableObjectNamespaceClient<Api> =>
+  typeof value === "object" &&
+  value !== null &&
+  hasFunction(value, "getByName") &&
+  hasFunction(value, "get") &&
+  hasFunction(value, "idFromName") &&
+  hasFunction(value, "idFromString") &&
+  hasFunction(value, "newUniqueId") &&
+  hasFunction(value, "jurisdiction");
+
+export const makeClient = <
+  Api extends object,
+  const Definition extends DurableObjectDefinition.Definition.Any | undefined = undefined,
+>(
+  definition: DurableObjectNamespaceBindingDefinition<Definition>,
+): ((
+  namespace: DurableObjectNamespaceClient<Api>,
+) => DurableObjectNamespaceEffectClient<Api, Definition>) => {
+  type NamespaceClient = DurableObjectNamespaceClient<Api>;
+  type StubClient = DurableObjectStubClient<Api>;
+
+  return (namespace: NamespaceClient) => {
+    const newUniqueId = (options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions) =>
+      Effect.sync(() => namespace.newUniqueId(options));
 
-    const get = Effect.fnUntraced(function* (
+    const idFromName = (name: string) => Effect.sync(() => namespace.idFromName(name));
+
+    const idFromString = (id: string) => Effect.sync(() => namespace.idFromString(id));
+
+    const get = (
       id: globalThis.DurableObjectId,
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
-    ) {
-      const namespace = yield* tag;
-      return namespace.get(id, options);
-    });
+    ) => Effect.sync(() => namespace.get(id, options));
 
-    const getByName = Effect.fnUntraced(function* (
+    const getByName = (
       name: string,
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
-    ) {
-      const namespace = yield* tag;
-      return namespace.getByName(name, options);
-    });
+    ) => Effect.sync(() => namespace.getByName(name, options));
 
-    const jurisdiction = Effect.fnUntraced(function* (value: globalThis.DurableObjectJurisdiction) {
-      const namespace = yield* tag;
-      return namespace.jurisdiction(value);
-    });
+    const jurisdiction = (value: globalThis.DurableObjectJurisdiction) =>
+      Effect.sync(() => namespace.jurisdiction(value));
 
     const fetch = (stub: StubClient, input: RequestInfo | URL, init?: RequestInit) =>
       Effect.tryPromise({
@@ -278,10 +413,10 @@ export const Service =
         catch: (cause) => new DurableObjectFetchError({ binding: definition.binding, cause }),
       });
 
-    const rpc = <Method extends StubMethodKey<NamespaceApi>>(
+    const rpc = <Method extends StubMethodKey<Api>>(
       stub: StubClient,
       method: Method,
-      ...args: StubMethodArgs<NamespaceApi, Method>
+      ...args: StubMethodArgs<Api, Method>
     ) =>
       Effect.gen(function* () {
         const methodName = String(method);
@@ -306,7 +441,7 @@ export const Service =
         return yield* RpcInvocation.invokeRpcMethod(
           stub,
           method,
-          encodedArgs as StubMethodArgs<NamespaceApi, Method>,
+          encodedArgs as StubMethodArgs<Api, Method>,
           (cause) =>
             new DurableObjectRpcError({
               binding: definition.binding,
@@ -316,14 +451,20 @@ export const Service =
         );
       });
 
-    const call = <Method extends StubMethodKey<NamespaceApi>>(
-      stub: StubClient,
-      method: Method,
-      ...args: StubMethodArgs<NamespaceApi, Method>
+    const decodeSuccess = <Method extends StubMethodKey<Api>>(
+      methodName: string,
+      value: Awaited<StubMethodCloudflareReturn<Api, Method>>,
     ) =>
       Effect.gen(function* () {
-        const methodName = String(method);
-        const value = yield* CloudflareRpc.resolve(yield* rpc(stub, method, ...args)).pipe(
+        if (definition.definition === undefined) {
+          return value as StubMethodSuccess<Api, Method>;
+        }
+
+        const decoded = yield* RpcDefinition.decodeSuccess(
+          definition.definition,
+          methodName as RpcDefinition.Definition.MethodNames<NonNullable<Definition>>,
+          value,
+        ).pipe(
           Effect.mapError(
             (cause) =>
               new DurableObjectRpcError({
@@ -334,15 +475,17 @@ export const Service =
           ),
         );
 
-        if (definition.definition === undefined) {
-          return value as StubMethodSuccess<NamespaceApi, Method>;
-        }
+        return decoded as StubMethodSuccess<Api, Method>;
+      });
 
-        const decoded = yield* RpcDefinition.decodeSuccess(
-          definition.definition,
-          methodName as RpcDefinition.Definition.MethodNames<NonNullable<Definition>>,
-          value,
-        ).pipe(
+    const call = <Method extends StubMethodKey<Api>>(
+      stub: StubClient,
+      method: Method,
+      ...args: StubMethodArgs<Api, Method>
+    ) =>
+      Effect.gen(function* () {
+        const methodName = String(method);
+        const value = yield* CloudflareRpc.resolve(yield* rpc(stub, method, ...args)).pipe(
           Effect.mapError(
             (cause) =>
               new DurableObjectRpcError({
@@ -353,29 +496,29 @@ export const Service =
           ),
         );
 
-        return decoded as StubMethodSuccess<NamespaceApi, Method>;
+        return yield* decodeSuccess<Method>(methodName, value);
       });
 
-    const scopedCall = <Method extends StubMethodKey<NamespaceApi>>(
+    const scopedCall = <Method extends StubMethodKey<Api>>(
       stub: StubClient,
       method: Method,
-      ...args: StubMethodArgs<NamespaceApi, Method>
+      ...args: StubMethodArgs<Api, Method>
     ) =>
       Effect.gen(function* () {
+        const methodName = String(method);
         const result = yield* rpc(stub, method, ...args);
-        return yield* CloudflareRpc.scoped(result);
+        const value = yield* CloudflareRpc.scoped(result);
+        return yield* decodeSuccess<Method>(methodName, value);
       });
 
-    const directMethods = makeDirectMethods<Self, NamespaceApi, Definition>(definition.definition, {
+    const directMethods = makeDirectMethods<never, Api, Definition>(definition.definition, {
       call,
       fetch,
       get,
       getByName,
     });
 
-    return Object.assign(tag, directMethods, {
-      [TypeId]: TypeId,
-      definition,
+    return Object.assign(directMethods, {
       newUniqueId,
       idFromName,
       idFromString,
@@ -386,46 +529,50 @@ export const Service =
       rpc,
       call,
       scopedCall,
-    }) as typeof tag &
-      DirectMethods<Self, NamespaceApi, Definition> & {
-        readonly [TypeId]: typeof TypeId;
-        readonly definition: DurableObjectNamespaceBindingDefinition<Definition>;
-        readonly newUniqueId: typeof newUniqueId;
-        readonly idFromName: typeof idFromName;
-        readonly idFromString: typeof idFromString;
-        readonly get: typeof get;
-        readonly getByName: typeof getByName;
-        readonly jurisdiction: typeof jurisdiction;
-        readonly fetch: typeof fetch;
-        readonly rpc: typeof rpc;
-        readonly call: typeof call;
-        readonly scopedCall: typeof scopedCall;
-      };
+      unsafeRaw: Effect.succeed(namespace),
+    }) as DurableObjectNamespaceEffectClient<Api, Definition>;
   };
+};
 
-const makeDirectMethods = <
+export const layer = <
   Self,
   Api extends object,
+  const Definition extends DurableObjectDefinition.Definition.Any | undefined = undefined,
+>(
+  tag: Context.Service<Self, DurableObjectNamespaceEffectClient<Api, Definition>>,
+  definition: DurableObjectNamespaceBindingDefinition<Definition>,
+) =>
+  Binding.layer(
+    tag,
+    definition.binding,
+    (value): value is DurableObjectNamespaceClient<Api> =>
+      isDurableObjectNamespaceClient<Api>(value),
+    makeClient<Api, Definition>(definition),
+  );
+
+export const makeDirectMethods = <
+  R,
+  Api extends object,
   Definition extends DurableObjectDefinition.Definition.Any | undefined,
 >(
   rpcDefinition: Definition | undefined,
   helpers: {
-    readonly call: StubCall<Api>;
+    readonly call: StubCall<R, Api>;
     readonly fetch: (
       stub: DurableObjectStubClient<Api>,
       input: RequestInfo | URL,
       init?: RequestInit,
-    ) => Effect.Effect<globalThis.Response, DurableObjectFetchError>;
+    ) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
     readonly get: (
       id: globalThis.DurableObjectId,
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
-    ) => Effect.Effect<DurableObjectStubClient<Api>, never, Self>;
+    ) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
     readonly getByName: (
       name: string,
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
-    ) => Effect.Effect<DurableObjectStubClient<Api>, never, Self>;
+    ) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
   },
-): DirectMethods<Self, Api, Definition> => {
+): DirectMethods<R, Api, Definition> => {
   const methods = {} as Record<string, unknown>;
 
   if (rpcDefinition !== undefined) {
@@ -441,8 +588,8 @@ const makeDirectMethods = <
     }
 
     const makeClient = (
-      getStub: () => Effect.Effect<DurableObjectStubClient<Api>, never, Self>,
-    ): DurableObjectDirectClient<Self, Api> => {
+      getStub: () => Effect.Effect<DurableObjectStubClient<Api>, never, R>,
+    ): DurableObjectDirectClient<R, Api> => {
       const client = {
         fetch: (input: RequestInfo | URL, init?: RequestInit) =>
           Effect.gen(function* () {
@@ -460,12 +607,12 @@ const makeDirectMethods = <
                 stub: DurableObjectStubClient<Api>,
                 method: string,
                 ...args: Array<unknown>
-              ) => Effect.Effect<unknown, DurableObjectRpcError>
+              ) => Effect.Effect<unknown, DurableObjectRpcError, R>
             )(stub, methodName, ...args);
           });
       }
 
-      return client as DurableObjectDirectClient<Self, Api>;
+      return client as DurableObjectDirectClient<R, Api>;
     };
 
     methods.byName = (
@@ -479,5 +626,5 @@ const makeDirectMethods = <
     ) => makeClient(() => helpers.get(id, options));
   }
 
-  return methods as DirectMethods<Self, Api, Definition>;
+  return methods as DirectMethods<R, Api, Definition>;
 };