effect-cf 0.41.0 → 0.42.0

package/dist/WorkerDefinition.mjs

@@ -1,5 +1,5 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
-import { assertNoReservedMethods, decodeArgs, encodeSuccess, make as make$1, method as method$1 } from "./RpcDefinition.mjs";
+import { assertNoReservedMethods, decodeArgs, encodeSuccess, make as make$1, method as method$1, native as native$1 } from "./RpcDefinition.mjs";
 import { recordDecodedArgs } from "./internal/RpcInvocation.mjs";
 import { layer, makeDirectMethods } from "./ServiceBinding.mjs";
 import { make as make$2 } from "./Worker.mjs";
@@ -11,7 +11,8 @@ var WorkerDefinition_exports = /* @__PURE__ */ __exportAll({
 	Worker: () => Worker,
 	implement: () => implement,
 	make: () => make,
-	method: () => method
+	method: () => method,
+	native: () => native
 });
 const reservedMethodNames = /* @__PURE__ */ new Set([
 	"constructor",
@@ -36,6 +37,7 @@ const assumeTagClass = (value) => {
 * Defines a single RPC method schema in a worker definition.
 */
 const method = method$1;
+const native = native$1;
 const makeDefinition = (id, methods) => {
 	assertNoReservedMethods("Worker", methods, reservedMethodNames);
 	const definition = make$1(id, methods);
@@ -100,4 +102,4 @@ const wrapHandlers = (definition, handlers) => {
 */
 const implement = (_definition, handlers) => handlers;
 //#endregion
-export { Tag, Worker, WorkerDefinition_exports, implement, make, method };
+export { Tag, Worker, WorkerDefinition_exports, implement, make, method, native };

package/dist/WorkersAi.d.mts

@@ -5,7 +5,7 @@ import * as Effect from "effect/Effect";
 import * as S from "effect/Schema";
 import { Layer } from "effect";
 declare namespace WorkersAi_d_exports {
-  export { LayerOptions, Tag, TagClass, WorkersAiAsyncBatchResponse, WorkersAiBinding, WorkersAiClient, WorkersAiDefinition, WorkersAiEmbeddingInput, WorkersAiEmbeddingResponse, WorkersAiModelsSearchObject, WorkersAiModelsSearchParams, WorkersAiOperationError, WorkersAiOptions, WorkersAiService, embeddingResponse, isWorkersAiBinding, layer, make, makeClient };
+  export { BindingNotFoundError, BindingValidationError, LayerOptions, Tag, TagClass, WorkersAiAsyncBatchResponse, WorkersAiBinding, WorkersAiClient, WorkersAiDefinition, WorkersAiEmbeddingInput, WorkersAiEmbeddingResponse, WorkersAiModelsSearchObject, WorkersAiModelsSearchParams, WorkersAiOperationError, WorkersAiOptions, WorkersAiService, embeddingResponse, isWorkersAiBinding, layer, make, makeClient };
 }
 declare const WorkersAiOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "WorkersAiOperationError";
@@ -81,4 +81,4 @@ declare const layer: <Self, ModelList extends AiModelListType = AiModels>(tag: C
 declare const make: <Id extends string>(id: Id) => TagClass<WorkersAiService<Id>, Id, AiModels>;
 declare const Tag: <Self>() => <Id extends string, ModelList extends AiModelListType = AiModels>(id: Id) => TagClass<Self, Id, ModelList>;
 //#endregion
-export { LayerOptions, Tag, TagClass, WorkersAiAsyncBatchResponse, WorkersAiBinding, WorkersAiClient, WorkersAiDefinition, WorkersAiEmbeddingInput, WorkersAiEmbeddingResponse, WorkersAiModelsSearchObject, WorkersAiModelsSearchParams, WorkersAiOperationError, WorkersAiOptions, WorkersAiService, WorkersAi_d_exports, embeddingResponse, isWorkersAiBinding, layer, make, makeClient };
+export { type BindingNotFoundError, type BindingValidationError, LayerOptions, Tag, TagClass, WorkersAiAsyncBatchResponse, WorkersAiBinding, WorkersAiClient, WorkersAiDefinition, WorkersAiEmbeddingInput, WorkersAiEmbeddingResponse, WorkersAiModelsSearchObject, WorkersAiModelsSearchParams, WorkersAiOperationError, WorkersAiOptions, WorkersAiService, WorkersAi_d_exports, embeddingResponse, isWorkersAiBinding, layer, make, makeClient };

package/dist/Workflow.d.mts

@@ -1,6 +1,8 @@
 import { WorkerEnv, WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
 import { ExecutionContext, WorkerContext } from "./Worker.mjs";
-import { Definition as Definition$1, Handler as Handler$1, LayerOptions as LayerOptions$1, Options as Options$1, Tag, TagClass as TagClass$1, implement } from "./WorkflowDefinition.mjs";
+import { WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowOperationError } from "./WorkflowBinding.mjs";
+import { Definition as Definition$1, Handler as Handler$1, LayerOptions as LayerOptions$1, Options as Options$1, Tag, TagClass, implement } from "./WorkflowDefinition.mjs";
 import * as Context$1 from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer$1 from "effect/Layer";
@@ -8,7 +10,7 @@ import * as Cause$1 from "effect/Cause";
 import { WorkflowEntrypoint, WorkflowEvent, WorkflowSleepDuration, WorkflowStep, WorkflowStepConfig, WorkflowStepContext, WorkflowStepEvent, WorkflowTimeoutDuration } from "cloudflare:workers";
 import { Scope } from "effect";
 declare namespace Workflow_d_exports {
-  export { Definition, Handler, LayerOptions, Options, Tag, TagClass, WorkflowClass, WorkflowEvent$1 as WorkflowEvent, WorkflowEventService, WorkflowHandler, WorkflowOptions, WorkflowRunContext, WorkflowStep$1 as WorkflowStep, WorkflowStepContext$1 as WorkflowStepContext, WorkflowStepError, WorkflowStepNonRetryableError, WorkflowStepService, implement, make, sleep, sleepUntil, step, waitForEvent };
+  export { BindingNotFoundError, BindingValidationError, Definition, Handler, LayerOptions, Options, Tag, TagClass, WorkflowClass, WorkflowEvent$1 as WorkflowEvent, WorkflowEventService, WorkflowHandler, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowOperationError, WorkflowOptions, WorkflowRunContext, WorkflowStep$1 as WorkflowStep, WorkflowStepContext$1 as WorkflowStepContext, WorkflowStepError, WorkflowStepNonRetryableError, WorkflowStepService, implement, make, sleep, sleepUntil, step, waitForEvent };
 }
 interface WorkflowEventService<Payload = unknown> {
   readonly raw: WorkflowEvent<unknown>;
@@ -79,8 +81,7 @@ declare namespace Definition {
   type Any = Definition$1.Any;
 }
 type LayerOptions = LayerOptions$1;
-type TagClass<Self, Id extends string, Payload extends Definition$1.Any["payload"], Result extends Definition$1.Any["result"]> = TagClass$1<Self, Id, Payload, Result>;
 type Handler<ROut, Self extends Definition$1.Any> = Handler$1<ROut, Self>;
 type Options<ROut, Self extends Definition$1.Any> = Options$1<ROut, Self>;
 //#endregion
-export { Definition, Handler, LayerOptions, Options, Tag, TagClass, WorkflowClass, WorkflowEvent$1 as WorkflowEvent, WorkflowEventService, WorkflowHandler, WorkflowOptions, WorkflowRunContext, WorkflowStep$1 as WorkflowStep, WorkflowStepContext$1 as WorkflowStepContext, WorkflowStepError, WorkflowStepNonRetryableError, WorkflowStepService, Workflow_d_exports, implement, make, sleep, sleepUntil, step, waitForEvent };
+export { type BindingNotFoundError, type BindingValidationError, Definition, Handler, LayerOptions, Options, Tag, type TagClass, WorkflowClass, WorkflowEvent$1 as WorkflowEvent, WorkflowEventService, WorkflowHandler, type WorkflowInstance, type WorkflowInstanceCreateBatchOptions, type WorkflowInstanceCreateOptions, type WorkflowOperationError, WorkflowOptions, WorkflowRunContext, WorkflowStep$1 as WorkflowStep, WorkflowStepContext$1 as WorkflowStepContext, WorkflowStepError, WorkflowStepNonRetryableError, WorkflowStepService, Workflow_d_exports, implement, make, sleep, sleepUntil, step, waitForEvent };

package/dist/WorkflowDefinition.d.mts

@@ -9,7 +9,7 @@ import * as Effect from "effect/Effect";
 import * as S from "effect/Schema";
 import { Layer } from "effect";
 declare namespace WorkflowDefinition_d_exports {
-  export { Definition, Handler, LayerOptions, Options, Tag, TagClass, Workflow, implement, make };
+  export { BindingNotFoundError, BindingValidationError, Definition, Handler, LayerOptions, Options, Tag, TagClass, Workflow, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowOperationError, implement, make };
 }
 interface Definition<Id extends string = string, Payload extends ServiceFreeSchema = ServiceFreeSchema, Result extends ServiceFreeSchema = ServiceFreeSchema> {
   readonly id: Id;
@@ -26,7 +26,7 @@ interface Options<ROut, Self extends Definition.Any> {
 type LayerOptions = {
   readonly binding: string;
 };
-interface TagClass<Self, Id extends string, Payload extends ServiceFreeSchema, Result extends ServiceFreeSchema> extends Context$1.ServiceClass<Self, `effect-cf/Workflow/${Id}`, WorkflowBindingClient<Payload, Result>> {
+type TagClass<Self, Id extends string, Payload extends ServiceFreeSchema, Result extends ServiceFreeSchema> = Context$1.ServiceClass<Self, `effect-cf/Workflow/${Id}`, WorkflowBindingClient<Payload, Result>> & {
   readonly id: Id;
   readonly payload: Payload;
   readonly result: Result;
@@ -36,7 +36,7 @@ interface TagClass<Self, Id extends string, Payload extends ServiceFreeSchema, R
   readonly createBatch: (batch: WorkflowInstanceCreateBatchOptions<S.Schema.Type<Payload>, S.Codec.Encoded<Payload>>) => Effect.Effect<ReadonlyArray<WorkflowInstance<S.Schema.Type<Result>>>, WorkflowOperationError | S.SchemaError, Self>;
   readonly get: (instanceId: string) => Effect.Effect<WorkflowInstance<S.Schema.Type<Result>>, WorkflowOperationError, Self>;
   readonly rawUnsafe: Effect.Effect<globalThis.Workflow<S.Codec.Encoded<Payload>>, never, Self>;
-}
+};
 declare const make: <Id extends string, Payload extends ServiceFreeSchema, Result extends ServiceFreeSchema>(id: Id, definition: {
   readonly payload: Payload;
   readonly result: Result;
@@ -48,4 +48,4 @@ declare const Tag: <Self>() => <Id extends string, Payload extends ServiceFreeSc
 declare const Workflow: typeof Tag;
 declare const implement: <ROut, const Self extends Definition.Any>(_definition: Self, handler: Handler<ROut, Self>) => Handler<ROut, Self>;
 //#endregion
-export { Definition, Handler, LayerOptions, Options, Tag, TagClass, Workflow, WorkflowDefinition_d_exports, implement, make };
+export { type BindingNotFoundError, type BindingValidationError, Definition, Handler, LayerOptions, Options, Tag, TagClass, Workflow, WorkflowDefinition_d_exports, type WorkflowInstance, type WorkflowInstanceCreateBatchOptions, type WorkflowInstanceCreateOptions, type WorkflowOperationError, implement, make };

package/dist/index.d.mts

@@ -9,8 +9,8 @@ import { QueueBinding_d_exports } from "./QueueBinding.mjs";
 import { QueueDefinition_d_exports } from "./QueueDefinition.mjs";
 import { Queue_d_exports } from "./Queue.mjs";
 import { RpcTracing_d_exports } from "./RpcTracing.mjs";
-import { ServiceBinding_d_exports } from "./ServiceBinding.mjs";
 import { WorkerDefinition_d_exports } from "./WorkerDefinition.mjs";
+import { ServiceBinding_d_exports } from "./ServiceBinding.mjs";
 import { Worker_d_exports } from "./Worker.mjs";
 import { DurableObjectState_d_exports } from "./DurableObjectState.mjs";
 import { Hyperdrive_d_exports } from "./Hyperdrive.mjs";
@@ -25,8 +25,8 @@ import { CloudflareOtlp_d_exports } from "./CloudflareOtlp.mjs";
 import { CloudflareTracer_d_exports } from "./CloudflareTracer.mjs";
 import { D1_d_exports } from "./D1.mjs";
 import { DurableObjectAlarm_d_exports } from "./DurableObjectAlarm.mjs";
-import { DurableObjectNamespace_d_exports } from "./DurableObjectNamespace.mjs";
 import { DurableObjectDefinition_d_exports } from "./DurableObjectDefinition.mjs";
+import { DurableObjectNamespace_d_exports } from "./DurableObjectNamespace.mjs";
 import { DurableObject_d_exports } from "./DurableObject.mjs";
 import { DurableObjectRpcWebSocket_d_exports } from "./DurableObjectRpcWebSocket.mjs";
 import { DurableObjectSqlite_d_exports } from "./DurableObjectSqlite.mjs";

package/dist/index.mjs

@@ -11,13 +11,13 @@ import { DurableObjectWebSocket_exports } from "./DurableObjectWebSocket.mjs";
 import { DurableObjectState_exports } from "./DurableObjectState.mjs";
 import { CloudflareOtlp_exports } from "./CloudflareOtlp.mjs";
 import { CloudflareTracer_exports } from "./CloudflareTracer.mjs";
+import { RpcTargets_exports } from "./RpcTargets.mjs";
 import { ContainerNamespace_exports } from "./ContainerNamespace.mjs";
 import { D1_exports } from "./D1.mjs";
 import { QueueBinding_exports } from "./QueueBinding.mjs";
 import { QueueDefinition_exports } from "./QueueDefinition.mjs";
 import { Queue_exports } from "./Queue.mjs";
 import { RpcDefinition_exports } from "./RpcDefinition.mjs";
-import { RpcTargets_exports } from "./RpcTargets.mjs";
 import { RpcTracing_exports } from "./RpcTracing.mjs";
 import { Rpc_exports } from "./Rpc.mjs";
 import { ServiceBinding_exports } from "./ServiceBinding.mjs";

package/dist/internal/RpcTargets.mjs

@@ -0,0 +1,5 @@
+import * as Context from "effect/Context";
+//#region src/internal/RpcTargets.ts
+var CurrentTargets = class extends Context.Service()("effect-cf/RpcTargets") {};
+//#endregion
+export { CurrentTargets };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.41.0",
+  "version": "0.42.0",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {

package/src/AiGateway.ts

@@ -10,6 +10,8 @@ import type { WorkerEnvironment } from "./Environment";
 import { isWorkersAiBinding, type WorkersAiBinding } from "./WorkersAi";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 const expectedAiGatewayBinding = "Workers AI binding with gateway()";
 
 export class AiGatewayOperationError extends Data.TaggedError("AiGatewayOperationError")<{

package/src/AnalyticsEngine.ts

@@ -21,6 +21,8 @@ import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 const expectedAnalyticsEngineDataset = "Analytics Engine dataset binding with writeDataPoint()";
 const defaultQueryApiBaseUrl = "https://api.cloudflare.com/client/v4";
 const textEncoder = new TextEncoder();

package/src/Artifacts.ts

@@ -17,6 +17,8 @@ import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 const expectedArtifactsBinding =
   "Artifacts binding with create(), get(), import(), list(), and delete()";
 

package/src/BrowserRendering.ts

@@ -8,6 +8,8 @@ import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 const expectedBrowserRenderingBinding = "Browser Rendering binding resource";
 
 export class BrowserRenderingOperationError extends Data.TaggedError(

package/src/ContainerNamespace.ts

@@ -6,9 +6,12 @@ import * as S from "effect/Schema";
 import type { Layer } from "effect";
 
 import * as Binding from "./Binding";
+import * as RpcTargets from "./RpcTargets";
 import type { WorkerEnvironment } from "./Environment";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 const expectedContainerNamespace = "Container namespace binding with getByName()";
 
 export type ContainerSignal = "SIGKILL" | "SIGINT" | "SIGTERM";
@@ -231,6 +234,7 @@ const tryContainerPromise = <A>(
   instance: string,
   operation: string,
   evaluate: () => Promise<A>,
+  target: ContainerStub,
 ): Effect.Effect<A, ContainerOperationError> =>
   Effect.tryPromise({
     try: evaluate,
@@ -241,13 +245,15 @@ const tryContainerPromise = <A>(
         operation,
         cause,
       }),
-  });
+  }).pipe(Effect.tapCause(() => RpcTargets.invalidate(target)));
 
 const makeInstanceClient = <Stub extends ContainerStub>(
   definition: ContainerNamespaceDefinition,
   instance: string,
   stub: Stub,
 ): ContainerInstanceClient<Stub> => {
+  const attempt = <A>(operation: string, evaluate: () => Promise<A>) =>
+    tryContainerPromise(definition, instance, operation, evaluate, stub);
   const spanOptions = (operation: string) => ({
     attributes: { binding: definition.binding, instance, operation },
   });
@@ -256,9 +262,7 @@ const makeInstanceClient = <Stub extends ContainerStub>(
       `ContainerNamespace.${operation}`,
       spanOptions(operation),
     )(function* (hosts: ReadonlyArray<string>) {
-      return yield* tryContainerPromise(definition, instance, operation, () =>
-        stub[operation]([...hosts]),
-      );
+      return yield* attempt(operation, () => stub[operation]([...hosts]));
     });
   const hostnameOperation = (
     operation: "allowHost" | "denyHost" | "removeAllowedHost" | "removeDeniedHost",
@@ -267,14 +271,12 @@ const makeInstanceClient = <Stub extends ContainerStub>(
       `ContainerNamespace.${operation}`,
       spanOptions(operation),
     )(function* (hostname: string) {
-      return yield* tryContainerPromise(definition, instance, operation, () =>
-        stub[operation](hostname),
-      );
+      return yield* attempt(operation, () => stub[operation](hostname));
     });
 
   return {
     rawUnsafe: Effect.succeed(stub),
-    state: tryContainerPromise(definition, instance, "state", () => stub.getState()).pipe(
+    state: attempt("state", () => stub.getState()).pipe(
       Effect.flatMap(S.decodeUnknownEffect(ContainerState)),
       Effect.mapError((cause) =>
         cause instanceof ContainerOperationError
@@ -292,41 +294,33 @@ const makeInstanceClient = <Stub extends ContainerStub>(
       "ContainerNamespace.fetch",
       spanOptions("fetch"),
     )(function* (input: RequestInfo | URL, init?: RequestInit) {
-      return yield* tryContainerPromise(definition, instance, "fetch", () =>
-        stub.fetch(input, init),
-      );
+      return yield* attempt("fetch", () => stub.fetch(input, init));
     }),
     start: Effect.fn(
       "ContainerNamespace.start",
       spanOptions("start"),
     )(function* (options?: ContainerStartOptions, waitOptions?: ContainerWaitOptions) {
-      return yield* tryContainerPromise(definition, instance, "start", () =>
-        stub.start(options, waitOptions),
-      );
+      return yield* attempt("start", () => stub.start(options, waitOptions));
     }),
     startAndWaitForPorts: Effect.fn(
       "ContainerNamespace.startAndWaitForPorts",
       spanOptions("startAndWaitForPorts"),
     )(function* (options?: ContainerStartAndWaitForPortsOptions) {
-      return yield* tryContainerPromise(definition, instance, "startAndWaitForPorts", () =>
-        stub.startAndWaitForPorts(options),
-      );
+      return yield* attempt("startAndWaitForPorts", () => stub.startAndWaitForPorts(options));
     }),
     waitForPort: Effect.fn(
       "ContainerNamespace.waitForPort",
       spanOptions("waitForPort"),
     )(function* (options: ContainerWaitOptions) {
-      return yield* tryContainerPromise(definition, instance, "waitForPort", () =>
-        stub.waitForPort(options),
-      );
+      return yield* attempt("waitForPort", () => stub.waitForPort(options));
     }),
     stop: Effect.fn(
       "ContainerNamespace.stop",
       spanOptions("stop"),
     )(function* (signal?: ContainerStopSignal) {
-      return yield* tryContainerPromise(definition, instance, "stop", () => stub.stop(signal));
+      return yield* attempt("stop", () => stub.stop(signal));
     }),
-    destroy: tryContainerPromise(definition, instance, "destroy", () => stub.destroy()).pipe(
+    destroy: attempt("destroy", () => stub.destroy()).pipe(
       Effect.withSpan("ContainerNamespace.destroy", spanOptions("destroy")),
     ),
     setAllowedHosts: hostListOperation("setAllowedHosts"),
@@ -352,23 +346,24 @@ export const makeClient =
       name: string,
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
     ) =>
-      Effect.try({
-        try: () =>
-          makeInstanceClient(
-            definition,
-            name,
-            // 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>,
-          ),
-        catch: (cause) =>
-          new ContainerOperationError({
-            binding: definition.binding,
-            instance: name,
-            operation: "getByName",
-            cause,
-          }),
-      });
+      RpcTargets.get(
+        namespace,
+        JSON.stringify(["container", name, options]),
+        () =>
+          // SAFETY: getByName returns the namespace's declared native stub type.
+          namespace.getByName(name, options) as ContainerStubOf<Namespace>,
+      ).pipe(
+        Effect.map((stub) => makeInstanceClient(definition, name, stub)),
+        Effect.mapError(
+          (error) =>
+            new ContainerOperationError({
+              binding: definition.binding,
+              instance: name,
+              operation: "getByName",
+              cause: error.cause,
+            }),
+        ),
+      );
 
     const byName = (
       name: string,

package/src/D1.ts

@@ -8,6 +8,8 @@ import type { SqlClient } from "effect/unstable/sql";
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 const TypeId = "~effect-cf/D1" as const;
 
 export type TypeId = typeof TypeId;
@@ -19,6 +21,18 @@ export interface D1Definition {
 
 export type D1SqlLayerOptions = Omit<D1Client.D1ClientConfig, "db">;
 
+export type ServiceClass<Self, Id extends string> = Binding.BindingService<Self, Id, D1Database> & {
+  [TypeId]: typeof TypeId;
+  definition: D1Definition;
+  sqlLayer: (
+    options?: D1SqlLayerOptions,
+  ) => Layer.Layer<
+    D1Client.D1Client | SqlClient.SqlClient,
+    Config.ConfigError | Binding.BindingNotFoundError | Binding.BindingValidationError,
+    WorkerEnvironment
+  >;
+};
+
 declare const D1ServiceTypeId: unique symbol;
 
 export interface D1Service<Id extends string> {
@@ -40,18 +54,12 @@ export const make = <Id extends string>(id: Id, definition: D1Definition) =>
 
 export const Service =
   <Self>() =>
-  <Id extends string>(id: Id, definition: D1Definition) => {
+  <Id extends string>(id: Id, definition: D1Definition): ServiceClass<Self, Id> => {
     const tag = Binding.Service<Self>()(id, definition.binding, isD1Database, undefined, {
       expected: expectedD1Database,
     });
 
-    const sqlLayer = (
-      options?: D1SqlLayerOptions,
-    ): Layer.Layer<
-      D1Client.D1Client | SqlClient.SqlClient,
-      Config.ConfigError | Binding.BindingNotFoundError | Binding.BindingValidationError,
-      WorkerEnvironment
-    > =>
+    const sqlLayer: ServiceClass<Self, Id>["sqlLayer"] = (options) =>
       Layer.unwrap(
         Effect.gen(function* () {
           const db = yield* tag;

package/src/DurableObject.ts

@@ -19,6 +19,17 @@ import * as Runtime from "./internal/Runtime";
 import * as Telemetry from "./internal/Telemetry";
 import type { ReceiverOptions, RpcInvocationInfo } from "./RpcTracing";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+export type {
+  DurableObjectFetchError,
+  DurableObjectNamespaceClient,
+  DurableObjectRpcError,
+  DurableObjectStubClient,
+  StubCall,
+  StubRpc,
+  StubScopedCall,
+} from "./DurableObjectNamespace";
+
 const reservedMethodNames: ReadonlySet<string> = RpcDefinition.reservedMethodNames;
 
 export type RuntimeContext<ROut> =
@@ -403,15 +414,17 @@ export type {
   LayerOptions,
   Method,
   Methods,
+  NativeSchema,
   NoReservedMethods,
   Options,
   ReservedMethodName,
+  RpcSchema,
   ServerApi,
   ServiceFreeSchema,
   TagClass,
 } from "./DurableObjectDefinition";
 
-export { implement, method, Tag } from "./DurableObjectDefinition";
+export { implement, method, native, Tag } from "./DurableObjectDefinition";
 
 // Preserve the original public type export while using a domain-role name internally.
 export type { DurableObjectRpcApi as "DurableObjectRpcShape" };

package/src/DurableObjectDefinition.ts

@@ -11,41 +11,55 @@ import * as RpcDefinition from "./RpcDefinition";
 import { recordDecodedArgs } from "./internal/RpcInvocation";
 import type { WorkerEnvironment } from "./Environment";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+export type {
+  DurableObjectFetchError,
+  DurableObjectNamespaceClient,
+  DurableObjectRpcError,
+  DurableObjectStubClient,
+  StubCall,
+  StubRpc,
+  StubScopedCall,
+} from "./DurableObjectNamespace";
+
 type ErasedInvoke<E> = (...args: ReadonlyArray<unknown>) => Effect.Effect<unknown, E>;
 
 export type ServiceFreeSchema = S.Codec<any, any, never, never>;
+export type NativeSchema<Schema extends ServiceFreeSchema = ServiceFreeSchema> =
+  RpcDefinition.NativeSchema<Schema>;
+export type RpcSchema = RpcDefinition.RpcSchema;
 
 export interface Method<
-  Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>,
-  Success extends ServiceFreeSchema = ServiceFreeSchema,
+  Args extends ReadonlyArray<RpcSchema> = ReadonlyArray<RpcSchema>,
+  Success extends RpcSchema = RpcSchema,
 > {
   readonly args: Args;
   readonly success: Success;
 }
 
 export namespace Method {
-  export type Any = Method<ReadonlyArray<ServiceFreeSchema>, ServiceFreeSchema>;
+  export type Any = Method<ReadonlyArray<RpcSchema>, RpcSchema>;
 
-  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = Args extends readonly []
+  type ArgsFromSchemas<Args extends ReadonlyArray<RpcSchema>> = Args extends readonly []
     ? []
     : Args extends readonly [
-          infer Head extends ServiceFreeSchema,
-          ...infer Tail extends ReadonlyArray<ServiceFreeSchema>,
+          infer Head extends RpcSchema,
+          ...infer Tail extends ReadonlyArray<RpcSchema>,
         ]
-      ? [S.Schema.Type<Head>, ...ArgsFromSchemas<Tail>]
-      : Array<S.Schema.Type<Args[number]>>;
+      ? [RpcDefinition.SchemaType<Head>, ...ArgsFromSchemas<Tail>]
+      : Array<RpcDefinition.SchemaType<Args[number]>>;
 
-  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = {
-    [Index in keyof Args]: S.Json;
+  type EncodedArgsFromSchemas<Args extends ReadonlyArray<RpcSchema>> = {
+    [Index in keyof Args]: RpcDefinition.WireEncoded<Args[Index]>;
   };
 
   export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
 
   export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
 
-  export type Success<Self extends Any> = S.Schema.Type<Self["success"]>;
+  export type Success<Self extends Any> = RpcDefinition.SchemaType<Self["success"]>;
 
-  export type EncodedSuccess<_Self extends Any> = S.Json;
+  export type EncodedSuccess<Self extends Any> = RpcDefinition.WireEncoded<Self["success"]>;
 }
 
 export type Methods = Record<string, Method.Any>;
@@ -178,20 +192,22 @@ export type TagClass<
 /**
  * Defines a single RPC method schema in a Durable Object definition.
  */
-export function method<Success extends ServiceFreeSchema>(definition: {
+export function method<Success extends RpcSchema>(definition: {
   readonly success: Success;
 }): Method<readonly [], Success>;
 export function method<
-  const Args extends ReadonlyArray<ServiceFreeSchema>,
-  Success extends ServiceFreeSchema,
+  const Args extends ReadonlyArray<RpcSchema>,
+  Success extends RpcSchema,
 >(definition: { readonly args: Args; readonly success: Success }): Method<Args, Success>;
 export function method(definition: {
-  readonly args?: ReadonlyArray<ServiceFreeSchema>;
-  readonly success: ServiceFreeSchema;
+  readonly args?: ReadonlyArray<RpcSchema>;
+  readonly success: RpcSchema;
 }): Method {
   return RpcDefinition.method(definition);
 }
 
+export const native = RpcDefinition.native;
+
 const makeDefinition = <Id extends string, const MethodDefinitions extends Methods>(
   id: Id,
   methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>,

package/src/DurableObjectNamespace.ts

@@ -120,12 +120,24 @@ type StubMethodCloudflareReturn<
   Method extends keyof Api,
 > = RpcInvocation.AsyncMethodCloudflareReturn<Api, Method>;
 
-type StubCall<R, Api extends object> = <Method extends StubMethodKey<Api>>(
+export 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, R>;
 
+export type StubRpc<R, Api extends object> = <Method extends StubMethodKey<Api>>(
+  stub: DurableObjectStubClient<Api>,
+  method: Method,
+  ...args: StubMethodArgs<Api, Method>
+) => Effect.Effect<StubMethodCloudflareReturn<Api, Method>, DurableObjectRpcError, R>;
+
+export type StubScopedCall<R, Api extends object> = <Method extends StubMethodKey<Api>>(
+  stub: DurableObjectStubClient<Api>,
+  method: Method,
+  ...args: StubMethodArgs<Api, Method>
+) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, DurableObjectRpcError, Scope.Scope | R>;
+
 type DurableObjectDirectClient<R, Api extends object> = {
   readonly fetch: (
     input: RequestInfo | URL,
@@ -227,22 +239,14 @@ export type DurableObjectNamespaceEffectClient<
    *
    * Most application code should use {@link call} instead.
    */
-  readonly rpc: <Method extends StubMethodKey<Api>>(
-    stub: DurableObjectStubClient<Api>,
-    method: Method,
-    ...args: StubMethodArgs<Api, Method>
-  ) => Effect.Effect<StubMethodCloudflareReturn<Api, Method>, DurableObjectRpcError>;
+  readonly rpc: StubRpc<never, Api>;
   /**
    * 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.
    */
-  readonly call: <Method extends StubMethodKey<Api>>(
-    stub: DurableObjectStubClient<Api>,
-    method: Method,
-    ...args: StubMethodArgs<Api, Method>
-  ) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError>;
+  readonly call: StubCall<never, Api>;
   /**
    * Invokes a Durable Object RPC method in the current `Scope`, resolves
    * Cloudflare's RPC result, decodes definition-backed success values, and
@@ -252,11 +256,7 @@ 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.
    */
-  readonly scopedCall: <Method extends StubMethodKey<Api>>(
-    stub: DurableObjectStubClient<Api>,
-    method: Method,
-    ...args: StubMethodArgs<Api, Method>
-  ) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, DurableObjectRpcError, Scope.Scope>;
+  readonly scopedCall: StubScopedCall<never, Api>;
   /**
    * Exposes the underlying native Durable Object namespace binding.
    *
@@ -292,25 +292,9 @@ export type DurableObjectNamespaceStaticClient<
     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>>,
-    DurableObjectRpcError,
-    Scope.Scope | R
-  >;
+  readonly rpc: StubRpc<R, Api>;
+  readonly call: StubCall<R, Api>;
+  readonly scopedCall: StubScopedCall<R, Api>;
   readonly rawUnsafe: () => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
 };
 

package/src/Email.ts

@@ -14,6 +14,8 @@ import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 const expectedSendEmailBinding = "Send Email binding with send()";
 const textEncoder = new TextEncoder();