effect-cf 0.20.1 → 0.23.0

package/dist/index.d.mts

@@ -1,14 +1,16 @@
-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-RTjgirMV.mjs";
+import { a as BindingService, c as Environment_d_exports, d as WorkerEnvironment, i as BindingNotFoundError, l as WorkerConfig, o as BindingValidationError, s as Binding_d_exports, t as Hyperdrive_d_exports, u as WorkerEnv } from "./Hyperdrive-COyg7R26.mjs";
 import { Cause, Config, Context, Data, DateTime, Duration, Effect, Layer, Option, Redacted, Schema, Scope } from "effect";
 import { Headers as Headers$1, HttpClient, HttpClientResponse, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { OtlpExporter } from "effect/unstable/observability";
 import { D1Client } from "@effect/sql-d1";
 import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, WorkflowEntrypoint, WorkflowEvent, WorkflowSleepDuration, WorkflowStep, WorkflowStepConfig, WorkflowStepContext, WorkflowStepEvent, WorkflowTimeoutDuration } from "cloudflare:workers";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
 import * as RpcServer from "effect/unstable/rpc/RpcServer";
 import { SqliteClient } from "@effect/sql-sqlite-do";
+import { SqlClient } from "effect/unstable/sql";
 import * as Tracer from "effect/Tracer";
 declare namespace WorkersAi_d_exports {
-  export { LayerOptions$19 as LayerOptions, Tag$18 as Tag, TagClass$17 as TagClass, WorkersAiAsyncBatchResponse, WorkersAiBinding, WorkersAiClient, WorkersAiDefinition, WorkersAiEmbeddingInput, WorkersAiEmbeddingResponse, WorkersAiModelsSearchObject, WorkersAiModelsSearchParams, WorkersAiOperationError, WorkersAiOptions, WorkersAiService, embeddingResponse, isWorkersAiBinding, layer$17 as layer, make$17 as make, makeClient$14 as makeClient };
+  export { LayerOptions$17 as LayerOptions, Tag$16 as Tag, TagClass$15 as TagClass, WorkersAiAsyncBatchResponse, WorkersAiBinding, WorkersAiClient, WorkersAiDefinition, WorkersAiEmbeddingInput, WorkersAiEmbeddingResponse, WorkersAiModelsSearchObject, WorkersAiModelsSearchParams, WorkersAiOperationError, WorkersAiOptions, WorkersAiService, embeddingResponse, isWorkersAiBinding, layer$17 as layer, make$17 as make, makeClient$14 as 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";
@@ -18,7 +20,9 @@ declare class WorkersAiOperationError extends WorkersAiOperationError_base<{
   readonly binding: string;
   readonly operation: string;
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 /** Typed Workers AI binding definition. */
 interface WorkersAiDefinition {
   /** Binding name as configured in `wrangler.jsonc`. */
@@ -57,7 +61,7 @@ interface WorkersAiClient<ModelList extends AiModelListType = AiModels> {
   readonly runEmbedding: <Input extends WorkersAiEmbeddingInput>(model: string, input: Input, options?: WorkersAiOptions) => Effect.Effect<WorkersAiEmbeddingResponse, WorkersAiOperationError>;
   readonly models: (params?: WorkersAiModelsSearchParams) => Effect.Effect<ReadonlyArray<WorkersAiModelsSearchObject>, WorkersAiOperationError>;
   readonly gateway: (gatewayId: string) => Effect.Effect<CloudflareAiGateway, WorkersAiOperationError>;
-  readonly unsafeRaw: Effect.Effect<WorkersAiBinding<ModelList>>;
+  readonly rawUnsafe: Effect.Effect<WorkersAiBinding<ModelList>>;
   readonly definition: WorkersAiDefinition;
 }
 declare const WorkersAiServiceTypeId: unique symbol;
@@ -67,12 +71,12 @@ interface WorkersAiService<Id extends string> {
     readonly id: Id;
   };
 }
-type LayerOptions$19 = {
+type LayerOptions$17 = {
   readonly binding: string;
 };
-interface TagClass$17<Self, Id extends string, ModelList extends AiModelListType = AiModels> extends Context.ServiceClass<Self, Id, WorkersAiClient<ModelList>> {
+interface TagClass$15<Self, Id extends string, ModelList extends AiModelListType = AiModels> extends Context.ServiceClass<Self, Id, WorkersAiClient<ModelList>> {
   readonly id: Id;
-  readonly layer: (options: LayerOptions$19) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$17) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
 declare const isWorkersAiBinding: (value: unknown) => value is WorkersAiBinding;
 declare const embeddingResponse: (value: {
@@ -81,10 +85,10 @@ declare const embeddingResponse: (value: {
 }) => WorkersAiEmbeddingResponse;
 declare const makeClient$14: <ModelList extends AiModelListType = AiModels>(definition: WorkersAiDefinition) => (ai: WorkersAiBinding<ModelList>) => WorkersAiClient<ModelList>;
 declare const layer$17: <Self, ModelList extends AiModelListType = AiModels>(tag: Context.Service<Self, WorkersAiClient<ModelList>>, definition: WorkersAiDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const make$17: <Id extends string>(id: Id) => TagClass$17<WorkersAiService<Id>, Id, AiModels>;
-declare const Tag$18: <Self>() => <Id extends string, ModelList extends AiModelListType = AiModels>(id: Id) => TagClass$17<Self, Id, ModelList>;
+declare const make$17: <Id extends string>(id: Id) => TagClass$15<WorkersAiService<Id>, Id, AiModels>;
+declare const Tag$16: <Self>() => <Id extends string, ModelList extends AiModelListType = AiModels>(id: Id) => TagClass$15<Self, Id, ModelList>;
 declare namespace AiGateway_d_exports {
-  export { AiGatewayBinding, AiGatewayClient, AiGatewayDefinition, AiGatewayFetchOptions, AiGatewayHeaders, AiGatewayLog, AiGatewayOperationError, AiGatewayPatchLog, AiGatewayProvider, AiGatewayRunOptions, AiGatewayService, AiGatewayUniversalRequest, LayerOptions$18 as LayerOptions, Tag$17 as Tag, TagClass$16 as TagClass, isAiGatewayBinding, layer$16 as layer, make$16 as make, makeClient$13 as makeClient, makeClientFromAi, makeHttpClient };
+  export { AiGatewayBinding, AiGatewayClient, AiGatewayDefinition, AiGatewayFetchOptions, AiGatewayHeaders, AiGatewayLog, AiGatewayOperationError, AiGatewayPatchLog, AiGatewayProvider, AiGatewayRunOptions, AiGatewayService, AiGatewayUniversalRequest, LayerOptions$16 as LayerOptions, Tag$15 as Tag, TagClass$14 as TagClass, isAiGatewayBinding, layer$16 as layer, make$16 as make, makeClient$13 as makeClient, makeClientFromAi, makeHttpClient };
 }
 declare const AiGatewayOperationError_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: "AiGatewayOperationError";
@@ -94,7 +98,9 @@ declare class AiGatewayOperationError extends AiGatewayOperationError_base<{
   readonly binding: string;
   readonly operation: string;
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 /** Typed AI Gateway client definition. */
 interface AiGatewayDefinition {
   /** Binding name as configured in `wrangler.jsonc`. */
@@ -123,7 +129,7 @@ interface AiGatewayClient {
   readonly fetch: (options: AiGatewayFetchOptions) => Effect.Effect<Response, AiGatewayOperationError>;
   readonly patchLog: (logId: string, data: AiGatewayPatchLog) => Effect.Effect<void, AiGatewayOperationError>;
   readonly getLog: (logId: string) => Effect.Effect<AiGatewayLog, AiGatewayOperationError>;
-  readonly unsafeRaw: Effect.Effect<AiGatewayBinding, AiGatewayOperationError>;
+  readonly rawUnsafe: Effect.Effect<AiGatewayBinding, AiGatewayOperationError>;
   readonly definition: AiGatewayDefinition;
 }
 declare const AiGatewayServiceTypeId: unique symbol;
@@ -133,28 +139,28 @@ interface AiGatewayService<Id extends string> {
     readonly id: Id;
   };
 }
-type LayerOptions$18 = {
+type LayerOptions$16 = {
   readonly binding: string;
   readonly gatewayId: string;
   readonly accountId?: string;
 };
-interface TagClass$16<Self, Id extends string> extends Context.ServiceClass<Self, Id, AiGatewayClient> {
+interface TagClass$14<Self, Id extends string> extends Context.ServiceClass<Self, Id, AiGatewayClient> {
   readonly id: Id;
-  readonly layer: (options: LayerOptions$18) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError | AiGatewayOperationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$16) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError | AiGatewayOperationError, WorkerEnvironment>;
 }
 declare const isAiGatewayBinding: (value: unknown) => value is WorkersAiBinding;
 declare const makeClient$13: (definition: AiGatewayDefinition, gateway: AiGatewayBinding) => {
   definition: AiGatewayDefinition;
-  run: (data: _$_cloudflare_workers_types0.AIGatewayUniversalRequest | readonly _$_cloudflare_workers_types0.AIGatewayUniversalRequest[], options: {
-    gateway?: _$_cloudflare_workers_types0.UniversalGatewayOptions;
+  run: (data: import("@cloudflare/workers-types").AIGatewayUniversalRequest | readonly import("@cloudflare/workers-types").AIGatewayUniversalRequest[], options?: {
+    gateway?: import("@cloudflare/workers-types").UniversalGatewayOptions;
     extraHeaders?: object;
-    signal?: _$_cloudflare_workers_types0.AbortSignal;
-  } | undefined) => Effect.Effect<_$_cloudflare_workers_types0.Response, AiGatewayOperationError, never>;
-  getUrl: (provider: string | undefined) => Effect.Effect<string, AiGatewayOperationError, never>;
+    signal?: import("@cloudflare/workers-types").AbortSignal;
+  } | undefined) => Effect.Effect<import("@cloudflare/workers-types").Response, AiGatewayOperationError, never>;
+  getUrl: (provider?: string | undefined) => Effect.Effect<string, AiGatewayOperationError, never>;
   fetch: (options: AiGatewayFetchOptions) => Effect.Effect<Response, AiGatewayOperationError, never>;
-  patchLog: (logId: string, data: _$_cloudflare_workers_types0.AiGatewayPatchLog) => Effect.Effect<void, AiGatewayOperationError, never>;
-  getLog: (logId: string) => Effect.Effect<_$_cloudflare_workers_types0.AiGatewayLog, AiGatewayOperationError, never>;
-  unsafeRaw: Effect.Effect<CloudflareAiGateway, never, never>;
+  patchLog: (logId: string, data: import("@cloudflare/workers-types").AiGatewayPatchLog) => Effect.Effect<void, AiGatewayOperationError, never>;
+  getLog: (logId: string) => Effect.Effect<import("@cloudflare/workers-types").AiGatewayLog, AiGatewayOperationError, never>;
+  rawUnsafe: Effect.Effect<CloudflareAiGateway, never, never>;
 };
 declare const makeClientFromAi: (definition: AiGatewayDefinition, ai: WorkersAiBinding) => AiGatewayClient;
 declare const makeHttpClient: (definition: Omit<AiGatewayDefinition, "binding"> & {
@@ -162,10 +168,10 @@ declare const makeHttpClient: (definition: Omit<AiGatewayDefinition, "binding">
   readonly binding?: string;
 }, request?: typeof fetch) => AiGatewayClient;
 declare const layer$16: <Self>(tag: Context.Service<Self, AiGatewayClient>, definition: AiGatewayDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const make$16: <Id extends string>(id: Id) => TagClass$16<AiGatewayService<Id>, Id>;
-declare const Tag$17: <Self>() => <Id extends string>(id: Id) => TagClass$16<Self, Id>;
+declare const make$16: <Id extends string>(id: Id) => TagClass$14<AiGatewayService<Id>, Id>;
+declare const Tag$15: <Self>() => <Id extends string>(id: Id) => TagClass$14<Self, Id>;
 declare namespace AnalyticsEngine_d_exports {
-  export { AnalyticsEngineBinding, AnalyticsEngineClient, AnalyticsEngineDataPoint, AnalyticsEngineDataPointSchema, AnalyticsEngineDefinition, AnalyticsEngineFieldValue, AnalyticsEngineFieldValueSchema, AnalyticsEngineInvalidWritePolicy, AnalyticsEngineOperationError, AnalyticsEngineQueryClient, AnalyticsEngineQueryColumn, AnalyticsEngineQueryDefinition, AnalyticsEngineQueryError, AnalyticsEngineQueryOptions, AnalyticsEngineQueryResult, AnalyticsEngineQueryRow, AnalyticsEngineQueryService, AnalyticsEngineService, AnalyticsEngineWriteBatchOptions, AnalyticsEngineWriteError, AnalyticsEngineWriteOptions, AnalyticsEngineWritePolicy, AnalyticsEngineWriteValidationError, AnalyticsEngineWriteViolation, LayerOptions$17 as LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag$16 as Tag, TagClass$15 as TagClass, isAnalyticsEngineDataset, layer$15 as layer, make$15 as make, makeClient$12 as makeClient, makeQuery, makeQueryClient, queryConfig, queryFetchLayer, queryFetchLayerConfig, queryLayer, queryLayerConfig, writeLimits };
+  export { AnalyticsEngineBinding, AnalyticsEngineClient, AnalyticsEngineDataPoint, AnalyticsEngineDataPointSchema, AnalyticsEngineDefinition, AnalyticsEngineFieldValue, AnalyticsEngineFieldValueSchema, AnalyticsEngineInvalidWritePolicy, AnalyticsEngineOperationError, AnalyticsEngineQueryClient, AnalyticsEngineQueryColumn, AnalyticsEngineQueryDefinition, AnalyticsEngineQueryError, AnalyticsEngineQueryOptions, AnalyticsEngineQueryResult, AnalyticsEngineQueryRow, AnalyticsEngineQueryService, AnalyticsEngineService, AnalyticsEngineWriteBatchOptions, AnalyticsEngineWriteError, AnalyticsEngineWriteOptions, AnalyticsEngineWritePolicy, AnalyticsEngineWriteValidationError, AnalyticsEngineWriteViolation, LayerOptions$15 as LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag$14 as Tag, TagClass$13 as TagClass, isAnalyticsEngineDataset, layer$15 as layer, layerFetch, layerFetchConfig, make$15 as make, makeClient$12 as makeClient, makeQuery, makeQueryClient, queryConfig, queryLayer, queryLayerConfig, writeLimits };
 }
 declare const writeLimits: {
   readonly maxBlobs: 20;
@@ -194,7 +200,9 @@ declare class AnalyticsEngineOperationError extends AnalyticsEngineOperationErro
   readonly binding: string;
   readonly operation: string;
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 interface AnalyticsEngineWriteViolation {
   readonly path: string;
   readonly message: string;
@@ -210,7 +218,9 @@ declare class AnalyticsEngineWriteValidationError extends AnalyticsEngineWriteVa
   readonly operation: string;
   readonly violations: ReadonlyArray<AnalyticsEngineWriteViolation>;
   readonly cause?: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 declare const AnalyticsEngineQueryError_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: "AnalyticsEngineQueryError";
 } & Readonly<A>;
@@ -272,7 +282,7 @@ interface AnalyticsEngineClient {
   readonly write: (dataPoint?: AnalyticsEngineDataPoint, options?: AnalyticsEngineWriteOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
   readonly writeDataPoints: (dataPoints: ReadonlyArray<AnalyticsEngineDataPoint>, options?: AnalyticsEngineWriteBatchOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
   readonly writeBatch: (dataPoints: ReadonlyArray<AnalyticsEngineDataPoint>, options?: AnalyticsEngineWriteBatchOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
-  readonly unsafeRaw: Effect.Effect<AnalyticsEngineBinding>;
+  readonly rawUnsafe: Effect.Effect<AnalyticsEngineBinding>;
   readonly definition: AnalyticsEngineDefinition;
 }
 interface AnalyticsEngineQueryClient {
@@ -298,7 +308,7 @@ interface AnalyticsEngineQueryService<Id extends string> {
     readonly id: Id;
   };
 }
-type LayerOptions$17 = {
+type LayerOptions$15 = {
   readonly binding: string;
   readonly write?: AnalyticsEngineWritePolicy;
 };
@@ -307,16 +317,16 @@ type QueryConfigOptions = {
   readonly apiToken?: Config.Config<Redacted.Redacted<string>>;
   readonly apiBaseUrl?: Config.Config<string>;
 };
-interface TagClass$15<Self, Id extends string> extends Context.ServiceClass<Self, Id, AnalyticsEngineClient> {
+interface TagClass$13<Self, Id extends string> extends Context.ServiceClass<Self, Id, AnalyticsEngineClient> {
   readonly id: Id;
-  readonly layer: (options: LayerOptions$17) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$15) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
 interface QueryTagClass<Self, Id extends string> extends Context.ServiceClass<Self, Id, AnalyticsEngineQueryClient> {
   readonly id: Id;
   readonly layer: (definition: AnalyticsEngineQueryDefinition) => Layer.Layer<Self, never, HttpClient.HttpClient>;
-  readonly fetchLayer: (definition: AnalyticsEngineQueryDefinition) => Layer.Layer<Self>;
+  readonly layerFetch: (definition: AnalyticsEngineQueryDefinition) => Layer.Layer<Self>;
   readonly layerConfig: (config?: Config.Config<AnalyticsEngineQueryDefinition>) => Layer.Layer<Self, Config.ConfigError, HttpClient.HttpClient>;
-  readonly fetchLayerConfig: (config?: Config.Config<AnalyticsEngineQueryDefinition>) => Layer.Layer<Self, Config.ConfigError>;
+  readonly layerFetchConfig: (config?: Config.Config<AnalyticsEngineQueryDefinition>) => Layer.Layer<Self, Config.ConfigError>;
 }
 declare const makeQueryClient: (definition: AnalyticsEngineQueryDefinition) => Effect.Effect<AnalyticsEngineQueryClient, never, HttpClient.HttpClient>;
 declare const isAnalyticsEngineDataset: (value: unknown) => value is AnalyticsEngineBinding;
@@ -327,16 +337,16 @@ declare const queryConfig: (options?: QueryConfigOptions) => Config.Config<{
   apiBaseUrl: string;
 }>;
 declare const queryLayer: <Self>(tag: Context.Service<Self, AnalyticsEngineQueryClient>, definition: AnalyticsEngineQueryDefinition) => Layer.Layer<Self, never, HttpClient.HttpClient>;
-declare const queryFetchLayer: <Self>(tag: Context.Service<Self, AnalyticsEngineQueryClient>, definition: AnalyticsEngineQueryDefinition) => Layer.Layer<Self, never, never>;
+declare const layerFetch: <Self>(tag: Context.Service<Self, AnalyticsEngineQueryClient>, definition: AnalyticsEngineQueryDefinition) => Layer.Layer<Self, never, never>;
 declare const queryLayerConfig: <Self>(tag: Context.Service<Self, AnalyticsEngineQueryClient>, config?: Config.Config<AnalyticsEngineQueryDefinition>) => Layer.Layer<Self, Config.ConfigError, HttpClient.HttpClient>;
-declare const queryFetchLayerConfig: <Self>(tag: Context.Service<Self, AnalyticsEngineQueryClient>, config?: Config.Config<AnalyticsEngineQueryDefinition>) => Layer.Layer<Self, Config.ConfigError, never>;
-declare const layer$15: <Self>(tag: Context.Service<Self, AnalyticsEngineClient>, definition: LayerOptions$17) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const make$15: <Id extends string>(id: Id) => TagClass$15<AnalyticsEngineService<Id>, Id>;
+declare const layerFetchConfig: <Self>(tag: Context.Service<Self, AnalyticsEngineQueryClient>, config?: Config.Config<AnalyticsEngineQueryDefinition>) => Layer.Layer<Self, Config.ConfigError, never>;
+declare const layer$15: <Self>(tag: Context.Service<Self, AnalyticsEngineClient>, definition: LayerOptions$15) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make$15: <Id extends string>(id: Id) => TagClass$13<AnalyticsEngineService<Id>, Id>;
 declare const makeQuery: <Id extends string>(id: Id) => QueryTagClass<AnalyticsEngineQueryService<Id>, Id>;
-declare const Tag$16: <Self>() => <Id extends string>(id: Id) => TagClass$15<Self, Id>;
+declare const Tag$14: <Self>() => <Id extends string>(id: Id) => TagClass$13<Self, Id>;
 declare const QueryTag: <Self>() => <Id extends string>(id: Id) => QueryTagClass<Self, Id>;
 declare namespace BrowserRendering_d_exports {
-  export { BrowserRenderingBinding, BrowserRenderingBrowserClient, BrowserRenderingBrowserLike, BrowserRenderingClient, BrowserRenderingConnect, BrowserRenderingDefinition, BrowserRenderingLaunch, BrowserRenderingOperationError, BrowserRenderingPageClient, BrowserRenderingPageLike, BrowserRenderingService, LayerOptions$16 as LayerOptions, Tag$15 as Tag, TagClass$14 as TagClass, isBrowserRenderingBinding, layer$14 as layer, make$14 as make, makeClient$11 as makeClient };
+  export { BrowserRenderingBinding, BrowserRenderingBrowserClient, BrowserRenderingBrowserLike, BrowserRenderingClient, BrowserRenderingConnect, BrowserRenderingDefinition, BrowserRenderingLaunch, BrowserRenderingOperationError, BrowserRenderingPageClient, BrowserRenderingPageLike, BrowserRenderingService, LayerOptions$14 as LayerOptions, Tag$13 as Tag, TagClass$12 as TagClass, isBrowserRenderingBinding, layer$14 as layer, make$14 as make, makeClient$11 as makeClient };
 }
 declare const BrowserRenderingOperationError_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: "BrowserRenderingOperationError";
@@ -346,7 +356,9 @@ declare class BrowserRenderingOperationError extends BrowserRenderingOperationEr
   readonly binding: string;
   readonly operation: string;
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 /** Typed Browser Rendering binding definition. */
 interface BrowserRenderingDefinition {
   /** Binding name as configured in `wrangler.jsonc`. */
@@ -390,7 +402,7 @@ interface BrowserRenderingBrowserClient<Browser extends BrowserRenderingBrowserL
 interface BrowserRenderingClient<RawBinding extends BrowserRenderingBinding = BrowserRenderingBinding> {
   readonly launchWith: <Browser extends BrowserRenderingBrowserLike<Page>, Page extends BrowserRenderingPageLike = BrowserRenderingPageLike, LaunchOptions = unknown>(launch: BrowserRenderingLaunch<RawBinding, Browser, LaunchOptions>, options?: LaunchOptions) => Effect.Effect<BrowserRenderingBrowserClient<Browser, Page>, BrowserRenderingOperationError>;
   readonly connectWith: <Browser extends BrowserRenderingBrowserLike<Page>, Page extends BrowserRenderingPageLike = BrowserRenderingPageLike, ConnectOptions = unknown>(connect: BrowserRenderingConnect<RawBinding, Browser, ConnectOptions>, options?: ConnectOptions) => Effect.Effect<BrowserRenderingBrowserClient<Browser, Page>, BrowserRenderingOperationError>;
-  readonly unsafeRaw: Effect.Effect<RawBinding>;
+  readonly rawUnsafe: Effect.Effect<RawBinding>;
   readonly definition: BrowserRenderingDefinition;
 }
 declare const BrowserRenderingServiceTypeId: unique symbol;
@@ -400,18 +412,18 @@ interface BrowserRenderingService<Id extends string> {
     readonly id: Id;
   };
 }
-type LayerOptions$16 = {
+type LayerOptions$14 = {
   readonly binding: string;
 };
-interface TagClass$14<Self, Id extends string> extends Context.ServiceClass<Self, Id, BrowserRenderingClient> {
+interface TagClass$12<Self, Id extends string> extends Context.ServiceClass<Self, Id, BrowserRenderingClient> {
   readonly id: Id;
-  readonly layer: (options: LayerOptions$16) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$14) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
 declare const isBrowserRenderingBinding: (value: unknown) => value is BrowserRenderingBinding;
 declare const makeClient$11: <RawBinding extends BrowserRenderingBinding = BrowserRenderingBinding>(definition: BrowserRenderingDefinition) => (binding: RawBinding) => BrowserRenderingClient<RawBinding>;
 declare const layer$14: <Self>(tag: Context.Service<Self, BrowserRenderingClient>, definition: BrowserRenderingDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const make$14: <Id extends string>(id: Id) => TagClass$14<BrowserRenderingService<Id>, Id>;
-declare const Tag$15: <Self>() => <Id extends string>(id: Id) => TagClass$14<Self, Id>;
+declare const make$14: <Id extends string>(id: Id) => TagClass$12<BrowserRenderingService<Id>, Id>;
+declare const Tag$13: <Self>() => <Id extends string>(id: Id) => TagClass$12<Self, Id>;
 declare namespace Cache_d_exports {
   export { CacheClient, CacheOperation, CacheOperationError, CacheQueryOptions, CacheRequest, CacheStorage, CacheStorageClient, layer$13 as layer, layerFrom, makeCacheClient, makeClient$10 as makeClient };
 }
@@ -429,7 +441,9 @@ declare class CacheOperationError extends CacheOperationError_base<{
   readonly cache: string;
   readonly operation: CacheOperation;
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 /** Effect wrapper around one Cloudflare `Cache` instance. */
 interface CacheClient {
   /** Cache name (`default` for `caches.default`). */
@@ -441,7 +455,7 @@ interface CacheClient {
   /** Deletes a cached response and reports whether it existed. */
   readonly delete: (request: CacheRequest, options?: CacheQueryOptions) => Effect.Effect<boolean, CacheOperationError>;
   /** Access to the native Cloudflare `Cache` instance. */
-  readonly unsafeRaw: Effect.Effect<CloudflareCache>;
+  readonly rawUnsafe: Effect.Effect<CloudflareCache>;
 }
 /** Effect wrapper around Cloudflare's global `caches` object. */
 interface CacheStorageClient {
@@ -450,7 +464,7 @@ interface CacheStorageClient {
   /** Opens a named cache. */
   readonly open: (name: string) => Effect.Effect<CacheClient, CacheOperationError>;
   /** Access to the native Cloudflare `CacheStorage` instance. */
-  readonly unsafeRaw: Effect.Effect<CloudflareCacheStorage>;
+  readonly rawUnsafe: Effect.Effect<CloudflareCacheStorage>;
 }
 declare const CacheStorage_base: Context.ServiceClass<CacheStorage, "effect-cf/CacheStorage", CacheStorageClient>;
 /** Service for Cloudflare's global Cache API. */
@@ -475,7 +489,9 @@ declare const StorageOperationError_base: new <A extends Record<string, any> = {
 declare class StorageOperationError extends StorageOperationError_base<{
   readonly operation: string;
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 type StorageEffect<A> = Effect.Effect<A, StorageOperationError>;
 /**
  * Effect wrapper for Cloudflare SQL cursor operations.
@@ -606,14 +622,18 @@ declare const DurableWebSocketSendError_base: new <A extends Record<string, any>
 /** Error raised when sending on a Durable Object websocket fails. */
 declare class DurableWebSocketSendError extends DurableWebSocketSendError_base<{
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 declare const DurableWebSocketCloseError_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: "DurableWebSocketCloseError";
 } & Readonly<A>;
 /** Error raised when closing a Durable Object websocket fails. */
 declare class DurableWebSocketCloseError extends DurableWebSocketCloseError_base<{
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 declare const DurableWebSocketAttachmentError_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: "DurableWebSocketAttachmentError";
 } & Readonly<A>;
@@ -621,7 +641,9 @@ declare const DurableWebSocketAttachmentError_base: new <A extends Record<string
 declare class DurableWebSocketAttachmentError extends DurableWebSocketAttachmentError_base<{
   readonly operation: "serialize" | "deserialize";
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 /** Effect-native wrapper around a hibernatable Durable Object websocket. */
 interface DurableWebSocket<Attachment = unknown> {
   /** Underlying Cloudflare websocket. */
@@ -666,7 +688,7 @@ interface AcceptedUpgrade<Attachment = unknown> {
  * return response.response;
  * ```
  */
-declare const acceptUpgrade: <Attachment = unknown>(options?: AcceptUpgradeOptions<Attachment>) => Effect.Effect<AcceptedUpgrade<Attachment>, never, DurableObjectState>;
+declare const acceptUpgrade: <Attachment = unknown>(options?: AcceptUpgradeOptions<Attachment> | undefined) => Effect.Effect<AcceptedUpgrade<Attachment>, DurableWebSocketAttachmentError, DurableObjectState>;
 type AttachmentInvalidPolicy = "ignore" | "ignore-and-close" | "fail";
 interface AttachmentRehydrateOptions {
   /** Optional Durable Object websocket tag filter. */
@@ -697,464 +719,142 @@ declare const handlers: <R = never, E = unknown>(options: DurableWebSocketHandle
   webSocketClose: ((socket: DurableWebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, E, R>) | undefined;
   webSocketError: ((socket: DurableWebSocket, error: unknown) => Effect.Effect<void, E, R>) | undefined;
 };
-declare namespace DurableObjectState_d_exports {
-  export { DurableObjectState, DurableObjectStateService, fromDurableObjectState };
+declare namespace Rpc_d_exports {
+  export { DisposableValue, MethodArgs, MethodKey, MethodReturn, Provider, Result$1 as Result, RpcStub, RpcTarget, Serializable, Stub, Stubable, Stubify, dispose, isDisposable, resolve, scoped };
 }
-/**
- * Effect-friendly wrapper around Cloudflare `DurableObjectState`.
- */
-interface DurableObjectStateService {
-  /** Underlying Cloudflare state instance. */
-  readonly raw: globalThis.DurableObjectState;
-  /** Durable Object id for the current instance. */
-  readonly id: globalThis.DurableObjectId;
-  /** Wrapped storage API. */
-  readonly storage: DurableObjectStorage;
-  /** Registers background work with Cloudflare's lifecycle. */
-  waitUntil(promise: Promise<unknown>): Effect.Effect<void>;
-  /**
-   * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate.
-   *
-   * Cloudflare resets a Durable Object if the callback throws/rejects, or if the
-   * callback exceeds the platform timeout (currently documented as 30 seconds).
-   * This safe default resolves the callback with the Effect `Exit` for typed
-   * Effect failures and resumes that `Exit` afterward, so typed failures remain
-   * ordinary Effect failures instead of resetting the Durable Object. Defects
-   * and interruptions still reject the callback.
-   */
-  blockConcurrencyWhile<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
-  /**
-   * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate and lets
-   * Effect failures reject the callback.
-   *
-   * Use this only when Cloudflare's reset-on-throw behavior is intentional. The
-   * platform also resets the Durable Object if the callback exceeds the
-   * documented timeout (currently 30 seconds).
-   */
-  blockConcurrencyWhileOrReset<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
-  /** Accepts a websocket connection for hibernation-capable Durable Objects. */
-  acceptWebSocket(ws: DurableWebSocket, tags?: Array<string>): Effect.Effect<void>;
-  /** Lists active sockets, optionally filtered by tag. */
-  getWebSockets(tag?: string): Effect.Effect<Array<DurableWebSocket>>;
-  /** Configures automatic request/response handling for sockets. */
-  setWebSocketAutoResponse(pair?: WebSocketRequestResponsePair): Effect.Effect<void>;
-  /** Gets the configured websocket auto-response pair. */
-  getWebSocketAutoResponse: Effect.Effect<WebSocketRequestResponsePair | null>;
-  /** Timestamp of the last automatic websocket response for a socket. */
-  getWebSocketAutoResponseTimestamp(ws: DurableWebSocket): Effect.Effect<Date | null>;
-  /** Sets the timeout for hibernatable websocket events. */
-  setHibernatableWebSocketEventTimeout(timeoutMs?: number): Effect.Effect<void>;
-  /** Gets the timeout for hibernatable websocket events. */
-  getHibernatableWebSocketEventTimeout: Effect.Effect<number | null>;
-  /** Reads tags attached to a websocket. */
-  getTags(ws: DurableWebSocket): Effect.Effect<Array<string>>;
-  /**
-   * Forcibly resets the Durable Object. Cloudflare logs an uncaught Error using
-   * the optional reason, and the method is not available in `wrangler dev` local
-   * development according to the Durable Object State docs.
-   */
-  abort(reason?: string): Effect.Effect<void>;
+type Stubable = Rpc.Stubable;
+type Stub<T extends Stubable> = Rpc.Stub<T>;
+type Provider<T extends object, Reserved extends string = never> = Rpc.Provider<T, Reserved>;
+type BaseType = void | undefined | null | boolean | number | bigint | string | TypedArray | ArrayBuffer | DataView | Date | Error | RegExp | ReadableStream<Uint8Array> | WritableStream<Uint8Array> | Request | Response | Headers;
+type Serializable<T> = BaseType | Map<T extends Map<infer Key, unknown> ? Serializable<Key> : never, T extends Map<unknown, infer Value> ? Serializable<Value> : never> | Set<T extends Set<infer Value> ? Serializable<Value> : never> | ReadonlyArray<T extends ReadonlyArray<infer Value> ? Serializable<Value> : never> | { [Key in keyof T]: Key extends number | string ? Serializable<T[Key]> : never; } | Stub<Stubable> | Stubable;
+type Stubify<T> = T extends Stubable ? Stub<T> : T extends Map<infer Key, infer Value> ? Map<Stubify<Key>, Stubify<Value>> : T extends Set<infer Value> ? Set<Stubify<Value>> : T extends Array<infer Value> ? Array<Stubify<Value>> : T extends ReadonlyArray<infer Value> ? ReadonlyArray<Stubify<Value>> : T extends BaseType ? T : T extends {
+  [key: string | number]: unknown;
+} ? { [Key in keyof T]: Stubify<T[Key]>; } : T;
+type MaybeProvider<T> = T extends object ? Provider<T> : unknown;
+type MaybeDisposable<T> = T extends object ? Disposable : unknown;
+type Result$1<T> = T extends Stubable ? Promise<Stub<T>> & Provider<T> : T extends Serializable<T> ? Promise<Stubify<T> & MaybeDisposable<T>> & MaybeProvider<T> : never;
+type MethodKey<Api> = { [Key in keyof Api]-?: Key extends string ? Api[Key] extends ((...args: Array<any>) => unknown) ? Key : never : never; }[keyof Api];
+type MethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...args: infer Args) => unknown) ? Args : never;
+type MethodReturn<Api, Method extends keyof Api> = Api[Method] extends ((...args: Array<any>) => infer Return) ? Return : never;
+type DisposableValue = {
+  [Symbol.dispose](): void;
+};
+declare const isDisposable: (value: unknown) => value is DisposableValue;
+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$7 as Definition, Method$3 as Method, Methods$2 as Methods, NoReservedMethods$2 as NoReservedMethods, ReservedMethodName$5 as ReservedMethodName, RpcArgumentCountError, RpcArgumentDecodeError, RpcArgumentEncodeError, RpcReservedMethodNameError, RpcSuccessDecodeError, RpcSuccessEncodeError, ServiceFreeSchema$2 as ServiceFreeSchema, WireError, assertNoReservedMethods, decodeArgs, decodeSuccess, decodeWireError, encodeArgs, encodeSuccess, encodeWireError, isWireError, make$13 as make, method$2 as method, reservedMethodNames };
 }
-declare const DurableObjectState_base: Context.ServiceClass<DurableObjectState, "effect-cf/DurableObjectState", DurableObjectStateService>;
-/**
- * Context tag for accessing the current Durable Object state service.
- */
-declare class DurableObjectState extends DurableObjectState_base {}
-/**
- * Wraps a native Cloudflare `DurableObjectState` as a {@link DurableObjectStateService}.
- */
-declare const fromDurableObjectState: (state: globalThis.DurableObjectState) => DurableObjectStateService;
-declare namespace CloudflareOtlp_d_exports {
-  export { DurableObjectLayerOptions, LayerOptions$15 as LayerOptions, ResourceOptions, Serialization, Signal, WorkerLayerOptions, durableObjectLayer, layer$12 as layer, layerJson, layerProtobuf, workerLayer };
+declare const RpcReservedMethodNameError_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: "RpcReservedMethodNameError";
+} & Readonly<A>;
+declare class RpcReservedMethodNameError extends RpcReservedMethodNameError_base<{
+  readonly definition: string;
+  readonly method: string;
+}> {
+  get message(): string;
+}
+declare const RpcArgumentCountError_base: Schema.Class<RpcArgumentCountError, Schema.TaggedStruct<"RpcArgumentCountError", {
+  readonly definition: Schema.String;
+  readonly method: Schema.String;
+  readonly expected: Schema.Number;
+  readonly actual: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+declare class RpcArgumentCountError extends RpcArgumentCountError_base {
+  get message(): string;
+}
+declare const RpcArgumentDecodeError_base: Schema.Class<RpcArgumentDecodeError, Schema.TaggedStruct<"RpcArgumentDecodeError", {
+  readonly definition: Schema.String;
+  readonly method: Schema.String;
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+declare class RpcArgumentDecodeError extends RpcArgumentDecodeError_base {
+  get message(): string;
 }
-/** Telemetry signal groups supported by the Cloudflare OTLP layers. */
-type Signal = "logs" | "traces" | "metrics";
-/** OTLP payload serialization used by the Effect OTLP exporters. */
-type Serialization = "json" | "protobuf";
-/**
- * Resource metadata shared by Worker and Durable Object OTLP layers.
- *
- * Precedence follows Effect's `OtlpResource.fromConfig`: explicit
- * `serviceName`/`serviceVersion` win over matching explicit `attributes`, and
- * explicit attributes win over `OTEL_SERVICE_NAME`, `OTEL_SERVICE_VERSION`, and
- * `OTEL_RESOURCE_ATTRIBUTES`. Omit an option to let operators set it from the
- * environment.
- */
-interface ResourceOptions {
-  /** Explicit service name. Takes precedence over OTEL environment variables. */
-  readonly serviceName?: string;
-  /** Explicit service version. Takes precedence over OTEL environment variables. */
-  readonly serviceVersion?: string;
-  /** Additional resource attributes attached to exported telemetry. */
-  readonly attributes?: Record<string, unknown>;
+declare const RpcArgumentEncodeError_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: "RpcArgumentEncodeError";
+} & Readonly<A>;
+declare class RpcArgumentEncodeError extends RpcArgumentEncodeError_base<{
+  readonly definition: string;
+  readonly method: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
 }
-/** Options shared by all Cloudflare OTLP telemetry layers. */
-interface LayerOptions$15 {
-  /**
-   * Telemetry signals to export. Defaults to logs, traces, and metrics.
-   *
-   * Each selected signal is still controlled by standard OTEL exporter config,
-   * such as `OTEL_TRACES_EXPORTER=otlp`.
-   */
-  readonly signals?: ReadonlyArray<Signal>;
-  /** OTLP payload serialization. Defaults to protobuf. */
-  readonly serialization?: Serialization;
-  /** Resource metadata forwarded to Effect's OTLP resource resolver. */
-  readonly resource?: ResourceOptions;
-  /**
-   * Explicit headers for every selected signal.
-   *
-   * When omitted, Effect reads `OTEL_EXPORTER_OTLP_HEADERS` and the
-   * signal-specific `OTEL_EXPORTER_OTLP_*_HEADERS` variables.
-   */
-  readonly headers?: Headers$1.Input;
-  /** Exclude log records emitted for spans when exporting logs. */
-  readonly loggerExcludeLogSpans?: boolean;
-  /** Merge the OTLP logger with existing loggers instead of replacing them. */
-  readonly loggerMergeWithExisting?: boolean;
-  /** Custom trace context lookup used by the Effect OTLP tracer. */
-  readonly tracerContext?: <X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X;
+declare const RpcSuccessDecodeError_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: "RpcSuccessDecodeError";
+} & Readonly<A>;
+declare class RpcSuccessDecodeError extends RpcSuccessDecodeError_base<{
+  readonly definition: string;
+  readonly method: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+declare const RpcSuccessEncodeError_base: Schema.Class<RpcSuccessEncodeError, Schema.TaggedStruct<"RpcSuccessEncodeError", {
+  readonly definition: Schema.String;
+  readonly method: Schema.String;
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+declare class RpcSuccessEncodeError extends RpcSuccessEncodeError_base {
+  get message(): string;
+}
+/** Errors raised server-side that must survive the Cloudflare RPC wire. */
+type WireError = RpcArgumentCountError | RpcArgumentDecodeError | RpcSuccessEncodeError;
+declare const isWireError: (error: unknown) => error is WireError;
+/**
+ * Encodes package RPC errors into a plain `Error` envelope so their tags
+ * survive Cloudflare RPC serialization, which drops custom error properties.
+ */
+declare const encodeWireError: (error: unknown) => unknown;
+/** Restores package RPC errors from the {@link encodeWireError} envelope. */
+declare const decodeWireError: (cause: unknown) => unknown;
+declare const reservedMethodNames: Set<string>;
+type ReservedMethodName$5 = "constructor" | "fetch" | "connect" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError" | "then" | "dup" | "dispose" | "serialize" | "deserialize";
+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> {
+  readonly args: Args;
+  readonly success: Success;
 }
-/** Resource metadata specific to Cloudflare Workers. */
-interface WorkerLayerOptions extends LayerOptions$15 {
-  /** Cloudflare Worker name to attach as `cloudflare.worker.name`. */
-  readonly workerName?: string;
+declare namespace Method$3 {
+  export type Any = Method$3<ReadonlyArray<ServiceFreeSchema$2>, ServiceFreeSchema$2>;
+  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$2>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$2>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
+  /** Method schemas cross the wire through their canonical JSON codec. */
+  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$2>> = { [Index in keyof Args]: Schema.Json; };
+  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
+  export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
+  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
+  export type EncodedSuccess<Self extends Any> = Schema.Json;
+  export {};
 }
-/** Resource metadata specific to Cloudflare Durable Objects. */
-interface DurableObjectLayerOptions extends LayerOptions$15 {
-  /** Durable Object class name to attach as `cloudflare.durable_object.class`. */
-  readonly className?: string;
-  /**
-   * Include the Durable Object id as `cloudflare.durable_object.id`.
-   *
-   * This is disabled by default because object ids can be high-cardinality.
-   */
-  readonly includeObjectId?: boolean;
+type Methods$2 = Record<string, Method$3.Any>;
+type NoReservedMethods$2<MethodsShape extends Methods$2, Reserved extends string = ReservedMethodName$5> = Extract<keyof MethodsShape, Reserved> extends never ? MethodsShape : never;
+interface Definition$7<Id extends string = string, MethodsShape extends Methods$2 = Methods$2> {
+  readonly id: Id;
+  readonly methods: MethodsShape;
 }
-/**
- * Base OTLP telemetry layer for Cloudflare-compatible runtimes.
- *
- * Standard OpenTelemetry environment variables are resolved by Effect's OTLP
- * layers. In Cloudflare Workers and Durable Objects, the current `env` object is
- * installed as the primary `ConfigProvider`; outside Cloudflare, the ambient
- * Effect `ConfigProvider` remains the fallback.
- */
-declare const layer$12: (options?: LayerOptions$15) => Layer.Layer<never, never, never>;
-/** Base OTLP telemetry layer forced to JSON serialization. */
-declare const layerJson: (options?: Omit<LayerOptions$15, "serialization">) => Layer.Layer<never, never, never>;
-/** Base OTLP telemetry layer forced to protobuf serialization. */
-declare const layerProtobuf: (options?: Omit<LayerOptions$15, "serialization">) => Layer.Layer<never, never, never>;
-/**
- * OTLP layer with Cloudflare Worker resource attributes.
- *
- * Provide this layer at runtime scope for long-lived metrics aggregation, or at
- * handler scope when traces/logs should flush as the Cloudflare event finishes.
- */
-declare const workerLayer: (options?: WorkerLayerOptions) => Layer.Layer<never, never, never>;
-/**
- * OTLP layer with Cloudflare Durable Object resource attributes.
- *
- * The layer reads {@link DurableObjectState} so it can optionally include the
- * Durable Object id. Prefer leaving `includeObjectId` disabled unless the
- * backend can tolerate high-cardinality resource attributes.
- */
-declare const durableObjectLayer: (options?: DurableObjectLayerOptions) => Layer.Layer<never, never, DurableObjectState>;
-declare namespace ContainerNamespace_d_exports {
-  export { ContainerInstanceClient, ContainerNamespace, ContainerNamespaceClient, ContainerNamespaceDefinition, ContainerNamespaceResource, ContainerNamespaceService, ContainerNamespaceStaticClient, ContainerOperationError, ContainerReadinessOptions, ContainerSignal, ContainerStartAndWaitForPortsOptions, ContainerStartOptions, ContainerState, ContainerStub, ContainerWaitOptions, LayerOptions$14 as LayerOptions, Tag$14 as Tag, TagClass$13 as TagClass, isContainerNamespaceResource, layer$11 as layer, make$13 as make, makeClient$9 as makeClient };
+declare namespace Definition$7 {
+  type Any = Definition$7<string, Methods$2>;
+  type ServerApi<Self extends Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$3.Args<Self["methods"][Key]>) => Promise<Method$3.Success<Self["methods"][Key]>>; };
+  type Api<Self extends Any, Reserved extends string = never> = Provider<ServerApi<Self>, Reserved>;
+  type MethodNames<Self extends Any> = Extract<keyof Self["methods"], string>;
 }
-/** Signal accepted by Cloudflare Container instances. */
-type ContainerSignal = "SIGKILL" | "SIGINT" | "SIGTERM";
-/** Per-instance Container startup configuration. */
-interface ContainerStartOptions {
-  readonly envVars?: Record<string, string>;
-  readonly entrypoint?: Array<string>;
-  readonly enableInternet?: boolean;
-  readonly labels?: Record<string, string>;
-}
-/** Serializable retry settings used while starting a Container. */
-interface ContainerWaitOptions {
-  readonly portToCheck: number;
-  readonly retries?: number;
-  readonly waitInterval?: number;
-}
-/** Serializable timeout settings used while waiting for Container ports. */
-interface ContainerReadinessOptions {
-  readonly instanceGetTimeoutMS?: number;
-  readonly portReadyTimeoutMS?: number;
-  readonly waitInterval?: number;
-}
-/** Options for starting a Container and waiting for its ports. */
-interface ContainerStartAndWaitForPortsOptions {
-  readonly startOptions?: ContainerStartOptions;
-  readonly ports?: number | Array<number>;
-  readonly cancellationOptions?: ContainerReadinessOptions;
-}
-/** Serializable state reported by a Cloudflare Container instance. */
-declare const ContainerState: Schema.Union<readonly [Schema.Struct<{
-  readonly lastChange: Schema.Finite;
-  readonly status: Schema.Literals<readonly ["running", "stopping", "stopped", "healthy"]>;
-}>, Schema.Struct<{
-  readonly lastChange: Schema.Finite;
-  readonly status: Schema.Literal<"stopped_with_code">;
-  readonly exitCode: Schema.optionalKey<Schema.Int>;
-}>]>;
-type ContainerState = typeof ContainerState.Type;
-/**
- * Native Container stub shape exposed by a Container namespace binding.
- *
- * This is structural so using Container bindings does not make
- * `@cloudflare/containers` a runtime dependency of effect-cf.
- */
-interface ContainerStub {
-  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
-  getState(): Promise<ContainerState>;
-  start(options?: ContainerStartOptions, waitOptions?: ContainerWaitOptions): Promise<void>;
-  startAndWaitForPorts(options?: ContainerStartAndWaitForPortsOptions): Promise<void>;
-  stop(signal?: ContainerSignal): Promise<void>;
-  destroy(): Promise<void>;
-}
-/** Native Container namespace binding shape. */
-interface ContainerNamespaceResource {
-  getByName(name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions): ContainerStub;
-}
-/** Container namespace binding metadata. */
-interface ContainerNamespaceDefinition {
-  /** Binding name as configured in `wrangler.jsonc`. */
-  readonly binding: string;
-}
-declare const ContainerOperationError_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: "ContainerOperationError";
-} & Readonly<A>;
-/** Failure raised when invoking a named Container operation. */
-declare class ContainerOperationError extends ContainerOperationError_base<{
-  readonly binding: string;
-  readonly instance: string;
-  readonly operation: string;
-  readonly cause: unknown;
-}> {}
-/** Effect-wrapped client for one named Container instance. */
-interface ContainerInstanceClient {
-  readonly unsafeRaw: Effect.Effect<ContainerStub, ContainerOperationError>;
-  readonly state: Effect.Effect<ContainerState, ContainerOperationError>;
-  readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<Response, ContainerOperationError>;
-  readonly start: (options?: ContainerStartOptions, waitOptions?: ContainerWaitOptions) => Effect.Effect<void, ContainerOperationError>;
-  readonly startAndWaitForPorts: (options?: ContainerStartAndWaitForPortsOptions) => Effect.Effect<void, ContainerOperationError>;
-  readonly stop: (signal?: ContainerSignal) => Effect.Effect<void, ContainerOperationError>;
-  readonly destroy: Effect.Effect<void, ContainerOperationError>;
-}
-/** Effect client for a Container namespace binding. */
-interface ContainerNamespaceClient {
-  readonly definition: ContainerNamespaceDefinition;
-  readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<ContainerInstanceClient, ContainerOperationError>;
-  readonly byName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => ContainerInstanceClient;
-  readonly unsafeRaw: Effect.Effect<ContainerNamespaceResource>;
-}
-type ContainerNamespaceStaticClient<R> = {
-  readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<ContainerInstanceClient, ContainerOperationError, R>;
-  readonly byName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => {
-    readonly state: Effect.Effect<ContainerState, ContainerOperationError, R>;
-    readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<Response, ContainerOperationError, R>;
-    readonly start: (options?: ContainerStartOptions, waitOptions?: ContainerWaitOptions) => Effect.Effect<void, ContainerOperationError, R>;
-    readonly startAndWaitForPorts: (options?: ContainerStartAndWaitForPortsOptions) => Effect.Effect<void, ContainerOperationError, R>;
-    readonly stop: (signal?: ContainerSignal) => Effect.Effect<void, ContainerOperationError, R>;
-    readonly destroy: Effect.Effect<void, ContainerOperationError, R>;
-    readonly unsafeRaw: Effect.Effect<ContainerStub, ContainerOperationError, R>;
-  };
-  readonly unsafeRaw: () => Effect.Effect<ContainerNamespaceResource, never, R>;
-};
-type LayerOptions$14 = {
-  readonly binding: string;
-};
-interface TagClass$13<Self, Id extends string> extends Context.ServiceClass<Self, Id, ContainerNamespaceClient>, ContainerNamespaceStaticClient<Self> {
-  readonly id: Id;
-  readonly layer: (options: LayerOptions$14) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-}
-declare const isContainerNamespaceResource: (value: unknown) => value is ContainerNamespaceResource;
-declare const makeClient$9: (definition: ContainerNamespaceDefinition) => (namespace: ContainerNamespaceResource) => ContainerNamespaceClient;
-declare const layer$11: <Self>(tag: Context.Service<Self, ContainerNamespaceClient>, definition: ContainerNamespaceDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const make$13: <Id extends string>(id: Id) => TagClass$13<ContainerNamespaceService<Id>, Id>;
-declare const ContainerNamespaceServiceTypeId: unique symbol;
-/** Nominal service marker for Container namespaces created with {@link make}. */
-interface ContainerNamespaceService<Id extends string> {
-  readonly [ContainerNamespaceServiceTypeId]: {
-    readonly id: Id;
-  };
-}
-/** Creates a typed Effect service for a Cloudflare Container namespace. */
-declare const Tag$14: <Self>() => <Id extends string>(id: Id) => TagClass$13<Self, Id>;
-declare const ContainerNamespace: typeof Tag$14;
-declare namespace D1_d_exports {
-  export { D1Definition, D1Service, D1SqlLayerOptions, Service$1 as Service, make$12 as make };
-}
-/** Typed D1 binding definition. */
-interface D1Definition {
-  /** Binding name as configured in `wrangler.jsonc`. */
-  readonly binding: string;
-}
-/** Options forwarded to `@effect/sql-d1` when building a SQL client layer. */
-type D1SqlLayerOptions = Omit<D1Client.D1ClientConfig, "db">;
-declare const D1ServiceTypeId: unique symbol;
-/** Nominal service marker for D1 services created with {@link make}. */
-interface D1Service<Id extends string> {
-  readonly [D1ServiceTypeId]: {
-    readonly id: Id;
-  };
-}
-/**
- * Creates a typed D1 service tag plus Effect helpers.
- */
-declare const make$12: <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 | import("effect/unstable/sql/SqlClient").SqlClient, BindingNotFoundError | BindingValidationError | import("effect/Config").ConfigError, WorkerEnvironment>;
-};
-/**
- * Builds a D1 service around a Cloudflare D1 database binding.
- *
- * The returned service exposes the raw `D1Database` binding and `sqlLayer(...)`
- * for providing `effect/unstable/sql` via `@effect/sql-d1`.
- *
- * @example
- * ```ts
- * class TodoDatabase extends D1.Service<TodoDatabase>()("TodoDatabase", {
- *   binding: "TODO_DB",
- * }) {}
- *
- * const SqlLive = TodoDatabase.sqlLayer();
- * ```
- */
-declare const Service$1: <Self>() => <Id extends string>(id: Id, definition: D1Definition) => BindingService<Self, Id, D1Database> & {
-  "effect-cf/D1": "effect-cf/D1";
-  definition: D1Definition;
-  sqlLayer: (options?: D1SqlLayerOptions) => Layer.Layer<D1Client.D1Client | import("effect/unstable/sql/SqlClient").SqlClient, BindingNotFoundError | BindingValidationError | import("effect/Config").ConfigError, WorkerEnvironment | Exclude<Exclude<Self, import("effect/Scope").Scope>, Self>>;
-};
-declare namespace Rpc_d_exports {
-  export { DisposableValue, MethodArgs, MethodKey, MethodReturn, Provider, Result$1 as Result, RpcStub, RpcTarget, Serializable, Stub, Stubable, Stubify, dispose, isDisposable, resolve, scoped };
-}
-type Stubable = Rpc.Stubable;
-type Stub<T extends Stubable> = Rpc.Stub<T>;
-type Provider<T extends object, Reserved extends string = never> = Rpc.Provider<T, Reserved>;
-type BaseType = void | undefined | null | boolean | number | bigint | string | TypedArray | ArrayBuffer | DataView | Date | Error | RegExp | ReadableStream<Uint8Array> | WritableStream<Uint8Array> | Request | Response | Headers;
-type Serializable<T> = BaseType | Map<T extends Map<infer Key, unknown> ? Serializable<Key> : never, T extends Map<unknown, infer Value> ? Serializable<Value> : never> | Set<T extends Set<infer Value> ? Serializable<Value> : never> | ReadonlyArray<T extends ReadonlyArray<infer Value> ? Serializable<Value> : never> | { [Key in keyof T]: Key extends number | string ? Serializable<T[Key]> : never; } | Stub<Stubable> | Stubable;
-type Stubify<T> = T extends Stubable ? Stub<T> : T extends Map<infer Key, infer Value> ? Map<Stubify<Key>, Stubify<Value>> : T extends Set<infer Value> ? Set<Stubify<Value>> : T extends Array<infer Value> ? Array<Stubify<Value>> : T extends ReadonlyArray<infer Value> ? ReadonlyArray<Stubify<Value>> : T extends BaseType ? T : T extends {
-  [key: string | number]: unknown;
-} ? { [Key in keyof T]: Stubify<T[Key]>; } : T;
-type MaybeProvider<T> = T extends object ? Provider<T> : unknown;
-type MaybeDisposable<T> = T extends object ? Disposable : unknown;
-type Result$1<T> = T extends Stubable ? Promise<Stub<T>> & Provider<T> : T extends Serializable<T> ? Promise<Stubify<T> & MaybeDisposable<T>> & MaybeProvider<T> : never;
-type MethodKey<Api> = { [Key in keyof Api]-?: Key extends string ? Api[Key] extends ((...args: Array<any>) => unknown) ? Key : never : never; }[keyof Api];
-type MethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...args: infer Args) => unknown) ? Args : never;
-type MethodReturn<Api, Method extends keyof Api> = Api[Method] extends ((...args: Array<any>) => infer Return) ? Return : never;
-type DisposableValue = {
-  [Symbol.dispose](): void;
-};
-declare const isDisposable: (value: unknown) => value is DisposableValue;
-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$11 as make, method$4 as method, reservedMethodNames };
-}
-declare const RpcReservedMethodNameError_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: "RpcReservedMethodNameError";
-} & Readonly<A>;
-declare class RpcReservedMethodNameError extends RpcReservedMethodNameError_base<{
-  readonly definition: string;
-  readonly method: string;
-}> {}
-declare const RpcArgumentCountError_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: "RpcArgumentCountError";
-} & Readonly<A>;
-declare class RpcArgumentCountError extends RpcArgumentCountError_base<{
-  readonly definition: string;
-  readonly method: string;
-  readonly expected: number;
-  readonly actual: number;
-}> {}
-declare const RpcArgumentDecodeError_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: "RpcArgumentDecodeError";
-} & Readonly<A>;
-declare class RpcArgumentDecodeError extends RpcArgumentDecodeError_base<{
-  readonly definition: string;
-  readonly method: string;
-  readonly index: number;
-  readonly cause: unknown;
-}> {}
-declare const RpcArgumentEncodeError_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: "RpcArgumentEncodeError";
-} & Readonly<A>;
-declare class RpcArgumentEncodeError extends RpcArgumentEncodeError_base<{
-  readonly definition: string;
-  readonly method: string;
-  readonly index: number;
-  readonly cause: unknown;
-}> {}
-declare const RpcSuccessDecodeError_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: "RpcSuccessDecodeError";
-} & Readonly<A>;
-declare class RpcSuccessDecodeError extends RpcSuccessDecodeError_base<{
-  readonly definition: string;
-  readonly method: string;
-  readonly cause: unknown;
-}> {}
-declare const RpcSuccessEncodeError_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: "RpcSuccessEncodeError";
-} & Readonly<A>;
-declare class RpcSuccessEncodeError extends RpcSuccessEncodeError_base<{
-  readonly definition: string;
-  readonly method: string;
-  readonly cause: unknown;
-}> {}
-declare const reservedMethodNames: Set<string>;
-type ReservedMethodName$6 = "constructor" | "fetch" | "connect" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError" | "then" | "dup" | "dispose" | "serialize" | "deserialize";
-type ServiceFreeSchema$4 = Schema.Codec<any, any, never, never>;
-interface Method$5<Args extends ReadonlyArray<ServiceFreeSchema$4> = ReadonlyArray<ServiceFreeSchema$4>, Success extends ServiceFreeSchema$4 = ServiceFreeSchema$4> {
-  readonly args: Args;
-  readonly success: Success;
-}
-declare namespace Method$5 {
-  export type Any = Method$5<ReadonlyArray<ServiceFreeSchema$4>, ServiceFreeSchema$4>;
-  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$4>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$4, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$4>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
-  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$4>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$4, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$4>] ? [Schema.Codec.Encoded<Head>, ...EncodedArgsFromSchemas<Tail>] : Array<Schema.Codec.Encoded<Args[number]>>;
-  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
-  export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
-  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
-  export type EncodedSuccess<Self extends Any> = Schema.Codec.Encoded<Self["success"]>;
-  export {};
-}
-type Methods$4 = Record<string, Method$5.Any>;
-type NoReservedMethods$4<MethodsShape extends Methods$4, Reserved extends string = ReservedMethodName$6> = Extract<keyof MethodsShape, Reserved> extends never ? MethodsShape : never;
-interface Definition$9<Id extends string = string, MethodsShape extends Methods$4 = Methods$4> {
-  readonly id: Id;
-  readonly methods: MethodsShape;
-}
-declare namespace Definition$9 {
-  type Any = Definition$9<string, Methods$4>;
-  type ServerApi<Self extends Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$5.Args<Self["methods"][Key]>) => Promise<Method$5.Success<Self["methods"][Key]>>; };
-  type Api<Self extends Any, Reserved extends string = never> = Provider<ServerApi<Self>, Reserved>;
-  type MethodNames<Self extends Any> = Extract<keyof Self["methods"], string>;
-}
-declare class ReservedMethodNameError extends Error {
-  readonly method: string;
-  readonly target: string;
-  constructor(target: string, method: string);
-}
-declare const assertNoReservedMethods: (target: string, methods: Record<string, unknown>, reserved: ReadonlySet<string>) => void;
-declare function method$4<Success extends ServiceFreeSchema$4>(definition: {
-  readonly success: Success;
-}): Method$5<readonly [], Success>;
-declare function method$4<const Args extends ReadonlyArray<ServiceFreeSchema$4>, Success extends ServiceFreeSchema$4>(definition: {
-  readonly args: Args;
-  readonly success: Success;
-}): Method$5<Args, Success>;
-declare const assertNoReservedMethodNames: (definition: Definition$9.Any) => Effect.Effect<void, RpcReservedMethodNameError>;
-declare const decodeArgs: <const Self extends Definition$9.Any, MethodName extends Definition$9.MethodNames<Self>>(definition: Self, methodName: MethodName, args: ReadonlyArray<unknown>) => Effect.Effect<Method$5.Args<Self["methods"][MethodName]>, RpcArgumentCountError | RpcArgumentDecodeError>;
-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$11: <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, QueueProducer, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse, isQueue, layer$10 as layer, makeClient$8 as makeClient };
+declare const assertNoReservedMethods: (target: string, methods: Record<string, unknown>, reserved: ReadonlySet<string>) => void;
+declare function method$2<Success extends ServiceFreeSchema$2>(definition: {
+  readonly success: Success;
+}): Method$3<readonly [], Success>;
+declare function method$2<const Args extends ReadonlyArray<ServiceFreeSchema$2>, Success extends ServiceFreeSchema$2>(definition: {
+  readonly args: Args;
+  readonly success: Success;
+}): Method$3<Args, Success>;
+declare const decodeArgs: <const Self extends Definition$7.Any, MethodName extends Definition$7.MethodNames<Self>>(definition: Self, methodName: MethodName, args: readonly unknown[]) => Effect.Effect<Self["methods"][MethodName]["args"] extends (infer T) ? T extends Self["methods"][MethodName]["args"] ? T extends readonly [] ? [] : T extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ... /*elided*/ any] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<T[number]>[] : never : never, RpcArgumentCountError | RpcArgumentDecodeError, never>;
+declare const encodeArgs: <const Self extends Definition$7.Any, MethodName extends Definition$7.MethodNames<Self>>(definition: Self, methodName: MethodName, args: Self["methods"][MethodName]["args"] extends (infer T) ? T extends Self["methods"][MethodName]["args"] ? T extends readonly [] ? [] : T extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends readonly ServiceFreeSchema$2[]] ? [Schema.Schema.Type<Head>, ... /*elided*/ any] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<T[number]>[] : never : never) => Effect.Effect<Self["methods"][MethodName]["args"] extends (infer T_1 extends readonly ServiceFreeSchema$2[]) ? { [Index in keyof T_1]: Schema.Json; } : never, RpcArgumentCountError | RpcArgumentEncodeError, never>;
+declare const encodeSuccess: <const Self extends Definition$7.Any, MethodName extends Definition$7.MethodNames<Self>>(definition: Self, methodName: MethodName, value: Method$3.Success<Self["methods"][MethodName]>) => Effect.Effect<Method$3.EncodedSuccess<Self["methods"][MethodName]>, RpcSuccessEncodeError>;
+declare const decodeSuccess: <const Self extends Definition$7.Any, MethodName extends Definition$7.MethodNames<Self>>(definition: Self, methodName: MethodName, value: unknown) => Effect.Effect<Method$3.Success<Self["methods"][MethodName]>, RpcSuccessDecodeError>;
+declare const make$13: <Id extends string, const MethodsShape extends Methods$2>(id: Id, methods: MethodsShape) => Definition$7<Id, MethodsShape>;
+declare namespace QueueBinding_d_exports {
+  export { MessageSendRequest, QueueBindingClient, QueueBindingDefinition, QueueMetrics, QueueOperationError, QueueProducer, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse, isQueue, layer$12 as layer, makeClient$9 as makeClient };
 }
 type QueueSendOptions = CloudflareQueueSendOptions;
 type QueueSendResponse = CloudflareQueueSendResponse;
@@ -1163,17 +863,17 @@ type QueueSendBatchResponse = CloudflareQueueSendBatchResponse;
 type QueueMetrics = CloudflareQueueMetrics;
 type MessageSendRequest<Body> = CloudflareMessageSendRequest<Body>;
 type QueueProducer<Body> = Pick<CloudflareQueue<Body>, "send"> & Partial<Pick<CloudflareQueue<Body>, "sendBatch" | "metrics">>;
-interface QueueBindingDefinition<Message extends ServiceFreeSchema$4> {
+interface QueueBindingDefinition<Message extends ServiceFreeSchema$2> {
   /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
   /** Codec used to encode messages before sending them to Cloudflare Queues. */
   readonly message: Message;
 }
-interface QueueBindingClient<Message extends ServiceFreeSchema$4> {
+interface QueueBindingClient<Message extends ServiceFreeSchema$2> {
   readonly send: (message: Schema.Schema.Type<Message>, options?: QueueSendOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError>;
   readonly sendBatch: (messages: Iterable<MessageSendRequest<Schema.Schema.Type<Message>>>, options?: QueueSendBatchOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError>;
   readonly metrics: () => Effect.Effect<QueueMetrics, QueueOperationError>;
-  readonly unsafeRaw: Effect.Effect<CloudflareQueue<Schema.Codec.Encoded<Message>>>;
+  readonly rawUnsafe: Effect.Effect<CloudflareQueue<Schema.Codec.Encoded<Message>>>;
 }
 declare const QueueOperationError_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: "QueueOperationError";
@@ -1185,46 +885,46 @@ declare class QueueOperationError extends QueueOperationError_base<{
   readonly message: string;
 }> {}
 declare const isQueue: <Body>(value: unknown) => value is QueueProducer<Body>;
-declare const makeClient$8: <Message extends ServiceFreeSchema$4>(definition: QueueBindingDefinition<Message>) => ((queue: QueueProducer<Schema.Codec.Encoded<Message>>) => QueueBindingClient<Message>);
-declare const layer$10: <Self, Message extends ServiceFreeSchema$4>(tag: Context.Service<Self, QueueBindingClient<Message>>, definition: QueueBindingDefinition<Message>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const makeClient$9: <Message extends ServiceFreeSchema$2>(definition: QueueBindingDefinition<Message>) => ((queue: QueueProducer<Schema.Codec.Encoded<Message>>) => QueueBindingClient<Message>);
+declare const layer$12: <Self, Message extends ServiceFreeSchema$2>(tag: Context.Service<Self, QueueBindingClient<Message>>, definition: QueueBindingDefinition<Message>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare namespace QueueDefinition_d_exports {
-  export { Definition$8 as Definition, Handler$3 as Handler, LayerOptions$13 as LayerOptions, Options$7 as Options, Queue$1 as Queue, Tag$13 as Tag, TagClass$12 as TagClass, implement$7 as implement, make$10 as make };
+  export { Definition$6 as Definition, Handler$3 as Handler, LayerOptions$13 as LayerOptions, Options$5 as Options, Queue$1 as Queue, Tag$12 as Tag, TagClass$11 as TagClass, implement$5 as implement, make$12 as make };
 }
-interface Definition$8<Id extends string = string, Message extends ServiceFreeSchema$4 = ServiceFreeSchema$4> {
+interface Definition$6<Id extends string = string, Message extends ServiceFreeSchema$2 = ServiceFreeSchema$2> {
   readonly id: Id;
   readonly message: Message;
 }
-declare namespace Definition$8 {
-  type Any = Definition$8<string, ServiceFreeSchema$4>;
+declare namespace Definition$6 {
+  type Any = Definition$6<string, ServiceFreeSchema$2>;
 }
-type Handler$3<ROut, Self extends Definition$8.Any> = (batch: QueueBatch<Schema.Schema.Type<Self["message"]>>) => Effect.Effect<void, unknown, ExecutionContext | WorkerContext | WorkerEnvironment | Scope.Scope | ROut>;
-interface Options$7<ROut, Self extends Definition$8.Any> extends Omit<WorkerOptions<ROut, Record<never, never>>, "queue" | "rpc"> {
+type Handler$3<ROut, Self extends Definition$6.Any> = (batch: QueueBatch<Schema.Schema.Type<Self["message"]>>) => Effect.Effect<void, unknown, ExecutionContext | WorkerContext | WorkerEnvironment | Scope.Scope | ROut>;
+interface Options$5<ROut, Self extends Definition$6.Any> extends Omit<WorkerOptions<ROut, Record<never, never>>, "queue" | "rpc"> {
   readonly queue: Handler$3<ROut, Self>;
   readonly rpc?: never;
 }
 type LayerOptions$13 = {
   readonly binding: string;
 };
-interface TagClass$12<Self, Id extends string, Message extends ServiceFreeSchema$4> extends Context.ServiceClass<Self, Id, QueueBindingClient<Message>> {
+interface TagClass$11<Self, Id extends string, Message extends ServiceFreeSchema$2> extends Context.ServiceClass<Self, `effect-cf/Queue/${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 make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$5<ROut, Definition$6<Id, Message>>) => WorkerClass<Record<never, never>, ROut>;
   readonly layer: (options: LayerOptions$13) => 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>;
+  readonly rawUnsafe: Effect.Effect<globalThis.Queue<Schema.Codec.Encoded<Message>>, never, Self>;
 }
-declare const make$10: <Id extends string, Message extends ServiceFreeSchema$4>(id: Id, definition: {
+declare const make$12: <Id extends string, Message extends ServiceFreeSchema$2>(id: Id, definition: {
   readonly message: Message;
-}) => TagClass$12<Definition$8<Id, Message>, Id, Message>;
-declare const Tag$13: <Self>() => <Id extends string, Message extends ServiceFreeSchema$4>(id: Id, definition: {
+}) => TagClass$11<Definition$6<Id, Message>, Id, Message>;
+declare const Tag$12: <Self>() => <Id extends string, Message extends ServiceFreeSchema$2>(id: Id, definition: {
   readonly message: Message;
-}) => TagClass$12<Self, Id, Message>;
-declare const Queue$1: typeof Tag$13;
-declare const implement$7: <ROut, const Self extends Definition$8.Any>(_definition: Self, handler: Handler$3<ROut, Self>) => Handler$3<ROut, Self>;
+}) => TagClass$11<Self, Id, Message>;
+declare const Queue$1: typeof Tag$12;
+declare const implement$5: <ROut, const Self extends Definition$6.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$12 as LayerOptions, Options$6 as Options, QueueBatch, QueueHandler, QueueMessage, QueueMessageDecodeError, QueueOptions, Tag$12 as Tag, TagClass$11 as TagClass, decodeBatch, fromMessage, fromMessageBatch, implement$6 as implement };
+  export { Definition$5 as Definition, Handler$2 as Handler, LayerOptions$12 as LayerOptions, Options$4 as Options, QueueBatch, QueueHandler, QueueMessage, QueueMessageDecodeError, QueueOptions, Tag$11 as Tag, TagClass$10 as TagClass, decodeBatch, fromMessage, fromMessageBatch, implement$4 as implement };
 }
 interface QueueMessage<Body> {
   readonly raw: globalThis.Message<unknown>;
@@ -1251,7 +951,9 @@ declare class QueueMessageDecodeError extends QueueMessageDecodeError_base<{
   readonly messageId: string;
   readonly index: number;
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 type RuntimeContext$2<ROut> = ExecutionContext | WorkerContext | WorkerEnvironment | ROut;
 type QueueHandlerContext<ROut> = RuntimeContext$2<ROut> | Scope.Scope;
 type QueueHandler<ROut, Body = unknown> = (batch: QueueBatch<Body>) => Effect.Effect<void, unknown, QueueHandlerContext<ROut>>;
@@ -1269,128 +971,47 @@ declare const fromMessage: <Body>(message: globalThis.Message<unknown>, body: Bo
 };
 declare const fromMessageBatch: <Body>(batch: globalThis.MessageBatch<unknown>, messages: ReadonlyArray<QueueMessage<Body>>) => QueueBatch<Body>;
 declare const decodeBatch: <Body>(batch: globalThis.MessageBatch<unknown>, decodeBody: (body: unknown) => Effect.Effect<Body, unknown>) => Effect.Effect<QueueBatch<Body>, QueueMessageDecodeError>;
-type Definition$7<Id extends string = string, Message extends Definition$8.Any["message"] = Definition$8.Any["message"]> = Definition$8<Id, Message>;
-declare namespace Definition$7 {
-  type Any = Definition$8.Any;
+type Definition$5<Id extends string = string, Message extends Definition$6.Any["message"] = Definition$6.Any["message"]> = Definition$6<Id, Message>;
+declare namespace Definition$5 {
+  type Any = Definition$6.Any;
 }
 type LayerOptions$12 = LayerOptions$13;
-type TagClass$11<Self, Id extends string, Message extends Definition$8.Any["message"]> = TagClass$12<Self, Id, Message>;
-declare const Tag$12: <Self>() => <Id extends string, Message extends Definition$8.Any["message"]>(id: Id, definition: {
+type TagClass$10<Self, Id extends string, Message extends Definition$6.Any["message"]> = TagClass$11<Self, Id, Message>;
+declare const Tag$11: <Self>() => <Id extends string, Message extends Definition$6.Any["message"]>(id: Id, definition: {
   readonly message: Message;
-}) => TagClass$11<Self, Id, Message>;
-declare const implement$6: typeof implement$7;
-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$11 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$11 as Tag, TagClass$10 as TagClass, Worker, implement$5 as implement, make$9 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> {
-  readonly args: Args;
-  readonly success: Success;
-}
-declare namespace Method$4 {
-  export type Any = Method$4<ReadonlyArray<ServiceFreeSchema$3>, ServiceFreeSchema$3>;
-  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$3>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$3, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$3>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
-  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$3>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$3, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$3>] ? [Schema.Codec.Encoded<Head>, ...EncodedArgsFromSchemas<Tail>] : Array<Schema.Codec.Encoded<Args[number]>>;
-  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
-  export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
-  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
-  export type EncodedSuccess<Self extends Any> = Schema.Codec.Encoded<Self["success"]>;
-  export {};
+}) => TagClass$10<Self, Id, Message>;
+declare const implement$4: typeof implement$5;
+type Handler$2<ROut, Self extends Definition$6.Any> = Handler$3<ROut, Self>;
+type Options$4<ROut, Self extends Definition$6.Any> = Options$5<ROut, Self>;
+//#endregion
+//#region src/internal/RpcInvocation.d.ts
+type AnyArgs = Array<any>;
+type AsyncMethodKey<Api> = { [Key in keyof Api]-?: Key extends string ? Api[Key] extends ((...args: AnyArgs) => Promise<unknown>) ? Key : never : never; }[keyof Api];
+type AsyncMethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...args: infer Args) => Promise<unknown>) ? Args : never;
+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$1<AsyncMethodSuccess<Api, Method>>;
+declare namespace ServiceBinding_d_exports {
+  export { Service$1 as Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceFetcher, isServiceBindingClient, layer$11 as layer, makeClient$8 as makeClient, makeDirectMethods$1 as makeDirectMethods };
 }
-type Methods$3 = Record<string, Method$4.Any>;
+declare const TypeId$2: "effect-cf/ServiceBinding";
 /**
- * RPC contract for a Worker service.
- *
- * Create with {@link make} and reuse to type both worker implementations and
- * service bindings in other workers.
+ * Minimum shape for a Cloudflare service binding.
  */
-interface Definition$6<Id extends string = string, MethodsShape extends Methods$3 = Methods$3> {
-  readonly id: Id;
-  readonly methods: MethodsShape;
-}
-declare namespace Definition$6 {
-  type Any = Definition$6<string, Methods$3>;
+interface ServiceFetcher {
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
 }
-type ReservedMethodName$5 = ReservedMethodName$3;
-type NoReservedMethods$3<MethodsShape extends Methods$3> = Extract<keyof MethodsShape, ReservedMethodName$5> extends never ? MethodsShape : never;
+type RpcClient$1<Api> = { readonly [Key in keyof Api as Key extends string ? Api[Key] extends ((...args: Array<any>) => unknown) ? Key : never : never]: Api[Key]; };
+type ReservedMethodName$4 = ReservedMethodName$3 | "fetch";
 /**
- * Promise-based client API derived from a {@link Definition}.
+ * Native Cloudflare service object including optional RPC methods.
  */
-type ServerApi$4<Self extends Definition$6.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$4.Args<Self["methods"][Key]>) => Promise<Method$4.Success<Self["methods"][Key]>>; };
-type Api$3<Self extends Definition$6.Any> = Provider<ServerApi$4<Self>, ReservedMethodName$5>;
-/**
- * Effect handlers for each RPC method in a worker definition.
- */
-type Handlers$3<ROut, Self extends Definition$6.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$4.Args<Self["methods"][Key]>) => WorkerRpcHandler<ROut, Method$4.Success<Self["methods"][Key]>>; };
-/**
- * Worker constructor options for a specific RPC definition.
- */
-interface Options$5<ROut, Self extends Definition$6.Any, REvent = never, EventLayerError = never> extends Omit<WorkerOptions<ROut, REvent, EventLayerError, Handlers$3<ROut | REvent, Self>>, "rpc"> {
-  readonly rpc: Handlers$3<ROut | REvent, Self>;
-}
-type LayerOptions$11 = {
-  readonly binding: string;
-};
-type TagClass$10<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, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$5<ROut, Definition$6<Id, MethodsShape>, REvent, EventLayerError>) => WorkerClass<Handlers$3<ROut | REvent, Definition$6<Id, MethodsShape>>, ROut | REvent>;
-  readonly layer: (options: LayerOptions$11) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-};
-/**
- * Defines a single RPC method schema in a worker definition.
- */
-declare const method$3: {
-  <Success extends ServiceFreeSchema$3>(definition: {
-    readonly success: Success;
-  }): Method$4<readonly [], Success>;
-  <const Args extends ReadonlyArray<ServiceFreeSchema$3>, Success extends ServiceFreeSchema$3>(definition: {
-    readonly args: Args;
-    readonly success: Success;
-  }): Method$4<Args, Success>;
-};
-declare const make$9: <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$10<Definition$6<Id, MethodsShape>, Id, MethodsShape>;
-declare const Tag$11: <Self>() => <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$10<Self, Id, MethodsShape>;
-declare const Worker: typeof Tag$11;
-/**
- * Helper for implementing handlers with the exact method shape of a definition.
- */
-declare const implement$5: <ROut, const Self extends Definition$6.Any>(_definition: Self, handlers: Handlers$3<ROut, Self>) => Handlers$3<ROut, Self>;
-/**
- * Convenience alias for a single worker RPC handler Effect.
- */
-type HandlerEffect$3<ROut, Self extends Definition$6.Any, Key extends keyof Self["methods"]> = WorkerRpcHandler<ROut, Method$4.Success<Self["methods"][Key]>>;
-//#endregion
-//#region src/internal/RpcInvocation.d.ts
-type AnyArgs = Array<any>;
-type AsyncMethodKey<Api> = { [Key in keyof Api]-?: Key extends string ? Api[Key] extends ((...args: AnyArgs) => Promise<unknown>) ? Key : never : never; }[keyof Api];
-type AsyncMethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...args: infer Args) => Promise<unknown>) ? Args : never;
-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$1<AsyncMethodSuccess<Api, Method>>;
-declare namespace ServiceBinding_d_exports {
-  export { Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceFetcher, isServiceBindingClient, layer$9 as layer, makeClient$7 as makeClient, makeDirectMethods$1 as makeDirectMethods };
-}
-declare const TypeId$1: "effect-cf/ServiceBinding";
-/**
- * Minimum shape for a Cloudflare service binding.
- */
-interface ServiceFetcher {
-  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
-}
-type RpcClient$1<Api> = { readonly [Key in keyof Api as Key extends string ? Api[Key] extends ((...args: Array<any>) => unknown) ? Key : never : never]: Api[Key]; };
-type ReservedMethodName$4 = ReservedMethodName$5 | "fetch";
-/**
- * Native Cloudflare service object including optional RPC methods.
- */
-type ServiceBindingClient<Api extends object> = ServiceFetcher & RpcClient$1<Provider<Api, ReservedMethodName$4>>;
-type ApiFromDefinition<Definition> = Definition extends Definition$6.Any ? ServerApi$4<Definition> : never;
-type ApiOrDefinition<Api extends object, Definition> = [Api] extends [never] ? ApiFromDefinition<Definition> : Api;
+type ServiceBindingClient<Api extends object> = ServiceFetcher & RpcClient$1<Provider<Api, ReservedMethodName$4>>;
+type ApiFromDefinition<Definition> = Definition extends Definition$4.Any ? ServerApi$2<Definition> : never;
+type ApiOrDefinition<Api extends object, Definition> = [Api] extends [never] ? ApiFromDefinition<Definition> : Api;
 /**
  * Binding metadata used to create an Effect service from a Worker binding.
  */
-interface ServiceBindingDefinition<Definition extends Definition$6.Any | undefined = undefined> {
+interface ServiceBindingDefinition<Definition extends Definition$4.Any | undefined = undefined> {
   /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
   /** Optional RPC schema used for argument/result encoding. */
@@ -1405,7 +1026,9 @@ declare const ServiceBindingFetchError_base: new <A extends Record<string, any>
 declare class ServiceBindingFetchError extends ServiceBindingFetchError_base<{
   readonly binding: string;
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 declare const ServiceBindingRpcError_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: "ServiceBindingRpcError";
 } & Readonly<A>;
@@ -1416,15 +1039,17 @@ declare class ServiceBindingRpcError extends ServiceBindingRpcError_base<{
   readonly binding: string;
   readonly method: string;
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 type ServiceMethodKey<Api> = AsyncMethodKey<Api>;
 type ServiceMethodArgs<Api, Method extends keyof Api> = AsyncMethodArgs<Api, Method>;
 type ServiceMethodSuccess<Api, Method extends keyof Api> = AsyncMethodSuccess<Api, Method>;
 type ServiceMethodCloudflareReturn<Api, Method extends keyof Api> = AsyncMethodCloudflareReturn<Api, Method>;
 type ServiceCall<R, Api> = <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError, R>;
-type DefinitionDirectMethods<R, Definition extends Definition$6.Any> = { readonly [Method in Definition$9.MethodNames<Definition>]: (...args: Method$5.Args<Definition["methods"][Method]>) => Effect.Effect<Method$5.Success<Definition["methods"][Method]>, ServiceBindingRpcError, R>; };
-type DirectMethods$1<R, Definition> = Definition extends Definition$6.Any ? DefinitionDirectMethods<R, Definition> : {};
-type ServiceBindingEffectClient<Api extends object, Definition extends Definition$6.Any | undefined = undefined> = DirectMethods$1<never, Definition> & {
+type DefinitionDirectMethods<R, Definition extends Definition$4.Any> = { readonly [Method in Definition$7.MethodNames<Definition>]: (...args: Method$3.Args<Definition["methods"][Method]>) => Effect.Effect<Method$3.Success<Definition["methods"][Method]>, ServiceBindingRpcError, R>; };
+type DirectMethods$1<R, Definition> = Definition extends Definition$4.Any ? DefinitionDirectMethods<R, Definition> : {};
+type ServiceBindingEffectClient<Api extends object, Definition extends Definition$4.Any | undefined = undefined> = DirectMethods$1<never, Definition> & {
   /**
    * Forwards an HTTP request to the bound Worker service.
    *
@@ -1509,15 +1134,15 @@ type ServiceBindingEffectClient<Api extends object, Definition extends Definitio
    */
   readonly scopedCall: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, unknown, Scope.Scope>;
 };
-type ServiceBindingStaticClient<R, Api extends object, Definition extends Definition$6.Any | undefined = undefined> = DirectMethods$1<R, Definition> & {
+type ServiceBindingStaticClient<R, Api extends object, Definition extends Definition$4.Any | undefined = undefined> = DirectMethods$1<R, Definition> & {
   readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, ServiceBindingFetchError, R>;
   readonly rpc: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodCloudflareReturn<Api, Method>, ServiceBindingRpcError, R>;
   readonly call: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError, R>;
   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$7: <Api extends object, const Definition extends Definition$6.Any | undefined = undefined>(definition: ServiceBindingDefinition<Definition>) => ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition>);
-declare const layer$9: <Self, Api extends object, const Definition extends Definition$6.Any | undefined = undefined>(tag: Context.Service<Self, ServiceBindingEffectClient<Api, Definition>>, definition: ServiceBindingDefinition<Definition>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const makeClient$8: <Api extends object, const Definition extends Definition$4.Any | undefined = undefined>(definition: ServiceBindingDefinition<Definition>) => ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition>);
+declare const layer$11: <Self, Api extends object, const Definition extends Definition$4.Any | undefined = undefined>(tag: Context.Service<Self, ServiceBindingEffectClient<Api, Definition>>, definition: ServiceBindingDefinition<Definition>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 /**
  * Creates a typed Effect service for a Worker service binding.
  *
@@ -1547,24 +1172,121 @@ declare const layer$9: <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$1]: typeof TypeId$1;
+declare const Service$1: <Self, Api extends object = never>() => <Id extends string, const Definition extends Definition$4.Any | undefined = undefined>(id: Id, definition: ServiceBindingDefinition<Definition>) => BindingService<Self, Id, ServiceBindingEffectClient<ApiOrDefinition<Api, Definition>, Definition>> & DirectMethods$1<Self, Definition> & {
+  readonly [TypeId$2]: typeof TypeId$2;
   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$1<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>, ServiceBindingRpcError, Self>;
-  readonly call: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: ServiceMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>, ServiceBindingRpcError, Self>;
-  readonly scopedCall: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: ServiceMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<Awaited<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>, unknown, Self | Scope.Scope>;
+  readonly fetch: (input: URL | RequestInfo<unknown, CfProperties<unknown>>, init?: RequestInit<CfProperties<unknown>> | undefined) => Effect.Effect<Response, ServiceBindingFetchError, Self>;
+  readonly rpc: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<Result$1<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>, ServiceBindingRpcError, Self>;
+  readonly call: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>, ServiceBindingRpcError, Self>;
+  readonly scopedCall: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<Awaited<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>, unknown, Self | Scope.Scope>;
+};
+declare const makeDirectMethods$1: <R, Api, Definition extends Definition$4.Any | undefined>(rpcDefinition: Definition | undefined, call: ServiceCall<R, Api>) => DirectMethods$1<R, Definition>;
+declare namespace WorkerDefinition_d_exports {
+  export { Api$1 as Api, Definition$4 as Definition, HandlerEffect$1 as HandlerEffect, Handlers$1 as Handlers, LayerOptions$11 as LayerOptions, Method$2 as Method, Methods$1 as Methods, NoReservedMethods$1 as NoReservedMethods, Options$3 as Options, ReservedMethodName$3 as ReservedMethodName, ServerApi$2 as ServerApi, ServiceFreeSchema$1 as ServiceFreeSchema, Tag$10 as Tag, TagClass$9 as TagClass, Worker, implement$3 as implement, make$11 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> {
+  readonly args: Args;
+  readonly success: Success;
+}
+declare namespace Method$2 {
+  export type Any = Method$2<ReadonlyArray<ServiceFreeSchema$1>, ServiceFreeSchema$1>;
+  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$1>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$1>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
+  /** Method schemas cross the wire through their canonical JSON codec. */
+  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$1>> = { [Index in keyof Args]: Schema.Json; };
+  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
+  export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
+  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
+  export type EncodedSuccess<Self extends Any> = Schema.Json;
+  export {};
+}
+type Methods$1 = Record<string, Method$2.Any>;
+/**
+ * RPC contract for a Worker service.
+ *
+ * Create with {@link make} and reuse to type both worker implementations and
+ * service bindings in other workers.
+ */
+interface Definition$4<Id extends string = string, MethodsShape extends Methods$1 = Methods$1> {
+  readonly id: Id;
+  readonly methods: MethodsShape;
+}
+declare namespace Definition$4 {
+  type Any = Definition$4<string, Methods$1>;
+}
+type ReservedMethodName$3 = ReservedMethodName$2;
+type NoReservedMethods$1<MethodsShape extends Methods$1> = Extract<keyof MethodsShape, ReservedMethodName$3> extends never ? MethodsShape : never;
+/**
+ * Promise-based client API derived from a {@link Definition}.
+ */
+type ServerApi$2<Self extends Definition$4.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$2.Args<Self["methods"][Key]>) => Promise<Method$2.Success<Self["methods"][Key]>>; };
+type Api$1<Self extends Definition$4.Any> = Provider<ServerApi$2<Self>, ReservedMethodName$3>;
+/**
+ * Effect handlers for each RPC method in a worker definition.
+ */
+type Handlers$1<ROut, Self extends Definition$4.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$2.Args<Self["methods"][Key]>) => WorkerRpcHandler<ROut, Method$2.Success<Self["methods"][Key]>>; };
+/**
+ * Worker constructor options for a specific RPC definition.
+ */
+interface Options$3<ROut, Self extends Definition$4.Any, REvent = never, EventLayerError = never> extends Omit<WorkerOptions<ROut, REvent, EventLayerError, Handlers$1<ROut | REvent, Self>>, "rpc"> {
+  readonly rpc: Handlers$1<ROut | REvent, Self>;
+}
+type LayerOptions$11 = {
+  readonly binding: string;
+};
+type TagClass$9<Self, Id extends string, MethodsShape extends Methods$1> = Context.ServiceClass<Self, Id, ServiceBindingEffectClient<Api$1<Definition$4<Id, MethodsShape>>, Definition$4<Id, MethodsShape>>> & ServiceBindingStaticClient<Self, Api$1<Definition$4<Id, MethodsShape>>, Definition$4<Id, MethodsShape>> & {
+  readonly id: Id;
+  readonly methods: MethodsShape;
+  readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$3<ROut, Definition$4<Id, MethodsShape>, REvent, EventLayerError>) => WorkerClass<Handlers$1<ROut | REvent, Definition$4<Id, MethodsShape>>, ROut | REvent>;
+  readonly layer: (options: LayerOptions$11) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
-declare const makeDirectMethods$1: <R, Api, Definition extends Definition$6.Any | undefined>(rpcDefinition: Definition | undefined, call: ServiceCall<R, Api>) => DirectMethods$1<R, Definition>;
+/**
+ * Defines a single RPC method schema in a worker definition.
+ */
+declare const method$1: {
+  <Success extends ServiceFreeSchema$1>(definition: {
+    readonly success: Success;
+  }): Method$2<readonly [], Success>;
+  <const Args extends ReadonlyArray<ServiceFreeSchema$1>, Success extends ServiceFreeSchema$1>(definition: {
+    readonly args: Args;
+    readonly success: Success;
+  }): Method$2<Args, Success>;
+};
+declare const make$11: <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$9<Definition$4<Id, MethodsShape>, Id, MethodsShape>;
+declare const Tag$10: <Self>() => <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$9<Self, Id, MethodsShape>;
+declare const Worker: typeof Tag$10;
+/**
+ * Helper for implementing handlers with the exact method shape of a definition.
+ */
+declare const implement$3: <ROut, const Self extends Definition$4.Any>(_definition: Self, handlers: Handlers$1<ROut, Self>) => Handlers$1<ROut, Self>;
+/**
+ * Convenience alias for a single worker RPC handler Effect.
+ */
+type HandlerEffect$1<ROut, Self extends Definition$4.Any, Key extends keyof Self["methods"]> = WorkerRpcHandler<ROut, Method$2.Success<Self["methods"][Key]>>;
 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$10 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$10 as Tag, TagClass$9 as TagClass, TagFactory$1 as TagFactory, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcHandler, WorkerRpcShape, implement$4 as implement, isWebSocketUpgrade, make$8 as make, makeFetchHandler, method$2 as method, renderHttpResponse };
+  export { Api$1 as Api, Definition$4 as Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect$1 as HandlerEffect, Handlers$1 as Handlers, LayerOptions$11 as LayerOptions, Method$2 as Method, Methods$1 as Methods, NativeRequest, NoReservedMethods$1 as NoReservedMethods, Options$3 as Options, ReservedMethodName$2 as ReservedMethodName, RpcHandlers$1 as RpcHandlers, ServerApi$2 as ServerApi, ServiceFreeSchema$1 as ServiceFreeSchema, Tag$10 as Tag, TagClass$9 as TagClass, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcHandler, WorkerRpcShape, implement$3 as implement, isWebSocketUpgrade, make$10 as make, makeFetchHandler, method$1 as method };
 }
 declare const ExecutionContext_base: Context.ServiceClass<ExecutionContext, "effect-cf/ExecutionContext", globalThis.ExecutionContext<unknown>>;
+/**
+ * Access to Cloudflare's native `ExecutionContext`.
+ */
 declare class ExecutionContext extends ExecutionContext_base {}
+/**
+ * Options for {@link WorkerContextService.waitUntil}.
+ */
 interface WorkerContextWaitUntilOptions<E, R> {
+  /**
+   * Failure mode for the background effect: `"observe"` (default) logs or
+   * routes the failure to `onFailure`, while `"propagate"` also rejects the
+   * native `waitUntil` promise.
+   */
   readonly mode?: "observe" | "propagate";
+  /** Custom failure handler for the background effect. */
   readonly onFailure?: (cause: Cause.Cause<E>) => Effect.Effect<void, never, R>;
 }
+/**
+ * Effect wrapper around `ExecutionContext` background APIs.
+ */
 interface WorkerContextService {
   readonly raw: globalThis.ExecutionContext;
   waitUntil<A, E, R, R2 = never>(effect: Effect.Effect<A, E, R>, options?: WorkerContextWaitUntilOptions<E, R2>): Effect.Effect<void, never, R | R2>;
@@ -1572,20 +1294,55 @@ interface WorkerContextService {
   readonly passThroughOnException: Effect.Effect<void>;
 }
 declare const WorkerContext_base: Context.ServiceClass<WorkerContext, "effect-cf/WorkerContext", WorkerContextService>;
+/**
+ * Service used inside handlers to schedule background work via `waitUntil`.
+ *
+ * @example
+ * ```ts
+ * const handler = Effect.gen(function* () {
+ *   const ctx = yield* Worker.WorkerContext;
+ *   yield* ctx.waitUntil(Effect.log("flush analytics"));
+ *   return new Response("ok");
+ * });
+ * ```
+ */
 declare class WorkerContext extends WorkerContext_base {}
 declare const NativeRequest_base: Context.ServiceClass<NativeRequest, "effect-cf/NativeRequest", Request<unknown, CfProperties<unknown>>>;
+/**
+ * Access to the incoming `Request` currently handled by a worker or Durable Object fetch.
+ */
 declare class NativeRequest extends NativeRequest_base {}
+/**
+ * Returns `true` when the request is a websocket upgrade request.
+ */
 declare const isWebSocketUpgrade: (request: Request) => boolean;
-type ReservedMethodName$3 = ReservedMethodName$6 | "fetch" | "connect" | "queue" | "scheduled" | "tail" | "tailStream" | "test" | "trace" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError";
+type ReservedMethodName$2 = ReservedMethodName$5 | "fetch" | "connect" | "queue" | "scheduled" | "tail" | "tailStream" | "test" | "trace" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError";
 type WorkerBaseContext<ROut> = ExecutionContext | WorkerContext | WorkerEnvironment | ROut;
 type WorkerFetchContext<ROut> = WorkerBaseContext<ROut> | NativeRequest | HttpServerRequest.HttpServerRequest | Scope.Scope;
 type WorkerRpcContext<ROut> = WorkerBaseContext<ROut> | Scope.Scope;
+/**
+ * Successful result of a worker fetch handler: either a native `Response`
+ * (returned to Cloudflare untouched) or an Effect `HttpServerResponse`
+ * (rendered through the Effect HTTP pipeline).
+ */
 type WorkerFetchSuccess = Response | HttpServerResponse.HttpServerResponse;
+/**
+ * Effect type for `fetch` handlers executed by {@link make}.
+ */
 type WorkerHandler<ROut, A = WorkerFetchSuccess> = Effect.Effect<A, unknown, WorkerFetchContext<ROut>>;
+/**
+ * Effect type for worker RPC handlers.
+ */
 type WorkerRpcHandler<ROut, A = unknown> = Effect.Effect<A, unknown, WorkerRpcContext<ROut>>;
+/**
+ * Shape of worker RPC handlers passed to {@link make}.
+ */
 type WorkerRpc<ROut> = Record<string, (...args: Array<any>) => WorkerRpcHandler<ROut>>;
 type WorkerRpcShape<Rpc extends WorkerRpc<ROut>, ROut> = { readonly [Key in keyof Rpc]: Rpc[Key] extends ((...args: infer Args) => Effect.Effect<infer A, unknown, WorkerRpcContext<ROut>>) ? (...args: Args) => Promise<A> : never; };
-type RpcHandlers$1<ROut, Api> = { readonly [Key in keyof Api as Key extends keyof WorkerEntrypoint ? never : Key extends string ? Key extends ReservedMethodName$3 ? never : [Api[Key]] extends [never] ? never : Api[Key] extends ((...args: Array<any>) => Promise<unknown>) ? Key : never : never]: Api[Key] extends ((...args: infer Args) => Promise<infer A>) ? (...args: Args) => WorkerRpcHandler<ROut, A> : never; };
+type RpcHandlers$1<ROut, Api> = { readonly [Key in keyof Api as Key extends keyof WorkerEntrypoint ? never : Key extends string ? Key extends ReservedMethodName$2 ? never : [Api[Key]] extends [never] ? never : Api[Key] extends ((...args: Array<any>) => Promise<unknown>) ? Key : never : never]: Api[Key] extends ((...args: infer Args) => Promise<infer A>) ? (...args: Args) => WorkerRpcHandler<ROut, A> : never; };
+/**
+ * Options for creating a worker class with Effect handlers.
+ */
 interface WorkerOptions<RRuntime, REvent = never, EventLayerError = never, Rpc extends WorkerRpc<RRuntime | REvent> = Record<never, never>> {
   /**
    * Layer provided around each Cloudflare event handled by this Worker.
@@ -1595,71 +1352,428 @@ interface WorkerOptions<RRuntime, REvent = never, EventLayerError = never, Rpc e
    * trace/log exporters that should flush at event completion.
    */
   readonly eventLayer?: Layer.Layer<REvent, EventLayerError, WorkerBaseContext<RRuntime>>;
+  /** Main request handler. */
   readonly fetch?: Effect.Effect<WorkerFetchSuccess, unknown, WorkerFetchContext<RRuntime | REvent>>;
+  /** Queue consumer handler invoked per message batch. */
   readonly queue?: QueueHandler<RRuntime | REvent>;
+  /** Optional RPC methods exposed as class instance methods. */
   readonly rpc?: Rpc;
 }
 type FetchWorkerOptions<RRuntime, REvent = never, EventLayerError = never> = Omit<WorkerOptions<RRuntime, REvent, EventLayerError, Record<never, never>>, "rpc"> & {
   readonly rpc?: never;
 };
+/**
+ * Cloudflare `WorkerEntrypoint` constructor produced by {@link make}.
+ */
 type WorkerClass<Rpc extends WorkerRpc<ROut>, ROut> = new (ctx: globalThis.ExecutionContext, env: WorkerEnv) => WorkerEntrypoint<WorkerEnv> & {
   fetch(request: Request): Promise<Response>;
   queue(batch: globalThis.MessageBatch): Promise<void>;
 } & WorkerRpcShape<Rpc, ROut>;
+/**
+ * `ExportedHandler`-compatible fetch object produced by {@link makeFetchHandler}.
+ */
 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$8<ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, fetch: WorkerHandler<ROut>): WorkerClass<Record<never, never>, ROut>;
-declare function make$8<ROut, LayerError, REvent = never, EventLayerError = never, const Rpc extends WorkerRpc<ROut | REvent> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptions<ROut, REvent, EventLayerError, Rpc>): WorkerClass<Rpc, ROut | REvent>;
+/**
+ * Creates a Cloudflare worker class backed by a single managed Effect runtime.
+ *
+ * The runtime layer is built when Cloudflare constructs the class and reused
+ * for every event the instance handles. Layer finalizers do not run when the
+ * isolate is evicted; Cloudflare provides no shutdown hook. Use `eventLayer`
+ * for resources that must be finalized per event.
+ *
+ * @example
+ * ```ts
+ * export default Worker.make(Layer.empty, {
+ *   fetch: Effect.succeed(new Response("ok")),
+ * });
+ * ```
+ */
+declare function make$10<ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, fetch: WorkerHandler<ROut>): WorkerClass<Record<never, never>, ROut>;
+declare function make$10<ROut, LayerError, REvent = never, EventLayerError = never, const Rpc extends WorkerRpc<ROut | REvent> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptions<ROut, REvent, EventLayerError, Rpc>): WorkerClass<Rpc, ROut | REvent>;
+/**
+ * Creates an `ExportedHandler`-compatible `{ fetch }` object backed by
+ * {@link make}.
+ *
+ * The Effect runtime is cached per `env` identity, so the user layer builds
+ * once per isolate instead of once per request. `ExecutionContext`-backed
+ * services (`Worker.ExecutionContext`, `Worker.WorkerContext`) are still
+ * provided fresh for every request. Layer finalizers do not run when the
+ * isolate is evicted; Cloudflare provides no shutdown hook. Use `eventLayer`
+ * for resources that must be finalized per event.
+ */
 declare const makeFetchHandler: <ROut, LayerError, REvent = never, EventLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptions<ROut, REvent, EventLayerError>) => 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> {
-  readonly args: Args;
-  readonly success: Success;
+declare namespace DurableObjectState_d_exports {
+  export { DurableObjectState, DurableObjectStateService, fromDurableObjectState };
 }
-declare namespace Method$3 {
-  export type Any = Method$3<ReadonlyArray<ServiceFreeSchema$2>, ServiceFreeSchema$2>;
-  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$2>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$2>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
-  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
-  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
-  export {};
+/**
+ * Effect-friendly wrapper around Cloudflare `DurableObjectState`.
+ */
+interface DurableObjectStateService {
+  /** Underlying Cloudflare state instance. */
+  readonly raw: globalThis.DurableObjectState;
+  /** Durable Object id for the current instance. */
+  readonly id: globalThis.DurableObjectId;
+  /** Wrapped storage API. */
+  readonly storage: DurableObjectStorage;
+  /** Registers background work with Cloudflare's lifecycle. */
+  waitUntil(promise: Promise<unknown>): Effect.Effect<void>;
+  /**
+   * Runs a background Effect via Cloudflare's `waitUntil` with the caller's
+   * Effect context, mirroring `WorkerContext.waitUntil` failure modes:
+   * `"observe"` (default) logs or routes failures to `onFailure`, while
+   * `"propagate"` also rejects the native `waitUntil` promise.
+   */
+  waitUntil<A, E, R, R2 = never>(effect: Effect.Effect<A, E, R>, options?: WorkerContextWaitUntilOptions<E, R2>): Effect.Effect<void, never, R | R2>;
+  /**
+   * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate.
+   *
+   * Cloudflare resets a Durable Object if the callback throws/rejects, or if the
+   * callback exceeds the platform timeout (currently documented as 30 seconds).
+   * This safe default resolves the callback with the Effect `Exit` for typed
+   * Effect failures and resumes that `Exit` afterward, so typed failures remain
+   * ordinary Effect failures instead of resetting the Durable Object. Defects
+   * and interruptions still reject the callback.
+   */
+  blockConcurrencyWhile<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
+  /**
+   * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate and lets
+   * Effect failures reject the callback.
+   *
+   * Use this only when Cloudflare's reset-on-throw behavior is intentional. The
+   * platform also resets the Durable Object if the callback exceeds the
+   * documented timeout (currently 30 seconds).
+   */
+  blockConcurrencyWhileOrReset<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
+  /** Accepts a websocket connection for hibernation-capable Durable Objects. */
+  acceptWebSocket(ws: DurableWebSocket, tags?: Array<string>): Effect.Effect<void>;
+  /** Lists active sockets, optionally filtered by tag. */
+  getWebSockets(tag?: string): Effect.Effect<Array<DurableWebSocket>>;
+  /** Configures automatic request/response handling for sockets. */
+  setWebSocketAutoResponse(pair?: WebSocketRequestResponsePair): Effect.Effect<void>;
+  /** Gets the configured websocket auto-response pair. */
+  getWebSocketAutoResponse: Effect.Effect<WebSocketRequestResponsePair | null>;
+  /** Timestamp of the last automatic websocket response for a socket. */
+  getWebSocketAutoResponseTimestamp(ws: DurableWebSocket): Effect.Effect<Date | null>;
+  /** Sets the timeout for hibernatable websocket events. */
+  setHibernatableWebSocketEventTimeout(timeoutMs?: number): Effect.Effect<void>;
+  /** Gets the timeout for hibernatable websocket events. */
+  getHibernatableWebSocketEventTimeout: Effect.Effect<number | null>;
+  /** Reads tags attached to a websocket. */
+  getTags(ws: DurableWebSocket): Effect.Effect<Array<string>>;
+  /**
+   * Forcibly resets the Durable Object. Cloudflare logs an uncaught Error using
+   * the optional reason, and the method is not available in `wrangler dev` local
+   * development according to the Durable Object State docs.
+   */
+  abort(reason?: string): Effect.Effect<void>;
 }
-type Methods$2 = Record<string, Method$3.Any>;
-type NoReservedMethods$2<MethodsShape extends Methods$2> = Extract<keyof MethodsShape, ReservedMethodName$3> extends never ? MethodsShape : never;
-interface Definition$5<Id extends string = string, MethodsShape extends Methods$2 = Methods$2> {
-  readonly id: Id;
-  readonly methods: MethodsShape;
+declare const DurableObjectState_base: Context.ServiceClass<DurableObjectState, "effect-cf/DurableObjectState", DurableObjectStateService>;
+/**
+ * Context tag for accessing the current Durable Object state service.
+ */
+declare class DurableObjectState extends DurableObjectState_base {}
+/**
+ * Wraps a native Cloudflare `DurableObjectState` as a {@link DurableObjectStateService}.
+ */
+declare const fromDurableObjectState: (state: globalThis.DurableObjectState) => DurableObjectStateService;
+declare namespace CloudflareOtlp_d_exports {
+  export { DurableObjectLayerOptions, LayerOptions$10 as LayerOptions, ResourceOptions, Serialization, Signal, WorkerLayerOptions, layer$10 as layer, layerDurableObject, layerJson, layerProtobuf, layerWorker };
 }
-declare namespace Definition$5 {
-  type Any = Definition$5<string, Methods$2>;
+/** Telemetry signal groups supported by the Cloudflare OTLP layers. */
+type Signal = "logs" | "traces" | "metrics";
+/** OTLP payload serialization used by the Effect OTLP exporters. */
+type Serialization = "json" | "protobuf";
+/**
+ * Resource metadata shared by Worker and Durable Object OTLP layers.
+ *
+ * Precedence follows Effect's `OtlpResource.fromConfig`: explicit
+ * `serviceName`/`serviceVersion` win over matching explicit `attributes`, and
+ * explicit attributes win over `OTEL_SERVICE_NAME`, `OTEL_SERVICE_VERSION`, and
+ * `OTEL_RESOURCE_ATTRIBUTES`. Omit an option to let operators set it from the
+ * environment.
+ */
+interface ResourceOptions {
+  /** Explicit service name. Takes precedence over OTEL environment variables. */
+  readonly serviceName?: string;
+  /** Explicit service version. Takes precedence over OTEL environment variables. */
+  readonly serviceVersion?: string;
+  /** Additional resource attributes attached to exported telemetry. */
+  readonly attributes?: Record<string, unknown>;
+}
+/** Options shared by all Cloudflare OTLP telemetry layers. */
+interface LayerOptions$10 {
+  /**
+   * Telemetry signals to export. Defaults to logs, traces, and metrics.
+   *
+   * Each selected signal is still controlled by standard OTEL exporter config,
+   * such as `OTEL_TRACES_EXPORTER=otlp`.
+   */
+  readonly signals?: ReadonlyArray<Signal>;
+  /** OTLP payload serialization. Defaults to protobuf. */
+  readonly serialization?: Serialization;
+  /** Resource metadata forwarded to Effect's OTLP resource resolver. */
+  readonly resource?: ResourceOptions;
+  /**
+   * Explicit headers for every selected signal.
+   *
+   * When omitted, Effect reads `OTEL_EXPORTER_OTLP_HEADERS` and the
+   * signal-specific `OTEL_EXPORTER_OTLP_*_HEADERS` variables.
+   */
+  readonly headers?: Headers$1.Input;
+  /** Exclude log records emitted for spans when exporting logs. */
+  readonly loggerExcludeLogSpans?: boolean;
+  /** Merge the OTLP logger with existing loggers instead of replacing them. */
+  readonly loggerMergeWithExisting?: boolean;
+  /** Custom trace context lookup used by the Effect OTLP tracer. */
+  readonly tracerContext?: <X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X;
 }
-type ServerApi$3<Self extends Definition$5.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$3.Args<Self["methods"][Key]>) => Promise<Method$3.Success<Self["methods"][Key]>>; };
-type Api$2<Self extends Definition$5.Any> = Provider<ServerApi$3<Self>, ReservedMethodName$3>;
-type Handlers$2<ROut, Self extends Definition$5.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$3.Args<Self["methods"][Key]>) => WorkerRpcHandler<ROut, Method$3.Success<Self["methods"][Key]>>; };
-interface Options$4<ROut, Self extends Definition$5.Any, REvent = never, EventLayerError = never> extends Omit<WorkerOptions<ROut, REvent, EventLayerError, Handlers$2<ROut | REvent, Self>>, "rpc"> {
-  readonly rpc: Handlers$2<ROut | REvent, Self>;
+/** Resource metadata specific to Cloudflare Workers. */
+interface WorkerLayerOptions extends LayerOptions$10 {
+  /** Cloudflare Worker name to attach as `cloudflare.worker.name`. */
+  readonly workerName?: string;
 }
-type LayerOptions$10 = LayerOptions$11;
-type TagClass$9<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>> & {
+/** Resource metadata specific to Cloudflare Durable Objects. */
+interface DurableObjectLayerOptions extends LayerOptions$10 {
+  /** Durable Object class name to attach as `cloudflare.durable_object.class`. */
+  readonly className?: string;
+  /**
+   * Include the Durable Object id as `cloudflare.durable_object.id`.
+   *
+   * This is disabled by default because object ids can be high-cardinality.
+   */
+  readonly includeObjectId?: boolean;
+}
+/**
+ * Base OTLP telemetry layer for Cloudflare-compatible runtimes.
+ *
+ * Standard OpenTelemetry environment variables are resolved by Effect's OTLP
+ * layers. In Cloudflare Workers and Durable Objects, the current `env` object is
+ * installed as the primary `ConfigProvider`; outside Cloudflare, the ambient
+ * Effect `ConfigProvider` remains the fallback.
+ *
+ * The layer provides {@link OtlpExporter.Flusher} for draining buffered
+ * telemetry before the isolate freezes.
+ */
+declare const layer$10: (options?: LayerOptions$10) => Layer.Layer<OtlpExporter.Flusher>;
+/** Base OTLP telemetry layer forced to JSON serialization. */
+declare const layerJson: (options?: Omit<LayerOptions$10, "serialization">) => Layer.Layer<OtlpExporter.Flusher>;
+/** Base OTLP telemetry layer forced to protobuf serialization. */
+declare const layerProtobuf: (options?: Omit<LayerOptions$10, "serialization">) => Layer.Layer<OtlpExporter.Flusher>;
+/**
+ * OTLP layer with Cloudflare Worker resource attributes.
+ *
+ * Provide this layer at runtime scope for long-lived metrics aggregation, or at
+ * handler scope when traces/logs should flush as the Cloudflare event finishes.
+ */
+declare const layerWorker: (options?: WorkerLayerOptions) => Layer.Layer<OtlpExporter.Flusher>;
+/**
+ * OTLP layer with Cloudflare Durable Object resource attributes.
+ *
+ * The layer reads {@link DurableObjectState} so it can optionally include the
+ * Durable Object id. Prefer leaving `includeObjectId` disabled unless the
+ * backend can tolerate high-cardinality resource attributes.
+ */
+declare const layerDurableObject: (options?: DurableObjectLayerOptions) => Layer.Layer<OtlpExporter.Flusher, never, DurableObjectState>;
+declare namespace ContainerNamespace_d_exports {
+  export { ContainerInstanceClient, ContainerNamespace, ContainerNamespaceClient, ContainerNamespaceDefinition, ContainerNamespaceResource, ContainerNamespaceService, ContainerNamespaceStaticClient, ContainerOperationError, ContainerReadinessOptions, ContainerSignal, ContainerStartAndWaitForPortsOptions, ContainerStartOptions, ContainerState, ContainerStopSignal, ContainerStub, ContainerStubOf, ContainerWaitOptions, LayerOptions$9 as LayerOptions, Tag$9 as Tag, TagClass$8 as TagClass, isContainerNamespaceResource, layer$9 as layer, make$9 as make, makeClient$7 as makeClient };
+}
+/** Named signal accepted by Cloudflare Container instances. */
+type ContainerSignal = "SIGKILL" | "SIGINT" | "SIGTERM";
+/** Named or numeric signal accepted by Container `stop()`. */
+type ContainerStopSignal = ContainerSignal | number;
+/** Per-instance Container startup configuration. */
+interface ContainerStartOptions {
+  readonly envVars?: Record<string, string>;
+  readonly entrypoint?: Array<string>;
+  readonly enableInternet?: boolean;
+  readonly labels?: Record<string, string>;
+}
+/** Serializable retry settings used while starting a Container. */
+interface ContainerWaitOptions {
+  readonly portToCheck: number;
+  readonly retries?: number;
+  readonly waitInterval?: number;
+}
+/** Serializable timeout settings used while waiting for Container ports. */
+interface ContainerReadinessOptions {
+  readonly instanceGetTimeoutMS?: number;
+  readonly portReadyTimeoutMS?: number;
+  readonly waitInterval?: number;
+}
+/** Options for starting a Container and waiting for its ports. */
+interface ContainerStartAndWaitForPortsOptions {
+  readonly startOptions?: ContainerStartOptions;
+  readonly ports?: number | Array<number>;
+  readonly cancellationOptions?: ContainerReadinessOptions;
+}
+/** Serializable state reported by a Cloudflare Container instance. */
+declare const ContainerState: Schema.Union<readonly [Schema.Struct<{
+  readonly lastChange: Schema.Finite;
+  readonly status: Schema.Literals<readonly ["running", "stopping", "stopped", "healthy"]>;
+}>, Schema.Struct<{
+  readonly lastChange: Schema.Finite;
+  readonly status: Schema.Literal<"stopped_with_code">;
+  readonly exitCode: Schema.optionalKey<Schema.Int>;
+}>]>;
+type ContainerState = typeof ContainerState.Type;
+/**
+ * Native Container stub shape exposed by a Container namespace binding.
+ *
+ * This is structural so using Container bindings does not make
+ * `@cloudflare/containers` a runtime dependency of effect-cf.
+ */
+interface ContainerStub {
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+  getState(): Promise<ContainerState>;
+  start(options?: ContainerStartOptions, waitOptions?: ContainerWaitOptions): Promise<void>;
+  startAndWaitForPorts(options?: ContainerStartAndWaitForPortsOptions): Promise<void>;
+  waitForPort(options: ContainerWaitOptions): Promise<number>;
+  stop(signal?: ContainerStopSignal): Promise<void>;
+  destroy(): Promise<void>;
+  setAllowedHosts(hosts: Array<string>): Promise<void>;
+  setDeniedHosts(hosts: Array<string>): Promise<void>;
+  allowHost(hostname: string): Promise<void>;
+  denyHost(hostname: string): Promise<void>;
+  removeAllowedHost(hostname: string): Promise<void>;
+  removeDeniedHost(hostname: string): Promise<void>;
+}
+/** Native Container namespace binding shape. */
+interface ContainerNamespaceResource {
+  getByName(name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions): ContainerStub;
+}
+/** Exact native stub type produced by a Container namespace binding. */
+type ContainerStubOf<Namespace extends ContainerNamespaceResource> = ReturnType<Namespace["getByName"]>;
+/** Container namespace binding metadata. */
+interface ContainerNamespaceDefinition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+declare const ContainerOperationError_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: "ContainerOperationError";
+} & Readonly<A>;
+/** Failure raised when invoking a named Container operation. */
+declare class ContainerOperationError extends ContainerOperationError_base<{
+  readonly binding: string;
+  readonly instance: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+/** Effect-wrapped client for one named Container instance. */
+interface ContainerInstanceClient<Stub extends ContainerStub = ContainerStub> {
+  readonly rawUnsafe: Effect.Effect<Stub, ContainerOperationError>;
+  readonly state: Effect.Effect<ContainerState, ContainerOperationError>;
+  readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<Response, ContainerOperationError>;
+  readonly start: (options?: ContainerStartOptions, waitOptions?: ContainerWaitOptions) => Effect.Effect<void, ContainerOperationError>;
+  readonly startAndWaitForPorts: (options?: ContainerStartAndWaitForPortsOptions) => Effect.Effect<void, ContainerOperationError>;
+  readonly waitForPort: (options: ContainerWaitOptions) => Effect.Effect<number, ContainerOperationError>;
+  readonly stop: (signal?: ContainerStopSignal) => Effect.Effect<void, ContainerOperationError>;
+  readonly destroy: Effect.Effect<void, ContainerOperationError>;
+  readonly setAllowedHosts: (hosts: ReadonlyArray<string>) => Effect.Effect<void, ContainerOperationError>;
+  readonly setDeniedHosts: (hosts: ReadonlyArray<string>) => Effect.Effect<void, ContainerOperationError>;
+  readonly allowHost: (hostname: string) => Effect.Effect<void, ContainerOperationError>;
+  readonly denyHost: (hostname: string) => Effect.Effect<void, ContainerOperationError>;
+  readonly removeAllowedHost: (hostname: string) => Effect.Effect<void, ContainerOperationError>;
+  readonly removeDeniedHost: (hostname: string) => Effect.Effect<void, ContainerOperationError>;
+}
+/** Effect client for a Container namespace binding. */
+interface ContainerNamespaceClient<Namespace extends ContainerNamespaceResource = ContainerNamespaceResource> {
+  readonly definition: ContainerNamespaceDefinition;
+  readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<ContainerInstanceClient<ContainerStubOf<Namespace>>, ContainerOperationError>;
+  readonly byName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => ContainerInstanceClient<ContainerStubOf<Namespace>>;
+  readonly rawUnsafe: Effect.Effect<Namespace>;
+}
+type ContainerNamespaceStaticClient<R, Namespace extends ContainerNamespaceResource = ContainerNamespaceResource> = {
+  readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<ContainerInstanceClient<ContainerStubOf<Namespace>>, ContainerOperationError, R>;
+  readonly byName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => {
+    readonly state: Effect.Effect<ContainerState, ContainerOperationError, R>;
+    readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<Response, ContainerOperationError, R>;
+    readonly start: (options?: ContainerStartOptions, waitOptions?: ContainerWaitOptions) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly startAndWaitForPorts: (options?: ContainerStartAndWaitForPortsOptions) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly waitForPort: (options: ContainerWaitOptions) => Effect.Effect<number, ContainerOperationError, R>;
+    readonly stop: (signal?: ContainerStopSignal) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly destroy: Effect.Effect<void, ContainerOperationError, R>;
+    readonly setAllowedHosts: (hosts: ReadonlyArray<string>) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly setDeniedHosts: (hosts: ReadonlyArray<string>) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly allowHost: (hostname: string) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly denyHost: (hostname: string) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly removeAllowedHost: (hostname: string) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly removeDeniedHost: (hostname: string) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly rawUnsafe: Effect.Effect<ContainerStubOf<Namespace>, ContainerOperationError, R>;
+  };
+  readonly rawUnsafe: Effect.Effect<Namespace, never, R>;
+};
+type LayerOptions$9 = {
+  readonly binding: string;
+};
+interface TagClass$8<Self, Id extends string, Namespace extends ContainerNamespaceResource = ContainerNamespaceResource> extends Context.ServiceClass<Self, `effect-cf/Container/${Id}`, ContainerNamespaceClient<Namespace>>, ContainerNamespaceStaticClient<Self, Namespace> {
   readonly id: Id;
-  readonly methods: MethodsShape;
-  readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$4<ROut, Definition$5<Id, MethodsShape>, REvent, EventLayerError>) => WorkerClass<Handlers$2<ROut | REvent, Definition$5<Id, MethodsShape>>, ROut | REvent>;
-  readonly layer: (options: LayerOptions$10) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$9) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+declare const isContainerNamespaceResource: (value: unknown) => value is ContainerNamespaceResource;
+declare const makeClient$7: (definition: ContainerNamespaceDefinition) => <Namespace extends ContainerNamespaceResource>(namespace: Namespace) => ContainerNamespaceClient<Namespace>;
+declare const layer$9: <Self, Namespace extends ContainerNamespaceResource>(tag: Context.Service<Self, ContainerNamespaceClient<Namespace>>, definition: ContainerNamespaceDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make$9: <Id extends string>(id: Id) => TagClass$8<ContainerNamespaceService<Id>, Id, ContainerNamespaceResource>;
+declare const ContainerNamespaceServiceTypeId: unique symbol;
+/** Nominal service marker for Container namespaces created with {@link make}. */
+interface ContainerNamespaceService<Id extends string> {
+  readonly [ContainerNamespaceServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+/** Creates a typed Effect service for a Cloudflare Container namespace. */
+declare const Tag$9: <Self, Namespace extends ContainerNamespaceResource = ContainerNamespaceResource>() => <Id extends string>(id: Id) => TagClass$8<Self, Id, Namespace>;
+declare const ContainerNamespace: typeof Tag$9;
+declare namespace D1_d_exports {
+  export { D1Definition, D1Service, D1SqlLayerOptions, Service, TypeId$1 as TypeId, make$8 as make };
+}
+declare const TypeId$1: "~effect-cf/D1";
+type TypeId$1 = typeof TypeId$1;
+/** Typed D1 binding definition. */
+interface D1Definition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+/** Options forwarded to `@effect/sql-d1` when building a SQL client layer. */
+type D1SqlLayerOptions = Omit<D1Client.D1ClientConfig, "db">;
+declare const D1ServiceTypeId: unique symbol;
+/** Nominal service marker for D1 services created with {@link make}. */
+interface D1Service<Id extends string> {
+  readonly [D1ServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+/**
+ * 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> & {
+  "~effect-cf/D1": "~effect-cf/D1";
+  definition: D1Definition;
+  sqlLayer: (options?: D1SqlLayerOptions) => Layer.Layer<D1Client.D1Client | SqlClient.SqlClient, Config.ConfigError | BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
-type TagFactory$1 = <Self>() => <Id extends string, const MethodsShape extends Methods$2>(id: Id, methods: MethodsShape & NoReservedMethods$2<MethodsShape>) => TagClass$9<Self, Id, MethodsShape>;
-declare const Tag$10: TagFactory$1;
-declare const method$2: {
-  <Success extends ServiceFreeSchema$2>(definition: {
-    readonly success: Success;
-  }): Method$3<readonly [], Success>;
-  <const Args extends ReadonlyArray<ServiceFreeSchema$2>, Success extends ServiceFreeSchema$2>(definition: {
-    readonly args: Args;
-    readonly success: Success;
-  }): Method$3<Args, Success>;
+/**
+ * Builds a D1 service around a Cloudflare D1 database binding.
+ *
+ * The returned service exposes the raw `D1Database` binding and `sqlLayer(...)`
+ * for providing `effect/unstable/sql` via `@effect/sql-d1`.
+ *
+ * @example
+ * ```ts
+ * class TodoDatabase extends D1.Service<TodoDatabase>()("TodoDatabase", {
+ *   binding: "TODO_DB",
+ * }) {}
+ *
+ * const SqlLive = TodoDatabase.sqlLayer();
+ * ```
+ */
+declare const Service: <Self>() => <Id extends string>(id: Id, definition: D1Definition) => BindingService<Self, Id, D1Database> & {
+  "~effect-cf/D1": "~effect-cf/D1";
+  definition: D1Definition;
+  sqlLayer: (options?: D1SqlLayerOptions) => Layer.Layer<D1Client.D1Client | SqlClient.SqlClient, Config.ConfigError | BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
-declare const implement$4: <ROut, const Self extends Definition$5.Any>(_definition: Self, handlers: Handlers$2<ROut, Self>) => Handlers$2<ROut, Self>;
-type HandlerEffect$2<ROut, Self extends Definition$5.Any, Key extends keyof Self["methods"]> = WorkerRpcHandler<ROut, Method$3.Success<Self["methods"][Key]>>;
 declare namespace DurableObjectNamespace_d_exports {
   export { DurableObjectFetchError, DurableObjectNamespaceBindingDefinition, DurableObjectNamespaceClient, DurableObjectNamespaceDefinition, DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient, DurableObjectRpcError, DurableObjectStubClient, isDurableObjectNamespaceClient, layer$8 as layer, makeClient$6 as makeClient, makeDirectMethods };
 }
@@ -1667,11 +1781,11 @@ interface DurableObjectFetcher {
   fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
 }
 type RpcClient<Api> = { readonly [Key in keyof Api as Key extends string ? Api[Key] extends ((...args: Array<any>) => unknown) ? Key : never : never]: Api[Key]; };
-type ReservedMethodName$2 = ReservedMethodName$1 | "fetch";
+type ReservedMethodName$1 = ReservedMethodName | "fetch";
 /**
  * Cloudflare Durable Object stub, optionally enriched with RPC methods.
  */
-type DurableObjectStubClient<Api extends object> = DurableObjectFetcher & RpcClient<Provider<Api, ReservedMethodName$2>> & {
+type DurableObjectStubClient<Api extends object> = DurableObjectFetcher & RpcClient<Provider<Api, ReservedMethodName$1>> & {
   readonly id: globalThis.DurableObjectId;
   readonly name?: string;
 };
@@ -1701,7 +1815,7 @@ interface DurableObjectNamespaceDefinition {
 /**
  * Namespace binding metadata with optional RPC schema.
  */
-interface DurableObjectNamespaceBindingDefinition<Definition extends Definition$4.Any | undefined = undefined> {
+interface DurableObjectNamespaceBindingDefinition<Definition extends Definition$3.Any | undefined = undefined> {
   /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
   /** Optional RPC schema used for argument/result encoding. */
@@ -1717,7 +1831,9 @@ declare class DurableObjectRpcError extends DurableObjectRpcError_base<{
   readonly binding: string;
   readonly method: string;
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 declare const DurableObjectFetchError_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: "DurableObjectFetchError";
 } & Readonly<A>;
@@ -1727,22 +1843,24 @@ declare const DurableObjectFetchError_base: new <A extends Record<string, any> =
 declare class DurableObjectFetchError extends DurableObjectFetchError_base<{
   readonly binding: string;
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 type StubMethodKey<Api> = AsyncMethodKey<Api>;
 type StubMethodArgs<Api, Method extends keyof Api> = AsyncMethodArgs<Api, Method>;
 type StubMethodSuccess<Api, Method extends keyof Api> = AsyncMethodSuccess<Api, Method>;
 type StubMethodCloudflareReturn<Api, Method extends keyof Api> = AsyncMethodCloudflareReturn<Api, Method>;
 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>;
-type DefinitionNamespaceDirectMethods<R, Api extends object, Definition extends Definition$4.Any> = { readonly [Method in Definition$9.MethodNames<Definition>]: (stub: DurableObjectStubClient<Api>, ...args: Method$5.Args<Definition["methods"][Method]>) => Effect.Effect<Method$5.Success<Definition["methods"][Method]>, DurableObjectRpcError, R>; };
-type DefinitionDurableObjectDirectClient<R, Definition extends Definition$4.Any> = {
+type DefinitionNamespaceDirectMethods<R, Api extends object, Definition extends Definition$3.Any> = { readonly [Method in Definition$7.MethodNames<Definition>]: (stub: DurableObjectStubClient<Api>, ...args: Method$3.Args<Definition["methods"][Method]>) => Effect.Effect<Method$3.Success<Definition["methods"][Method]>, DurableObjectRpcError, R>; };
+type DefinitionDurableObjectDirectClient<R, Definition extends Definition$3.Any> = {
   readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
-} & { readonly [Method in Definition$9.MethodNames<Definition>]: (...args: Method$5.Args<Definition["methods"][Method]>) => Effect.Effect<Method$5.Success<Definition["methods"][Method]>, DurableObjectRpcError, R>; };
-type DefinitionNamespaceDirectClientMethods<R, Definition extends Definition$4.Any> = {
+} & { readonly [Method in Definition$7.MethodNames<Definition>]: (...args: Method$3.Args<Definition["methods"][Method]>) => Effect.Effect<Method$3.Success<Definition["methods"][Method]>, DurableObjectRpcError, R>; };
+type DefinitionNamespaceDirectClientMethods<R, Definition extends Definition$3.Any> = {
   readonly byName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => DefinitionDurableObjectDirectClient<R, Definition>;
   readonly byId: (id: globalThis.DurableObjectId, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => DefinitionDurableObjectDirectClient<R, Definition>;
 };
-type DirectMethods<R, Api extends object, Definition> = Definition extends Definition$4.Any ? DefinitionNamespaceDirectMethods<R, Api, Definition> & DefinitionNamespaceDirectClientMethods<R, Definition> : {};
-type DurableObjectNamespaceEffectClient<Api extends object, Definition extends Definition$4.Any | undefined = undefined> = DirectMethods<never, Api, Definition> & {
+type DirectMethods<R, Api extends object, Definition> = Definition extends Definition$3.Any ? DefinitionNamespaceDirectMethods<R, Api, Definition> & DefinitionNamespaceDirectClientMethods<R, Definition> : {};
+type DurableObjectNamespaceEffectClient<Api extends object, Definition extends Definition$3.Any | undefined = undefined> = DirectMethods<never, Api, Definition> & {
   /** Creates a globally unique Durable Object id. */
   readonly newUniqueId: (options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions) => Effect.Effect<globalThis.DurableObjectId>;
   /** Deterministically maps a name to a Durable Object id. */
@@ -1849,9 +1967,9 @@ type DurableObjectNamespaceEffectClient<Api extends object, Definition extends D
    * Prefer the typed helpers above unless Cloudflare exposes a platform feature
    * that is not wrapped by effect-cf yet.
    */
-  readonly unsafeRaw: Effect.Effect<DurableObjectNamespaceClient<Api>>;
+  readonly rawUnsafe: Effect.Effect<DurableObjectNamespaceClient<Api>>;
 };
-type DurableObjectNamespaceStaticClient<R, Api extends object, Definition extends Definition$4.Any | undefined = undefined> = DirectMethods<R, Api, Definition> & {
+type DurableObjectNamespaceStaticClient<R, Api extends object, Definition extends Definition$3.Any | undefined = undefined> = DirectMethods<R, Api, Definition> & {
   readonly newUniqueId: (options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions) => Effect.Effect<globalThis.DurableObjectId, never, R>;
   readonly idFromName: (name: string) => Effect.Effect<globalThis.DurableObjectId, never, R>;
   readonly idFromString: (id: string) => Effect.Effect<globalThis.DurableObjectId, never, R>;
@@ -1862,97 +1980,98 @@ type DurableObjectNamespaceStaticClient<R, Api extends object, Definition extend
   readonly rpc: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodCloudflareReturn<Api, Method>, DurableObjectRpcError, R>;
   readonly call: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError, R>;
   readonly scopedCall: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, unknown, Scope.Scope | R>;
-  readonly unsafeRaw: () => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
+  readonly rawUnsafe: () => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
 };
 declare const isDurableObjectNamespaceClient: <Api extends object>(value: unknown) => value is DurableObjectNamespaceClient<Api>;
-declare const makeClient$6: <Api extends object, const Definition extends Definition$4.Any | undefined = undefined>(definition: DurableObjectNamespaceBindingDefinition<Definition>) => ((namespace: DurableObjectNamespaceClient<Api>) => DurableObjectNamespaceEffectClient<Api, Definition>);
-declare const layer$8: <Self, Api extends object, const Definition extends Definition$4.Any | undefined = undefined>(tag: Context.Service<Self, DurableObjectNamespaceEffectClient<Api, Definition>>, definition: DurableObjectNamespaceBindingDefinition<Definition>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const makeDirectMethods: <R, Api extends object, Definition extends Definition$4.Any | undefined>(rpcDefinition: Definition | undefined, helpers: {
+declare const makeClient$6: <Api extends object, const Definition extends Definition$3.Any | undefined = undefined>(definition: DurableObjectNamespaceBindingDefinition<Definition>) => ((namespace: DurableObjectNamespaceClient<Api>) => DurableObjectNamespaceEffectClient<Api, Definition>);
+declare const layer$8: <Self, Api extends object, const Definition extends Definition$3.Any | undefined = undefined>(tag: Context.Service<Self, DurableObjectNamespaceEffectClient<Api, Definition>>, definition: DurableObjectNamespaceBindingDefinition<Definition>) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const makeDirectMethods: <R, Api extends object, Definition extends Definition$3.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>;
   readonly get: (id: globalThis.DurableObjectId, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
   readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
 }) => 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$9 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$9 as Tag, TagClass$8 as TagClass, implement$3 as implement, make$7 as make, method$1 as method };
+  export { Api, Definition$3 as Definition, DurableObject$1 as DurableObject, HandlerEffect, Handlers, LayerOptions$8 as LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options$2 as Options, ReservedMethodName, ServerApi$1 as ServerApi, ServiceFreeSchema, Tag$8 as Tag, TagClass$7 as TagClass, implement$2 as implement, make$7 as make, 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> {
+type ServiceFreeSchema = Schema.Codec<any, any, never, never>;
+interface Method$1<Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema = ServiceFreeSchema> {
   readonly args: Args;
   readonly success: Success;
 }
-declare namespace Method$2 {
-  export type Any = Method$2<ReadonlyArray<ServiceFreeSchema$1>, ServiceFreeSchema$1>;
-  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$1>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$1>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
-  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$1>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$1>] ? [Schema.Codec.Encoded<Head>, ...EncodedArgsFromSchemas<Tail>] : Array<Schema.Codec.Encoded<Args[number]>>;
+declare namespace Method$1 {
+  export type Any = Method$1<ReadonlyArray<ServiceFreeSchema>, ServiceFreeSchema>;
+  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends ReadonlyArray<ServiceFreeSchema>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
+  /** Method schemas cross the wire through their canonical JSON codec. */
+  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = { [Index in keyof Args]: Schema.Json; };
   export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
   export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
   export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
-  export type EncodedSuccess<Self extends Any> = Schema.Codec.Encoded<Self["success"]>;
+  export type EncodedSuccess<Self extends Any> = Schema.Json;
   export {};
 }
-type Methods$1 = Record<string, Method$2.Any>;
+type Methods = Record<string, Method$1.Any>;
 /**
  * RPC contract for a Durable Object class.
  */
-interface Definition$4<Id extends string = string, MethodsShape extends Methods$1 = Methods$1> {
+interface Definition$3<Id extends string = string, MethodsShape extends Methods = Methods> {
   readonly id: Id;
   readonly methods: MethodsShape;
 }
-declare namespace Definition$4 {
-  type Any = Definition$4<string, Methods$1>;
+declare namespace Definition$3 {
+  type Any = Definition$3<string, Methods>;
 }
-type ReservedMethodName$1 = ReservedMethodName$6 | "fetch" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError";
-type NoReservedMethods$1<MethodsShape extends Methods$1> = Extract<keyof MethodsShape, ReservedMethodName$1> extends never ? MethodsShape : never;
+type ReservedMethodName = ReservedMethodName$5 | "fetch" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError";
+type NoReservedMethods<MethodsShape extends Methods> = Extract<keyof MethodsShape, ReservedMethodName> extends never ? MethodsShape : never;
 /**
  * Promise-based client API derived from a Durable Object definition.
  */
-type ServerApi$2<Self extends Definition$4.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$2.Args<Self["methods"][Key]>) => Promise<Method$2.Success<Self["methods"][Key]>>; };
-type Api$1<Self extends Definition$4.Any> = Provider<ServerApi$2<Self>, ReservedMethodName$1>;
+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>;
 /**
  * Effect handlers for each RPC method in a Durable Object definition.
  */
-type Handlers$1<ROut, Self extends Definition$4.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$2.Args<Self["methods"][Key]>) => DurableObjectHandler<ROut, Method$2.Success<Self["methods"][Key]>>; };
+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]>>; };
 /**
  * Durable Object constructor options for a specific RPC definition.
  */
-interface Options$3<ROut, Self extends Definition$4.Any, REvent = never, EventLayerError = never> extends Omit<DurableObjectOptions<ROut, REvent, EventLayerError, Handlers$1<ROut | REvent, Self>>, "rpc"> {
-  readonly rpc: Handlers$1<ROut | REvent, Self>;
+interface Options$2<ROut, Self extends Definition$3.Any, REvent = never, EventLayerError = never> extends Omit<DurableObjectOptions<ROut, REvent, EventLayerError, Handlers<ROut | REvent, Self>>, "rpc"> {
+  readonly rpc: Handlers<ROut | REvent, Self>;
 }
-type LayerOptions$9 = {
+type LayerOptions$8 = {
   readonly binding: string;
 };
-type TagClass$8<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$7<Self, Id extends string, MethodsShape extends Methods> = Context.ServiceClass<Self, `effect-cf/DurableObject/${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, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options: Options$3<ROut, Definition$4<Id, MethodsShape>, REvent, EventLayerError>) => DurableObjectClass<Handlers$1<ROut | REvent, Definition$4<Id, MethodsShape>>, ROut | REvent>;
-  readonly layer: (options: LayerOptions$9) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options: Options$2<ROut, Definition$3<Id, MethodsShape>, REvent, EventLayerError>) => DurableObjectClass<Handlers<ROut | REvent, Definition$3<Id, MethodsShape>>, ROut | REvent>;
+  readonly layer: (options: LayerOptions$8) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
 /**
  * Defines a single RPC method schema in a Durable Object definition.
  */
-declare const method$1: {
-  <Success extends ServiceFreeSchema$1>(definition: {
+declare const method: {
+  <Success extends ServiceFreeSchema>(definition: {
     readonly success: Success;
-  }): Method$2<readonly [], Success>;
-  <const Args extends ReadonlyArray<ServiceFreeSchema$1>, Success extends ServiceFreeSchema$1>(definition: {
+  }): Method$1<readonly [], Success>;
+  <const Args extends ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema>(definition: {
     readonly args: Args;
     readonly success: Success;
-  }): Method$2<Args, Success>;
+  }): Method$1<Args, Success>;
 };
-declare const make$7: <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$8<Definition$4<Id, MethodsShape>, Id, MethodsShape>;
-declare const Tag$9: <Self>() => <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$8<Self, Id, MethodsShape>;
-declare const DurableObject$1: typeof Tag$9;
+declare const make$7: <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape>) => TagClass$7<Definition$3<Id, MethodsShape>, Id, MethodsShape>;
+declare const Tag$8: <Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape>) => TagClass$7<Self, Id, MethodsShape>;
+declare const DurableObject$1: typeof Tag$8;
 /**
  * Helper for implementing handlers with the exact method shape of a definition.
  */
-declare const implement$3: <ROut, const Self extends Definition$4.Any>(_definition: Self, handlers: Handlers$1<ROut, Self>) => Handlers$1<ROut, Self>;
+declare const implement$2: <ROut, const Self extends Definition$3.Any>(_definition: Self, handlers: Handlers<ROut, Self>) => Handlers<ROut, Self>;
 /**
  * Convenience alias for a single Durable Object RPC handler Effect.
  */
-type HandlerEffect$1<ROut, Self extends Definition$4.Any, Key extends keyof Self["methods"]> = DurableObjectHandler<ROut, Method$2.Success<Self["methods"][Key]>>;
+type HandlerEffect<ROut, Self extends Definition$3.Any, Key extends keyof Self["methods"]> = DurableObjectHandler<ROut, Method$1.Success<Self["methods"][Key]>>;
 declare namespace DurableObject_d_exports {
-  export { Api, Definition$3 as Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcShape, HandlerEffect, Handlers, LayerOptions$8 as LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options$2 as Options, ReservedMethodName, RpcHandlers, ServerApi$1 as ServerApi, ServiceFreeSchema, Tag$8 as Tag, TagClass$7 as TagClass, TagFactory, implement$2 as implement, make$6 as make, method };
+  export { Api, Definition$3 as Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcShape, HandlerEffect, Handlers, LayerOptions$8 as LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options$2 as Options, ReservedMethodName, RpcHandlers, ServerApi$1 as ServerApi, ServiceFreeSchema, Tag$8 as Tag, TagClass$7 as TagClass, implement$2 as implement, make$6 as make, method };
 }
 type RuntimeContext$1<ROut> = DurableObjectState | WorkerEnvironment | ROut;
 type HandlerContext<ROut> = RuntimeContext$1<ROut> | Scope.Scope;
@@ -2013,54 +2132,6 @@ type DurableObjectClass<Rpc extends DurableObjectRpc<ROut>, ROut> = new (state:
  * Creates a Durable Object class backed by a single managed Effect runtime.
  */
 declare const make$6: <ROut, LayerError, REvent = never, EventLayerError = never, const Rpc extends DurableObjectRpc<ROut | REvent> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options?: DurableObjectOptions<ROut, REvent, EventLayerError, Rpc>) => DurableObjectClass<Rpc, ROut | REvent>;
-type ServiceFreeSchema = Schema.Codec<any, any, never, never>;
-interface Method$1<Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema = ServiceFreeSchema> {
-  readonly args: Args;
-  readonly success: Success;
-}
-declare namespace Method$1 {
-  export type Any = Method$1<ReadonlyArray<ServiceFreeSchema>, ServiceFreeSchema>;
-  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends ReadonlyArray<ServiceFreeSchema>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
-  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
-  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
-  export {};
-}
-type Methods = Record<string, Method$1.Any>;
-type ReservedMethodName = ReservedMethodName$1;
-type NoReservedMethods<MethodsShape extends Methods> = Extract<keyof MethodsShape, ReservedMethodName> extends never ? MethodsShape : never;
-interface Definition$3<Id extends string = string, MethodsShape extends Methods = Methods> {
-  readonly id: Id;
-  readonly methods: MethodsShape;
-}
-declare namespace Definition$3 {
-  type Any = Definition$3<string, Methods>;
-}
-type LayerOptions$8 = LayerOptions$9;
-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, REvent = never, EventLayerError = never> extends Omit<DurableObjectOptions<ROut, REvent, EventLayerError, Handlers<ROut | REvent, Self>>, "rpc"> {
-  readonly rpc: Handlers<ROut | REvent, Self>;
-}
-type TagClass$7<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, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options: Options$2<ROut, Definition$3<Id, MethodsShape>, REvent, EventLayerError>) => DurableObjectClass<Handlers<ROut | REvent, Definition$3<Id, MethodsShape>>, ROut | REvent>;
-  readonly layer: (options: LayerOptions$8) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-};
-type TagFactory = <Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape>) => TagClass$7<Self, Id, MethodsShape>;
-declare const Tag$8: TagFactory;
-declare const method: {
-  <Success extends ServiceFreeSchema>(definition: {
-    readonly success: Success;
-  }): Method$1<readonly [], Success>;
-  <const Args extends ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema>(definition: {
-    readonly args: Args;
-    readonly success: Success;
-  }): Method$1<Args, Success>;
-};
-declare const implement$2: <ROut, const Self extends Definition$3.Any>(_definition: Self, handlers: Handlers<ROut, Self>) => Handlers<ROut, Self>;
-type HandlerEffect<ROut, Self extends Definition$3.Any, Key extends keyof Self["methods"]> = DurableObjectHandler<ROut, Method$1.Success<Self["methods"][Key]>>;
 declare namespace DurableObjectAlarm_d_exports {
   export { AlarmDefinitionConfig, AlarmDefinitionEntry, AlarmDefinitionPayload, AlarmDefinitions, AlarmFailurePolicy, AlarmPayload, AlarmPayloadSchema, AlarmRef, AlarmRetryPolicy, AlarmScheduler, DefinedAlarmEvent, DefinedAlarmHandlers, DurableObjectAlarm, DurableObjectAlarmError, DurableObjectAlarmEvent, InvalidAlarmPayloadError, InvalidAlarmRefError, InvalidProcessDueAlarmsOptionsError, InvalidRepeatEveryError, ProcessDueAlarmsFailure, ProcessDueAlarmsFailureAction, ProcessDueAlarmsHandler, ProcessDueAlarmsMode, ProcessDueAlarmsOptions, ProcessDueAlarmsResult, ScheduleAlarmInput, StoredAlarmDecodeError, define, process, processDue };
 }
@@ -2077,32 +2148,42 @@ declare const InvalidAlarmRefError_base: new <A extends Record<string, any> = {}
 } & Readonly<A>;
 declare class InvalidAlarmRefError extends InvalidAlarmRefError_base<{
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 declare const InvalidAlarmPayloadError_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: "InvalidAlarmPayloadError";
 } & Readonly<A>;
 declare class InvalidAlarmPayloadError extends InvalidAlarmPayloadError_base<{
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 declare const InvalidRepeatEveryError_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: "InvalidRepeatEveryError";
 } & Readonly<A>;
 declare class InvalidRepeatEveryError extends InvalidRepeatEveryError_base<{
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 declare const InvalidProcessDueAlarmsOptionsError_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: "InvalidProcessDueAlarmsOptionsError";
 } & Readonly<A>;
 declare class InvalidProcessDueAlarmsOptionsError extends InvalidProcessDueAlarmsOptionsError_base<{
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 declare const StoredAlarmDecodeError_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: "StoredAlarmDecodeError";
 } & Readonly<A>;
 declare class StoredAlarmDecodeError extends StoredAlarmDecodeError_base<{
   readonly cause: unknown;
   readonly storageId: string;
-}> {}
+}> {
+  get message(): string;
+}
 type DurableObjectAlarmError = InvalidAlarmPayloadError | InvalidAlarmRefError | InvalidProcessDueAlarmsOptionsError | InvalidRepeatEveryError | StorageOperationError | StoredAlarmDecodeError;
 /**
  * Events handled by `processDueAlarms`.
@@ -2416,12 +2497,12 @@ declare class DurableObjectRpcWebSocket extends DurableObjectRpcWebSocket_base {
 /**
  * Builds a layer that bridges Durable Object websocket events to `RpcServer.Protocol`.
  */
-declare const layer$7: (options?: LayerOptions$7) => Layer.Layer<DurableObjectRpcWebSocket | RpcServer.Protocol, never, DurableObjectState | RpcSerialization.RpcSerialization>;
+declare const layer$7: (options?: LayerOptions$7) => Layer.Layer<RpcServer.Protocol | DurableObjectRpcWebSocket, never, DurableObjectState | RpcSerialization.RpcSerialization>;
 declare namespace DurableObjectSqlite_d_exports {
   export { SqliteLayerOptions, layer$6 as layer };
 }
 /** Options forwarded to `@effect/sql-sqlite-do` when building a SQL client layer. */
-type SqliteLayerOptions = Omit<SqliteClient.SqliteClientConfig, "db">;
+type SqliteLayerOptions = Omit<SqliteClient.SqliteClientConfig, "db" | "storage">;
 /**
  * Provides `effect/unstable/sql` from the current Durable Object SQLite storage.
  *
@@ -2433,7 +2514,7 @@ type SqliteLayerOptions = Omit<SqliteClient.SqliteClientConfig, "db">;
  * );
  * ```
  */
-declare const layer$6: (options?: SqliteLayerOptions) => Layer.Layer<import("effect/unstable/sql/SqlClient").SqlClient | SqliteClient.SqliteClient, never, DurableObjectState>;
+declare const layer$6: (options?: SqliteLayerOptions) => Layer.Layer<SqliteClient.SqliteClient | SqlClient.SqlClient, never, DurableObjectState>;
 declare namespace Email_d_exports {
   export { EmailAddress, EmailAttachment, EmailBinding, EmailClient, EmailDefinition, EmailErrorCode, EmailMessage, EmailMessageBuilder, EmailOperationError, EmailRecipients, EmailSendError, EmailSendInput, EmailSendOptions, EmailSendResult, EmailService, EmailValidationError, EmailViolation, LayerOptions$6 as LayerOptions, Tag$7 as Tag, TagClass$6 as TagClass, emailErrorCodes, isEmailBinding, isEmailMessageBuilder, layer$5 as layer, make$5 as make, makeClient$5 as makeClient, sendLimits, validateMessage };
 }
@@ -2450,7 +2531,14 @@ declare const sendLimits: {
   /** Allowlisted custom headers, excluding `X-` prefixed headers. */
   readonly maxAllowlistHeaders: 20;
 };
-/** Error codes reported by Cloudflare Email Sending. */
+/**
+ * Error codes reported by Cloudflare Email Sending.
+ *
+ * Surfaced on {@link EmailOperationError} `code` on a best-effort basis: the
+ * runtime attaches them as a non-standard `code` property on thrown errors,
+ * which may be missing depending on the runtime or dev-time proxying
+ * (miniflare remote bindings serialize errors and can strip it).
+ */
 declare const emailErrorCodes: readonly ["E_VALIDATION_ERROR", "E_FIELD_MISSING", "E_TOO_MANY_RECIPIENTS", "E_TOO_MANY_ATTACHMENTS", "E_SENDER_NOT_VERIFIED", "E_RECIPIENT_NOT_ALLOWED", "E_RECIPIENT_SUPPRESSED", "E_SENDER_DOMAIN_NOT_AVAILABLE", "E_CONTENT_TOO_LARGE", "E_DELIVERY_FAILED", "E_RATE_LIMIT_EXCEEDED", "E_DAILY_LIMIT_EXCEEDED", "E_INTERNAL_SERVER_ERROR", "E_HEADER_NOT_ALLOWED", "E_HEADER_USE_API_FIELD", "E_HEADER_VALUE_INVALID", "E_HEADER_VALUE_TOO_LONG", "E_HEADER_NAME_INVALID", "E_HEADERS_TOO_LARGE", "E_HEADERS_TOO_MANY"];
 /** A documented Cloudflare Email Sending error code. */
 type EmailErrorCode = (typeof emailErrorCodes)[number];
@@ -2462,9 +2550,17 @@ declare class EmailOperationError extends EmailOperationError_base<{
   readonly binding: string;
   readonly operation: string;
   readonly cause: unknown;
-  /** Cloudflare error code taken from the thrown error, when present. */
+  /**
+   * Cloudflare error code taken from the thrown error, when present.
+   *
+   * Best-effort: may be `undefined` depending on the runtime or dev-time
+   * proxying — miniflare remote bindings (`"remote": true`) serialize thrown
+   * errors and can strip the non-standard `code` property.
+   */
   readonly code?: EmailErrorCode | (string & {});
-}> {}
+}> {
+  get message(): string;
+}
 /** A single message field that violates a documented Email Sending limit. */
 interface EmailViolation {
   readonly path: string;
@@ -2480,7 +2576,9 @@ declare class EmailValidationError extends EmailValidationError_base<{
   readonly binding: string;
   readonly operation: string;
   readonly violations: ReadonlyArray<EmailViolation>;
-}> {}
+}> {
+  get message(): string;
+}
 /** Typed Cloudflare Send Email binding definition. */
 interface EmailDefinition {
   /** Binding name as configured in `wrangler.jsonc`. */
@@ -2504,7 +2602,7 @@ interface EmailClient {
     (message: EmailMessage): Effect.Effect<EmailSendResult, EmailSendError>;
     (builder: EmailMessageBuilder): Effect.Effect<EmailSendResult, EmailSendError>;
   };
-  readonly unsafeRaw: Effect.Effect<EmailBinding>;
+  readonly rawUnsafe: Effect.Effect<EmailBinding>;
   readonly definition: EmailDefinition;
 }
 declare const EmailServiceTypeId: unique symbol;
@@ -2539,9 +2637,10 @@ declare const layer$5: <Self>(tag: Context.Service<Self, EmailClient>, definitio
 declare const make$5: <Id extends string>(id: Id) => TagClass$6<EmailService<Id>, Id>;
 declare const Tag$7: <Self>() => <Id extends string>(id: Id) => TagClass$6<Self, Id>;
 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$5 as LayerOptions, ProcessOptions, Step, Steps, Tag$6 as Tag, TagClass$5 as TagClass, draw, empty, isImagesBinding, layer$4 as layer, make$4 as make, makeClient$4 as makeClient, transform };
+  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$5 as LayerOptions, ProcessOptions, Step, Steps, Tag$6 as Tag, TagClass$5 as TagClass, TypeId, draw, empty, isImagesBinding, layer$4 as layer, make$4 as make, makeClient$4 as makeClient, transform };
 }
-declare const TypeId: "effect-cf/Images/Steps";
+declare const TypeId: "~effect-cf/Images/Steps";
+type TypeId = typeof TypeId;
 declare const ImagesOperationError_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: "ImagesOperationError";
 } & Readonly<A>;
@@ -2550,7 +2649,9 @@ declare class ImagesOperationError extends ImagesOperationError_base<{
   readonly binding: string;
   readonly operation: string;
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 /** Typed Cloudflare Images binding definition. */
 interface ImagesDefinition {
   /** Binding name as configured in `wrangler.jsonc`. */
@@ -2580,6 +2681,65 @@ type Step = Data.TaggedEnum<{
   };
   readonly Draw: DrawStepOptions;
 }>;
+declare const Step: {
+  readonly $is: <Tag extends "Draw" | "Transform">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Draw";
+    readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
+    readonly options?: ImageDrawOptions;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Transform";
+    readonly transform: ImageTransform;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends { readonly [Tag in "Draw" | "Transform"]: (args: Extract<{
+      readonly _tag: "Draw";
+      readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
+      readonly options?: ImageDrawOptions;
+    } | {
+      readonly _tag: "Transform";
+      readonly transform: ImageTransform;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Draw";
+      readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
+      readonly options?: ImageDrawOptions;
+    } | {
+      readonly _tag: "Transform";
+      readonly transform: ImageTransform;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Draw" | "Transform"]>>;
+    <Cases extends { readonly [Tag in "Draw" | "Transform"]: (args: Extract<{
+      readonly _tag: "Draw";
+      readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
+      readonly options?: ImageDrawOptions;
+    } | {
+      readonly _tag: "Transform";
+      readonly transform: ImageTransform;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
+      readonly _tag: "Draw";
+      readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
+      readonly options?: ImageDrawOptions;
+    } | {
+      readonly _tag: "Transform";
+      readonly transform: ImageTransform;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Draw" | "Transform"]>>;
+  };
+  readonly Draw: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Draw";
+    readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
+    readonly options?: ImageDrawOptions;
+  }, "_tag">;
+  readonly Transform: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Transform";
+    readonly transform: ImageTransform;
+  }, "_tag">;
+};
 interface Steps {
   readonly [TypeId]: typeof TypeId;
   readonly steps: ReadonlyArray<Step>;
@@ -2606,7 +2766,7 @@ 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<CloudflareHostedImagesBinding>;
+  readonly rawUnsafe: Effect.Effect<CloudflareHostedImagesBinding>;
 }
 interface ImagesRuntimeBinding {
   readonly info: (image: ImageInputValue, options?: ImageInputOptions) => Promise<ImageInfoResponse>;
@@ -2618,7 +2778,7 @@ interface ImagesClient {
   readonly input: (image: ImageInputValue, options?: ImageInputOptions) => Effect.Effect<CloudflareImageTransformer, ImagesOperationError>;
   readonly process: (steps: Steps, options: ProcessOptions) => Effect.Effect<ImagesTransformationResultClient, ImagesOperationError>;
   readonly hosted: Option.Option<HostedImagesClient>;
-  readonly unsafeRaw: Effect.Effect<ImagesRuntimeBinding>;
+  readonly rawUnsafe: Effect.Effect<ImagesRuntimeBinding>;
   readonly definition: ImagesDefinition;
 }
 declare const ImagesServiceTypeId: unique symbol;
@@ -2637,27 +2797,35 @@ interface TagClass$5<Self, Id extends string> extends Context.ServiceClass<Self,
 }
 /** 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 transform: {
+  (transform: ImageTransform): (steps: Steps) => Steps;
+  (steps: Steps, transform: ImageTransform): Steps;
+};
+declare const draw: {
+  (draw: DrawStepOptions): (steps: Steps) => Steps;
+  (steps: Steps, draw: DrawStepOptions): Steps;
+};
 declare const isImagesBinding: (value: unknown) => value is ImagesRuntimeBinding;
 declare const makeClient$4: (definition: ImagesDefinition) => (images: ImagesRuntimeBinding) => ImagesClient;
 declare const layer$4: <Self>(tag: Context.Service<Self, ImagesClient>, definition: ImagesDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const make$4: <Id extends string>(id: Id) => TagClass$5<ImagesService<Id>, Id>;
 declare const Tag$6: <Self>() => <Id extends string>(id: Id) => TagClass$5<Self, Id>;
 declare namespace Kv_d_exports {
-  export { Definition$2 as Definition, KvClient, KvDefinition, KvListKey, KvListOptions, KvListResult, KvOperationError, KvPutOptions, KvWithMetadata, LayerOptions$4 as LayerOptions, Tag$5 as Tag, TagClass$4 as TagClass, isKvNamespace, layer$3 as layer, makeClient$3 as makeClient };
+  export { Definition$2 as Definition, KvClient, KvDefinition, KvListKey, KvListOptions, KvListResult, KvOperation, KvOperationError, KvPutOptions, KvWithMetadata, LayerOptions$4 as LayerOptions, Tag$5 as Tag, TagClass$4 as TagClass, isKvNamespace, layer$3 as layer, makeClient$3 as makeClient };
 }
+/** KV operation represented by {@link KvOperationError}. */
+type KvOperation = "put" | "get" | "getWithMetadata" | "list" | "delete";
 declare const KvOperationError_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: "KvOperationError";
 } & Readonly<A>;
 /** Error raised when a KV operation fails. */
 declare class KvOperationError extends KvOperationError_base<{
   readonly binding: string;
-  readonly operation: string;
+  readonly operation: KvOperation;
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 /** `KVNamespace.put` options. */
 type KvPutOptions = CloudflareKVNamespacePutOptions;
 /** `KVNamespace.list` options with optional metadata decoding schema. */
@@ -2712,8 +2880,8 @@ interface KvClient<Key, Value, EncodedValue> {
   readonly get: (key: Key) => Effect.Effect<Option.Option<Value>, KvOperationError | Schema.SchemaError>;
   readonly getWithMetadata: <Metadata>(key: Key, metadataSchema: Schema.Codec<Metadata, unknown>) => Effect.Effect<Option.Option<KvWithMetadata<Value, Metadata>>, KvOperationError | Schema.SchemaError>;
   readonly list: <Metadata = unknown>(options?: KvListOptions<Metadata>) => Effect.Effect<KvListResult<Key, Metadata>, KvOperationError | Schema.SchemaError>;
-  readonly remove: (key: Key) => Effect.Effect<void, KvOperationError | Schema.SchemaError>;
-  readonly unsafeRaw: Effect.Effect<KVNamespace>;
+  readonly delete: (key: Key) => Effect.Effect<void, KvOperationError | Schema.SchemaError>;
+  readonly rawUnsafe: Effect.Effect<KVNamespace>;
   readonly definition: KvDefinition<Key, Value, EncodedValue>;
 }
 type LayerOptions$4 = {
@@ -2733,17 +2901,21 @@ declare const Tag$5: <Self>() => <Id extends string, Key, Value, EncodedValue>(i
   readonly value: Schema.Codec<Value, EncodedValue>;
 }) => TagClass$4<Self, Id, Key, Value, EncodedValue>;
 declare namespace R2_d_exports {
-  export { LayerOptions$3 as LayerOptions, R2Client, R2Definition, R2GetOptions, R2ListOptions, R2MultipartOptions, R2MultipartUploadClient, R2ObjectBodyClient, R2OperationError, R2PutOptions, R2PutValue, R2Service, R2UploadPartOptions, R2UploadPartValue, Tag$4 as Tag, TagClass$3 as TagClass, isR2Bucket, layer$2 as layer, make$3 as make, makeClient$2 as makeClient };
+  export { LayerOptions$3 as LayerOptions, R2Client, R2Definition, R2GetOptions, R2ListOptions, R2MultipartOptions, R2MultipartUploadClient, R2ObjectBodyClient, R2Operation, R2OperationError, R2PutOptions, R2PutValue, R2Service, R2UploadPartOptions, R2UploadPartValue, Tag$4 as Tag, TagClass$3 as TagClass, isR2Bucket, layer$2 as layer, make$3 as make, makeClient$2 as makeClient };
 }
+/** R2 operation represented by {@link R2OperationError}. */
+type R2Operation = "head" | "get" | "put" | "delete" | "list" | "createMultipartUpload" | "resumeMultipartUpload" | "uploadPart" | "abortMultipartUpload" | "completeMultipartUpload" | "arrayBuffer" | "bytes" | "text" | "json" | "blob";
 declare const R2OperationError_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: "R2OperationError";
 } & Readonly<A>;
 /** Error raised when an R2 operation fails. */
 declare class R2OperationError extends R2OperationError_base<{
   readonly binding: string;
-  readonly operation: string;
+  readonly operation: R2Operation;
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 /** Typed R2 bucket binding definition. */
 interface R2Definition {
   /** Binding name as configured in `wrangler.jsonc`. */
@@ -2790,7 +2962,7 @@ interface R2Client {
   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<CloudflareR2Objects, R2OperationError>;
-  readonly unsafeRaw: Effect.Effect<CloudflareR2Bucket>;
+  readonly rawUnsafe: Effect.Effect<CloudflareR2Bucket>;
   readonly definition: R2Definition;
 }
 declare const R2ServiceTypeId: unique symbol;
@@ -2812,8 +2984,72 @@ declare const makeClient$2: (definition: R2Definition) => ((bucket: CloudflareR2
 declare const layer$2: <Self>(tag: Context.Service<Self, R2Client>, definition: R2Definition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const make$3: <Id extends string>(id: Id) => TagClass$3<R2Service<Id>, Id>;
 declare const Tag$4: <Self>() => <Id extends string>(id: Id) => TagClass$3<Self, Id>;
+declare namespace Vectorize_d_exports {
+  export { LayerOptions$2 as LayerOptions, Tag$3 as Tag, TagClass$2 as TagClass, VectorizeBinding, VectorizeClient, VectorizeDefinition, VectorizeIndexDetails, VectorizeIndexInfo, VectorizeMatch, VectorizeMatches, VectorizeMutation, VectorizeOperation, VectorizeOperationError, VectorizeQueryOptions, VectorizeService, VectorizeValues, VectorizeVector, VectorizeVectorMetadata, VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue, isVectorizeBinding, layer$1 as layer, make$2 as make, makeClient$1 as makeClient };
+}
+/** Vectorize operation represented by {@link VectorizeOperationError}. */
+type VectorizeOperation = "describe" | "query" | "queryById" | "insert" | "upsert" | "deleteByIds" | "getByIds";
+declare const VectorizeOperationError_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: "VectorizeOperationError";
+} & Readonly<A>;
+/** Error raised when a Vectorize operation fails. */
+declare class VectorizeOperationError extends VectorizeOperationError_base<{
+  readonly binding: string;
+  readonly operation: VectorizeOperation;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+/** Typed Vectorize binding definition. */
+interface VectorizeDefinition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+type VectorizeBinding = CloudflareVectorize | CloudflareVectorizeIndex;
+type VectorizeVector = CloudflareVectorizeVector;
+type VectorizeVectorMetadata = CloudflareVectorizeVectorMetadata;
+type VectorizeVectorMetadataValue = CloudflareVectorizeVectorMetadataValue;
+type VectorizeVectorMetadataFilter = CloudflareVectorizeVectorMetadataFilter;
+type VectorizeQueryOptions = CloudflareVectorizeQueryOptions;
+type VectorizeMatches = CloudflareVectorizeMatches;
+type VectorizeMatch = CloudflareVectorizeMatch;
+type VectorizeIndexInfo = CloudflareVectorizeIndexInfo;
+type VectorizeIndexDetails = CloudflareVectorizeIndexDetails;
+type VectorizeMutation = CloudflareVectorizeAsyncMutation | CloudflareVectorizeVectorMutation;
+type VectorizeValues = Float32Array | Float64Array | ReadonlyArray<number>;
+interface VectorizeClient {
+  readonly describe: Effect.Effect<VectorizeIndexInfo | VectorizeIndexDetails, VectorizeOperationError>;
+  readonly query: (vector: VectorizeValues, options?: VectorizeQueryOptions) => Effect.Effect<VectorizeMatches, VectorizeOperationError>;
+  readonly queryById: (vectorId: string, options?: VectorizeQueryOptions) => Effect.Effect<VectorizeMatches, VectorizeOperationError>;
+  readonly insert: (vectors: ReadonlyArray<VectorizeVector>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
+  readonly upsert: (vectors: ReadonlyArray<VectorizeVector>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
+  readonly deleteByIds: (ids: ReadonlyArray<string>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
+  readonly delete: (ids: ReadonlyArray<string>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
+  readonly getByIds: (ids: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<VectorizeVector>, VectorizeOperationError>;
+  readonly rawUnsafe: Effect.Effect<VectorizeBinding>;
+  readonly definition: VectorizeDefinition;
+}
+declare const VectorizeServiceTypeId: unique symbol;
+/** Nominal service marker for Vectorize services created with {@link make}. */
+interface VectorizeService<Id extends string> {
+  readonly [VectorizeServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+type LayerOptions$2 = {
+  readonly binding: string;
+};
+interface TagClass$2<Self, Id extends string> extends Context.ServiceClass<Self, Id, VectorizeClient> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions$2) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+declare const isVectorizeBinding: (value: unknown) => value is VectorizeBinding;
+declare const makeClient$1: (definition: VectorizeDefinition) => (index: VectorizeBinding) => VectorizeClient;
+declare const layer$1: <Self>(tag: Context.Service<Self, VectorizeClient>, definition: VectorizeDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make$2: <Id extends string>(id: Id) => TagClass$2<VectorizeService<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$1 as layer, makeClient$1 as makeClient };
+  export { WorkflowBindingClient, WorkflowBindingDefinition, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowInstanceEvent, WorkflowInstanceRestartOptions, WorkflowInstanceStatus, WorkflowInstanceStatusName, WorkflowOperationError, WorkflowResultDecodeError, isWorkflow, layer, makeClient };
 }
 type WorkflowInstanceCreateOptions<Payload> = Omit<CloudflareWorkflowInstanceCreateOptions<Payload>, "params">;
 type WorkflowInstanceCreateBatchOptions<Payload, EncodedPayload = unknown> = ReadonlyArray<{
@@ -2849,7 +3085,7 @@ interface WorkflowInstanceEvent {
   readonly type: string;
   readonly payload: unknown;
 }
-interface WorkflowBindingDefinition<Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4> {
+interface WorkflowBindingDefinition<Payload extends ServiceFreeSchema$2, Result extends ServiceFreeSchema$2> {
   /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
   /** Codec used to encode payloads passed to `Workflow.create`. */
@@ -2857,11 +3093,11 @@ interface WorkflowBindingDefinition<Payload extends ServiceFreeSchema$4, Result
   /** Codec used to decode completed workflow status output. */
   readonly result: Result;
 }
-interface WorkflowBindingClient<Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4> {
+interface WorkflowBindingClient<Payload extends ServiceFreeSchema$2, Result extends ServiceFreeSchema$2> {
   readonly create: (payload: Schema.Schema.Type<Payload>, options?: WorkflowInstanceCreateOptions<Schema.Codec.Encoded<Payload>>) => Effect.Effect<WorkflowInstance<Schema.Schema.Type<Result>>, WorkflowOperationError | Schema.SchemaError>;
   readonly createBatch: (batch: WorkflowInstanceCreateBatchOptions<Schema.Schema.Type<Payload>, Schema.Codec.Encoded<Payload>>) => Effect.Effect<ReadonlyArray<WorkflowInstance<Schema.Schema.Type<Result>>>, WorkflowOperationError | Schema.SchemaError>;
   readonly get: (instanceId: string) => Effect.Effect<WorkflowInstance<Schema.Schema.Type<Result>>, WorkflowOperationError>;
-  readonly unsafeRaw: Effect.Effect<CloudflareWorkflow<Schema.Codec.Encoded<Payload>>>;
+  readonly rawUnsafe: Effect.Effect<CloudflareWorkflow<Schema.Codec.Encoded<Payload>>>;
 }
 declare const WorkflowOperationError_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: "WorkflowOperationError";
@@ -2870,7 +3106,9 @@ declare class WorkflowOperationError extends WorkflowOperationError_base<{
   readonly binding: string;
   readonly operation: string;
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 declare const WorkflowResultDecodeError_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: "WorkflowResultDecodeError";
 } & Readonly<A>;
@@ -2878,51 +3116,53 @@ declare class WorkflowResultDecodeError extends WorkflowResultDecodeError_base<{
   readonly binding: string;
   readonly instanceId: string;
   readonly cause: unknown;
-}> {}
+}> {
+  get message(): string;
+}
 declare const isWorkflow: <Payload>(value: unknown) => value is CloudflareWorkflow<Payload>;
-declare const makeClient$1: <Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4>(definition: WorkflowBindingDefinition<Payload, Result>) => ((workflow: CloudflareWorkflow<Schema.Codec.Encoded<Payload>>) => WorkflowBindingClient<Payload, Result>);
-declare const layer$1: <Self, Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4>(tag: Context.Service<Self, WorkflowBindingClient<Payload, Result>>, definition: WorkflowBindingDefinition<Payload, Result>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const makeClient: <Payload extends ServiceFreeSchema$2, Result extends ServiceFreeSchema$2>(definition: WorkflowBindingDefinition<Payload, Result>) => ((workflow: CloudflareWorkflow<Schema.Codec.Encoded<Payload>>) => WorkflowBindingClient<Payload, Result>);
+declare const layer: <Self, Payload extends ServiceFreeSchema$2, Result extends ServiceFreeSchema$2>(tag: Context.Service<Self, WorkflowBindingClient<Payload, Result>>, definition: WorkflowBindingDefinition<Payload, Result>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare namespace WorkflowDefinition_d_exports {
-  export { Definition$1 as Definition, Handler$1 as Handler, LayerOptions$2 as LayerOptions, Options$1 as Options, Tag$3 as Tag, TagClass$2 as TagClass, Workflow, implement$1 as implement, make$2 as make };
+  export { Definition$1 as Definition, Handler$1 as Handler, LayerOptions$1 as LayerOptions, Options$1 as Options, Tag$2 as Tag, TagClass$1 as TagClass, Workflow, implement$1 as implement, make$1 as make };
 }
-interface Definition$1<Id extends string = string, Payload extends ServiceFreeSchema$4 = ServiceFreeSchema$4, Result extends ServiceFreeSchema$4 = ServiceFreeSchema$4> {
+interface Definition$1<Id extends string = string, Payload extends ServiceFreeSchema$2 = ServiceFreeSchema$2, Result extends ServiceFreeSchema$2 = ServiceFreeSchema$2> {
   readonly id: Id;
   readonly payload: Payload;
   readonly result: Result;
 }
 declare namespace Definition$1 {
-  type Any = Definition$1<string, ServiceFreeSchema$4, ServiceFreeSchema$4>;
+  type Any = Definition$1<string, ServiceFreeSchema$2, ServiceFreeSchema$2>;
 }
 type Handler$1<ROut, Self extends Definition$1.Any> = (payload: Schema.Schema.Type<Self["payload"]>) => Effect.Effect<Schema.Schema.Type<Self["result"]>, unknown, WorkflowRunContext<ROut>>;
 interface Options$1<ROut, Self extends Definition$1.Any> {
   readonly run: Handler$1<ROut, Self>;
 }
-type LayerOptions$2 = {
+type LayerOptions$1 = {
   readonly binding: string;
 };
-interface TagClass$2<Self, Id extends string, Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4> extends Context.ServiceClass<Self, Id, WorkflowBindingClient<Payload, Result>> {
+interface TagClass$1<Self, Id extends string, Payload extends ServiceFreeSchema$2, Result extends ServiceFreeSchema$2> extends Context.ServiceClass<Self, `effect-cf/Workflow/${Id}`, WorkflowBindingClient<Payload, Result>> {
   readonly id: Id;
   readonly payload: Payload;
   readonly result: Result;
   readonly make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$1<ROut, Definition$1<Id, Payload, Result>>) => WorkflowClass<Schema.Codec.Encoded<Payload>, Schema.Codec.Encoded<Result>, ROut>;
-  readonly layer: (options: LayerOptions$2) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$1) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
   readonly create: (payload: Schema.Schema.Type<Payload>, options?: WorkflowInstanceCreateOptions<Schema.Codec.Encoded<Payload>>) => Effect.Effect<WorkflowInstance<Schema.Schema.Type<Result>>, WorkflowOperationError | Schema.SchemaError, Self>;
   readonly createBatch: (batch: WorkflowInstanceCreateBatchOptions<Schema.Schema.Type<Payload>, Schema.Codec.Encoded<Payload>>) => Effect.Effect<ReadonlyArray<WorkflowInstance<Schema.Schema.Type<Result>>>, WorkflowOperationError | Schema.SchemaError, Self>;
   readonly get: (instanceId: string) => Effect.Effect<WorkflowInstance<Schema.Schema.Type<Result>>, WorkflowOperationError, Self>;
-  readonly unsafeRaw: () => Effect.Effect<globalThis.Workflow<Schema.Codec.Encoded<Payload>>, never, Self>;
+  readonly rawUnsafe: Effect.Effect<globalThis.Workflow<Schema.Codec.Encoded<Payload>>, never, Self>;
 }
-declare const make$2: <Id extends string, Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4>(id: Id, definition: {
+declare const make$1: <Id extends string, Payload extends ServiceFreeSchema$2, Result extends ServiceFreeSchema$2>(id: Id, definition: {
   readonly payload: Payload;
   readonly result: Result;
-}) => TagClass$2<Definition$1<Id, Payload, Result>, Id, Payload, Result>;
-declare const Tag$3: <Self>() => <Id extends string, Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4>(id: Id, definition: {
+}) => TagClass$1<Definition$1<Id, Payload, Result>, Id, Payload, Result>;
+declare const Tag$2: <Self>() => <Id extends string, Payload extends ServiceFreeSchema$2, Result extends ServiceFreeSchema$2>(id: Id, definition: {
   readonly payload: Payload;
   readonly result: Result;
-}) => TagClass$2<Self, Id, Payload, Result>;
-declare const Workflow: typeof Tag$3;
+}) => TagClass$1<Self, Id, Payload, Result>;
+declare const Workflow: typeof Tag$2;
 declare const implement$1: <ROut, const Self extends Definition$1.Any>(_definition: Self, handler: Handler$1<ROut, Self>) => Handler$1<ROut, Self>;
 declare namespace Workflow_d_exports {
-  export { Definition, Handler, LayerOptions$1 as LayerOptions, Options, Tag$2 as Tag, TagClass$1 as TagClass, WorkflowClass, WorkflowEvent$1 as WorkflowEvent, WorkflowEventService, WorkflowHandler, WorkflowOptions, WorkflowRunContext, WorkflowStep$1 as WorkflowStep, WorkflowStepContext$1 as WorkflowStepContext, WorkflowStepService, implement, make$1 as make, sleep, sleepUntil, step, waitForEvent };
+  export { Definition, Handler, LayerOptions, Options, Tag$1 as Tag, TagClass, WorkflowClass, WorkflowEvent$1 as WorkflowEvent, WorkflowEventService, WorkflowHandler, WorkflowOptions, WorkflowRunContext, WorkflowStep$1 as WorkflowStep, WorkflowStepContext$1 as WorkflowStepContext, WorkflowStepError, WorkflowStepService, implement, make, sleep, sleepUntil, step, waitForEvent };
 }
 interface WorkflowEventService<Payload = unknown> {
   readonly raw: WorkflowEvent<unknown>;
@@ -2933,15 +3173,26 @@ interface WorkflowEventService<Payload = unknown> {
 }
 declare const WorkflowEvent_base: Context.ServiceClass<WorkflowEvent$1, "effect-cf/WorkflowEvent", WorkflowEventService<unknown>>;
 declare class WorkflowEvent$1 extends WorkflowEvent_base {}
+declare const WorkflowStepError_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: "WorkflowStepError";
+} & Readonly<A>;
+/** Failure raised when a Cloudflare Workflow step operation rejects. */
+declare class WorkflowStepError extends WorkflowStepError_base<{
+  readonly step?: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
 interface WorkflowStepService {
   readonly raw: WorkflowStep;
-  do<A, E, R>(name: string, effect: Effect.Effect<A, E, R>, config?: WorkflowStepConfig): Effect.Effect<A, unknown, Exclude<R, WorkflowStepContext$1>>;
-  readonly sleep: (name: string, duration: WorkflowSleepDuration) => Effect.Effect<void, unknown>;
-  readonly sleepUntil: (name: string, timestamp: Date | number) => Effect.Effect<void, unknown>;
+  do<A, E, R>(name: string, effect: Effect.Effect<A, E, R>, config?: WorkflowStepConfig): Effect.Effect<A, WorkflowStepError, Exclude<R, WorkflowStepContext$1>>;
+  readonly sleep: (name: string, duration: WorkflowSleepDuration) => Effect.Effect<void, WorkflowStepError>;
+  readonly sleepUntil: (name: string, timestamp: Date | number) => Effect.Effect<void, WorkflowStepError>;
   readonly waitForEvent: <Payload>(name: string, options: {
     readonly type: string;
     readonly timeout?: WorkflowTimeoutDuration | number;
-  }) => Effect.Effect<WorkflowStepEvent<Payload>, unknown>;
+  }) => Effect.Effect<WorkflowStepEvent<Payload>, WorkflowStepError>;
 }
 declare const WorkflowStep_base: Context.ServiceClass<WorkflowStep$1, "effect-cf/WorkflowStep", WorkflowStepService>;
 declare class WorkflowStep$1 extends WorkflowStep_base {}
@@ -2956,86 +3207,26 @@ interface WorkflowOptions<ROut, Payload = unknown, Result = unknown> {
 type WorkflowClass<Payload, Result, _ROut> = new (ctx: globalThis.ExecutionContext, env: WorkerEnv) => WorkflowEntrypoint<WorkerEnv, Payload> & {
   run(event: Readonly<WorkflowEvent<Payload>>, step: WorkflowStep): Promise<Result>;
 };
-declare const make$1: <ROut, LayerError, Payload = unknown, Result = unknown>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkflowOptions<ROut, Payload, Result>) => WorkflowClass<Payload, Result, ROut>;
-declare const step: <A, E, R>(name: string, effect: Effect.Effect<A, E, R>, config?: WorkflowStepConfig) => Effect.Effect<A, unknown, WorkflowStep$1 | Exclude<R, WorkflowStepContext$1>>;
-declare const sleep: (name: string, duration: WorkflowSleepDuration) => Effect.Effect<void, unknown, WorkflowStep$1>;
-declare const sleepUntil: (name: string, timestamp: Date | number) => Effect.Effect<void, unknown, WorkflowStep$1>;
+declare const make: <ROut, LayerError, Payload = unknown, Result = unknown>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkflowOptions<ROut, Payload, Result>) => WorkflowClass<Payload, Result, ROut>;
+declare const step: <A, E, R>(name: string, effect: Effect.Effect<A, E, R>, config?: WorkflowStepConfig) => Effect.Effect<A, WorkflowStepError, WorkflowStep$1 | Exclude<R, WorkflowStepContext$1>>;
+declare const sleep: (name: string, duration: WorkflowSleepDuration) => Effect.Effect<void, WorkflowStepError, WorkflowStep$1>;
+declare const sleepUntil: (name: string, timestamp: Date | number) => Effect.Effect<void, WorkflowStepError, WorkflowStep$1>;
 declare const waitForEvent: <Payload>(name: string, options: {
   readonly type: string;
   readonly timeout?: WorkflowTimeoutDuration | number;
-}) => Effect.Effect<WorkflowStepEvent<Payload>, unknown, WorkflowStep$1>;
+}) => Effect.Effect<WorkflowStepEvent<Payload>, WorkflowStepError, WorkflowStep$1>;
 type Definition<Id extends string = string, Payload extends Definition$1.Any["payload"] = Definition$1.Any["payload"], Result extends Definition$1.Any["result"] = Definition$1.Any["result"]> = Definition$1<Id, Payload, Result>;
 declare namespace Definition {
   type Any = Definition$1.Any;
 }
-type LayerOptions$1 = LayerOptions$2;
-type TagClass$1<Self, Id extends string, Payload extends Definition$1.Any["payload"], Result extends Definition$1.Any["result"]> = TagClass$2<Self, Id, Payload, Result>;
-declare const Tag$2: <Self>() => <Id extends string, Payload extends Definition$1.Any["payload"], Result extends Definition$1.Any["result"]>(id: Id, definition: {
+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>;
+declare const Tag$1: <Self>() => <Id extends string, Payload extends Definition$1.Any["payload"], Result extends Definition$1.Any["result"]>(id: Id, definition: {
   readonly payload: Payload;
   readonly result: Result;
-}) => TagClass$1<Self, Id, Payload, Result>;
+}) => TagClass<Self, Id, Payload, Result>;
 declare const implement: typeof implement$1;
 type Handler<ROut, Self extends Definition$1.Any> = Handler$1<ROut, Self>;
 type Options<ROut, Self extends Definition$1.Any> = Options$1<ROut, Self>;
-declare namespace Vectorize_d_exports {
-  export { LayerOptions, Tag$1 as Tag, TagClass, VectorizeBinding, VectorizeClient, VectorizeDefinition, VectorizeIndexDetails, VectorizeIndexInfo, VectorizeMatch, VectorizeMatches, VectorizeMutation, VectorizeOperationError, VectorizeQueryOptions, VectorizeService, VectorizeValues, VectorizeVector, VectorizeVectorMetadata, VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue, isVectorizeBinding, layer, make, makeClient };
-}
-declare const VectorizeOperationError_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: "VectorizeOperationError";
-} & Readonly<A>;
-/** Error raised when a Vectorize operation fails. */
-declare class VectorizeOperationError extends VectorizeOperationError_base<{
-  readonly binding: string;
-  readonly operation: string;
-  readonly cause: unknown;
-}> {}
-/** Typed Vectorize binding definition. */
-interface VectorizeDefinition {
-  /** Binding name as configured in `wrangler.jsonc`. */
-  readonly binding: string;
-}
-type VectorizeBinding = CloudflareVectorize | CloudflareVectorizeIndex;
-type VectorizeVector = CloudflareVectorizeVector;
-type VectorizeVectorMetadata = CloudflareVectorizeVectorMetadata;
-type VectorizeVectorMetadataValue = CloudflareVectorizeVectorMetadataValue;
-type VectorizeVectorMetadataFilter = CloudflareVectorizeVectorMetadataFilter;
-type VectorizeQueryOptions = CloudflareVectorizeQueryOptions;
-type VectorizeMatches = CloudflareVectorizeMatches;
-type VectorizeMatch = CloudflareVectorizeMatch;
-type VectorizeIndexInfo = CloudflareVectorizeIndexInfo;
-type VectorizeIndexDetails = CloudflareVectorizeIndexDetails;
-type VectorizeMutation = CloudflareVectorizeAsyncMutation | CloudflareVectorizeVectorMutation;
-type VectorizeValues = Float32Array | Float64Array | ReadonlyArray<number>;
-interface VectorizeClient {
-  readonly describe: Effect.Effect<VectorizeIndexInfo | VectorizeIndexDetails, VectorizeOperationError>;
-  readonly query: (vector: VectorizeValues, options?: VectorizeQueryOptions) => Effect.Effect<VectorizeMatches, VectorizeOperationError>;
-  readonly queryById: (vectorId: string, options?: VectorizeQueryOptions) => Effect.Effect<VectorizeMatches, VectorizeOperationError>;
-  readonly insert: (vectors: ReadonlyArray<VectorizeVector>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
-  readonly upsert: (vectors: ReadonlyArray<VectorizeVector>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
-  readonly deleteByIds: (ids: ReadonlyArray<string>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
-  readonly delete: (ids: ReadonlyArray<string>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
-  readonly getByIds: (ids: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<VectorizeVector>, VectorizeOperationError>;
-  readonly unsafeRaw: Effect.Effect<VectorizeBinding>;
-  readonly definition: VectorizeDefinition;
-}
-declare const VectorizeServiceTypeId: unique symbol;
-/** Nominal service marker for Vectorize services created with {@link make}. */
-interface VectorizeService<Id extends string> {
-  readonly [VectorizeServiceTypeId]: {
-    readonly id: Id;
-  };
-}
-type LayerOptions = {
-  readonly binding: string;
-};
-interface TagClass<Self, Id extends string> extends Context.ServiceClass<Self, Id, VectorizeClient> {
-  readonly id: Id;
-  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-}
-declare const isVectorizeBinding: (value: unknown) => value is VectorizeBinding;
-declare const makeClient: (definition: VectorizeDefinition) => (index: VectorizeBinding) => VectorizeClient;
-declare const layer: <Self>(tag: Context.Service<Self, VectorizeClient>, definition: VectorizeDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const make: <Id extends string>(id: Id) => TagClass<VectorizeService<Id>, Id>;
-declare const Tag$1: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 //#endregion
-export { AiGateway_d_exports as AiGateway, AnalyticsEngine_d_exports as AnalyticsEngine, Binding_d_exports as Binding, BrowserRendering_d_exports as BrowserRendering, Cache_d_exports as Cache, CloudflareOtlp_d_exports as CloudflareOtlp, ContainerNamespace_d_exports as ContainerNamespace, 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, DurableObjectSqlite_d_exports as DurableObjectSqlite, DurableObjectState_d_exports as DurableObjectState, DurableObjectStorage_d_exports as DurableObjectStorage, DurableObjectWebSocket_d_exports as DurableObjectWebSocket, Email_d_exports as Email, 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, Vectorize_d_exports as Vectorize, Worker_d_exports as Worker, WorkerConfig, WorkerDefinition_d_exports as WorkerDefinition, type WorkerEnv, WorkerEnvironment, WorkersAi_d_exports as WorkersAi, Workflow_d_exports as Workflow, WorkflowBinding_d_exports as WorkflowBinding, WorkflowDefinition_d_exports as WorkflowDefinition };
+export { AiGateway_d_exports as AiGateway, AnalyticsEngine_d_exports as AnalyticsEngine, Binding_d_exports as Binding, BrowserRendering_d_exports as BrowserRendering, Cache_d_exports as Cache, CloudflareOtlp_d_exports as CloudflareOtlp, ContainerNamespace_d_exports as ContainerNamespace, 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, DurableObjectSqlite_d_exports as DurableObjectSqlite, DurableObjectState_d_exports as DurableObjectState, DurableObjectStorage_d_exports as DurableObjectStorage, DurableObjectWebSocket_d_exports as DurableObjectWebSocket, Email_d_exports as Email, Environment_d_exports as Environment, 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, Vectorize_d_exports as Vectorize, Worker_d_exports as Worker, WorkerConfig, WorkerDefinition_d_exports as WorkerDefinition, type WorkerEnv, WorkerEnvironment, WorkersAi_d_exports as WorkersAi, Workflow_d_exports as Workflow, WorkflowBinding_d_exports as WorkflowBinding, WorkflowDefinition_d_exports as WorkflowDefinition };