effect-cf 0.7.0 → 0.8.0

package/dist/index.d.mts

@@ -1,129 +1,21 @@
-import { Cause, Config, ConfigProvider, Context, DateTime, Duration, Effect, Layer, Option, Schema, Scope } from "effect";
+import { a as BindingService, c as WorkerConfig, i as BindingNotFoundError, l as WorkerEnv, o as BindingValidationError, s as Binding_d_exports, t as Hyperdrive_d_exports, u as WorkerEnvironment } from "./Hyperdrive-By6DrSS_.mjs";
+import { Cause, Context, Data, DateTime, Duration, Effect, Layer, Option, Schema, Scope } from "effect";
 import { D1Client } from "@effect/sql-d1";
 import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, WorkflowEntrypoint, WorkflowEvent, WorkflowSleepDuration, WorkflowStep, WorkflowStepConfig, WorkflowStepContext, WorkflowStepEvent, WorkflowTimeoutDuration } from "cloudflare:workers";
 import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
 import * as RpcServer from "effect/unstable/rpc/RpcServer";
+import * as _$effect_unstable_sql_SqlClient0 from "effect/unstable/sql/SqlClient";
 import * as _$effect_Types0 from "effect/Types";
 import * as _$effect_Cause0 from "effect/Cause";
-import * as _$effect_Redacted0 from "effect/Redacted";
 import * as _$effect_Layer0 from "effect/Layer";
-import * as _$effect_unstable_sql_SqlClient0 from "effect/unstable/sql/SqlClient";
-import * as _$effect_Config0 from "effect/Config";
 import * as _$effect_Scope0 from "effect/Scope";
+import * as _$effect_Config0 from "effect/Config";
 
-//#region src/Environment.d.ts
-/** Cloudflare worker environment object (`env`). */
-type WorkerEnv = Cloudflare.Env;
-declare const WorkerEnvironment_base: Context.ServiceClass<WorkerEnvironment, "effect-cf/WorkerEnvironment", Cloudflare.Env>;
-/**
- * Context service for reading worker bindings from the current `env` object.
- */
-declare class WorkerEnvironment extends WorkerEnvironment_base {}
-type ScalarConfigValue = string | number | boolean;
-type ScalarConfigKey = Extract<{ readonly [Key in keyof Cloudflare.Env]-?: NonNullable<Cloudflare.Env[Key]> extends ScalarConfigValue ? Key : never }[keyof Cloudflare.Env], string>;
-/**
- * Effect `Config` helpers for scalar Cloudflare vars and secrets declared on
- * `Cloudflare.Env` / generated `worker-configuration.d.ts`.
- *
- * Users still author their app config explicitly with Effect `Config`:
- *
- * ```ts
- * import { Config, Effect } from "effect";
- * import { WorkerConfig } from "effect-cf";
- *
- * const AppConfig = Config.all({
- *   databaseUrl: WorkerConfig.redacted("DATABASE_URL"),
- *   port: WorkerConfig.integer("PORT").pipe(Config.withDefault(8787)),
- * });
- *
- * const program = Effect.gen(function* () {
- *   const config = yield* AppConfig;
- *   // ...
- * }).pipe(Effect.provide(WorkerConfig.layer));
- * ```
- *
- * Keys are constrained to scalar `Cloudflare.Env` properties (`string`,
- * `number`, or `boolean`, including optional scalar properties). Binding
- * objects such as `KVNamespace`, `DurableObjectNamespace`, and service
- * bindings are intentionally excluded; keep using the package binding helpers
- * for those live resources.
- */
-declare namespace WorkerConfig {
-  /** Scalar env value types supported by the typed config key helpers. */
-  type Scalar = ScalarConfigValue;
-  /** Scalar keys available on the current consumer's `Cloudflare.Env`. */
-  type Key = ScalarConfigKey;
-  /** Read a scalar Cloudflare var or secret as a string. */
-  const string: <const Name extends Key>(name: Name) => Config.Config<string>;
-  /** Read a scalar Cloudflare secret as a redacted string. */
-  const redacted: <const Name extends Key>(name: Name) => Config.Config<_$effect_Redacted0.Redacted<string>>;
-  /** Read a scalar Cloudflare var or secret as a number. */
-  const number: <const Name extends Key>(name: Name) => Config.Config<number>;
-  /** Read a scalar Cloudflare var or secret as an integer. */
-  const integer: <const Name extends Key>(name: Name) => Config.Config<number>;
-  /** Read a scalar Cloudflare var or secret as a boolean. */
-  const boolean: <const Name extends Key>(name: Name) => Config.Config<boolean>;
-  /** Build a `ConfigProvider` from a Cloudflare worker `env` object. */
-  const providerFromEnv: (env: WorkerEnv) => ConfigProvider.ConfigProvider;
-  /**
-   * Build a `ConfigProvider` from the current `WorkerEnvironment` with a custom
-   * conversion function.
-   */
-  const providerWith: (makeProvider: (env: WorkerEnv) => ConfigProvider.ConfigProvider) => Effect.Effect<ConfigProvider.ConfigProvider, never, WorkerEnvironment>;
-  /** Build a `ConfigProvider` from the current `WorkerEnvironment`. */
-  const provider: Effect.Effect<ConfigProvider.ConfigProvider, never, WorkerEnvironment>;
-  /**
-   * Replace the active Effect `ConfigProvider` with one backed by the current
-   * Cloudflare worker `env` object.
-   */
-  const providerLayer: _$effect_Layer0.Layer<never, never, WorkerEnvironment>;
-  /** Alias for `providerLayer` for concise use in worker layers. */
-  const layer: _$effect_Layer0.Layer<never, never, WorkerEnvironment>;
-  /** Build a `ConfigProvider` layer with a custom `env` conversion function. */
-  const layerWith: (makeProvider: (env: WorkerEnv) => ConfigProvider.ConfigProvider) => _$effect_Layer0.Layer<never, never, WorkerEnvironment>;
-}
-declare namespace Binding_d_exports {
-  export { BindingNotFoundError, BindingService, BindingValidationError, Service$2 as Service, TypeId$1 as TypeId, layer$6 as layer };
-}
-/** Internal type id marker used by binding helper services. */
-declare const TypeId$1: "effect-cf/Binding";
-declare const BindingNotFoundError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
-  readonly _tag: "BindingNotFoundError";
-} & Readonly<A>;
-/** Error raised when a configured binding does not exist on `env`. */
-declare class BindingNotFoundError extends BindingNotFoundError_base<{
-  readonly binding: string;
-}> {}
-declare const BindingValidationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
-  readonly _tag: "BindingValidationError";
-} & Readonly<A>;
-/** Error raised when a binding exists but does not match the expected shape. */
-declare class BindingValidationError extends BindingValidationError_base<{
-  readonly binding: string;
-}> {}
-/**
- * Creates a Context tag + layer for reading and validating a Cloudflare binding.
- */
-interface BindingService<Self, Id extends string, Service> extends Context.ServiceClass<Self, Id, Service> {
-  readonly [TypeId$1]: typeof TypeId$1;
-  readonly binding: string;
-  readonly layer: Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-}
-declare const layer$6: <Self, Resource, Service = Resource>(tag: Context.Service<Self, Service>, binding: string, isResource: (value: unknown) => value is Resource, wrap?: (resource: Resource) => Service) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const Service$2: <Self>() => <Id extends string, Resource, Service = Resource>(id: Id, binding: string, isResource: (value: unknown) => value is Resource, wrap?: (resource: Resource) => Service) => BindingService<Self, Id, Service>;
+//#region src/D1.d.ts
 declare namespace D1_d_exports {
-  export { D1Definition, D1OperationError, D1Service, D1SqlLayerOptions, Service$1 as Service, make$8 as make };
+  export { D1Definition, D1Service, D1SqlLayerOptions, Service$1 as Service, make$10 as make };
 }
-declare const D1OperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
-  readonly _tag: "D1OperationError";
-} & Readonly<A>;
-/** Error raised when a D1 operation fails. */
-declare class D1OperationError extends D1OperationError_base<{
-  readonly binding: string;
-  readonly operation: string;
-  readonly cause: unknown;
-}> {}
 /** Typed D1 binding definition. */
 interface D1Definition {
   /** Binding name as configured in `wrangler.jsonc`. */
@@ -141,21 +33,16 @@ interface D1Service<Id extends string> {
 /**
  * Creates a typed D1 service tag plus Effect helpers.
  */
-declare const make$8: <Id extends string>(id: Id, definition: D1Definition) => BindingService<D1Service<Id>, Id, D1Database> & {
+declare const make$10: <Id extends string>(id: Id, definition: D1Definition) => BindingService<D1Service<Id>, Id, D1Database> & {
   "effect-cf/D1": "effect-cf/D1";
   definition: D1Definition;
   sqlLayer: (options?: D1SqlLayerOptions) => Layer.Layer<D1Client.D1Client | _$effect_unstable_sql_SqlClient0.SqlClient, BindingNotFoundError | BindingValidationError | _$effect_Config0.ConfigError, WorkerEnvironment>;
-  prepare: (query: string) => Effect.Effect<D1PreparedStatement, D1OperationError, D1Service<Id>>;
-  batch: <T = unknown>(statements: readonly D1PreparedStatement[]) => Effect.Effect<D1Result<T>[], D1OperationError, D1Service<Id>>;
-  exec: (query: string) => Effect.Effect<D1ExecResult, D1OperationError, D1Service<Id>>;
-  unsafeRaw: () => Effect.Effect<D1Database, never, D1Service<Id>>;
 };
 /**
  * Builds a D1 service around a Cloudflare D1 database binding.
  *
- * The returned service exposes the raw `D1Database` binding, small native D1
- * helpers, and `sqlLayer(...)` for providing `effect/unstable/sql` via
- * `@effect/sql-d1`.
+ * The returned service exposes the raw `D1Database` binding and `sqlLayer(...)`
+ * for providing `effect/unstable/sql` via `@effect/sql-d1`.
  *
  * @example
  * ```ts
@@ -170,10 +57,6 @@ declare const Service$1: <Self>() => <Id extends string>(id: Id, definition: D1D
   "effect-cf/D1": "effect-cf/D1";
   definition: D1Definition;
   sqlLayer: (options?: D1SqlLayerOptions) => Layer.Layer<D1Client.D1Client | _$effect_unstable_sql_SqlClient0.SqlClient, BindingNotFoundError | BindingValidationError | _$effect_Config0.ConfigError, WorkerEnvironment | Exclude<Exclude<Self, _$effect_Scope0.Scope>, Self>>;
-  prepare: (query: string) => Effect.Effect<D1PreparedStatement, D1OperationError, Self>;
-  batch: <T = unknown>(statements: readonly D1PreparedStatement[]) => Effect.Effect<D1Result<T>[], D1OperationError, Self>;
-  exec: (query: string) => Effect.Effect<D1ExecResult, D1OperationError, Self>;
-  unsafeRaw: () => Effect.Effect<D1Database, never, Self>;
 };
 declare namespace Rpc_d_exports {
   export { DisposableValue, MethodArgs, MethodKey, MethodReturn, Provider, Result, RpcStub, RpcTarget, Serializable, Stub, Stubable, Stubify, dispose, isDisposable, resolve, scoped };
@@ -200,7 +83,7 @@ declare const dispose: (value: unknown) => Effect.Effect<void>;
 declare const resolve: <A>(value: A) => Effect.Effect<Awaited<A>, unknown>;
 declare const scoped: <A>(value: A) => Effect.Effect<Awaited<A>, unknown, Scope.Scope>;
 declare namespace RpcDefinition_d_exports {
-  export { Definition$9 as Definition, Method$5 as Method, Methods$4 as Methods, NoReservedMethods$4 as NoReservedMethods, ReservedMethodName$6 as ReservedMethodName, ReservedMethodNameError, RpcArgumentCountError, RpcArgumentDecodeError, RpcArgumentEncodeError, RpcReservedMethodNameError, RpcSuccessDecodeError, RpcSuccessEncodeError, ServiceFreeSchema$4 as ServiceFreeSchema, assertNoReservedMethodNames, assertNoReservedMethods, decodeArgs, decodeSuccess, encodeArgs, encodeSuccess, make$7 as make, method$4 as method, reservedMethodNames };
+  export { Definition$9 as Definition, Method$5 as Method, Methods$4 as Methods, NoReservedMethods$4 as NoReservedMethods, ReservedMethodName$6 as ReservedMethodName, ReservedMethodNameError, RpcArgumentCountError, RpcArgumentDecodeError, RpcArgumentEncodeError, RpcReservedMethodNameError, RpcSuccessDecodeError, RpcSuccessEncodeError, ServiceFreeSchema$4 as ServiceFreeSchema, assertNoReservedMethodNames, assertNoReservedMethods, decodeArgs, decodeSuccess, encodeArgs, encodeSuccess, make$9 as make, method$4 as method, reservedMethodNames };
 }
 declare const RpcReservedMethodNameError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
   readonly _tag: "RpcReservedMethodNameError";
@@ -299,9 +182,9 @@ declare const decodeArgs: <const Self extends Definition$9.Any, MethodName exten
 declare const encodeArgs: <const Self extends Definition$9.Any, MethodName extends Definition$9.MethodNames<Self>>(definition: Self, methodName: MethodName, args: Method$5.Args<Self["methods"][MethodName]>) => Effect.Effect<Method$5.EncodedArgs<Self["methods"][MethodName]>, RpcArgumentCountError | RpcArgumentEncodeError>;
 declare const encodeSuccess: <const Self extends Definition$9.Any, MethodName extends Definition$9.MethodNames<Self>>(definition: Self, methodName: MethodName, value: Method$5.Success<Self["methods"][MethodName]>) => Effect.Effect<Method$5.EncodedSuccess<Self["methods"][MethodName]>, RpcSuccessEncodeError>;
 declare const decodeSuccess: <const Self extends Definition$9.Any, MethodName extends Definition$9.MethodNames<Self>>(definition: Self, methodName: MethodName, value: unknown) => Effect.Effect<Method$5.Success<Self["methods"][MethodName]>, RpcSuccessDecodeError>;
-declare const make$7: <Id extends string, const MethodsShape extends Methods$4>(id: Id, methods: MethodsShape) => Definition$9<Id, MethodsShape>;
+declare const make$9: <Id extends string, const MethodsShape extends Methods$4>(id: Id, methods: MethodsShape) => Definition$9<Id, MethodsShape>;
 declare namespace QueueBinding_d_exports {
-  export { MessageSendRequest, QueueBindingClient, QueueBindingDefinition, QueueMetrics, QueueOperationError, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse, isQueue, layer$5 as layer, makeClient$4 as makeClient };
+  export { MessageSendRequest, QueueBindingClient, QueueBindingDefinition, QueueMetrics, QueueOperationError, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse, isQueue, layer$7 as layer, makeClient$6 as makeClient };
 }
 type QueueSendOptions = globalThis.QueueSendOptions;
 type QueueSendResponse = globalThis.QueueSendResponse;
@@ -330,10 +213,10 @@ declare class QueueOperationError extends QueueOperationError_base<{
   readonly cause: unknown;
 }> {}
 declare const isQueue: <Body>(value: unknown) => value is globalThis.Queue<Body>;
-declare const makeClient$4: <Message extends ServiceFreeSchema$4>(definition: QueueBindingDefinition<Message>) => ((queue: globalThis.Queue<Schema.Codec.Encoded<Message>>) => QueueBindingClient<Message>);
-declare const layer$5: <Self, Message extends ServiceFreeSchema$4>(tag: Context.Service<Self, QueueBindingClient<Message>>, definition: QueueBindingDefinition<Message>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const makeClient$6: <Message extends ServiceFreeSchema$4>(definition: QueueBindingDefinition<Message>) => ((queue: globalThis.Queue<Schema.Codec.Encoded<Message>>) => QueueBindingClient<Message>);
+declare const layer$7: <Self, Message extends ServiceFreeSchema$4>(tag: Context.Service<Self, QueueBindingClient<Message>>, definition: QueueBindingDefinition<Message>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare namespace QueueDefinition_d_exports {
-  export { Definition$8 as Definition, Handler$3 as Handler, LayerOptions$9 as LayerOptions, Options$7 as Options, Queue$1 as Queue, Tag$9 as Tag, TagClass$8 as TagClass, implement$7 as implement, make$6 as make };
+  export { Definition$8 as Definition, Handler$3 as Handler, LayerOptions$11 as LayerOptions, Options$7 as Options, Queue$1 as Queue, Tag$11 as Tag, TagClass$10 as TagClass, implement$7 as implement, make$8 as make };
 }
 interface Definition$8<Id extends string = string, Message extends ServiceFreeSchema$4 = ServiceFreeSchema$4> {
   readonly id: Id;
@@ -347,31 +230,31 @@ interface Options$7<ROut, Self extends Definition$8.Any> extends Omit<WorkerOpti
   readonly queue: Handler$3<ROut, Self>;
   readonly rpc?: never;
 }
-type LayerOptions$9 = {
+type LayerOptions$11 = {
   readonly binding: string;
 };
-interface TagClass$8<Self, Id extends string, Message extends ServiceFreeSchema$4> extends Context.ServiceClass<Self, Id, QueueBindingClient<Message>> {
+interface TagClass$10<Self, Id extends string, Message extends ServiceFreeSchema$4> extends Context.ServiceClass<Self, Id, QueueBindingClient<Message>> {
   readonly id: Id;
   readonly message: Message;
   readonly make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$7<ROut, Definition$8<Id, Message>>) => WorkerClass<Record<never, never>, ROut>;
-  readonly layer: (options: LayerOptions$9) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$11) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
   readonly send: (message: Schema.Schema.Type<Message>, options?: QueueSendOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError, Self>;
   readonly sendBatch: (messages: Iterable<MessageSendRequest<Schema.Schema.Type<Message>>>, options?: QueueSendBatchOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError, Self>;
   readonly metrics: () => Effect.Effect<QueueMetrics, QueueOperationError, Self>;
   readonly unsafeRaw: () => Effect.Effect<globalThis.Queue<Schema.Codec.Encoded<Message>>, never, Self>;
 }
-declare const make$6: <Id extends string, Message extends ServiceFreeSchema$4>(id: Id, definition: {
+declare const make$8: <Id extends string, Message extends ServiceFreeSchema$4>(id: Id, definition: {
   readonly message: Message;
-}) => TagClass$8<Definition$8<Id, Message>, Id, Message>;
-declare const Tag$9: <Self>() => <Id extends string, Message extends ServiceFreeSchema$4>(id: Id, definition: {
+}) => TagClass$10<Definition$8<Id, Message>, Id, Message>;
+declare const Tag$11: <Self>() => <Id extends string, Message extends ServiceFreeSchema$4>(id: Id, definition: {
   readonly message: Message;
-}) => TagClass$8<Self, Id, Message>;
+}) => TagClass$10<Self, Id, Message>;
 declare const Queue$1: <Self>() => <Id extends string, Message extends ServiceFreeSchema$4>(id: Id, definition: {
   readonly message: Message;
-}) => TagClass$8<Self, Id, Message>;
+}) => TagClass$10<Self, Id, Message>;
 declare const implement$7: <ROut, const Self extends Definition$8.Any>(_definition: Self, handler: Handler$3<ROut, Self>) => Handler$3<ROut, Self>;
 declare namespace Queue_d_exports {
-  export { Definition$7 as Definition, Handler$2 as Handler, LayerOptions$8 as LayerOptions, Options$6 as Options, QueueBatch, QueueHandler, QueueMessage, QueueMessageDecodeError, QueueOptions, Tag$8 as Tag, TagClass$7 as TagClass, decodeBatch, fromMessage, fromMessageBatch, implement$6 as implement };
+  export { Definition$7 as Definition, Handler$2 as Handler, LayerOptions$10 as LayerOptions, Options$6 as Options, QueueBatch, QueueHandler, QueueMessage, QueueMessageDecodeError, QueueOptions, Tag$10 as Tag, TagClass$9 as TagClass, decodeBatch, fromMessage, fromMessageBatch, implement$6 as implement };
 }
 interface QueueMessage<Body> {
   readonly raw: globalThis.Message<unknown>;
@@ -420,16 +303,16 @@ type Definition$7<Id extends string = string, Message extends Definition$8.Any["
 declare namespace Definition$7 {
   type Any = Definition$8.Any;
 }
-type LayerOptions$8 = LayerOptions$9;
-type TagClass$7<Self, Id extends string, Message extends Definition$8.Any["message"]> = TagClass$8<Self, Id, Message>;
-declare const Tag$8: <Self>() => <Id extends string, Message extends Definition$8.Any["message"]>(id: Id, definition: {
+type LayerOptions$10 = LayerOptions$11;
+type TagClass$9<Self, Id extends string, Message extends Definition$8.Any["message"]> = TagClass$10<Self, Id, Message>;
+declare const Tag$10: <Self>() => <Id extends string, Message extends Definition$8.Any["message"]>(id: Id, definition: {
   readonly message: Message;
-}) => TagClass$7<Self, Id, Message>;
+}) => TagClass$9<Self, Id, Message>;
 declare const implement$6: <ROut, const Self extends Definition$8.Any>(_definition: Self, handler: Handler$3<ROut, Self>) => Handler$3<ROut, Self>;
 type Handler$2<ROut, Self extends Definition$8.Any> = Handler$3<ROut, Self>;
 type Options$6<ROut, Self extends Definition$8.Any> = Options$7<ROut, Self>;
 declare namespace WorkerDefinition_d_exports {
-  export { Api$3 as Api, Definition$6 as Definition, HandlerEffect$3 as HandlerEffect, Handlers$3 as Handlers, LayerOptions$7 as LayerOptions, Method$4 as Method, Methods$3 as Methods, NoReservedMethods$3 as NoReservedMethods, Options$5 as Options, ReservedMethodName$5 as ReservedMethodName, ServerApi$4 as ServerApi, ServiceFreeSchema$3 as ServiceFreeSchema, Tag$7 as Tag, TagClass$6 as TagClass, Worker, implement$5 as implement, make$5 as make, method$3 as method };
+  export { Api$3 as Api, Definition$6 as Definition, HandlerEffect$3 as HandlerEffect, Handlers$3 as Handlers, LayerOptions$9 as LayerOptions, Method$4 as Method, Methods$3 as Methods, NoReservedMethods$3 as NoReservedMethods, Options$5 as Options, ReservedMethodName$5 as ReservedMethodName, ServerApi$4 as ServerApi, ServiceFreeSchema$3 as ServiceFreeSchema, Tag$9 as Tag, TagClass$8 as TagClass, Worker, implement$5 as implement, make$7 as make, method$3 as method };
 }
 type ServiceFreeSchema$3 = Schema.Codec<any, any, never, never>;
 interface Method$4<Args extends ReadonlyArray<ServiceFreeSchema$3> = ReadonlyArray<ServiceFreeSchema$3>, Success extends ServiceFreeSchema$3 = ServiceFreeSchema$3> {
@@ -477,14 +360,14 @@ type Handlers$3<ROut, Self extends Definition$6.Any> = { readonly [Key in keyof
 interface Options$5<ROut, Self extends Definition$6.Any> extends Omit<WorkerOptions<ROut, Handlers$3<ROut, Self>>, "rpc"> {
   readonly rpc: Handlers$3<ROut, Self>;
 }
-type LayerOptions$7 = {
+type LayerOptions$9 = {
   readonly binding: string;
 };
-type TagClass$6<Self, Id extends string, MethodsShape extends Methods$3> = Context.ServiceClass<Self, Id, ServiceBindingEffectClient<Api$3<Definition$6<Id, MethodsShape>>, Definition$6<Id, MethodsShape>>> & ServiceBindingStaticClient<Self, Api$3<Definition$6<Id, MethodsShape>>, Definition$6<Id, MethodsShape>> & {
+type TagClass$8<Self, Id extends string, MethodsShape extends Methods$3> = Context.ServiceClass<Self, Id, ServiceBindingEffectClient<Api$3<Definition$6<Id, MethodsShape>>, Definition$6<Id, MethodsShape>>> & ServiceBindingStaticClient<Self, Api$3<Definition$6<Id, MethodsShape>>, Definition$6<Id, MethodsShape>> & {
   readonly id: Id;
   readonly methods: MethodsShape;
   readonly make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$5<ROut, Definition$6<Id, MethodsShape>>) => WorkerClass<Handlers$3<ROut, Definition$6<Id, MethodsShape>>, ROut>;
-  readonly layer: (options: LayerOptions$7) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$9) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
 /**
  * Defines a single RPC method schema in a worker definition.
@@ -498,9 +381,9 @@ declare const method$3: {
     readonly success: Success;
   }): Method$4<Args, Success>;
 };
-declare const make$5: <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$6<Definition$6<Id, MethodsShape>, Id, MethodsShape>;
-declare const Tag$7: <Self>() => <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$6<Self, Id, MethodsShape>;
-declare const Worker: <Self>() => <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$6<Self, Id, MethodsShape>;
+declare const make$7: <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$8<Definition$6<Id, MethodsShape>, Id, MethodsShape>;
+declare const Tag$9: <Self>() => <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$8<Self, Id, MethodsShape>;
+declare const Worker: <Self>() => <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$8<Self, Id, MethodsShape>;
 /**
  * Helper for implementing handlers with the exact method shape of a definition.
  */
@@ -517,9 +400,9 @@ type AsyncMethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...a
 type AsyncMethodSuccess<Api, Method extends keyof Api> = Api[Method] extends ((...args: AnyArgs) => Promise<infer A>) ? A : never;
 type AsyncMethodCloudflareReturn<Api, Method extends keyof Api> = Result<AsyncMethodSuccess<Api, Method>>;
 declare namespace ServiceBinding_d_exports {
-  export { Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceFetcher, isServiceBindingClient, layer$4 as layer, makeClient$3 as makeClient, makeDirectMethods$1 as makeDirectMethods };
+  export { Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceFetcher, isServiceBindingClient, layer$6 as layer, makeClient$5 as makeClient, makeDirectMethods$1 as makeDirectMethods };
 }
-declare const TypeId: "effect-cf/ServiceBinding";
+declare const TypeId$1: "effect-cf/ServiceBinding";
 /**
  * Minimum shape for a Cloudflare service binding.
  */
@@ -663,8 +546,8 @@ type ServiceBindingStaticClient<R, Api extends object, Definition extends Defini
   readonly scopedCall: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, unknown, Scope.Scope | R>;
 };
 declare const isServiceBindingClient: <Api extends object>(value: unknown) => value is ServiceBindingClient<Api>;
-declare const makeClient$3: <Api extends object, const Definition extends Definition$6.Any | undefined = undefined>(definition: ServiceBindingDefinition<Definition>) => ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition>);
-declare const layer$4: <Self, Api extends object, const Definition extends Definition$6.Any | undefined = undefined>(tag: Context.Service<Self, ServiceBindingEffectClient<Api, Definition>>, definition: ServiceBindingDefinition<Definition>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const makeClient$5: <Api extends object, const Definition extends Definition$6.Any | undefined = undefined>(definition: ServiceBindingDefinition<Definition>) => ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition>);
+declare const layer$6: <Self, Api extends object, const Definition extends Definition$6.Any | undefined = undefined>(tag: Context.Service<Self, ServiceBindingEffectClient<Api, Definition>>, definition: ServiceBindingDefinition<Definition>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 /**
  * Creates a typed Effect service for a Worker service binding.
  *
@@ -695,7 +578,7 @@ declare const layer$4: <Self, Api extends object, const Definition extends Defin
  * ```
  */
 declare const Service: <Self, Api extends object = never>() => <Id extends string, const Definition extends Definition$6.Any | undefined = undefined>(id: Id, definition: ServiceBindingDefinition<Definition>) => BindingService<Self, Id, ServiceBindingEffectClient<ApiOrDefinition<Api, Definition>, Definition>> & DirectMethods$1<Self, Definition> & {
-  readonly [TypeId]: typeof TypeId;
+  readonly [TypeId$1]: typeof TypeId$1;
   readonly definition: ServiceBindingDefinition<Definition>;
   readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<Response, ServiceBindingFetchError, Self>;
   readonly rpc: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: ServiceMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<Result<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>, ServiceBindingRpcError, Self>;
@@ -704,7 +587,7 @@ declare const Service: <Self, Api extends object = never>() => <Id extends strin
 };
 declare const makeDirectMethods$1: <R, Api, Definition extends Definition$6.Any | undefined>(rpcDefinition: Definition | undefined, call: ServiceCall<R, Api>) => DirectMethods$1<R, Definition>;
 declare namespace Worker_d_exports {
-  export { Api$2 as Api, Definition$5 as Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect$2 as HandlerEffect, Handlers$2 as Handlers, LayerOptions$6 as LayerOptions, Method$3 as Method, Methods$2 as Methods, NativeRequest, NoReservedMethods$2 as NoReservedMethods, Options$4 as Options, ReservedMethodName$3 as ReservedMethodName, RpcHandlers$1 as RpcHandlers, ServerApi$3 as ServerApi, ServiceFreeSchema$2 as ServiceFreeSchema, Tag$6 as Tag, TagClass$5 as TagClass, TagFactory$1 as TagFactory, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcHandler, WorkerRpcShape, implement$4 as implement, isWebSocketUpgrade, make$4 as make, makeFetchHandler, method$2 as method, renderHttpResponse };
+  export { Api$2 as Api, Definition$5 as Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect$2 as HandlerEffect, Handlers$2 as Handlers, LayerOptions$8 as LayerOptions, Method$3 as Method, Methods$2 as Methods, NativeRequest, NoReservedMethods$2 as NoReservedMethods, Options$4 as Options, ReservedMethodName$3 as ReservedMethodName, RpcHandlers$1 as RpcHandlers, ServerApi$3 as ServerApi, ServiceFreeSchema$2 as ServiceFreeSchema, Tag$8 as Tag, TagClass$7 as TagClass, TagFactory$1 as TagFactory, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcHandler, WorkerRpcShape, implement$4 as implement, isWebSocketUpgrade, make$6 as make, makeFetchHandler, method$2 as method, renderHttpResponse };
 }
 declare const ExecutionContext_base: Context.ServiceClass<ExecutionContext, "effect-cf/ExecutionContext", globalThis.ExecutionContext<unknown>>;
 declare class ExecutionContext extends ExecutionContext_base {}
@@ -749,8 +632,8 @@ interface FetchHandler<Env extends WorkerEnv = WorkerEnv> {
   readonly fetch: (request: Request, env: Env, ctx: globalThis.ExecutionContext) => Promise<Response>;
 }
 declare const renderHttpResponse: <A extends HttpServerResponse.HttpServerResponse, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Response, E, R>;
-declare function make$4<ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, fetch: WorkerHandler<ROut>): WorkerClass<Record<never, never>, ROut>;
-declare function make$4<ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptions<ROut, Rpc>): WorkerClass<Rpc, ROut>;
+declare function make$6<ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, fetch: WorkerHandler<ROut>): WorkerClass<Record<never, never>, ROut>;
+declare function make$6<ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptions<ROut, Rpc>): WorkerClass<Rpc, ROut>;
 declare const makeFetchHandler: <ROut, LayerError, Env extends WorkerEnv = WorkerEnv>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptions<ROut>) => FetchHandler<Env>;
 type ServiceFreeSchema$2 = Schema.Codec<any, any, never, never>;
 interface Method$3<Args extends ReadonlyArray<ServiceFreeSchema$2> = ReadonlyArray<ServiceFreeSchema$2>, Success extends ServiceFreeSchema$2 = ServiceFreeSchema$2> {
@@ -779,15 +662,15 @@ type Handlers$2<ROut, Self extends Definition$5.Any> = { readonly [Key in keyof
 interface Options$4<ROut, Self extends Definition$5.Any> extends Omit<WorkerOptions<ROut, Handlers$2<ROut, Self>>, "rpc"> {
   readonly rpc: Handlers$2<ROut, Self>;
 }
-type LayerOptions$6 = LayerOptions$7;
-type TagClass$5<Self, Id extends string, MethodsShape extends Methods$2> = Context.ServiceClass<Self, Id, ServiceBindingEffectClient<Api$2<Definition$5<Id, MethodsShape>>, Definition$5<Id, MethodsShape>>> & ServiceBindingStaticClient<Self, Api$2<Definition$5<Id, MethodsShape>>, Definition$5<Id, MethodsShape>> & {
+type LayerOptions$8 = LayerOptions$9;
+type TagClass$7<Self, Id extends string, MethodsShape extends Methods$2> = Context.ServiceClass<Self, Id, ServiceBindingEffectClient<Api$2<Definition$5<Id, MethodsShape>>, Definition$5<Id, MethodsShape>>> & ServiceBindingStaticClient<Self, Api$2<Definition$5<Id, MethodsShape>>, Definition$5<Id, MethodsShape>> & {
   readonly id: Id;
   readonly methods: MethodsShape;
   readonly make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$4<ROut, Definition$5<Id, MethodsShape>>) => WorkerClass<Handlers$2<ROut, Definition$5<Id, MethodsShape>>, ROut>;
-  readonly layer: (options: LayerOptions$6) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$8) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
-type TagFactory$1 = <Self>() => <Id extends string, const MethodsShape extends Methods$2>(id: Id, methods: MethodsShape & NoReservedMethods$2<MethodsShape>) => TagClass$5<Self, Id, MethodsShape>;
-declare const Tag$6: TagFactory$1;
+type TagFactory$1 = <Self>() => <Id extends string, const MethodsShape extends Methods$2>(id: Id, methods: MethodsShape & NoReservedMethods$2<MethodsShape>) => TagClass$7<Self, Id, MethodsShape>;
+declare const Tag$8: TagFactory$1;
 declare const method$2: {
   <Success extends ServiceFreeSchema$2>(definition: {
     readonly success: Success;
@@ -1101,7 +984,7 @@ declare class DurableObjectState extends DurableObjectState_base {}
  */
 declare const fromDurableObjectState: (state: globalThis.DurableObjectState) => DurableObjectStateService;
 declare namespace DurableObjectNamespace_d_exports {
-  export { DurableObjectFetchError, DurableObjectNamespaceBindingDefinition, DurableObjectNamespaceClient, DurableObjectNamespaceDefinition, DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient, DurableObjectRpcError, DurableObjectStubClient, isDurableObjectNamespaceClient, layer$3 as layer, makeClient$2 as makeClient, makeDirectMethods };
+  export { DurableObjectFetchError, DurableObjectNamespaceBindingDefinition, DurableObjectNamespaceClient, DurableObjectNamespaceDefinition, DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient, DurableObjectRpcError, DurableObjectStubClient, isDurableObjectNamespaceClient, layer$5 as layer, makeClient$4 as makeClient, makeDirectMethods };
 }
 interface DurableObjectFetcher {
   fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
@@ -1299,8 +1182,8 @@ type DurableObjectNamespaceStaticClient<R, Api extends object, Definition extend
   readonly unsafeRaw: () => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
 };
 declare const isDurableObjectNamespaceClient: <Api extends object>(value: unknown) => value is DurableObjectNamespaceClient<Api>;
-declare const makeClient$2: <Api extends object, const Definition extends Definition$4.Any | undefined = undefined>(definition: DurableObjectNamespaceBindingDefinition<Definition>) => ((namespace: DurableObjectNamespaceClient<Api>) => DurableObjectNamespaceEffectClient<Api, Definition>);
-declare const layer$3: <Self, Api extends object, const Definition extends Definition$4.Any | undefined = undefined>(tag: Context.Service<Self, DurableObjectNamespaceEffectClient<Api, Definition>>, definition: DurableObjectNamespaceBindingDefinition<Definition>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const makeClient$4: <Api extends object, const Definition extends Definition$4.Any | undefined = undefined>(definition: DurableObjectNamespaceBindingDefinition<Definition>) => ((namespace: DurableObjectNamespaceClient<Api>) => DurableObjectNamespaceEffectClient<Api, Definition>);
+declare const layer$5: <Self, Api extends object, const Definition extends Definition$4.Any | undefined = undefined>(tag: Context.Service<Self, DurableObjectNamespaceEffectClient<Api, Definition>>, definition: DurableObjectNamespaceBindingDefinition<Definition>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const makeDirectMethods: <R, Api extends object, Definition extends Definition$4.Any | undefined>(rpcDefinition: Definition | undefined, helpers: {
   readonly call: StubCall<R, Api>;
   readonly fetch: (stub: DurableObjectStubClient<Api>, input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
@@ -1308,7 +1191,7 @@ declare const makeDirectMethods: <R, Api extends object, Definition extends Defi
   readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
 }) => DirectMethods<R, Api, Definition>;
 declare namespace DurableObjectDefinition_d_exports {
-  export { Api$1 as Api, Definition$4 as Definition, DurableObject$1 as DurableObject, HandlerEffect$1 as HandlerEffect, Handlers$1 as Handlers, LayerOptions$5 as LayerOptions, Method$2 as Method, Methods$1 as Methods, NoReservedMethods$1 as NoReservedMethods, Options$3 as Options, ReservedMethodName$1 as ReservedMethodName, ServerApi$2 as ServerApi, ServiceFreeSchema$1 as ServiceFreeSchema, Tag$5 as Tag, TagClass$4 as TagClass, implement$3 as implement, make$3 as make, method$1 as method };
+  export { Api$1 as Api, Definition$4 as Definition, DurableObject$1 as DurableObject, HandlerEffect$1 as HandlerEffect, Handlers$1 as Handlers, LayerOptions$7 as LayerOptions, Method$2 as Method, Methods$1 as Methods, NoReservedMethods$1 as NoReservedMethods, Options$3 as Options, ReservedMethodName$1 as ReservedMethodName, ServerApi$2 as ServerApi, ServiceFreeSchema$1 as ServiceFreeSchema, Tag$7 as Tag, TagClass$6 as TagClass, implement$3 as implement, make$5 as make, method$1 as method };
 }
 type ServiceFreeSchema$1 = Schema.Codec<any, any, never, never>;
 interface Method$2<Args extends ReadonlyArray<ServiceFreeSchema$1> = ReadonlyArray<ServiceFreeSchema$1>, Success extends ServiceFreeSchema$1 = ServiceFreeSchema$1> {
@@ -1353,14 +1236,14 @@ type Handlers$1<ROut, Self extends Definition$4.Any> = { readonly [Key in keyof
 interface Options$3<ROut, Self extends Definition$4.Any> extends Omit<DurableObjectOptions<ROut, Handlers$1<ROut, Self>>, "rpc"> {
   readonly rpc: Handlers$1<ROut, Self>;
 }
-type LayerOptions$5 = {
+type LayerOptions$7 = {
   readonly binding: string;
 };
-type TagClass$4<Self, Id extends string, MethodsShape extends Methods$1> = Context.ServiceClass<Self, Id, DurableObjectNamespaceEffectClient<Api$1<Definition$4<Id, MethodsShape>>, Definition$4<Id, MethodsShape>>> & DurableObjectNamespaceStaticClient<Self, Api$1<Definition$4<Id, MethodsShape>>, Definition$4<Id, MethodsShape>> & {
+type TagClass$6<Self, Id extends string, MethodsShape extends Methods$1> = Context.ServiceClass<Self, Id, DurableObjectNamespaceEffectClient<Api$1<Definition$4<Id, MethodsShape>>, Definition$4<Id, MethodsShape>>> & DurableObjectNamespaceStaticClient<Self, Api$1<Definition$4<Id, MethodsShape>>, Definition$4<Id, MethodsShape>> & {
   readonly id: Id;
   readonly methods: MethodsShape;
   readonly make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options: Options$3<ROut, Definition$4<Id, MethodsShape>>) => DurableObjectClass<Handlers$1<ROut, Definition$4<Id, MethodsShape>>, ROut>;
-  readonly layer: (options: LayerOptions$5) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$7) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
 /**
  * Defines a single RPC method schema in a Durable Object definition.
@@ -1374,9 +1257,9 @@ declare const method$1: {
     readonly success: Success;
   }): Method$2<Args, Success>;
 };
-declare const make$3: <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$4<Definition$4<Id, MethodsShape>, Id, MethodsShape>;
-declare const Tag$5: <Self>() => <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$4<Self, Id, MethodsShape>;
-declare const DurableObject$1: <Self>() => <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$4<Self, Id, MethodsShape>;
+declare const make$5: <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$6<Definition$4<Id, MethodsShape>, Id, MethodsShape>;
+declare const Tag$7: <Self>() => <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$6<Self, Id, MethodsShape>;
+declare const DurableObject$1: <Self>() => <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$6<Self, Id, MethodsShape>;
 /**
  * Helper for implementing handlers with the exact method shape of a definition.
  */
@@ -1386,7 +1269,7 @@ declare const implement$3: <ROut, const Self extends Definition$4.Any>(_definiti
  */
 type HandlerEffect$1<ROut, Self extends Definition$4.Any, Key extends keyof Self["methods"]> = DurableObjectHandler<ROut, Method$2.Success<Self["methods"][Key]>>;
 declare namespace DurableObject_d_exports {
-  export { Api, Definition$3 as Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcShape, HandlerEffect, Handlers, LayerOptions$4 as LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options$2 as Options, ReservedMethodName, RpcHandlers, ServerApi$1 as ServerApi, ServiceFreeSchema, Tag$4 as Tag, TagClass$3 as TagClass, TagFactory, implement$2 as implement, make$2 as make, method };
+  export { Api, Definition$3 as Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcShape, HandlerEffect, Handlers, LayerOptions$6 as LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options$2 as Options, ReservedMethodName, RpcHandlers, ServerApi$1 as ServerApi, ServiceFreeSchema, Tag$6 as Tag, TagClass$5 as TagClass, TagFactory, implement$2 as implement, make$4 as make, method };
 }
 type RuntimeContext$1<ROut> = DurableObjectState | WorkerEnvironment | ROut;
 type HandlerContext<ROut> = RuntimeContext$1<ROut> | Scope.Scope;
@@ -1429,7 +1312,7 @@ type DurableObjectClass<Rpc extends DurableObjectRpc<ROut>, ROut> = new (state:
 /**
  * Creates a Durable Object class backed by a single managed Effect runtime.
  */
-declare const make$2: <ROut, LayerError, const Rpc extends DurableObjectRpc<ROut> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options?: DurableObjectOptions<ROut, Rpc>) => DurableObjectClass<Rpc, ROut>;
+declare const make$4: <ROut, LayerError, const Rpc extends DurableObjectRpc<ROut> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options?: DurableObjectOptions<ROut, Rpc>) => DurableObjectClass<Rpc, ROut>;
 type ServiceFreeSchema = Schema.Codec<any, any, never, never>;
 interface Method$1<Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema = ServiceFreeSchema> {
   readonly args: Args;
@@ -1452,21 +1335,21 @@ interface Definition$3<Id extends string = string, MethodsShape extends Methods
 declare namespace Definition$3 {
   type Any = Definition$3<string, Methods>;
 }
-type LayerOptions$4 = LayerOptions$5;
+type LayerOptions$6 = LayerOptions$7;
 type ServerApi$1<Self extends Definition$3.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$1.Args<Self["methods"][Key]>) => Promise<Method$1.Success<Self["methods"][Key]>> };
 type Api<Self extends Definition$3.Any> = Provider<ServerApi$1<Self>, ReservedMethodName>;
 type Handlers<ROut, Self extends Definition$3.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$1.Args<Self["methods"][Key]>) => DurableObjectHandler<ROut, Method$1.Success<Self["methods"][Key]>> };
 interface Options$2<ROut, Self extends Definition$3.Any> extends Omit<DurableObjectOptions<ROut, Handlers<ROut, Self>>, "rpc"> {
   readonly rpc: Handlers<ROut, Self>;
 }
-type TagClass$3<Self, Id extends string, MethodsShape extends Methods> = Context.ServiceClass<Self, Id, DurableObjectNamespaceEffectClient<Api<Definition$3<Id, MethodsShape>>, Definition$3<Id, MethodsShape>>> & DurableObjectNamespaceStaticClient<Self, Api<Definition$3<Id, MethodsShape>>, Definition$3<Id, MethodsShape>> & {
+type TagClass$5<Self, Id extends string, MethodsShape extends Methods> = Context.ServiceClass<Self, Id, DurableObjectNamespaceEffectClient<Api<Definition$3<Id, MethodsShape>>, Definition$3<Id, MethodsShape>>> & DurableObjectNamespaceStaticClient<Self, Api<Definition$3<Id, MethodsShape>>, Definition$3<Id, MethodsShape>> & {
   readonly id: Id;
   readonly methods: MethodsShape;
   readonly make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options: Options$2<ROut, Definition$3<Id, MethodsShape>>) => DurableObjectClass<Handlers<ROut, Definition$3<Id, MethodsShape>>, ROut>;
-  readonly layer: (options: LayerOptions$4) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$6) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
-type TagFactory = <Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape>) => TagClass$3<Self, Id, MethodsShape>;
-declare const Tag$4: TagFactory;
+type TagFactory = <Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape>) => TagClass$5<Self, Id, MethodsShape>;
+declare const Tag$6: TagFactory;
 declare const method: {
   <Success extends ServiceFreeSchema>(definition: {
     readonly success: Success;
@@ -1803,12 +1686,12 @@ declare class DurableObjectAlarm extends DurableObjectAlarm_base {
   static readonly layer: Layer.Layer<DurableObjectAlarm, never, DurableObjectState>;
 }
 declare namespace DurableObjectRpcWebSocket_d_exports {
-  export { DurableObjectRpcWebSocket, DurableObjectRpcWebSocketService, LayerOptions$3 as LayerOptions, NativeWebSocketMessage, layer$2 as layer };
+  export { DurableObjectRpcWebSocket, DurableObjectRpcWebSocketService, LayerOptions$5 as LayerOptions, NativeWebSocketMessage, layer$4 as layer };
 }
 /**
  * Configuration for {@link layer}.
  */
-interface LayerOptions$3 {
+interface LayerOptions$5 {
   /** Tag used to select hibernated sockets. */
   readonly tag?: string | undefined;
   /** Socket attachment key used to persist client ids across hibernation. */
@@ -1833,9 +1716,117 @@ declare class DurableObjectRpcWebSocket extends DurableObjectRpcWebSocket_base {
 /**
  * Builds a layer that bridges Durable Object websocket events to `RpcServer.Protocol`.
  */
-declare const layer$2: (options?: LayerOptions$3) => Layer.Layer<DurableObjectRpcWebSocket | RpcServer.Protocol, never, DurableObjectState | RpcSerialization.RpcSerialization>;
+declare const layer$4: (options?: LayerOptions$5) => Layer.Layer<DurableObjectRpcWebSocket | RpcServer.Protocol, never, DurableObjectState | RpcSerialization.RpcSerialization>;
+declare namespace Images_d_exports {
+  export { DrawStepOptions, HostedImagesClient, ImageDrawOptions, ImageHandleClient, ImageInfoResponse, ImageInputOptions, ImageInputValue, ImageList, ImageListOptions, ImageMetadata, ImageOutputOptions, ImageTransform, ImageTransformationOutputOptions, ImageTransformationResult, ImageUpdateOptions, ImageUploadOptions, ImageUploadValue, ImagesClient, ImagesDefinition, ImagesOperationError, ImagesRuntimeBinding, ImagesService, ImagesTransformationResultClient, LayerOptions$4 as LayerOptions, ProcessOptions, Step, Steps, Tag$5 as Tag, TagClass$4 as TagClass, draw, empty, isImagesBinding, layer$3 as layer, make$3 as make, makeClient$3 as makeClient, transform };
+}
+declare const TypeId: "effect-cf/Images/Steps";
+declare const ImagesOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "ImagesOperationError";
+} & Readonly<A>;
+/** Error raised when a Cloudflare Images operation fails. */
+declare class ImagesOperationError extends ImagesOperationError_base<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {}
+/** Typed Cloudflare Images binding definition. */
+interface ImagesDefinition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+type ImageInfoResponse = globalThis.ImageInfoResponse;
+type ImageTransform = globalThis.ImageTransform;
+type ImageDrawOptions = globalThis.ImageDrawOptions;
+type ImageInputOptions = globalThis.ImageInputOptions;
+type ImageOutputOptions = globalThis.ImageOutputOptions;
+type ImageTransformationOutputOptions = globalThis.ImageTransformationOutputOptions;
+type ImageTransformationResult = globalThis.ImageTransformationResult;
+type ImageUploadOptions = globalThis.ImageUploadOptions;
+type ImageUpdateOptions = globalThis.ImageUpdateOptions;
+type ImageListOptions = globalThis.ImageListOptions;
+type ImageList = globalThis.ImageList;
+type ImageMetadata = globalThis.ImageMetadata;
+type ImageInputValue = ReadableStream<Uint8Array> | ArrayBuffer;
+type ImageUploadValue = ReadableStream<Uint8Array> | ArrayBuffer;
+interface DrawStepOptions {
+  readonly image: ReadableStream<Uint8Array> | globalThis.ImageTransformer;
+  readonly options?: ImageDrawOptions;
+}
+type Step = Data.TaggedEnum<{
+  readonly Transform: {
+    readonly transform: ImageTransform;
+  };
+  readonly Draw: DrawStepOptions;
+}>;
+interface Steps {
+  readonly [TypeId]: typeof TypeId;
+  readonly steps: ReadonlyArray<Step>;
+}
+interface ProcessOptions {
+  readonly stream: ImageInputValue;
+  readonly inputOptions?: ImageInputOptions;
+  readonly outputOptions: ImageOutputOptions;
+}
+interface ImagesTransformationResultClient {
+  readonly raw: globalThis.ImageTransformationResult;
+  readonly response: Effect.Effect<globalThis.Response, ImagesOperationError>;
+  readonly contentType: Effect.Effect<string, ImagesOperationError>;
+  readonly image: (options?: ImageTransformationOutputOptions) => Effect.Effect<ReadableStream<Uint8Array>, ImagesOperationError>;
+}
+interface ImageHandleClient {
+  readonly raw: globalThis.ImageHandle;
+  readonly details: Effect.Effect<Option.Option<ImageMetadata>, ImagesOperationError>;
+  readonly bytes: Effect.Effect<Option.Option<ReadableStream<Uint8Array>>, ImagesOperationError>;
+  readonly update: (options: ImageUpdateOptions) => Effect.Effect<ImageMetadata, ImagesOperationError>;
+  readonly delete: Effect.Effect<boolean, ImagesOperationError>;
+}
+interface HostedImagesClient {
+  readonly image: (imageId: string) => ImageHandleClient;
+  readonly upload: (image: ImageUploadValue, options?: ImageUploadOptions) => Effect.Effect<ImageMetadata, ImagesOperationError>;
+  readonly list: (options?: ImageListOptions) => Effect.Effect<ImageList, ImagesOperationError>;
+  readonly unsafeRaw: Effect.Effect<globalThis.HostedImagesBinding>;
+}
+interface ImagesRuntimeBinding {
+  readonly info: (image: ImageInputValue, options?: ImageInputOptions) => Promise<ImageInfoResponse>;
+  readonly input: (image: ImageInputValue, options?: ImageInputOptions) => globalThis.ImageTransformer;
+  readonly hosted?: globalThis.HostedImagesBinding;
+}
+interface ImagesClient {
+  readonly info: (image: ImageInputValue, options?: ImageInputOptions) => Effect.Effect<ImageInfoResponse, ImagesOperationError>;
+  readonly input: (image: ImageInputValue, options?: ImageInputOptions) => Effect.Effect<globalThis.ImageTransformer, ImagesOperationError>;
+  readonly process: (steps: Steps, options: ProcessOptions) => Effect.Effect<ImagesTransformationResultClient, ImagesOperationError>;
+  readonly hosted: Option.Option<HostedImagesClient>;
+  readonly unsafeRaw: Effect.Effect<ImagesRuntimeBinding>;
+  readonly definition: ImagesDefinition;
+}
+declare const ImagesServiceTypeId: unique symbol;
+/** Nominal service marker for Images services created with {@link make}. */
+interface ImagesService<Id extends string> {
+  readonly [ImagesServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+type LayerOptions$4 = {
+  readonly binding: string;
+};
+interface TagClass$4<Self, Id extends string> extends Context.ServiceClass<Self, Id, ImagesClient> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions$4) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+/** Empty Images transformation pipeline. */
+declare const empty: Steps;
+declare function transform(transform: ImageTransform): (steps: Steps) => Steps;
+declare function transform(steps: Steps, transform: ImageTransform): Steps;
+declare function draw(draw: DrawStepOptions): (steps: Steps) => Steps;
+declare function draw(steps: Steps, draw: DrawStepOptions): Steps;
+declare const isImagesBinding: (value: unknown) => value is ImagesRuntimeBinding;
+declare const makeClient$3: (definition: ImagesDefinition) => (images: ImagesRuntimeBinding) => ImagesClient;
+declare const layer$3: <Self>(tag: Context.Service<Self, ImagesClient>, definition: ImagesDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make$3: <Id extends string>(id: Id) => TagClass$4<ImagesService<Id>, Id>;
+declare const Tag$5: <Self>() => <Id extends string>(id: Id) => TagClass$4<Self, Id>;
 declare namespace Kv_d_exports {
-  export { Definition$2 as Definition, KvClient, KvDefinition, KvListKey, KvListOptions, KvListResult, KvOperationError, KvPutOptions, KvWithMetadata, LayerOptions$2 as LayerOptions, Tag$3 as Tag, TagClass$2 as TagClass, isKvNamespace, layer$1 as layer, makeClient$1 as makeClient };
+  export { Definition$2 as Definition, KvClient, KvDefinition, KvListKey, KvListOptions, KvListResult, KvOperationError, KvPutOptions, KvWithMetadata, LayerOptions$3 as LayerOptions, Tag$4 as Tag, TagClass$3 as TagClass, isKvNamespace, layer$2 as layer, makeClient$2 as makeClient };
 }
 declare const KvOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
   readonly _tag: "KvOperationError";
@@ -1904,28 +1895,94 @@ interface KvClient<Key, Value, EncodedValue> {
   readonly unsafeRaw: Effect.Effect<KVNamespace>;
   readonly definition: KvDefinition<Key, Value, EncodedValue>;
 }
-type LayerOptions$2 = {
+type LayerOptions$3 = {
   readonly binding: string;
 };
-interface TagClass$2<Self, Id extends string, Key, Value, EncodedValue> extends Context.ServiceClass<Self, Id, KvClient<Key, Value, EncodedValue>> {
+interface TagClass$3<Self, Id extends string, Key, Value, EncodedValue> extends Context.ServiceClass<Self, Id, KvClient<Key, Value, EncodedValue>> {
   readonly id: Id;
   readonly keySchema: Schema.Codec<Key, string>;
   readonly valueSchema: Schema.Codec<Value, EncodedValue>;
-  readonly layer: (options: LayerOptions$2) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-  readonly put: (key: Key, value: Value, options?: KvPutOptions) => Effect.Effect<void, KvOperationError | Schema.SchemaError, Self>;
-  readonly get: (key: Key) => Effect.Effect<Option.Option<Value>, KvOperationError | Schema.SchemaError, Self>;
-  readonly getWithMetadata: <Metadata>(key: Key, metadataSchema: Schema.Codec<Metadata, unknown>) => Effect.Effect<Option.Option<KvWithMetadata<Value, Metadata>>, KvOperationError | Schema.SchemaError, Self>;
-  readonly list: <Metadata = unknown>(options?: KvListOptions<Metadata>) => Effect.Effect<KvListResult<Key, Metadata>, KvOperationError | Schema.SchemaError, Self>;
-  readonly remove: (key: Key) => Effect.Effect<void, KvOperationError | Schema.SchemaError, Self>;
-  readonly unsafeRaw: () => Effect.Effect<KVNamespace, never, Self>;
+  readonly layer: (options: LayerOptions$3) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
 declare const isKvNamespace: (value: unknown) => value is KVNamespace;
-declare const makeClient$1: <Key, Value, EncodedValue>(definition: KvDefinition<Key, Value, EncodedValue>) => ((kv: KVNamespace) => KvClient<Key, Value, EncodedValue>);
-declare const layer$1: <Self, Key, Value, EncodedValue>(tag: Context.Service<Self, KvClient<Key, Value, EncodedValue>>, definition: KvDefinition<Key, Value, EncodedValue>) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const Tag$3: <Self>() => <Id extends string, Key, Value, EncodedValue>(id: Id, definition: {
+declare const makeClient$2: <Key, Value, EncodedValue>(definition: KvDefinition<Key, Value, EncodedValue>) => ((kv: KVNamespace) => KvClient<Key, Value, EncodedValue>);
+declare const layer$2: <Self, Key, Value, EncodedValue>(tag: Context.Service<Self, KvClient<Key, Value, EncodedValue>>, definition: KvDefinition<Key, Value, EncodedValue>) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const Tag$4: <Self>() => <Id extends string, Key, Value, EncodedValue>(id: Id, definition: {
   readonly key: Schema.Codec<Key, string>;
   readonly value: Schema.Codec<Value, EncodedValue>;
-}) => TagClass$2<Self, Id, Key, Value, EncodedValue>;
+}) => TagClass$3<Self, Id, Key, Value, EncodedValue>;
+declare namespace R2_d_exports {
+  export { LayerOptions$2 as LayerOptions, R2Client, R2Definition, R2GetOptions, R2ListOptions, R2MultipartOptions, R2MultipartUploadClient, R2OperationError, R2PutOptions, R2PutValue, R2Service, R2UploadPartOptions, R2UploadPartValue, Tag$3 as Tag, TagClass$2 as TagClass, isR2Bucket, layer$1 as layer, make$2 as make, makeClient$1 as makeClient };
+}
+declare const R2OperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "R2OperationError";
+} & Readonly<A>;
+/** Error raised when an R2 operation fails. */
+declare class R2OperationError extends R2OperationError_base<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {}
+/** Typed R2 bucket binding definition. */
+interface R2Definition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+type R2GetOptions = globalThis.R2GetOptions;
+type R2PutOptions = globalThis.R2PutOptions;
+type R2ListOptions = globalThis.R2ListOptions;
+type R2MultipartOptions = globalThis.R2MultipartOptions;
+type R2UploadPartOptions = globalThis.R2UploadPartOptions;
+type R2PutValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | null | Blob;
+type R2UploadPartValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | Blob;
+interface R2MultipartUploadClient {
+  readonly raw: globalThis.R2MultipartUpload;
+  readonly key: string;
+  readonly uploadId: string;
+  readonly uploadPart: (partNumber: number, value: R2UploadPartValue, options?: R2UploadPartOptions) => Effect.Effect<globalThis.R2UploadedPart, R2OperationError>;
+  readonly abort: Effect.Effect<void, R2OperationError>;
+  readonly complete: (uploadedParts: ReadonlyArray<globalThis.R2UploadedPart>) => Effect.Effect<globalThis.R2Object, R2OperationError>;
+}
+interface R2Client {
+  readonly head: (key: string) => Effect.Effect<Option.Option<globalThis.R2Object>, R2OperationError>;
+  readonly get: {
+    (key: string, options: R2GetOptions & {
+      readonly onlyIf: globalThis.R2Conditional | Headers;
+    }): Effect.Effect<Option.Option<globalThis.R2ObjectBody | globalThis.R2Object>, R2OperationError>;
+    (key: string, options?: R2GetOptions): Effect.Effect<Option.Option<globalThis.R2ObjectBody>, R2OperationError>;
+  };
+  readonly put: {
+    (key: string, value: R2PutValue, options: R2PutOptions & {
+      readonly onlyIf: globalThis.R2Conditional | Headers;
+    }): Effect.Effect<Option.Option<globalThis.R2Object>, R2OperationError>;
+    (key: string, value: R2PutValue, options?: R2PutOptions): Effect.Effect<globalThis.R2Object, R2OperationError>;
+  };
+  readonly createMultipartUpload: (key: string, options?: R2MultipartOptions) => Effect.Effect<R2MultipartUploadClient, R2OperationError>;
+  readonly resumeMultipartUpload: (key: string, uploadId: string) => Effect.Effect<R2MultipartUploadClient, R2OperationError>;
+  readonly delete: (keys: string | ReadonlyArray<string>) => Effect.Effect<void, R2OperationError>;
+  readonly list: (options?: R2ListOptions) => Effect.Effect<globalThis.R2Objects, R2OperationError>;
+  readonly unsafeRaw: Effect.Effect<globalThis.R2Bucket>;
+  readonly definition: R2Definition;
+}
+declare const R2ServiceTypeId: unique symbol;
+/** Nominal service marker for R2 services created with {@link make}. */
+interface R2Service<Id extends string> {
+  readonly [R2ServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+type LayerOptions$2 = {
+  readonly binding: string;
+};
+interface TagClass$2<Self, Id extends string> extends Context.ServiceClass<Self, Id, R2Client> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions$2) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+declare const isR2Bucket: (value: unknown) => value is globalThis.R2Bucket;
+declare const makeClient$1: (definition: R2Definition) => ((bucket: globalThis.R2Bucket) => R2Client);
+declare const layer$1: <Self>(tag: Context.Service<Self, R2Client>, definition: R2Definition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make$2: <Id extends string>(id: Id) => TagClass$2<R2Service<Id>, Id>;
+declare const Tag$3: <Self>() => <Id extends string>(id: Id) => TagClass$2<Self, Id>;
 declare namespace WorkflowBinding_d_exports {
   export { WorkflowBindingClient, WorkflowBindingDefinition, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowInstanceEvent, WorkflowInstanceRestartOptions, WorkflowInstanceStatus, WorkflowInstanceStatusName, WorkflowOperationError, WorkflowResultDecodeError, isWorkflow, layer, makeClient };
 }
@@ -2094,4 +2151,4 @@ declare const implement: <ROut, const Self extends Definition$1.Any>(_definition
 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 { Binding_d_exports as Binding, D1_d_exports as D1, DurableObject_d_exports as DurableObject, DurableObjectAlarm_d_exports as DurableObjectAlarm, DurableObjectDefinition_d_exports as DurableObjectDefinition, DurableObjectNamespace_d_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_d_exports as DurableObjectRpcWebSocket, DurableObjectState_d_exports as DurableObjectState, DurableObjectStorage_d_exports as DurableObjectStorage, DurableObjectWebSocket_d_exports as DurableObjectWebSocket, Kv_d_exports as Kv, Queue_d_exports as Queue, QueueBinding_d_exports as QueueBinding, QueueDefinition_d_exports as QueueDefinition, Rpc_d_exports as Rpc, RpcDefinition_d_exports as RpcDefinition, ServiceBinding_d_exports as ServiceBinding, Worker_d_exports as Worker, WorkerConfig, WorkerDefinition_d_exports as WorkerDefinition, type WorkerEnv, WorkerEnvironment, Workflow_d_exports as Workflow, WorkflowBinding_d_exports as WorkflowBinding, WorkflowDefinition_d_exports as WorkflowDefinition };
+export { Binding_d_exports as Binding, D1_d_exports as D1, DurableObject_d_exports as DurableObject, DurableObjectAlarm_d_exports as DurableObjectAlarm, DurableObjectDefinition_d_exports as DurableObjectDefinition, DurableObjectNamespace_d_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_d_exports as DurableObjectRpcWebSocket, DurableObjectState_d_exports as DurableObjectState, DurableObjectStorage_d_exports as DurableObjectStorage, DurableObjectWebSocket_d_exports as DurableObjectWebSocket, Hyperdrive_d_exports as Hyperdrive, Images_d_exports as Images, Kv_d_exports as Kv, Queue_d_exports as Queue, QueueBinding_d_exports as QueueBinding, QueueDefinition_d_exports as QueueDefinition, R2_d_exports as R2, Rpc_d_exports as Rpc, RpcDefinition_d_exports as RpcDefinition, ServiceBinding_d_exports as ServiceBinding, Worker_d_exports as Worker, WorkerConfig, WorkerDefinition_d_exports as WorkerDefinition, type WorkerEnv, WorkerEnvironment, Workflow_d_exports as Workflow, WorkflowBinding_d_exports as WorkflowBinding, WorkflowDefinition_d_exports as WorkflowDefinition };