effect-cf 0.26.0 → 0.28.0

package/src/ComputerWorkspaceHost.ts

@@ -125,32 +125,45 @@ const toWorkspaceOptions = (config: ComputerWorkspaceHostConfig): WorkspaceOptio
     );
   }
 
-  return {
+  // SAFETY: Cloudflare's native DurableObjectStorage implements the narrower storage methods used
+  // by Computer; the union also accepts Computer's structural test/storage contract directly.
+  const options: WorkspaceOptions = {
     storage: config.storage as DurableObjectStorageLike,
     git: config.git ?? createGitClient(),
-    ...(config.gitIdentity === undefined ? {} : { defaultGitIdentity: config.gitIdentity }),
-    ...(backends.length === 0 ? {} : { backends }),
-    ...(config.sessionId === undefined ? {} : { sessionId: config.sessionId }),
-    ...(config.mounts === undefined ? {} : { mounts: config.mounts }),
-    ...(config.observer === undefined ? {} : { observer: config.observer }),
-    ...(config.retryScheduler === undefined ? {} : { retryScheduler: config.retryScheduler }),
-    ...(config.retry === undefined ? {} : { retry: config.retry }),
-    ...(config.assets === undefined ? {} : { assets: config.assets }),
-    ...(config.artifacts === undefined
-      ? {}
-      : {
-          artifacts: {
-            binding: config.artifacts.binding as unknown as NonNullable<
-              WorkspaceOptions["artifacts"]
-            >["binding"],
-            ...(config.artifacts.sessionId === undefined
-              ? {}
-              : { sessionId: config.artifacts.sessionId }),
-          },
-        }),
-    ...(config.now === undefined ? {} : { now: config.now }),
-    ...(config.useThink === undefined ? {} : { useThink: config.useThink }),
   };
+
+  if (config.gitIdentity !== undefined) options.defaultGitIdentity = config.gitIdentity;
+  if (backends.length !== 0) options.backends = backends;
+  if (config.sessionId !== undefined) options.sessionId = config.sessionId;
+  if (config.mounts !== undefined) options.mounts = config.mounts;
+  if (config.observer !== undefined) options.observer = config.observer;
+  if (config.retryScheduler !== undefined) options.retryScheduler = config.retryScheduler;
+  if (config.retry !== undefined) options.retry = config.retry;
+  if (config.assets !== undefined) options.assets = config.assets;
+
+  if (config.artifacts !== undefined) {
+    const erasedArtifactsBinding: unknown = config.artifacts.binding;
+    // SAFETY: the local binding intentionally models the same Cloudflare Artifacts RPC surface;
+    // its readonly result arrays are valid runtime inputs to Computer, whose dependency declaration
+    // unnecessarily requires mutable arrays.
+    const artifactsBinding = erasedArtifactsBinding as NonNullable<
+      WorkspaceOptions["artifacts"]
+    >["binding"];
+    const artifacts: NonNullable<WorkspaceOptions["artifacts"]> = {
+      binding: artifactsBinding,
+    };
+
+    if (config.artifacts.sessionId !== undefined) {
+      artifacts.sessionId = config.artifacts.sessionId;
+    }
+
+    options.artifacts = artifacts;
+  }
+
+  if (config.now !== undefined) options.now = config.now;
+  if (config.useThink !== undefined) options.useThink = config.useThink;
+
+  return options;
 };
 
 // Cloudflare constructs Durable Objects with `(state, env)`. Keeping the
@@ -185,11 +198,13 @@ export const withComputerWorkspace = <TBase extends DurableObjectConstructor>(
     env: ConstructorParameters<TBase>[1],
   ) => ComputerWorkspaceHostConfig,
 ): WithWorkspaceCtor<TBase> => {
-  const CapturedBase = class extends (Base as DurableObjectConstructor) {
+  const CapturedBase = class extends Base {
     readonly [HostArguments]: CapturedHostArguments;
 
     constructor(...args: Array<any>) {
       super(...args);
+      // SAFETY: Cloudflare constructs Durable Objects with DurableObjectState as constructor
+      // argument zero; the open base tuple retains arbitrary trailing constructor arguments.
       this[HostArguments] = {
         state: args[0] as globalThis.DurableObjectState,
         env: args[1],
@@ -197,20 +212,33 @@ export const withComputerWorkspace = <TBase extends DurableObjectConstructor>(
     }
   };
 
-  const WithWorkspace = withWorkspace(CapturedBase, (self) => {
+  const workspaceConstructor: unknown = withWorkspace(CapturedBase, (self) => {
+    // SAFETY: CapturedBase initializes this private symbol for every constructed instance before
+    // withWorkspace evaluates its options callback.
     const { env, state } = (self as HostArgumentsInstance)[HostArguments];
 
     return toWorkspaceOptions(
+      // SAFETY: CapturedBase is an identity subclass of Base, so its instance retains Base's full
+      // public instance contract. The captured environment is constructor argument one.
       config(self as InstanceType<TBase>, state, env as ConstructorParameters<TBase>[1]),
     );
-  }) as unknown as DurableObjectConstructor;
+  });
+  // SAFETY: withWorkspace returns a constructable identity subclass; this local constructor view
+  // intentionally hides its generic intersection so TypeScript can extend it.
+  const WithWorkspace = workspaceConstructor as DurableObjectConstructor;
 
   class WithComputerWorkspace extends WithWorkspace {
     constructor(...args: Array<any>) {
       super(...args);
+      // SAFETY: Cloudflare supplies DurableObjectState at constructor argument zero, and
+      // withWorkspace adds the WorkspaceHandle methods implemented by this instance.
       HostRegistry.register(args[0] as globalThis.DurableObjectState, this as WorkspaceHandle);
     }
   }
 
-  return WithComputerWorkspace as unknown as WithWorkspaceCtor<TBase>;
+  const erasedConstructor: unknown = WithComputerWorkspace;
+
+  // SAFETY: WithComputerWorkspace only adds registration to the constructor produced by
+  // withWorkspace, preserving Base's constructor and instance members plus the workspace host.
+  return erasedConstructor as WithWorkspaceCtor<TBase>;
 };

package/src/ContainerNamespace.ts

@@ -1,4 +1,4 @@
-import { Context, Data, Effect, Schema as S, type Layer } from "effect";
+import { Context, Data, Effect, Predicate, Schema as S, type Layer } from "effect";
 
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
@@ -344,10 +344,10 @@ const makeInstanceClient = <Stub extends ContainerStub>(
   };
 };
 
-export const isContainerNamespaceResource = (value: unknown): value is ContainerNamespaceResource =>
-  typeof value === "object" &&
-  value !== null &&
-  typeof Reflect.get(value, "getByName") === "function";
+export const isContainerNamespaceResource = <Candidate>(
+  value: Candidate,
+): value is Candidate & ContainerNamespaceResource =>
+  Predicate.hasProperty(value, "getByName") && Predicate.isFunction(value.getByName);
 
 export const makeClient =
   (definition: ContainerNamespaceDefinition) =>
@@ -363,7 +363,7 @@ export const makeClient =
           makeInstanceClient(
             definition,
             name,
-            // getByName has a single call signature, so its return type is
+            // SAFETY: getByName has a single call signature, so its return type is
             // exactly the namespace's stub type.
             namespace.getByName(name, options) as ContainerStubOf<Namespace>,
           ),
@@ -422,9 +422,7 @@ export const layer = <Self, Namespace extends ContainerNamespaceResource>(
   Binding.layer(
     tag,
     definition.binding,
-    // Runtime validation stays structural; the exact namespace type is
-    // asserted by the consumer's binding declaration, like env typing.
-    isContainerNamespaceResource as (value: unknown) => value is Namespace,
+    (value): value is Namespace => isContainerNamespaceResource(value),
     makeClient(definition),
     {
       expected: expectedContainerNamespace,
@@ -499,6 +497,7 @@ export const Tag =
 
     const rawUnsafe = Effect.flatMap(tag, (namespace) => namespace.rawUnsafe);
 
+    // SAFETY: the assigned namespace helpers exactly implement TagClass for this service tag.
     return Object.assign(tag, {
       id,
       layer: makeLayer,

package/src/D1.ts

@@ -1,5 +1,5 @@
 import { D1Client } from "@effect/sql-d1";
-import { Effect, Layer, type Config } from "effect";
+import { Effect, Layer, Predicate, type Config } from "effect";
 import type { SqlClient } from "effect/unstable/sql";
 
 import * as Binding from "./Binding";
@@ -28,19 +28,13 @@ export interface D1Service<Id extends string> {
   };
 }
 
-const isD1Database = (value: unknown): value is D1Database => {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-
-  const resource = value as Record<string, unknown>;
-
-  return (
-    typeof resource.prepare === "function" &&
-    typeof resource.batch === "function" &&
-    typeof resource.exec === "function"
-  );
-};
+const isD1Database = <Candidate>(value: Candidate): value is Candidate & D1Database =>
+  Predicate.hasProperty(value, "prepare") &&
+  Predicate.isFunction(value.prepare) &&
+  Predicate.hasProperty(value, "batch") &&
+  Predicate.isFunction(value.batch) &&
+  Predicate.hasProperty(value, "exec") &&
+  Predicate.isFunction(value.exec);
 
 /**
  * Creates a typed D1 service tag plus Effect helpers.

package/src/DurableObject.ts

@@ -52,7 +52,7 @@ export type DurableObjectRpc<ROut> = Record<
   (...args: Array<any>) => DurableObjectHandler<ROut>
 >;
 
-export type DurableObjectRpcShape<Rpc extends DurableObjectRpc<ROut>, ROut> = {
+export type DurableObjectRpcApi<Rpc extends DurableObjectRpc<ROut>, ROut> = {
   readonly [Key in keyof Rpc]: Rpc[Key] extends (
     ...args: infer Args
   ) => Effect.Effect<infer A, unknown, HandlerContext<ROut>>
@@ -66,7 +66,7 @@ export type RpcHandlers<ROut, Api> = {
     : Key extends string
       ? [Api[Key]] extends [never]
         ? never
-        : Api[Key] extends (...args: Array<any>) => Promise<unknown>
+        : Api[Key] extends (...args: Array<any>) => Promise<any>
           ? Key
           : never
       : never]: Api[Key] extends (...args: infer Args) => Promise<infer A>
@@ -142,7 +142,7 @@ export interface DurableObjectOptions<
   ) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
   readonly webSocketError?: (
     socket: DurableWebSocket,
-    error: unknown,
+    cause: unknown,
   ) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
 }
 
@@ -152,7 +152,7 @@ export interface DurableObjectOptions<
 export type DurableObjectClass<Rpc extends DurableObjectRpc<ROut>, ROut> = new (
   state: globalThis.DurableObjectState,
   env: WorkerEnv,
-) => CloudflareDurableObject<WorkerEnv> & DurableObjectRpcShape<Rpc, ROut>;
+) => CloudflareDurableObject<WorkerEnv> & DurableObjectRpcApi<Rpc, ROut>;
 
 /**
  * Creates a Durable Object class backed by a single managed Effect runtime.
@@ -190,11 +190,24 @@ export const make = <
       effect: Effect.Effect<A, E, HandlerContext<ROut | REvent>>,
       runOptions: RunOptions = {},
     ): Promise<A> {
-      return Runtime.runEventPromise(
-        this.runtime,
-        effect,
-        runOptions.eventLayer === false ? undefined : options.eventLayer,
-      );
+      const eventLayer = runOptions.eventLayer === false ? undefined : options.eventLayer;
+
+      if (eventLayer === undefined) {
+        // SAFETY: event-layer bypass is used only for initialize; otherwise an absent layer means REvent is never.
+        return Runtime.runEventPromise(
+          this.runtime,
+          effect as Effect.Effect<A, E, HandlerContext<ROut>>,
+        );
+      }
+
+      return Runtime.runEventPromise<
+        A,
+        E,
+        RuntimeContext<ROut>,
+        REvent,
+        EventLayerError,
+        LayerError
+      >(this.runtime, effect, eventLayer);
     }
 
     fetch(request: Request): Promise<Response> {
@@ -242,9 +255,9 @@ export const make = <
       }
     }
 
-    webSocketError(socket: WebSocket, error: unknown): Promise<void> | void {
+    webSocketError(socket: WebSocket, cause: unknown): Promise<void> | void {
       if (options.webSocketError !== undefined) {
-        return this[RunSymbol](options.webSocketError(fromWebSocket(socket), error));
+        return this[RunSymbol](options.webSocketError(fromWebSocket(socket), cause));
       }
     }
   }
@@ -280,3 +293,6 @@ export type {
 } from "./DurableObjectDefinition";
 
 export { implement, method, Tag } from "./DurableObjectDefinition";
+
+// Preserve the original public type export while using a domain-role name internally.
+export type { DurableObjectRpcApi as "DurableObjectRpcShape" };

package/src/DurableObjectAlarm.ts

@@ -1,4 +1,15 @@
-import { Clock, Context, Data, DateTime, Duration, Effect, Exit, Layer, Schema as S } from "effect";
+import {
+  Clock,
+  Context,
+  Data,
+  DateTime,
+  Duration,
+  Effect,
+  Exit,
+  Layer,
+  Predicate,
+  Schema as S,
+} from "effect";
 
 import { DurableObjectState } from "./DurableObjectState";
 import type { SqlStorageValue, StorageOperationError } from "./DurableObjectStorage";
@@ -442,10 +453,10 @@ const getFailureRetryDelay = (options: ProcessDueAlarmsOptions<unknown, unknown>
   );
 
 const getFailureActionMode = (action: ProcessDueAlarmsFailureAction) =>
-  typeof action === "string" ? action : action.mode;
+  Predicate.isString(action) ? action : action.mode;
 
 const getFailureActionRetryDelay = (action: ProcessDueAlarmsFailureAction) =>
-  typeof action === "string" || action.mode !== "retry" ? undefined : action.retryFailedAfter;
+  Predicate.isString(action) || action.mode !== "retry" ? undefined : action.retryFailedAfter;
 
 export const processDue = <R = never, E = never, OnFailureR = never, OnFailureE = never>(
   handle: ProcessDueAlarmsHandler<R, E>,
@@ -497,8 +508,7 @@ export type DefinedAlarmHandlers<Definitions extends AlarmDefinitions, R = never
 
 const isAlarmDefinitionConfig = (
   definition: AlarmDefinitionEntry,
-): definition is AlarmDefinitionConfig =>
-  typeof definition === "object" && definition !== null && "payload" in definition;
+): definition is AlarmDefinitionConfig => Predicate.isObject(definition) && "payload" in definition;
 
 const getAlarmDefinitionSchema = (definition: AlarmDefinitionEntry) =>
   isAlarmDefinitionConfig(definition) ? definition.payload : definition;
@@ -534,6 +544,7 @@ export const define = <const Definitions extends AlarmDefinitions>(definitions:
           }
 
           const schema = getAlarmDefinitionSchema(definition);
+          // SAFETY: schema is selected from the same tagged definition used to select its handler.
           const payload = yield* (
             S.decodeUnknownEffect(schema)(event.payload) as Effect.Effect<
               AlarmDefinitionPayload<Definitions[keyof Definitions & string]>,
@@ -550,6 +561,7 @@ export const define = <const Definitions extends AlarmDefinitions>(definitions:
           );
           const handler = handlers[event.tag];
 
+          // SAFETY: event.tag indexes the matching definition and handler, whose payload schema was decoded above.
           yield* handler({ ...event, payload } as never);
         }),
       {

package/src/DurableObjectDefinition.ts

@@ -9,12 +9,8 @@ import type * as Rpc from "./Rpc";
 import * as RpcDefinition from "./RpcDefinition";
 import type { WorkerEnvironment } from "./Environment";
 
-/**
- * The client tuple types are re-established by the final `TagClass` cast, so
- * these internal invocations erase the binding client's generic argument
- * tuples instead of instantiating them at `never`.
- */
-type UnsafeInvoke<E> = (...args: ReadonlyArray<unknown>) => Effect.Effect<unknown, E>;
+/** Internal dynamic invocation used only before the public client contract is restored. */
+type ErasedInvoke<E> = (...args: ReadonlyArray<unknown>) => Effect.Effect<unknown, E>;
 
 export type ServiceFreeSchema = S.Codec<any, any, never, never>;
 
@@ -49,7 +45,7 @@ export namespace Method {
 
   export type Success<Self extends Any> = S.Schema.Type<Self["success"]>;
 
-  export type EncodedSuccess<Self extends Any> = S.Json;
+  export type EncodedSuccess<_Self extends Any> = S.Json;
 }
 
 export type Methods = Record<string, Method.Any>;
@@ -57,9 +53,12 @@ export type Methods = Record<string, Method.Any>;
 /**
  * RPC contract for a Durable Object class.
  */
-export interface Definition<Id extends string = string, MethodsShape extends Methods = Methods> {
+export interface Definition<
+  Id extends string = string,
+  MethodDefinitions extends Methods = Methods,
+> {
   readonly id: Id;
-  readonly methods: MethodsShape;
+  readonly methods: MethodDefinitions;
 }
 
 export namespace Definition {
@@ -74,8 +73,8 @@ export type ReservedMethodName =
   | "webSocketClose"
   | "webSocketError";
 
-export type NoReservedMethods<MethodsShape extends Methods> =
-  Extract<keyof MethodsShape, ReservedMethodName> extends never ? MethodsShape : never;
+export type NoReservedMethods<MethodDefinitions extends Methods> =
+  Extract<keyof MethodDefinitions, ReservedMethodName> extends never ? MethodDefinitions : never;
 
 const reservedMethodNames = new Set<string>([
   "constructor",
@@ -113,6 +112,10 @@ type BoundaryHandlers<ROut, Self extends Definition.Any> = {
   ) => DurableObjectHandler<ROut, Method.EncodedSuccess<Self["methods"][Key]>>;
 };
 
+type MutableBoundaryHandlers<ROut, Self extends Definition.Any> = {
+  -readonly [Key in keyof BoundaryHandlers<ROut, Self>]: BoundaryHandlers<ROut, Self>[Key];
+};
+
 /**
  * Durable Object constructor options for a specific RPC definition.
  */
@@ -137,26 +140,30 @@ export type LayerOptions = {
   readonly binding: string;
 };
 
-export type TagClass<Self, Id extends string, MethodsShape extends Methods> = Context.ServiceClass<
+export type TagClass<
+  Self,
+  Id extends string,
+  MethodDefinitions extends Methods,
+> = Context.ServiceClass<
   Self,
   `effect-cf/DurableObject/${Id}`,
   DurableObjectNamespace.DurableObjectNamespaceEffectClient<
-    Api<Definition<Id, MethodsShape>>,
-    Definition<Id, MethodsShape>
+    Api<Definition<Id, MethodDefinitions>>,
+    Definition<Id, MethodDefinitions>
   >
 > &
   DurableObjectNamespace.DurableObjectNamespaceStaticClient<
     Self,
-    Api<Definition<Id, MethodsShape>>,
-    Definition<Id, MethodsShape>
+    Api<Definition<Id, MethodDefinitions>>,
+    Definition<Id, MethodDefinitions>
   > & {
     readonly id: Id;
-    readonly methods: MethodsShape;
+    readonly methods: MethodDefinitions;
     readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(
       layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>,
-      options: Options<ROut, Definition<Id, MethodsShape>, REvent, EventLayerError>,
+      options: Options<ROut, Definition<Id, MethodDefinitions>, REvent, EventLayerError>,
     ) => DurableObjectEntrypoint.DurableObjectClass<
-      Handlers<ROut | REvent, Definition<Id, MethodsShape>>,
+      Handlers<ROut | REvent, Definition<Id, MethodDefinitions>>,
       ROut | REvent
     >;
     readonly layer: (
@@ -171,18 +178,19 @@ export type TagClass<Self, Id extends string, MethodsShape extends Methods> = Co
 /**
  * Defines a single RPC method schema in a Durable Object definition.
  */
-export const method = RpcDefinition.method as {
-  <Success extends ServiceFreeSchema>(definition: {
-    readonly success: Success;
-  }): Method<readonly [], Success>;
-  <
-    const Args extends ReadonlyArray<ServiceFreeSchema>,
-    Success extends ServiceFreeSchema,
-  >(definition: {
-    readonly args: Args;
-    readonly success: Success;
-  }): Method<Args, Success>;
-};
+export function method<Success extends ServiceFreeSchema>(definition: {
+  readonly success: Success;
+}): Method<readonly [], Success>;
+export function method<
+  const Args extends ReadonlyArray<ServiceFreeSchema>,
+  Success extends ServiceFreeSchema,
+>(definition: { readonly args: Args; readonly success: Success }): Method<Args, Success>;
+export function method(definition: {
+  readonly args?: ReadonlyArray<ServiceFreeSchema>;
+  readonly success: ServiceFreeSchema;
+}): Method {
+  return RpcDefinition.method(definition);
+}
 
 /**
  * Creates a Durable Object RPC definition plus implementation/binding helpers.
@@ -197,11 +205,11 @@ export const method = RpcDefinition.method as {
  * });
  * ```
  */
-const makeDefinition = <Id extends string, const MethodsShape extends Methods>(
+const makeDefinition = <Id extends string, const MethodDefinitions extends Methods>(
   id: Id,
-  methods: MethodsShape & NoReservedMethods<MethodsShape>,
+  methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>,
 ) => {
-  type SelfDefinition = Definition<Id, MethodsShape>;
+  type SelfDefinition = Definition<Id, MethodDefinitions>;
   RpcDefinition.assertNoReservedMethods("Durable Object", methods, reservedMethodNames);
   const definition: SelfDefinition = RpcDefinition.make(id, methods);
 
@@ -217,24 +225,20 @@ const makeDefinition = <Id extends string, const MethodsShape extends Methods>(
   });
 };
 
-export const make = <Id extends string, const MethodsShape extends Methods>(
+export const make = <Id extends string, const MethodDefinitions extends Methods>(
   id: Id,
-  methods: MethodsShape & NoReservedMethods<MethodsShape>,
-) =>
-  Tag<Definition<Id, MethodsShape>>()<Id, MethodsShape>(
-    id,
-    methods as MethodsShape & NoReservedMethods<MethodsShape>,
-  );
+  methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>,
+) => Tag<Definition<Id, MethodDefinitions>>()<Id, MethodDefinitions>(id, methods);
 
 export const Tag =
   <Self>() =>
-  <Id extends string, const MethodsShape extends Methods>(
+  <Id extends string, const MethodDefinitions extends Methods>(
     id: Id,
-    methods: MethodsShape & NoReservedMethods<MethodsShape>,
-  ) => {
-    const definition = makeDefinition<Id, MethodsShape>(id, methods);
+    methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>,
+  ): TagClass<Self, Id, MethodDefinitions> => {
+    const definition = makeDefinition<Id, MethodDefinitions>(id, methods);
 
-    type SelfDefinition = Definition<Id, MethodsShape>;
+    type SelfDefinition = Definition<Id, MethodDefinitions>;
     type ClientApi = Api<SelfDefinition>;
     const serviceKey: `effect-cf/DurableObject/${Id}` = `effect-cf/DurableObject/${id}`;
     const tag = Context.Service<
@@ -315,46 +319,50 @@ export const Tag =
       return yield* namespace.fetch(stub, input, init);
     });
 
-    const rpc = Effect.fn("DurableObject.rpc")(function* <Method extends keyof ClientApi>(
+    const rpc = Effect.fn("DurableObject.rpc")(function* <MethodName extends keyof ClientApi>(
       stub: DurableObjectNamespace.DurableObjectStubClient<ClientApi>,
-      method: Method,
-      ...args: ClientApi[Method] extends (...args: infer Args) => unknown ? Args : never
+      methodName: MethodName,
+      ...args: ClientApi[MethodName] extends (...args: infer Args) => Promise<any> ? Args : never
     ) {
       const namespace = yield* tag;
+      // SAFETY: ClientApi derives every key and argument tuple from the definition. This internal
+      // erased view only bypasses TypeScript's expansion of Rpc.Provider's callable intersection;
+      // TagClass restores the exact generic return contract before this helper is exported.
+      const invokeRpc = namespace.rpc as ErasedInvoke<DurableObjectNamespace.DurableObjectRpcError>;
 
-      return yield* (namespace.rpc as UnsafeInvoke<DurableObjectNamespace.DurableObjectRpcError>)(
-        stub,
-        method,
-        ...args,
-      );
+      return yield* invokeRpc(stub, methodName, ...args);
     });
 
-    const call = Effect.fn("DurableObject.call")(function* <Method extends keyof ClientApi>(
+    const call = Effect.fn("DurableObject.call")(function* <MethodName extends keyof ClientApi>(
       stub: DurableObjectNamespace.DurableObjectStubClient<ClientApi>,
-      method: Method,
-      ...args: ClientApi[Method] extends (...args: infer Args) => unknown ? Args : never
+      methodName: MethodName,
+      ...args: ClientApi[MethodName] extends (...args: infer Args) => Promise<any> ? Args : never
     ) {
       const namespace = yield* tag;
+      // SAFETY: ClientApi derives every key and argument tuple from the definition. This internal
+      // erased view only bypasses TypeScript's expansion of Rpc.Provider's callable intersection;
+      // TagClass restores the exact generic return contract before this helper is exported.
+      const invokeCall =
+        namespace.call as ErasedInvoke<DurableObjectNamespace.DurableObjectRpcError>;
 
-      return yield* (namespace.call as UnsafeInvoke<DurableObjectNamespace.DurableObjectRpcError>)(
-        stub,
-        method,
-        ...args,
-      );
+      return yield* invokeCall(stub, methodName, ...args);
     });
 
     const scopedCall = Effect.fn("DurableObject.scopedCall")(function* <
-      Method extends keyof ClientApi,
+      MethodName extends keyof ClientApi,
     >(
       stub: DurableObjectNamespace.DurableObjectStubClient<ClientApi>,
-      method: Method,
-      ...args: ClientApi[Method] extends (...args: infer Args) => unknown ? Args : never
+      methodName: MethodName,
+      ...args: ClientApi[MethodName] extends (...args: infer Args) => Promise<any> ? Args : never
     ) {
       const namespace = yield* tag;
+      // SAFETY: ClientApi derives every key and argument tuple from the definition. This internal
+      // erased view only bypasses TypeScript's expansion of Rpc.Provider's callable intersection;
+      // TagClass restores the exact generic return contract before this helper is exported.
+      const invokeScopedCall =
+        namespace.scopedCall as ErasedInvoke<DurableObjectNamespace.DurableObjectRpcError>;
 
-      return yield* (
-        namespace.scopedCall as UnsafeInvoke<DurableObjectNamespace.DurableObjectRpcError>
-      )(stub, method, ...args);
+      return yield* invokeScopedCall(stub, methodName, ...args);
     });
 
     const rawUnsafe = Effect.fnUntraced(function* () {
@@ -366,6 +374,8 @@ export const Tag =
     const directMethods = DurableObjectNamespace.makeDirectMethods<Self, ClientApi, SelfDefinition>(
       definition,
       {
+        // SAFETY: direct methods call this helper only with method names and tuples obtained from
+        // the same definition; the public direct-method contract restores the result type.
         call: call as never,
         fetch,
         get,
@@ -373,7 +383,7 @@ export const Tag =
       },
     );
 
-    return Object.assign(tag, directMethods, {
+    const service: unknown = Object.assign(tag, directMethods, {
       id: definition.id,
       methods: definition.methods,
       make: definition.make,
@@ -389,7 +399,12 @@ export const Tag =
       call,
       scopedCall,
       rawUnsafe,
-    }) as unknown as TagClass<Self, Id, MethodsShape>;
+    });
+
+    // SAFETY: every assigned member above is derived from the same definition and service tag;
+    // the erased internal invocation results are exposed only through TagClass's schema-derived
+    // client contract.
+    return service as TagClass<Self, Id, MethodDefinitions>;
   };
 
 export const DurableObject = Tag;
@@ -398,8 +413,10 @@ const wrapHandlers = <ROut, const Self extends Definition.Any>(
   definition: Self,
   handlers: Handlers<ROut, Self>,
 ): BoundaryHandlers<ROut, Self> => {
-  const wrapped = {} as Record<string, unknown>;
+  const wrapped: MutableBoundaryHandlers<ROut, Self> = Object.create(Object.prototype);
 
+  // SAFETY: definition.methods owns the complete method-name domain for Self; Object.keys only
+  // erases that key information and cannot introduce additional names.
   for (const key of Object.keys(definition.methods) as Array<
     RpcDefinition.Definition.MethodNames<Self>
   >) {
@@ -414,7 +431,7 @@ const wrapHandlers = <ROut, const Self extends Definition.Any>(
       });
   }
 
-  return wrapped as BoundaryHandlers<ROut, Self>;
+  return wrapped;
 };
 
 /**