effect-cf 0.6.0 → 0.8.0

package/src/DurableObjectNamespace.ts

@@ -1,4 +1,4 @@
-import { Data, Effect, type Scope } 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,6 +99,10 @@ type StubMethodSuccess<Api, Method extends keyof Api> = RpcInvocation.AsyncMetho
   Api,
   Method
 >;
+type StubMethodCloudflareReturn<
+  Api,
+  Method extends keyof Api,
+> = RpcInvocation.AsyncMethodCloudflareReturn<Api, Method>;
 
 type StubCall<R, Api extends object> = <Method extends StubMethodKey<Api>>(
   stub: DurableObjectStubClient<Api>,
@@ -128,6 +122,7 @@ type DurableObjectDirectClient<R, Api extends object> = {
 };
 
 type DefinitionNamespaceDirectMethods<
+  R,
   Api extends object,
   Definition extends DurableObjectDefinition.Definition.Any,
 > = {
@@ -136,7 +131,8 @@ type DefinitionNamespaceDirectMethods<
     ...args: RpcDefinition.Method.Args<Definition["methods"][Method]>
   ) => Effect.Effect<
     RpcDefinition.Method.Success<Definition["methods"][Method]>,
-    DurableObjectRpcError
+    DurableObjectRpcError,
+    R
   >;
 };
 
@@ -177,7 +173,7 @@ type DirectMethods<
   Api extends object,
   Definition,
 > = Definition extends DurableObjectDefinition.Definition.Any
-  ? DefinitionNamespaceDirectMethods<Api, Definition> &
+  ? DefinitionNamespaceDirectMethods<R, Api, Definition> &
       DefinitionNamespaceDirectClientMethods<R, Definition>
   : {};
 
@@ -185,280 +181,231 @@ 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<StubMethodSuccess<Api, Method>, DurableObjectRpcError>;
+  ) => 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>>;
 };
 
-/**
- * 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");
+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 makeClient = (
-      namespace: NamespaceClient,
-    ): DurableObjectNamespaceEffectClient<NamespaceApi, Definition> => {
-      const newUniqueId = (options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions) =>
-        Effect.sync(() => namespace.newUniqueId(options));
-
-      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,
-      ) => Effect.sync(() => namespace.get(id, options));
-
-      const getByName = (
-        name: string,
-        options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
-      ) => Effect.sync(() => namespace.getByName(name, options));
-
-      const jurisdiction = (value: globalThis.DurableObjectJurisdiction) =>
-        Effect.sync(() => namespace.jurisdiction(value));
-
-      const fetch = (stub: StubClient, input: RequestInfo | URL, init?: RequestInit) =>
-        Effect.tryPromise({
-          try: () => stub.fetch(input, init),
-          catch: (cause) => new DurableObjectFetchError({ binding: definition.binding, cause }),
-        });
-
-      const rpc = <Method extends StubMethodKey<NamespaceApi>>(
-        stub: StubClient,
-        method: Method,
-        ...args: StubMethodArgs<NamespaceApi, Method>
-      ) =>
-        Effect.gen(function* () {
-          const methodName = String(method);
-          const encodedArgs =
-            definition.definition === undefined
-              ? args
-              : yield* RpcDefinition.encodeArgs(
-                  definition.definition,
-                  methodName as RpcDefinition.Definition.MethodNames<NonNullable<Definition>>,
-                  args as never,
-                ).pipe(
-                  Effect.mapError(
-                    (cause) =>
-                      new DurableObjectRpcError({
-                        binding: definition.binding,
-                        method: methodName,
-                        cause,
-                      }),
-                  ),
-                );
-
-          return yield* RpcInvocation.invokeRpcMethod(
-            stub,
-            method,
-            encodedArgs as StubMethodArgs<NamespaceApi, Method>,
-            (cause) =>
-              new DurableObjectRpcError({
-                binding: definition.binding,
-                method: methodName,
-                cause,
-              }),
-          );
-        });
-
-      const call = <Method extends StubMethodKey<NamespaceApi>>(
-        stub: StubClient,
-        method: Method,
-        ...args: StubMethodArgs<NamespaceApi, Method>
-      ) =>
-        Effect.gen(function* () {
-          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,
-                }),
-            ),
-          );
-
-          if (definition.definition === undefined) {
-            return value as StubMethodSuccess<NamespaceApi, Method>;
-          }
-
-          const decoded = yield* RpcDefinition.decodeSuccess(
-            definition.definition,
-            methodName as RpcDefinition.Definition.MethodNames<NonNullable<Definition>>,
-            value,
-          ).pipe(
-            Effect.mapError(
-              (cause) =>
-                new DurableObjectRpcError({
-                  binding: definition.binding,
-                  method: methodName,
-                  cause,
-                }),
-            ),
-          );
-
-          return decoded as StubMethodSuccess<NamespaceApi, Method>;
-        });
-
-      const scopedCall = <Method extends StubMethodKey<NamespaceApi>>(
-        stub: StubClient,
-        method: Method,
-        ...args: StubMethodArgs<NamespaceApi, Method>
-      ) =>
-        Effect.gen(function* () {
-          const result = yield* rpc(stub, method, ...args);
-          return yield* CloudflareRpc.scoped(result);
-        });
-
-      const directMethods = makeDirectMethods<never, NamespaceApi, Definition>(
-        definition.definition,
-        {
-          call,
-          fetch,
-          get,
-          getByName,
-        },
-      );
-
-      return Object.assign(directMethods, {
-        newUniqueId,
-        idFromName,
-        idFromString,
-        get,
-        getByName,
-        jurisdiction,
-        fetch,
-        rpc,
-        call,
-        scopedCall,
-        unsafeRaw: Effect.succeed(namespace),
-      }) as DurableObjectNamespaceEffectClient<NamespaceApi, Definition>;
-    };
+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>;
 
-    const tag = Binding.Service<Self>()(
-      id,
-      definition.binding,
-      (value): value is NamespaceClient => isDurableObjectNamespaceClient(value),
-      makeClient,
-    );
-
-    const newUniqueId = Effect.fnUntraced(function* (
-      options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions,
-    ) {
-      const namespace = yield* tag;
-      return yield* namespace.newUniqueId(options);
-    });
+  return (namespace: NamespaceClient) => {
+    const newUniqueId = (options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions) =>
+      Effect.sync(() => namespace.newUniqueId(options));
 
-    const idFromName = Effect.fnUntraced(function* (name: string) {
-      const namespace = yield* tag;
-      return yield* namespace.idFromName(name);
-    });
+    const idFromName = (name: string) => Effect.sync(() => namespace.idFromName(name));
 
-    const idFromString = Effect.fnUntraced(function* (id: string) {
-      const namespace = yield* tag;
-      return yield* namespace.idFromString(id);
-    });
+    const idFromString = (id: string) => Effect.sync(() => namespace.idFromString(id));
 
-    const get = Effect.fnUntraced(function* (
+    const get = (
       id: globalThis.DurableObjectId,
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
-    ) {
-      const namespace = yield* tag;
-      return yield* 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 yield* namespace.getByName(name, options);
-    });
+    ) => Effect.sync(() => namespace.getByName(name, options));
 
-    const jurisdiction = Effect.fnUntraced(function* (value: globalThis.DurableObjectJurisdiction) {
-      const namespace = yield* tag;
-      return yield* namespace.jurisdiction(value);
-    });
+    const jurisdiction = (value: globalThis.DurableObjectJurisdiction) =>
+      Effect.sync(() => namespace.jurisdiction(value));
 
     const fetch = (stub: StubClient, input: RequestInfo | URL, init?: RequestInit) =>
       Effect.tryPromise({
@@ -466,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);
@@ -494,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,
@@ -504,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({
@@ -522,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({
@@ -541,34 +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 unsafeRaw = Effect.fnUntraced(function* () {
-      const namespace = yield* tag;
-      return yield* namespace.unsafeRaw;
-    });
-
-    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,
@@ -579,26 +529,28 @@ export const Service =
       rpc,
       call,
       scopedCall,
-      unsafeRaw,
-    }) 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;
-        readonly unsafeRaw: typeof unsafeRaw;
-      };
+      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,
@@ -655,7 +607,7 @@ const makeDirectMethods = <
                 stub: DurableObjectStubClient<Api>,
                 method: string,
                 ...args: Array<unknown>
-              ) => Effect.Effect<unknown, DurableObjectRpcError>
+              ) => Effect.Effect<unknown, DurableObjectRpcError, R>
             )(stub, methodName, ...args);
           });
       }