effect-cf 0.23.1 → 0.25.0

package/dist/index.d.mts

@@ -1,16 +1,18 @@
-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 { a as Environment_d_exports, c as WorkerEnvironment, i as Binding_d_exports, n as BindingService, o as WorkerConfig, r as BindingValidationError, s as WorkerEnv, t as BindingNotFoundError } from "./Binding-DI7u3fEY.mjs";
+import { t as Hyperdrive_d_exports } from "./Hyperdrive-BwYp8Rsz.mjs";
+import { A as Rpc_d_exports, C as QueueBinding_d_exports, D as RpcDefinition_d_exports, E as ReservedMethodName$2, M as DurableWebSocket, N as DurableObjectStorage_d_exports, O as ServiceFreeSchema$1, P as StorageOperationError, S as QueueDefinition_d_exports, T as Method$2, _ as AsyncMethodArgs, a as WorkflowInstanceCreateOptions, b as AsyncMethodSuccess, c as DurableObjectState, d as ExecutionContext, f as NativeRequest, g as ServiceBinding_d_exports, h as WorkerDefinition_d_exports, i as WorkflowInstanceCreateBatchOptions, j as DurableObjectWebSocket_d_exports, k as Provider, m as Worker_d_exports, n as WorkflowBinding_d_exports, p as WorkerContext, r as WorkflowInstance, s as WorkflowOperationError, t as WorkflowBindingClient, u as DurableObjectState_d_exports, v as AsyncMethodCloudflareReturn, w as Definition$4, x as Queue_d_exports, y as AsyncMethodKey } from "./WorkflowBinding--eMVaixT.mjs";
+import { Config, Context, Data, DateTime, Duration, Effect, Layer, Option, Redacted, Schema, Scope } from "effect";
+import { Headers as Headers$1, HttpClient, HttpClientResponse } 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 { DurableObject, 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$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 };
+  export { LayerOptions$14 as LayerOptions, Tag$13 as Tag, TagClass$12 as TagClass, WorkersAiAsyncBatchResponse, WorkersAiBinding, WorkersAiClient, WorkersAiDefinition, WorkersAiEmbeddingInput, WorkersAiEmbeddingResponse, WorkersAiModelsSearchObject, WorkersAiModelsSearchParams, WorkersAiOperationError, WorkersAiOptions, WorkersAiService, embeddingResponse, isWorkersAiBinding, layer$14 as layer, make$13 as make, makeClient$11 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";
@@ -71,24 +73,24 @@ interface WorkersAiService<Id extends string> {
     readonly id: Id;
   };
 }
-type LayerOptions$17 = {
+type LayerOptions$14 = {
   readonly binding: string;
 };
-interface TagClass$15<Self, Id extends string, ModelList extends AiModelListType = AiModels> extends Context.ServiceClass<Self, Id, WorkersAiClient<ModelList>> {
+interface TagClass$12<Self, Id extends string, ModelList extends AiModelListType = AiModels> extends Context.ServiceClass<Self, Id, WorkersAiClient<ModelList>> {
   readonly id: Id;
-  readonly layer: (options: LayerOptions$17) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$14) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
 declare const isWorkersAiBinding: (value: unknown) => value is WorkersAiBinding;
 declare const embeddingResponse: (value: {
   readonly data?: ReadonlyArray<ReadonlyArray<number>>;
   readonly shape?: ReadonlyArray<number>;
 }) => 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$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 const makeClient$11: <ModelList extends AiModelListType = AiModels>(definition: WorkersAiDefinition) => (ai: WorkersAiBinding<ModelList>) => WorkersAiClient<ModelList>;
+declare const layer$14: <Self, ModelList extends AiModelListType = AiModels>(tag: Context.Service<Self, WorkersAiClient<ModelList>>, definition: WorkersAiDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make$13: <Id extends string>(id: Id) => TagClass$12<WorkersAiService<Id>, Id, AiModels>;
+declare const Tag$13: <Self>() => <Id extends string, ModelList extends AiModelListType = AiModels>(id: Id) => TagClass$12<Self, Id, ModelList>;
 declare namespace AiGateway_d_exports {
-  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 };
+  export { AiGatewayBinding, AiGatewayClient, AiGatewayDefinition, AiGatewayFetchOptions, AiGatewayHeaders, AiGatewayLog, AiGatewayOperationError, AiGatewayPatchLog, AiGatewayProvider, AiGatewayRunOptions, AiGatewayService, AiGatewayUniversalRequest, LayerOptions$13 as LayerOptions, Tag$12 as Tag, TagClass$11 as TagClass, isAiGatewayBinding, layer$13 as layer, make$12 as make, makeClient$10 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";
@@ -139,17 +141,17 @@ interface AiGatewayService<Id extends string> {
     readonly id: Id;
   };
 }
-type LayerOptions$16 = {
+type LayerOptions$13 = {
   readonly binding: string;
   readonly gatewayId: string;
   readonly accountId?: string;
 };
-interface TagClass$14<Self, Id extends string> extends Context.ServiceClass<Self, Id, AiGatewayClient> {
+interface TagClass$11<Self, Id extends string> extends Context.ServiceClass<Self, Id, AiGatewayClient> {
   readonly id: Id;
-  readonly layer: (options: LayerOptions$16) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError | AiGatewayOperationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$13) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError | AiGatewayOperationError, WorkerEnvironment>;
 }
 declare const isAiGatewayBinding: (value: unknown) => value is WorkersAiBinding;
-declare const makeClient$13: (definition: AiGatewayDefinition, gateway: AiGatewayBinding) => {
+declare const makeClient$10: (definition: AiGatewayDefinition, gateway: AiGatewayBinding) => {
   definition: AiGatewayDefinition;
   run: (data: import("@cloudflare/workers-types").AIGatewayUniversalRequest | readonly import("@cloudflare/workers-types").AIGatewayUniversalRequest[], options?: {
     gateway?: import("@cloudflare/workers-types").UniversalGatewayOptions;
@@ -167,11 +169,11 @@ declare const makeHttpClient: (definition: Omit<AiGatewayDefinition, "binding">
   readonly accountId: string;
   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$14<AiGatewayService<Id>, Id>;
-declare const Tag$15: <Self>() => <Id extends string>(id: Id) => TagClass$14<Self, Id>;
+declare const layer$13: <Self>(tag: Context.Service<Self, AiGatewayClient>, definition: AiGatewayDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make$12: <Id extends string>(id: Id) => TagClass$11<AiGatewayService<Id>, Id>;
+declare const Tag$12: <Self>() => <Id extends string>(id: Id) => TagClass$11<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$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 };
+  export { AnalyticsEngineBinding, AnalyticsEngineClient, AnalyticsEngineDataPoint, AnalyticsEngineDataPointSchema, AnalyticsEngineDefinition, AnalyticsEngineFieldValue, AnalyticsEngineFieldValueSchema, AnalyticsEngineInvalidWritePolicy, AnalyticsEngineOperationError, AnalyticsEngineQueryClient, AnalyticsEngineQueryColumn, AnalyticsEngineQueryDefinition, AnalyticsEngineQueryError, AnalyticsEngineQueryOptions, AnalyticsEngineQueryResult, AnalyticsEngineQueryRow, AnalyticsEngineQueryService, AnalyticsEngineService, AnalyticsEngineWriteError, AnalyticsEngineWriteOptions, AnalyticsEngineWritePolicy, AnalyticsEngineWriteValidationError, AnalyticsEngineWriteViolation, LayerOptions$12 as LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag$11 as Tag, TagClass$10 as TagClass, isAnalyticsEngineDataset, layer$12 as layer, layerFetch, layerFetchConfig, make$11 as make, makeClient$9 as makeClient, makeQuery, makeQueryClient, queryConfig, queryLayer, queryLayerConfig, writeLimits };
 }
 declare const writeLimits: {
   readonly maxBlobs: 20;
@@ -252,14 +254,7 @@ interface AnalyticsEngineWriteOptions {
    */
   readonly onInvalid?: AnalyticsEngineInvalidWritePolicy;
 }
-interface AnalyticsEngineWriteBatchOptions extends AnalyticsEngineWriteOptions {
-  /**
-   * Maximum points per native batch call. Values are clamped to Cloudflare's
-   * per-invocation limit.
-   */
-  readonly batchSize?: number;
-}
-type AnalyticsEngineWritePolicy = AnalyticsEngineWriteBatchOptions;
+type AnalyticsEngineWritePolicy = AnalyticsEngineWriteOptions;
 interface AnalyticsEngineQueryResult<Row = AnalyticsEngineQueryRow> {
   readonly meta: ReadonlyArray<AnalyticsEngineQueryColumn>;
   readonly data: ReadonlyArray<Row>;
@@ -279,9 +274,7 @@ interface AnalyticsEngineQueryOptions {
 }
 interface AnalyticsEngineClient {
   readonly writeDataPoint: (dataPoint?: AnalyticsEngineDataPoint, options?: AnalyticsEngineWriteOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
-  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 writeDataPoints: (dataPoints: ReadonlyArray<AnalyticsEngineDataPoint>, options?: AnalyticsEngineWriteOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
   readonly rawUnsafe: Effect.Effect<AnalyticsEngineBinding>;
   readonly definition: AnalyticsEngineDefinition;
 }
@@ -308,7 +301,7 @@ interface AnalyticsEngineQueryService<Id extends string> {
     readonly id: Id;
   };
 }
-type LayerOptions$15 = {
+type LayerOptions$12 = {
   readonly binding: string;
   readonly write?: AnalyticsEngineWritePolicy;
 };
@@ -317,9 +310,9 @@ type QueryConfigOptions = {
   readonly apiToken?: Config.Config<Redacted.Redacted<string>>;
   readonly apiBaseUrl?: Config.Config<string>;
 };
-interface TagClass$13<Self, Id extends string> extends Context.ServiceClass<Self, Id, AnalyticsEngineClient> {
+interface TagClass$10<Self, Id extends string> extends Context.ServiceClass<Self, Id, AnalyticsEngineClient> {
   readonly id: Id;
-  readonly layer: (options: LayerOptions$15) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$12) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
 interface QueryTagClass<Self, Id extends string> extends Context.ServiceClass<Self, Id, AnalyticsEngineQueryClient> {
   readonly id: Id;
@@ -330,7 +323,7 @@ interface QueryTagClass<Self, Id extends string> extends Context.ServiceClass<Se
 }
 declare const makeQueryClient: (definition: AnalyticsEngineQueryDefinition) => Effect.Effect<AnalyticsEngineQueryClient, never, HttpClient.HttpClient>;
 declare const isAnalyticsEngineDataset: (value: unknown) => value is AnalyticsEngineBinding;
-declare const makeClient$12: (definition: AnalyticsEngineDefinition, defaults?: AnalyticsEngineWritePolicy) => (dataset: AnalyticsEngineBinding) => AnalyticsEngineClient;
+declare const makeClient$9: (definition: AnalyticsEngineDefinition, defaults?: AnalyticsEngineWritePolicy) => (dataset: AnalyticsEngineBinding) => AnalyticsEngineClient;
 declare const queryConfig: (options?: QueryConfigOptions) => Config.Config<{
   accountId: string;
   apiToken: Redacted.Redacted<string>;
@@ -340,13 +333,13 @@ declare const queryLayer: <Self>(tag: Context.Service<Self, AnalyticsEngineQuery
 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 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 layer$12: <Self>(tag: Context.Service<Self, AnalyticsEngineClient>, definition: LayerOptions$12) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make$11: <Id extends string>(id: Id) => TagClass$10<AnalyticsEngineService<Id>, Id>;
 declare const makeQuery: <Id extends string>(id: Id) => QueryTagClass<AnalyticsEngineQueryService<Id>, Id>;
-declare const Tag$14: <Self>() => <Id extends string>(id: Id) => TagClass$13<Self, Id>;
+declare const Tag$11: <Self>() => <Id extends string>(id: Id) => TagClass$10<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$14 as LayerOptions, Tag$13 as Tag, TagClass$12 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$11 as LayerOptions, Tag$10 as Tag, TagClass$9 as TagClass, isBrowserRenderingBinding, layer$11 as layer, make$10 as make, makeClient$8 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";
@@ -412,20 +405,20 @@ interface BrowserRenderingService<Id extends string> {
     readonly id: Id;
   };
 }
-type LayerOptions$14 = {
+type LayerOptions$11 = {
   readonly binding: string;
 };
-interface TagClass$12<Self, Id extends string> extends Context.ServiceClass<Self, Id, BrowserRenderingClient> {
+interface TagClass$9<Self, Id extends string> extends Context.ServiceClass<Self, Id, BrowserRenderingClient> {
   readonly id: Id;
-  readonly layer: (options: LayerOptions$14) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$11) => 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$12<BrowserRenderingService<Id>, Id>;
-declare const Tag$13: <Self>() => <Id extends string>(id: Id) => TagClass$12<Self, Id>;
+declare const makeClient$8: <RawBinding extends BrowserRenderingBinding = BrowserRenderingBinding>(definition: BrowserRenderingDefinition) => (binding: RawBinding) => BrowserRenderingClient<RawBinding>;
+declare const layer$11: <Self>(tag: Context.Service<Self, BrowserRenderingClient>, definition: BrowserRenderingDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make$10: <Id extends string>(id: Id) => TagClass$9<BrowserRenderingService<Id>, Id>;
+declare const Tag$10: <Self>() => <Id extends string>(id: Id) => TagClass$9<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 };
+  export { CacheClient, CacheOperation, CacheOperationError, CacheQueryOptions, CacheRequest, CacheStorage, CacheStorageClient, layer$10 as layer, layerFrom, makeCacheClient, makeClient$7 as makeClient };
 }
 /** Request key accepted by Cloudflare's Cache API. */
 type CacheRequest = CloudflareRequestInfo | URL;
@@ -472,1014 +465,13 @@ declare class CacheStorage extends CacheStorage_base {}
 /** Wraps a native Cloudflare `Cache` instance. */
 declare const makeCacheClient: (cache: CloudflareCache, name?: string) => CacheClient;
 /** Wraps a native Cloudflare `CacheStorage` instance. */
-declare const makeClient$10: (storage: CloudflareCacheStorage) => CacheStorageClient;
+declare const makeClient$7: (storage: CloudflareCacheStorage) => CacheStorageClient;
 /** Provides Cache API services from an explicit native `CacheStorage` instance. */
 declare const layerFrom: (storage: CloudflareCacheStorage) => Layer.Layer<CacheStorage>;
 /** Provides Cache API services from Cloudflare's global `caches` object. */
-declare const layer$13: Layer.Layer<CacheStorage>;
-declare namespace DurableObjectStorage_d_exports {
-  export { DurableObjectStorage, DurableObjectTransaction, SchemaBackedSyncKvStorage, SqlCursor, SqlStorage, SqlStorageValue, StorageOperationError, SyncKvDefinition, SyncKvStorage, fromDurableObjectStorage };
-}
-/** Supported primitive value types for Durable Object SQL APIs. */
-type SqlStorageValue = globalThis.SqlStorageValue;
-declare const StorageOperationError_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: "StorageOperationError";
-} & Readonly<A>;
-/** Error type used when a storage operation throws or rejects. */
-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.
- */
-interface SqlCursor<T extends Record<string, SqlStorageValue>> {
-  next(): StorageEffect<{
-    done?: false;
-    value: T;
-  } | {
-    done: true;
-    value?: never;
-  }>;
-  toArray(): StorageEffect<Array<T>>;
-  one(): StorageEffect<T>;
-  raw<U extends Array<SqlStorageValue>>(): StorageEffect<IterableIterator<U>>;
-  readonly columnNames: Array<string>;
-  readonly rowsRead: StorageEffect<number>;
-  readonly rowsWritten: StorageEffect<number>;
-}
-/**
- * Effect wrapper for Durable Object SQLite APIs.
- */
-interface SqlStorage {
-  /** Executes a SQL statement and returns a typed cursor. */
-  exec<T extends Record<string, SqlStorageValue>>(query: string, ...bindings: Array<SqlStorageValue>): StorageEffect<SqlCursor<T>>;
-  readonly databaseSize: number;
-}
-/**
- * Schema pair used by `SyncKvStorage.schema(...)`.
- */
-interface SyncKvDefinition<Key, Value, EncodedValue> {
-  readonly key: Schema.Codec<Key, string>;
-  readonly value: Schema.Codec<Value, EncodedValue>;
-}
-/**
- * Sync KV wrapper that transparently encodes keys/values through Effect Schema.
- */
-interface SchemaBackedSyncKvStorage<Key, Value> {
-  get(key: Key): Effect.Effect<Option.Option<Value>, unknown>;
-  put(key: Key, value: Value): Effect.Effect<void, unknown>;
-  delete(key: Key): Effect.Effect<boolean, unknown>;
-  list(options?: globalThis.SyncKvListOptions): Effect.Effect<Array<[Key, Value]>, unknown>;
-}
-/**
- * Effect wrapper for synchronous KV attached to Durable Object SQLite storage.
- */
-interface SyncKvStorage {
-  get<T = unknown>(key: string): StorageEffect<T | undefined>;
-  put<T>(key: string, value: T): StorageEffect<void>;
-  delete(key: string): StorageEffect<boolean>;
-  list<T = unknown>(options?: globalThis.SyncKvListOptions): StorageEffect<Array<[string, T]>>;
-  schema<Key, Value, EncodedValue>(definition: SyncKvDefinition<Key, Value, EncodedValue>): SchemaBackedSyncKvStorage<Key, Value>;
-}
-/**
- * Effect wrapper around Cloudflare transaction callbacks.
- */
-interface DurableObjectTransaction {
-  get<T = unknown>(key: string, options?: globalThis.DurableObjectGetOptions): StorageEffect<T | undefined>;
-  get<T = unknown>(keys: Array<string>, options?: globalThis.DurableObjectGetOptions): StorageEffect<Map<string, T>>;
-  list<T = unknown>(options?: globalThis.DurableObjectListOptions): StorageEffect<Map<string, T>>;
-  put<T>(key: string, value: T, options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
-  put<T>(entries: Record<string, T>, options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
-  delete(key: string, options?: globalThis.DurableObjectPutOptions): StorageEffect<boolean>;
-  delete(keys: Array<string>, options?: globalThis.DurableObjectPutOptions): StorageEffect<number>;
-  rollback(): StorageEffect<void>;
-  getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
-  setAlarm(scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-  deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-}
-/**
- * Effect wrapper around Cloudflare Durable Object storage.
- *
- * @example
- * ```ts
- * const program = Effect.gen(function* () {
- *   const state = yield* DurableObjectState;
- *   yield* state.storage.put("counter", 1);
- *   const value = yield* state.storage.get<number>("counter");
- *   return value;
- * });
- * ```
- */
-interface DurableObjectStorage {
-  get<T = unknown>(key: string, options?: globalThis.DurableObjectGetOptions): StorageEffect<T | undefined>;
-  put<T>(key: string, value: T, options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
-  delete(key: string, options?: globalThis.DurableObjectPutOptions): StorageEffect<boolean>;
-  /**
-   * Deletes all stored data. On compatibility dates before 2026-02-24, Cloudflare
-   * documents that active alarms must be deleted separately with `deleteAlarm()`.
-   */
-  deleteAll(options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
-  getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
-  setAlarm(scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-  deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-  /**
-   * SQLite-backed Durable Object storage only.
-   *
-   * The callback Effect must complete synchronously. If it requires asynchronous
-   * work, use `transaction` instead so Cloudflare can run the async transaction
-   * callback under the platform's transaction contract.
-   */
-  transactionSync<A, E, R>(closure: () => Effect.Effect<A, E, R>): Effect.Effect<A, E | StorageOperationError, R>;
-  /**
-   * Runs an async transaction and exposes a typed transaction wrapper.
-   */
-  transaction<A, E, R>(closure: (txn: DurableObjectTransaction) => Effect.Effect<A, E, R>): Effect.Effect<A, E | StorageOperationError, R>;
-  /** Flushes pending writes to disk. */
-  sync(): StorageEffect<void>;
-  /** SQLite-backed Durable Object storage point-in-time recovery API only. */
-  getCurrentBookmark(): StorageEffect<string>;
-  /** SQLite-backed Durable Object storage point-in-time recovery API only. */
-  onNextSessionRestoreBookmark(bookmark: string): StorageEffect<string>;
-  readonly sql: SqlStorage;
-  readonly kv: SyncKvStorage;
-}
-/**
- * Wraps native Cloudflare storage APIs as Effect-returning helpers.
- */
-declare const fromDurableObjectStorage: (storage: globalThis.DurableObjectStorage) => DurableObjectStorage;
-declare namespace DurableObjectWebSocket_d_exports {
-  export { AcceptUpgradeOptions, AcceptedUpgrade, AttachmentInvalidPolicy, AttachmentRehydrateOptions, DurableWebSocket, DurableWebSocketAttachment, DurableWebSocketAttachmentError, DurableWebSocketCloseError, DurableWebSocketHandlers, DurableWebSocketSendData, DurableWebSocketSendError, RehydratedDurableWebSocket, acceptUpgrade, attachment, fromWebSocket, handlers };
-}
-/** Data supported by Cloudflare websocket `send`. */
-type DurableWebSocketSendData = string | ArrayBuffer | ArrayBufferView;
-declare const DurableWebSocketSendError_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: "DurableWebSocketSendError";
-} & Readonly<A>;
-/** 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>;
-/** Error raised when serializing or deserializing a websocket attachment fails. */
-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. */
-  readonly raw: WebSocket;
-  /** Sends a message through the socket. */
-  send(data: DurableWebSocketSendData): Effect.Effect<void, DurableWebSocketSendError>;
-  /** Closes the socket. */
-  close(code?: number, reason?: string): Effect.Effect<void, DurableWebSocketCloseError>;
-  /** Serializes hibernation attachment metadata onto the socket. */
-  serializeAttachment<A = Attachment>(value: A): Effect.Effect<void, DurableWebSocketAttachmentError>;
-  /** Deserializes hibernation attachment metadata from the socket. */
-  readonly deserializeAttachment: Effect.Effect<unknown, DurableWebSocketAttachmentError>;
-}
-/** Wraps a native Cloudflare websocket in the Effect-native Durable Object API. */
-declare const fromWebSocket: <Attachment = unknown>(raw: WebSocket) => DurableWebSocket<Attachment>;
-/**
- * Options for accepting an incoming websocket request in a Durable Object.
- */
-interface AcceptUpgradeOptions<Attachment = unknown> {
-  /** Optional websocket tags for Durable Object hibernation filtering. */
-  readonly tags?: ReadonlyArray<string> | undefined;
-  /** Optional attachment serialized onto the server socket. */
-  readonly attachment?: Attachment | undefined;
-}
-/**
- * Result of a websocket upgrade accepted by {@link acceptUpgrade}.
- */
-interface AcceptedUpgrade<Attachment = unknown> {
-  readonly client: WebSocket;
-  readonly server: DurableWebSocket<Attachment>;
-  readonly response: Response;
-}
-/**
- * Accepts a websocket upgrade and registers the server socket on `DurableObjectState`.
- *
- * @example
- * ```ts
- * const response = yield* DurableObjectWebSocket.acceptUpgrade({
- *   tags: ["room:general"],
- * });
- *
- * return response.response;
- * ```
- */
-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. */
-  readonly tag?: string | undefined;
-  /** Invalid attachment behavior. Defaults to skipping invalid sockets. */
-  readonly onInvalid?: AttachmentInvalidPolicy | undefined;
-}
-interface RehydratedDurableWebSocket<Attachment> {
-  readonly socket: DurableWebSocket<Attachment>;
-  readonly attachment: Attachment;
-}
-interface DurableWebSocketAttachment<Attachment, Encoded> {
-  serialize(socket: DurableWebSocket<unknown>, value: Attachment): Effect.Effect<void, DurableWebSocketAttachmentError>;
-  deserialize(socket: DurableWebSocket<unknown>): Effect.Effect<Option.Option<Attachment>, DurableWebSocketAttachmentError>;
-  rehydrate(options?: AttachmentRehydrateOptions): Effect.Effect<Array<RehydratedDurableWebSocket<Attachment>>, DurableWebSocketAttachmentError, DurableObjectState>;
-  readonly schema: Schema.Codec<Attachment, Encoded, never, never>;
-}
-/** Creates typed attachment helpers for accepted and rehydrated sockets. */
-declare const attachment: <const AttachmentSchema extends Schema.Codec<any, any, never, never>>(schema: AttachmentSchema) => DurableWebSocketAttachment<Schema.Schema.Type<AttachmentSchema>, Schema.Codec.Encoded<AttachmentSchema>>;
-interface DurableWebSocketHandlers<R = never, E = unknown> {
-  readonly message?: (socket: DurableWebSocket, message: string | ArrayBuffer) => Effect.Effect<void, E, R>;
-  readonly close?: (socket: DurableWebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, E, R>;
-  readonly error?: (socket: DurableWebSocket, error: unknown) => Effect.Effect<void, E, R>;
-}
-/** Maps compact websocket lifecycle handler names to `DurableObject.make` options. */
-declare const handlers: <R = never, E = unknown>(options: DurableWebSocketHandlers<R, E>) => {
-  webSocketMessage: ((socket: DurableWebSocket, message: string | ArrayBuffer) => Effect.Effect<void, E, R>) | undefined;
-  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 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$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 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;
-}
-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;
-}
-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;
-}
-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 {};
-}
-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;
-}
-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>;
-}
-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;
-type QueueSendBatchOptions = CloudflareQueueSendBatchOptions;
-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$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$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 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";
-} & Readonly<A>;
-declare class QueueOperationError extends QueueOperationError_base<{
-  readonly binding: string;
-  readonly operation: string;
-  readonly cause: unknown;
-  readonly message: string;
-}> {}
-declare const isQueue: <Body>(value: unknown) => value is QueueProducer<Body>;
-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$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$6<Id extends string = string, Message extends ServiceFreeSchema$2 = ServiceFreeSchema$2> {
-  readonly id: Id;
-  readonly message: Message;
-}
-declare namespace Definition$6 {
-  type Any = Definition$6<string, ServiceFreeSchema$2>;
-}
-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$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$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 rawUnsafe: Effect.Effect<globalThis.Queue<Schema.Codec.Encoded<Message>>, never, Self>;
-}
-declare const make$12: <Id extends string, Message extends ServiceFreeSchema$2>(id: Id, definition: {
-  readonly message: Message;
-}) => 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$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$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>;
-  readonly id: string;
-  readonly timestamp: Date;
-  readonly body: Body;
-  readonly attempts: number;
-  readonly ack: Effect.Effect<void>;
-  readonly retry: (options?: globalThis.QueueRetryOptions) => Effect.Effect<void>;
-}
-interface QueueBatch<Body> {
-  readonly raw: globalThis.MessageBatch<unknown>;
-  readonly messages: ReadonlyArray<QueueMessage<Body>>;
-  readonly queue: string;
-  readonly metadata: globalThis.MessageBatchMetadata;
-  readonly ackAll: Effect.Effect<void>;
-  readonly retryAll: (options?: globalThis.QueueRetryOptions) => Effect.Effect<void>;
-}
-declare const QueueMessageDecodeError_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: "QueueMessageDecodeError";
-} & Readonly<A>;
-declare class QueueMessageDecodeError extends QueueMessageDecodeError_base<{
-  readonly queue: string;
-  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>>;
-interface QueueOptions<ROut, Body = unknown> {
-  readonly queue: QueueHandler<ROut, Body>;
-}
-declare const fromMessage: <Body>(message: globalThis.Message<unknown>, body: Body) => {
-  raw: Message<unknown>;
-  id: string;
-  timestamp: Date;
-  body: Body;
-  attempts: number;
-  ack: Effect.Effect<void, never, never>;
-  retry: (options?: globalThis.QueueRetryOptions) => Effect.Effect<void, never, never>;
-};
-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$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$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$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 };
-}
-declare const TypeId$2: "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$3 | "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$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$4.Any | undefined = undefined> {
-  /** Binding name as configured in `wrangler.jsonc`. */
-  readonly binding: string;
-  /** Optional RPC schema used for argument/result encoding. */
-  readonly definition?: Definition;
-}
-declare const ServiceBindingFetchError_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: "ServiceBindingFetchError";
-} & Readonly<A>;
-/**
- * Failure raised when calling `fetch` on a service binding.
- */
-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>;
-/**
- * Failure raised when invoking an RPC method on a service binding.
- */
-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$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.
-   *
-   * Use this when the service binding is acting as an HTTP origin rather than a
-   * Cloudflare RPC target.
-   *
-   * @example
-   * ```ts
-   * import { Effect } from "effect";
-   *
-   * const program = Effect.gen(function* () {
-   *   const api = yield* ApiWorker;
-   *   return yield* api.fetch(new Request("https://internal.example/users"));
-   * });
-   * ```
-   */
-  readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, ServiceBindingFetchError>;
-  /**
-   * Invokes a Worker RPC method and returns Cloudflare's raw RPC result.
-   *
-   * This preserves Cloudflare RPC behavior such as promise-like pipelining and
-   * transferable / disposable result objects. It does not resolve the returned
-   * promise-like value and it does not decode definition-backed success schemas.
-   *
-   * Most application code should use {@link call} instead.
-   *
-   * @example
-   * ```ts
-   * import { Effect } from "effect";
-   *
-   * const program = Effect.gen(function* () {
-   *   const counter = yield* CounterService;
-   *
-   *   const result = yield* counter.rpc("increment", 41);
-   *   const value = yield* Effect.promise(() => result);
-   *
-   *   return value;
-   * });
-   * ```
-   */
-  readonly rpc: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodCloudflareReturn<Api, Method>, ServiceBindingRpcError>;
-  /**
-   * Invokes a Worker RPC method, resolves Cloudflare's RPC result, and decodes
-   * the success value when the binding was created from a definition.
-   *
-   * This is the normal choice when application code wants the final typed value.
-   *
-   * @example
-   * ```ts
-   * import { Effect } from "effect";
-   *
-   * const program = Effect.gen(function* () {
-   *   const counter = yield* CounterService;
-   *   const value = yield* counter.call("increment", 41);
-   *
-   *   return value;
-   * });
-   * ```
-   */
-  readonly call: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError>;
-  /**
-   * Invokes a Worker RPC method in the current `Scope`, resolves Cloudflare's RPC
-   * result, decodes definition-backed success values, and disposes the resolved
-   * result when the scope closes if it implements `Symbol.dispose`.
-   *
-   * Use this for RPC methods that return Cloudflare RPC resources or other
-   * disposable objects whose lifetime should be tied to an Effect scope.
-   *
-   * @example
-   * ```ts
-   * import { Effect } from "effect";
-   *
-   * const program = Effect.scoped(
-   *   Effect.gen(function* () {
-   *     const files = yield* FileService;
-   *     const handle = yield* files.scopedCall("open", "report.csv");
-   *
-   *     return yield* handle.read();
-   *   }),
-   * );
-   * ```
-   */
-  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$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$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.
- *
- * Returned value includes:
- * - a Context tag for dependency injection
- * - `fetch(...)` for raw HTTP forwarding
- * - `rpc(...)` for raw Cloudflare RPC results
- * - `call(...)` for resolved and decoded RPC results
- * - `scopedCall(...)` for scoped and decoded disposable RPC results
- * - direct RPC methods when `definition` is provided
- *
- * @example
- * ```ts
- * const Counter = WorkerDefinition.make("Counter", {
- *   increment: WorkerDefinition.method({
- *     args: [Schema.Number],
- *     success: Schema.Number,
- *   }),
- * });
- *
- * const CounterLive = Counter.layer({ binding: "COUNTER" });
- *
- * const program = Effect.gen(function* () {
- *   const counter = yield* Counter;
- *   const next = yield* counter.increment(1);
- *   return next;
- * });
- * ```
- */
-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: 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>;
-};
-/**
- * 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$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>;
-  waitUntilPropagating<A, E, R, R2 = never>(effect: Effect.Effect<A, E, R>, options?: Omit<WorkerContextWaitUntilOptions<E, R2>, "mode">): Effect.Effect<void, never, R | R2>;
-  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$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$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.
-   *
-   * The layer is built inside the event's Effect scope and finalized when the
-   * event effect completes. Use this for event-scoped resources such as OTLP
-   * 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>;
-}
-/**
- * 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>;
-declare namespace DurableObjectState_d_exports {
-  export { DurableObjectState, DurableObjectStateService, fromDurableObjectState };
-}
-/**
- * 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>;
-}
-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 const layer$10: Layer.Layer<CacheStorage>;
 declare namespace CloudflareOtlp_d_exports {
-  export { DurableObjectLayerOptions, LayerOptions$10 as LayerOptions, ResourceOptions, Serialization, Signal, WorkerLayerOptions, layer$10 as layer, layerDurableObject, layerJson, layerProtobuf, layerWorker };
+  export { DurableObjectLayerOptions, LayerOptions$10 as LayerOptions, ResourceOptions, Serialization, Signal, WorkerLayerOptions, layer$9 as layer, layerDurableObject, layerJson, layerProtobuf, layerWorker };
 }
 /** Telemetry signal groups supported by the Cloudflare OTLP layers. */
 type Signal = "logs" | "traces" | "metrics";
@@ -1556,7 +548,7 @@ interface DurableObjectLayerOptions extends LayerOptions$10 {
  * 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>;
+declare const layer$9: (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. */
@@ -1577,7 +569,7 @@ declare const layerWorker: (options?: WorkerLayerOptions) => Layer.Layer<OtlpExp
  */
 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 };
+  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$8 as layer, make$9 as make, makeClient$6 as makeClient };
 }
 /** Named signal accepted by Cloudflare Container instances. */
 type ContainerSignal = "SIGKILL" | "SIGINT" | "SIGTERM";
@@ -1714,8 +706,8 @@ interface TagClass$8<Self, Id extends string, Namespace extends ContainerNamespa
   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 makeClient$6: (definition: ContainerNamespaceDefinition) => <Namespace extends ContainerNamespaceResource>(namespace: Namespace) => ContainerNamespaceClient<Namespace>;
+declare const layer$8: <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}. */
@@ -1775,7 +767,7 @@ declare const Service: <Self>() => <Id extends string>(id: Id, definition: D1Def
   sqlLayer: (options?: D1SqlLayerOptions) => Layer.Layer<D1Client.D1Client | SqlClient.SqlClient, Config.ConfigError | BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
 declare namespace DurableObjectNamespace_d_exports {
-  export { DurableObjectFetchError, DurableObjectNamespaceBindingDefinition, DurableObjectNamespaceClient, DurableObjectNamespaceDefinition, DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient, DurableObjectRpcError, DurableObjectStubClient, isDurableObjectNamespaceClient, layer$8 as layer, makeClient$6 as makeClient, makeDirectMethods };
+  export { DurableObjectFetchError, DurableObjectNamespaceBindingDefinition, DurableObjectNamespaceClient, DurableObjectNamespaceDefinition, DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient, DurableObjectRpcError, DurableObjectStubClient, isDurableObjectNamespaceClient, layer$7 as layer, makeClient$5 as makeClient, makeDirectMethods };
 }
 interface DurableObjectFetcher {
   fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
@@ -1851,10 +843,10 @@ 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$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 DefinitionNamespaceDirectMethods<R, Api extends object, Definition extends Definition$3.Any> = { readonly [Method in Definition$4.MethodNames<Definition>]: (stub: DurableObjectStubClient<Api>, ...args: Method$2.Args<Definition["methods"][Method]>) => Effect.Effect<Method$2.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$7.MethodNames<Definition>]: (...args: Method$3.Args<Definition["methods"][Method]>) => Effect.Effect<Method$3.Success<Definition["methods"][Method]>, DurableObjectRpcError, R>; };
+} & { readonly [Method in Definition$4.MethodNames<Definition>]: (...args: Method$2.Args<Definition["methods"][Method]>) => Effect.Effect<Method$2.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>;
@@ -1983,8 +975,8 @@ type DurableObjectNamespaceStaticClient<R, Api extends object, Definition extend
   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$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 makeClient$5: <Api extends object, const Definition extends Definition$3.Any | undefined = undefined>(definition: DurableObjectNamespaceBindingDefinition<Definition>) => ((namespace: DurableObjectNamespaceClient<Api>) => DurableObjectNamespaceEffectClient<Api, Definition>);
+declare const layer$7: <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>;
@@ -1992,7 +984,7 @@ declare const makeDirectMethods: <R, Api extends object, Definition extends Defi
   readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
 }) => DirectMethods<R, Api, Definition>;
 declare namespace DurableObjectDefinition_d_exports {
-  export { Api, 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 };
+  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, ServiceFreeSchema, Tag$8 as Tag, TagClass$7 as TagClass, implement$2 as implement, make$7 as make, method };
 }
 type ServiceFreeSchema = Schema.Codec<any, any, never, never>;
 interface Method$1<Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema = ServiceFreeSchema> {
@@ -2021,13 +1013,13 @@ interface Definition$3<Id extends string = string, MethodsShape extends Methods
 declare namespace Definition$3 {
   type Any = Definition$3<string, Methods>;
 }
-type ReservedMethodName = ReservedMethodName$5 | "fetch" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError";
+type ReservedMethodName = ReservedMethodName$2 | "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$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 ServerApi<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<Self>, ReservedMethodName>;
 /**
  * Effect handlers for each RPC method in a Durable Object definition.
  */
@@ -2071,7 +1063,7 @@ declare const implement$2: <ROut, const Self extends Definition$3.Any>(_definiti
  */
 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, 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, 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;
@@ -2133,7 +1125,7 @@ type DurableObjectClass<Rpc extends DurableObjectRpc<ROut>, ROut> = new (state:
  */
 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>;
 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 };
+  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, processDue };
 }
 /**
  * JSON-serializable alarm payload stored with each scheduled alarm.
@@ -2395,7 +1387,6 @@ type AlarmScheduler = {
   readonly scheduleAlarm: (input: ScheduleAlarmInput) => Effect.Effect<void, InvalidAlarmPayloadError | InvalidAlarmRefError | InvalidRepeatEveryError | StorageOperationError>;
 };
 declare const processDue: <R = never, E = never, OnFailureR = never, OnFailureE = never>(handle: ProcessDueAlarmsHandler<R, E>, options?: ProcessDueAlarmsOptions<OnFailureR, OnFailureE>) => Effect.Effect<ProcessDueAlarmsResult, E | OnFailureE | DurableObjectAlarmError, OnFailureR | R | DurableObjectAlarm>;
-declare const process: typeof processDue;
 type AlarmPayloadSchema = Schema.Codec<any, any, never, never>;
 type AlarmFailurePolicy = "ordered" | "retry" | "skip-and-advance-repeat";
 interface AlarmRetryPolicy {
@@ -2467,7 +1458,7 @@ declare class DurableObjectAlarm extends DurableObjectAlarm_base {
   static readonly layer: Layer.Layer<DurableObjectAlarm, never, DurableObjectState>;
 }
 declare namespace DurableObjectRpcWebSocket_d_exports {
-  export { DurableObjectRpcWebSocket, DurableObjectRpcWebSocketService, LayerOptions$7 as LayerOptions, NativeWebSocketMessage, layer$7 as layer };
+  export { DurableObjectRpcWebSocket, DurableObjectRpcWebSocketService, LayerOptions$7 as LayerOptions, NativeWebSocketMessage, layer$6 as layer };
 }
 /**
  * Configuration for {@link layer}.
@@ -2497,9 +1488,9 @@ 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<RpcServer.Protocol | DurableObjectRpcWebSocket, never, DurableObjectState | RpcSerialization.RpcSerialization>;
+declare const layer$6: (options?: LayerOptions$7) => Layer.Layer<RpcServer.Protocol | DurableObjectRpcWebSocket, never, DurableObjectState | RpcSerialization.RpcSerialization>;
 declare namespace DurableObjectSqlite_d_exports {
-  export { SqliteLayerOptions, layer$6 as layer };
+  export { SqliteLayerOptions, layer$5 as layer };
 }
 /** Options forwarded to `@effect/sql-sqlite-do` when building a SQL client layer. */
 type SqliteLayerOptions = Omit<SqliteClient.SqliteClientConfig, "db" | "storage">;
@@ -2514,9 +1505,9 @@ type SqliteLayerOptions = Omit<SqliteClient.SqliteClientConfig, "db" | "storage"
  * );
  * ```
  */
-declare const layer$6: (options?: SqliteLayerOptions) => Layer.Layer<SqliteClient.SqliteClient | SqlClient.SqlClient, never, DurableObjectState>;
+declare const layer$5: (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 };
+  export { EmailAddress, EmailAttachment, EmailBinding, EmailClient, EmailDefinition, EmailErrorCode, EmailMessageBuilder, EmailOperationError, EmailRecipients, EmailSendError, EmailSendOptions, EmailSendResult, EmailService, EmailValidationError, EmailViolation, LayerOptions$6 as LayerOptions, Tag$7 as Tag, TagClass$6 as TagClass, emailErrorCodes, isEmailBinding, layer$4 as layer, make$5 as make, makeClient$4 as makeClient, sendLimits, validateMessage };
 }
 /** Documented Cloudflare Email Sending limits. */
 declare const sendLimits: {
@@ -2586,9 +1577,7 @@ interface EmailDefinition {
 }
 type EmailAddress = CloudflareEmailAddress;
 type EmailAttachment = CloudflareEmailAttachment;
-type EmailMessage = CloudflareEmailMessage;
 type EmailMessageBuilder = Parameters<CloudflareSendEmail["send"]>[0];
-type EmailSendInput = EmailMessage | EmailMessageBuilder;
 type EmailSendResult = CloudflareEmailSendResult;
 type EmailBinding = CloudflareSendEmail;
 type EmailRecipients = string | EmailAddress | ReadonlyArray<string | EmailAddress>;
@@ -2598,10 +1587,7 @@ interface EmailSendOptions {
   readonly validate?: boolean;
 }
 interface EmailClient {
-  readonly send: {
-    (message: EmailMessage): Effect.Effect<EmailSendResult, EmailSendError>;
-    (builder: EmailMessageBuilder): Effect.Effect<EmailSendResult, EmailSendError>;
-  };
+  readonly send: (message: EmailMessageBuilder) => Effect.Effect<EmailSendResult, EmailSendError>;
   readonly rawUnsafe: Effect.Effect<EmailBinding>;
   readonly definition: EmailDefinition;
 }
@@ -2620,11 +1606,6 @@ interface TagClass$6<Self, Id extends string> extends Context.ServiceClass<Self,
   readonly id: Id;
   readonly layer: (options: LayerOptions$6) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
-/**
- * Distinguishes structured Email Sending messages from raw MIME `EmailMessage`
- * values, which only carry envelope `from` and `to` addresses.
- */
-declare const isEmailMessageBuilder: (message: EmailSendInput) => message is EmailMessageBuilder;
 /**
  * Validates a structured message against documented Cloudflare Email Sending
  * limits and returns every violation found. Total message size is not checked
@@ -2632,12 +1613,12 @@ declare const isEmailMessageBuilder: (message: EmailSendInput) => message is Ema
  */
 declare const validateMessage: (message: EmailMessageBuilder) => ReadonlyArray<EmailViolation>;
 declare const isEmailBinding: (value: unknown) => value is EmailBinding;
-declare const makeClient$5: (definition: EmailDefinition, options?: EmailSendOptions) => (email: EmailBinding) => EmailClient;
-declare const layer$5: <Self>(tag: Context.Service<Self, EmailClient>, definition: LayerOptions$6) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const makeClient$4: (definition: EmailDefinition, options?: EmailSendOptions) => (email: EmailBinding) => EmailClient;
+declare const layer$4: <Self>(tag: Context.Service<Self, EmailClient>, definition: LayerOptions$6) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 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, TypeId, 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$3 as layer, make$4 as make, makeClient$3 as makeClient, transform };
 }
 declare const TypeId: "~effect-cf/Images/Steps";
 type TypeId = typeof TypeId;
@@ -2806,12 +1787,12 @@ declare const draw: {
   (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 makeClient$3: (definition: ImagesDefinition) => (images: ImagesRuntimeBinding) => ImagesClient;
+declare const layer$3: <Self>(tag: Context.Service<Self, ImagesClient>, definition: ImagesDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const make$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, 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 };
+  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$2 as layer, makeClient$2 as makeClient };
 }
 /** KV operation represented by {@link KvOperationError}. */
 type KvOperation = "put" | "get" | "getWithMetadata" | "list" | "delete";
@@ -2894,14 +1875,14 @@ interface TagClass$4<Self, Id extends string, Key, Value, EncodedValue> extends
   readonly layer: (options: LayerOptions$4) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
 declare const isKvNamespace: (value: unknown) => value is KVNamespace;
-declare const makeClient$3: <Key, Value, EncodedValue>(definition: KvDefinition<Key, Value, EncodedValue>) => ((kv: KVNamespace) => KvClient<Key, Value, EncodedValue>);
-declare const layer$3: <Self, Key, Value, EncodedValue>(tag: Context.Service<Self, KvClient<Key, Value, EncodedValue>>, definition: KvDefinition<Key, Value, EncodedValue>) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const makeClient$2: <Key, Value, EncodedValue>(definition: KvDefinition<Key, Value, EncodedValue>) => ((kv: KVNamespace) => KvClient<Key, Value, EncodedValue>);
+declare const layer$2: <Self, Key, Value, EncodedValue>(tag: Context.Service<Self, KvClient<Key, Value, EncodedValue>>, definition: KvDefinition<Key, Value, EncodedValue>) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const Tag$5: <Self>() => <Id extends string, Key, Value, EncodedValue>(id: Id, definition: {
   readonly key: Schema.Codec<Key, string>;
   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, 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 };
+  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$1 as layer, make$3 as make, makeClient$1 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";
@@ -2980,12 +1961,12 @@ interface TagClass$3<Self, Id extends string> extends Context.ServiceClass<Self,
   readonly layer: (options: LayerOptions$3) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
 declare const isR2Bucket: (value: unknown) => value is CloudflareR2Bucket;
-declare const makeClient$2: (definition: R2Definition) => ((bucket: CloudflareR2Bucket) => R2Client);
-declare const layer$2: <Self>(tag: Context.Service<Self, R2Client>, definition: R2Definition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const makeClient$1: (definition: R2Definition) => ((bucket: CloudflareR2Bucket) => R2Client);
+declare const layer$1: <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 };
+  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, make$2 as make, makeClient };
 }
 /** Vectorize operation represented by {@link VectorizeOperationError}. */
 type VectorizeOperation = "describe" | "query" | "queryById" | "insert" | "upsert" | "deleteByIds" | "getByIds";
@@ -3044,94 +2025,20 @@ interface TagClass$2<Self, Id extends string> extends Context.ServiceClass<Self,
   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 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$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, makeClient };
-}
-type WorkflowInstanceCreateOptions<Payload> = Omit<CloudflareWorkflowInstanceCreateOptions<Payload>, "params">;
-type WorkflowInstanceCreateBatchOptions<Payload, EncodedPayload = unknown> = ReadonlyArray<{
-  readonly payload: Payload;
-} & WorkflowInstanceCreateOptions<EncodedPayload>>;
-interface WorkflowInstanceRestartOptions {
-  readonly from?: {
-    readonly name?: string;
-    readonly count?: number;
-    readonly type?: string;
-  };
-}
-type WorkflowInstanceStatusName = CloudflareInstanceStatus["status"];
-interface WorkflowInstanceStatus<Result> {
-  readonly status: WorkflowInstanceStatusName;
-  readonly output: Option.Option<Result>;
-  readonly error: Option.Option<{
-    readonly name: string;
-    readonly message: string;
-  }>;
-}
-interface WorkflowInstance<Result> {
-  readonly raw: CloudflareWorkflowInstance;
-  readonly id: string;
-  readonly pause: Effect.Effect<void, WorkflowOperationError>;
-  readonly resume: Effect.Effect<void, WorkflowOperationError>;
-  readonly terminate: Effect.Effect<void, WorkflowOperationError>;
-  readonly restart: (options?: WorkflowInstanceRestartOptions) => Effect.Effect<void, WorkflowOperationError>;
-  readonly status: Effect.Effect<WorkflowInstanceStatus<Result>, WorkflowOperationError | WorkflowResultDecodeError>;
-  readonly sendEvent: (event: WorkflowInstanceEvent) => Effect.Effect<void, WorkflowOperationError>;
-}
-interface WorkflowInstanceEvent {
-  readonly type: string;
-  readonly payload: unknown;
-}
-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`. */
-  readonly payload: Payload;
-  /** Codec used to decode completed workflow status output. */
-  readonly result: Result;
-}
-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 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";
-} & Readonly<A>;
-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>;
-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: <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$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$2 = ServiceFreeSchema$2, Result extends ServiceFreeSchema$2 = ServiceFreeSchema$2> {
+interface Definition$1<Id extends string = string, Payload extends ServiceFreeSchema$1 = ServiceFreeSchema$1, Result extends ServiceFreeSchema$1 = ServiceFreeSchema$1> {
   readonly id: Id;
   readonly payload: Payload;
   readonly result: Result;
 }
 declare namespace Definition$1 {
-  type Any = Definition$1<string, ServiceFreeSchema$2, ServiceFreeSchema$2>;
+  type Any = Definition$1<string, ServiceFreeSchema$1, ServiceFreeSchema$1>;
 }
 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> {
@@ -3140,7 +2047,7 @@ interface Options$1<ROut, Self extends Definition$1.Any> {
 type LayerOptions$1 = {
   readonly binding: string;
 };
-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>> {
+interface TagClass$1<Self, Id extends string, Payload extends ServiceFreeSchema$1, Result extends ServiceFreeSchema$1> extends Context.ServiceClass<Self, `effect-cf/Workflow/${Id}`, WorkflowBindingClient<Payload, Result>> {
   readonly id: Id;
   readonly payload: Payload;
   readonly result: Result;
@@ -3151,11 +2058,11 @@ interface TagClass$1<Self, Id extends string, Payload extends ServiceFreeSchema$
   readonly get: (instanceId: string) => Effect.Effect<WorkflowInstance<Schema.Schema.Type<Result>>, WorkflowOperationError, Self>;
   readonly rawUnsafe: Effect.Effect<globalThis.Workflow<Schema.Codec.Encoded<Payload>>, never, Self>;
 }
-declare const make$1: <Id extends string, Payload extends ServiceFreeSchema$2, Result extends ServiceFreeSchema$2>(id: Id, definition: {
+declare const make$1: <Id extends string, Payload extends ServiceFreeSchema$1, Result extends ServiceFreeSchema$1>(id: Id, definition: {
   readonly payload: Payload;
   readonly result: Result;
 }) => 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: {
+declare const Tag$2: <Self>() => <Id extends string, Payload extends ServiceFreeSchema$1, Result extends ServiceFreeSchema$1>(id: Id, definition: {
   readonly payload: Payload;
   readonly result: Result;
 }) => TagClass$1<Self, Id, Payload, Result>;