effect-cf 0.22.0 → 0.23.0

package/dist/index.d.mts

@@ -719,1029 +719,1061 @@ declare const handlers: <R = never, E = unknown>(options: DurableWebSocketHandle
   webSocketClose: ((socket: DurableWebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, E, R>) | undefined;
   webSocketError: ((socket: DurableWebSocket, error: unknown) => Effect.Effect<void, E, R>) | undefined;
 };
-declare namespace DurableObjectState_d_exports {
-  export { DurableObjectState, DurableObjectStateService, fromDurableObjectState };
+declare namespace Rpc_d_exports {
+  export { DisposableValue, MethodArgs, MethodKey, MethodReturn, Provider, Result$1 as Result, RpcStub, RpcTarget, Serializable, Stub, Stubable, Stubify, dispose, isDisposable, resolve, scoped };
 }
-/**
- * Effect-friendly wrapper around Cloudflare `DurableObjectState`.
- */
-interface DurableObjectStateService {
-  /** Underlying Cloudflare state instance. */
-  readonly raw: globalThis.DurableObjectState;
-  /** Durable Object id for the current instance. */
-  readonly id: globalThis.DurableObjectId;
-  /** Wrapped storage API. */
-  readonly storage: DurableObjectStorage;
-  /** Registers background work with Cloudflare's lifecycle. */
-  waitUntil(promise: Promise<unknown>): Effect.Effect<void>;
-  /**
-   * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate.
-   *
-   * Cloudflare resets a Durable Object if the callback throws/rejects, or if the
-   * callback exceeds the platform timeout (currently documented as 30 seconds).
-   * This safe default resolves the callback with the Effect `Exit` for typed
-   * Effect failures and resumes that `Exit` afterward, so typed failures remain
-   * ordinary Effect failures instead of resetting the Durable Object. Defects
-   * and interruptions still reject the callback.
-   */
-  blockConcurrencyWhile<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
-  /**
-   * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate and lets
-   * Effect failures reject the callback.
-   *
-   * Use this only when Cloudflare's reset-on-throw behavior is intentional. The
-   * platform also resets the Durable Object if the callback exceeds the
-   * documented timeout (currently 30 seconds).
-   */
-  blockConcurrencyWhileOrReset<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
-  /** Accepts a websocket connection for hibernation-capable Durable Objects. */
-  acceptWebSocket(ws: DurableWebSocket, tags?: Array<string>): Effect.Effect<void>;
-  /** Lists active sockets, optionally filtered by tag. */
-  getWebSockets(tag?: string): Effect.Effect<Array<DurableWebSocket>>;
-  /** Configures automatic request/response handling for sockets. */
-  setWebSocketAutoResponse(pair?: WebSocketRequestResponsePair): Effect.Effect<void>;
-  /** Gets the configured websocket auto-response pair. */
-  getWebSocketAutoResponse: Effect.Effect<WebSocketRequestResponsePair | null>;
-  /** Timestamp of the last automatic websocket response for a socket. */
-  getWebSocketAutoResponseTimestamp(ws: DurableWebSocket): Effect.Effect<Date | null>;
-  /** Sets the timeout for hibernatable websocket events. */
-  setHibernatableWebSocketEventTimeout(timeoutMs?: number): Effect.Effect<void>;
-  /** Gets the timeout for hibernatable websocket events. */
-  getHibernatableWebSocketEventTimeout: Effect.Effect<number | null>;
-  /** Reads tags attached to a websocket. */
-  getTags(ws: DurableWebSocket): Effect.Effect<Array<string>>;
-  /**
-   * Forcibly resets the Durable Object. Cloudflare logs an uncaught Error using
-   * the optional reason, and the method is not available in `wrangler dev` local
-   * development according to the Durable Object State docs.
-   */
-  abort(reason?: string): Effect.Effect<void>;
+type Stubable = Rpc.Stubable;
+type Stub<T extends Stubable> = Rpc.Stub<T>;
+type Provider<T extends object, Reserved extends string = never> = Rpc.Provider<T, Reserved>;
+type BaseType = void | undefined | null | boolean | number | bigint | string | TypedArray | ArrayBuffer | DataView | Date | Error | RegExp | ReadableStream<Uint8Array> | WritableStream<Uint8Array> | Request | Response | Headers;
+type Serializable<T> = BaseType | Map<T extends Map<infer Key, unknown> ? Serializable<Key> : never, T extends Map<unknown, infer Value> ? Serializable<Value> : never> | Set<T extends Set<infer Value> ? Serializable<Value> : never> | ReadonlyArray<T extends ReadonlyArray<infer Value> ? Serializable<Value> : never> | { [Key in keyof T]: Key extends number | string ? Serializable<T[Key]> : never; } | Stub<Stubable> | Stubable;
+type Stubify<T> = T extends Stubable ? Stub<T> : T extends Map<infer Key, infer Value> ? Map<Stubify<Key>, Stubify<Value>> : T extends Set<infer Value> ? Set<Stubify<Value>> : T extends Array<infer Value> ? Array<Stubify<Value>> : T extends ReadonlyArray<infer Value> ? ReadonlyArray<Stubify<Value>> : T extends BaseType ? T : T extends {
+  [key: string | number]: unknown;
+} ? { [Key in keyof T]: Stubify<T[Key]>; } : T;
+type MaybeProvider<T> = T extends object ? Provider<T> : unknown;
+type MaybeDisposable<T> = T extends object ? Disposable : unknown;
+type Result$1<T> = T extends Stubable ? Promise<Stub<T>> & Provider<T> : T extends Serializable<T> ? Promise<Stubify<T> & MaybeDisposable<T>> & MaybeProvider<T> : never;
+type MethodKey<Api> = { [Key in keyof Api]-?: Key extends string ? Api[Key] extends ((...args: Array<any>) => unknown) ? Key : never : never; }[keyof Api];
+type MethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...args: infer Args) => unknown) ? Args : never;
+type MethodReturn<Api, Method extends keyof Api> = Api[Method] extends ((...args: Array<any>) => infer Return) ? Return : never;
+type DisposableValue = {
+  [Symbol.dispose](): void;
+};
+declare const isDisposable: (value: unknown) => value is DisposableValue;
+declare const dispose: (value: unknown) => Effect.Effect<void>;
+declare const resolve: <A>(value: A) => Effect.Effect<Awaited<A>, unknown>;
+declare const scoped: <A>(value: A) => Effect.Effect<Awaited<A>, unknown, Scope.Scope>;
+declare namespace RpcDefinition_d_exports {
+  export { Definition$7 as Definition, Method$3 as Method, Methods$2 as Methods, NoReservedMethods$2 as NoReservedMethods, ReservedMethodName$5 as ReservedMethodName, RpcArgumentCountError, RpcArgumentDecodeError, RpcArgumentEncodeError, RpcReservedMethodNameError, RpcSuccessDecodeError, RpcSuccessEncodeError, ServiceFreeSchema$2 as ServiceFreeSchema, WireError, assertNoReservedMethods, decodeArgs, decodeSuccess, decodeWireError, encodeArgs, encodeSuccess, encodeWireError, isWireError, make$13 as make, method$2 as method, reservedMethodNames };
 }
-declare const DurableObjectState_base: Context.ServiceClass<DurableObjectState, "effect-cf/DurableObjectState", DurableObjectStateService>;
-/**
- * Context tag for accessing the current Durable Object state service.
- */
-declare class DurableObjectState extends DurableObjectState_base {}
-/**
- * Wraps a native Cloudflare `DurableObjectState` as a {@link DurableObjectStateService}.
- */
-declare const fromDurableObjectState: (state: globalThis.DurableObjectState) => DurableObjectStateService;
-declare namespace CloudflareOtlp_d_exports {
-  export { DurableObjectLayerOptions, LayerOptions$13 as LayerOptions, ResourceOptions, Serialization, Signal, WorkerLayerOptions, layer$12 as layer, layerDurableObject, layerJson, layerProtobuf, layerWorker };
+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;
 }
-/** Telemetry signal groups supported by the Cloudflare OTLP layers. */
-type Signal = "logs" | "traces" | "metrics";
-/** OTLP payload serialization used by the Effect OTLP exporters. */
-type Serialization = "json" | "protobuf";
-/**
- * Resource metadata shared by Worker and Durable Object OTLP layers.
- *
- * Precedence follows Effect's `OtlpResource.fromConfig`: explicit
- * `serviceName`/`serviceVersion` win over matching explicit `attributes`, and
- * explicit attributes win over `OTEL_SERVICE_NAME`, `OTEL_SERVICE_VERSION`, and
- * `OTEL_RESOURCE_ATTRIBUTES`. Omit an option to let operators set it from the
- * environment.
- */
-interface ResourceOptions {
-  /** Explicit service name. Takes precedence over OTEL environment variables. */
-  readonly serviceName?: string;
-  /** Explicit service version. Takes precedence over OTEL environment variables. */
-  readonly serviceVersion?: string;
-  /** Additional resource attributes attached to exported telemetry. */
-  readonly attributes?: Record<string, unknown>;
+declare const 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;
 }
-/** Options shared by all Cloudflare OTLP telemetry layers. */
-interface LayerOptions$13 {
-  /**
-   * Telemetry signals to export. Defaults to logs, traces, and metrics.
-   *
-   * Each selected signal is still controlled by standard OTEL exporter config,
-   * such as `OTEL_TRACES_EXPORTER=otlp`.
-   */
-  readonly signals?: ReadonlyArray<Signal>;
-  /** OTLP payload serialization. Defaults to protobuf. */
-  readonly serialization?: Serialization;
-  /** Resource metadata forwarded to Effect's OTLP resource resolver. */
-  readonly resource?: ResourceOptions;
-  /**
-   * Explicit headers for every selected signal.
-   *
-   * When omitted, Effect reads `OTEL_EXPORTER_OTLP_HEADERS` and the
-   * signal-specific `OTEL_EXPORTER_OTLP_*_HEADERS` variables.
-   */
-  readonly headers?: Headers$1.Input;
-  /** Exclude log records emitted for spans when exporting logs. */
-  readonly loggerExcludeLogSpans?: boolean;
-  /** Merge the OTLP logger with existing loggers instead of replacing them. */
-  readonly loggerMergeWithExisting?: boolean;
-  /** Custom trace context lookup used by the Effect OTLP tracer. */
-  readonly tracerContext?: <X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X;
+declare const 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;
 }
-/** Resource metadata specific to Cloudflare Workers. */
-interface WorkerLayerOptions extends LayerOptions$13 {
-  /** Cloudflare Worker name to attach as `cloudflare.worker.name`. */
-  readonly workerName?: 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;
 }
-/** Resource metadata specific to Cloudflare Durable Objects. */
-interface DurableObjectLayerOptions extends LayerOptions$13 {
-  /** Durable Object class name to attach as `cloudflare.durable_object.class`. */
-  readonly className?: string;
-  /**
-   * Include the Durable Object id as `cloudflare.durable_object.id`.
-   *
-   * This is disabled by default because object ids can be high-cardinality.
-   */
-  readonly includeObjectId?: boolean;
+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;
 /**
- * Base OTLP telemetry layer for Cloudflare-compatible runtimes.
- *
- * Standard OpenTelemetry environment variables are resolved by Effect's OTLP
- * layers. In Cloudflare Workers and Durable Objects, the current `env` object is
- * installed as the primary `ConfigProvider`; outside Cloudflare, the ambient
- * Effect `ConfigProvider` remains the fallback.
- *
- * The layer provides {@link OtlpExporter.Flusher} for draining buffered
- * telemetry before the isolate freezes.
- */
-declare const layer$12: (options?: LayerOptions$13) => Layer.Layer<OtlpExporter.Flusher>;
-/** Base OTLP telemetry layer forced to JSON serialization. */
-declare const layerJson: (options?: Omit<LayerOptions$13, "serialization">) => Layer.Layer<OtlpExporter.Flusher>;
-/** Base OTLP telemetry layer forced to protobuf serialization. */
-declare const layerProtobuf: (options?: Omit<LayerOptions$13, "serialization">) => Layer.Layer<OtlpExporter.Flusher>;
-/**
- * OTLP layer with Cloudflare Worker resource attributes.
- *
- * Provide this layer at runtime scope for long-lived metrics aggregation, or at
- * handler scope when traces/logs should flush as the Cloudflare event finishes.
- */
-declare const layerWorker: (options?: WorkerLayerOptions) => Layer.Layer<OtlpExporter.Flusher>;
-/**
- * OTLP layer with Cloudflare Durable Object resource attributes.
- *
- * The layer reads {@link DurableObjectState} so it can optionally include the
- * Durable Object id. Prefer leaving `includeObjectId` disabled unless the
- * backend can tolerate high-cardinality resource attributes.
+ * Encodes package RPC errors into a plain `Error` envelope so their tags
+ * survive Cloudflare RPC serialization, which drops custom error properties.
  */
-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, ContainerStub, ContainerWaitOptions, LayerOptions$12 as LayerOptions, Tag$12 as Tag, TagClass$11 as TagClass, isContainerNamespaceResource, layer$11 as layer, make$13 as make, makeClient$9 as makeClient };
+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;
 }
-/** Signal accepted by Cloudflare Container instances. */
-type ContainerSignal = "SIGKILL" | "SIGINT" | "SIGTERM";
-/** Per-instance Container startup configuration. */
-interface ContainerStartOptions {
-  readonly envVars?: Record<string, string>;
-  readonly entrypoint?: Array<string>;
-  readonly enableInternet?: boolean;
-  readonly labels?: Record<string, string>;
+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 {};
 }
-/** Serializable retry settings used while starting a Container. */
-interface ContainerWaitOptions {
-  readonly portToCheck: number;
-  readonly retries?: number;
-  readonly waitInterval?: number;
+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;
 }
-/** Serializable timeout settings used while waiting for Container ports. */
-interface ContainerReadinessOptions {
-  readonly instanceGetTimeoutMS?: number;
-  readonly portReadyTimeoutMS?: number;
-  readonly waitInterval?: number;
+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>;
 }
-/** Options for starting a Container and waiting for its ports. */
-interface ContainerStartAndWaitForPortsOptions {
-  readonly startOptions?: ContainerStartOptions;
-  readonly ports?: number | Array<number>;
-  readonly cancellationOptions?: ContainerReadinessOptions;
+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 };
 }
-/** Serializable state reported by a Cloudflare Container instance. */
-declare const ContainerState: Schema.Union<readonly [Schema.Struct<{
-  readonly lastChange: Schema.Finite;
-  readonly status: Schema.Literals<readonly ["running", "stopping", "stopped", "healthy"]>;
-}>, Schema.Struct<{
-  readonly lastChange: Schema.Finite;
-  readonly status: Schema.Literal<"stopped_with_code">;
-  readonly exitCode: Schema.optionalKey<Schema.Int>;
-}>]>;
-type ContainerState = typeof ContainerState.Type;
-/**
- * Native Container stub shape exposed by a Container namespace binding.
- *
- * This is structural so using Container bindings does not make
- * `@cloudflare/containers` a runtime dependency of effect-cf.
- */
-interface ContainerStub {
-  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
-  getState(): Promise<ContainerState>;
-  start(options?: ContainerStartOptions, waitOptions?: ContainerWaitOptions): Promise<void>;
-  startAndWaitForPorts(options?: ContainerStartAndWaitForPortsOptions): Promise<void>;
-  stop(signal?: ContainerSignal): Promise<void>;
-  destroy(): Promise<void>;
+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;
 }
-/** Native Container namespace binding shape. */
-interface ContainerNamespaceResource {
-  getByName(name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions): ContainerStub;
+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>>>;
 }
-/** Container namespace binding metadata. */
-interface ContainerNamespaceDefinition {
-  /** Binding name as configured in `wrangler.jsonc`. */
+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 ContainerOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "ContainerOperationError";
+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>;
-/** Failure raised when invoking a named Container operation. */
-declare class ContainerOperationError extends ContainerOperationError_base<{
-  readonly binding: string;
-  readonly instance: string;
-  readonly operation: string;
+declare class QueueMessageDecodeError extends QueueMessageDecodeError_base<{
+  readonly queue: string;
+  readonly messageId: string;
+  readonly index: number;
   readonly cause: unknown;
 }> {
   get message(): string;
 }
-/** Effect-wrapped client for one named Container instance. */
-interface ContainerInstanceClient {
-  readonly rawUnsafe: Effect.Effect<ContainerStub, ContainerOperationError>;
-  readonly state: Effect.Effect<ContainerState, ContainerOperationError>;
-  readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<Response, ContainerOperationError>;
-  readonly start: (options?: ContainerStartOptions, waitOptions?: ContainerWaitOptions) => Effect.Effect<void, ContainerOperationError>;
-  readonly startAndWaitForPorts: (options?: ContainerStartAndWaitForPortsOptions) => Effect.Effect<void, ContainerOperationError>;
-  readonly stop: (signal?: ContainerSignal) => Effect.Effect<void, ContainerOperationError>;
-  readonly destroy: Effect.Effect<void, ContainerOperationError>;
-}
-/** Effect client for a Container namespace binding. */
-interface ContainerNamespaceClient {
-  readonly definition: ContainerNamespaceDefinition;
-  readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<ContainerInstanceClient, ContainerOperationError>;
-  readonly byName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => ContainerInstanceClient;
-  readonly rawUnsafe: Effect.Effect<ContainerNamespaceResource>;
+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>;
 }
-type ContainerNamespaceStaticClient<R> = {
-  readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<ContainerInstanceClient, ContainerOperationError, R>;
-  readonly byName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => {
-    readonly state: Effect.Effect<ContainerState, ContainerOperationError, R>;
-    readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<Response, ContainerOperationError, R>;
-    readonly start: (options?: ContainerStartOptions, waitOptions?: ContainerWaitOptions) => Effect.Effect<void, ContainerOperationError, R>;
-    readonly startAndWaitForPorts: (options?: ContainerStartAndWaitForPortsOptions) => Effect.Effect<void, ContainerOperationError, R>;
-    readonly stop: (signal?: ContainerSignal) => Effect.Effect<void, ContainerOperationError, R>;
-    readonly destroy: Effect.Effect<void, ContainerOperationError, R>;
-    readonly rawUnsafe: Effect.Effect<ContainerStub, ContainerOperationError, R>;
-  };
-  readonly rawUnsafe: Effect.Effect<ContainerNamespaceResource, never, R>;
-};
-type LayerOptions$12 = {
-  readonly binding: string;
+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>;
 };
-interface TagClass$11<Self, Id extends string> extends Context.ServiceClass<Self, `effect-cf/Container/${Id}`, ContainerNamespaceClient>, ContainerNamespaceStaticClient<Self> {
-  readonly id: Id;
-  readonly layer: (options: LayerOptions$12) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-}
-declare const isContainerNamespaceResource: (value: unknown) => value is ContainerNamespaceResource;
-declare const makeClient$9: (definition: ContainerNamespaceDefinition) => (namespace: ContainerNamespaceResource) => ContainerNamespaceClient;
-declare const layer$11: <Self>(tag: Context.Service<Self, ContainerNamespaceClient>, definition: ContainerNamespaceDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const make$13: <Id extends string>(id: Id) => TagClass$11<ContainerNamespaceService<Id>, Id>;
-declare const ContainerNamespaceServiceTypeId: unique symbol;
-/** Nominal service marker for Container namespaces created with {@link make}. */
-interface ContainerNamespaceService<Id extends string> {
-  readonly [ContainerNamespaceServiceTypeId]: {
-    readonly id: Id;
-  };
-}
-/** Creates a typed Effect service for a Cloudflare Container namespace. */
-declare const Tag$12: <Self>() => <Id extends string>(id: Id) => TagClass$11<Self, Id>;
-declare const ContainerNamespace: typeof Tag$12;
-declare namespace D1_d_exports {
-  export { D1Definition, D1Service, D1SqlLayerOptions, Service$1 as Service, TypeId$2 as TypeId, make$12 as make };
+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;
 }
-declare const TypeId$2: "~effect-cf/D1";
-type TypeId$2 = typeof TypeId$2;
-/** Typed D1 binding definition. */
-interface D1Definition {
-  /** Binding name as configured in `wrangler.jsonc`. */
-  readonly binding: string;
+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 };
 }
-/** Options forwarded to `@effect/sql-d1` when building a SQL client layer. */
-type D1SqlLayerOptions = Omit<D1Client.D1ClientConfig, "db">;
-declare const D1ServiceTypeId: unique symbol;
-/** Nominal service marker for D1 services created with {@link make}. */
-interface D1Service<Id extends string> {
-  readonly [D1ServiceTypeId]: {
-    readonly id: Id;
-  };
+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";
 /**
- * Creates a typed D1 service tag plus Effect helpers.
+ * Native Cloudflare service object including optional RPC methods.
  */
-declare const make$12: <Id extends string>(id: Id, definition: D1Definition) => BindingService<D1Service<Id>, Id, D1Database> & {
-  "~effect-cf/D1": "~effect-cf/D1";
-  definition: D1Definition;
-  sqlLayer: (options?: D1SqlLayerOptions) => Layer.Layer<D1Client.D1Client | SqlClient.SqlClient, Config.ConfigError | BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-};
+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;
 /**
- * Builds a D1 service around a Cloudflare D1 database binding.
- *
- * The returned service exposes the raw `D1Database` binding and `sqlLayer(...)`
- * for providing `effect/unstable/sql` via `@effect/sql-d1`.
- *
- * @example
- * ```ts
- * class TodoDatabase extends D1.Service<TodoDatabase>()("TodoDatabase", {
- *   binding: "TODO_DB",
- * }) {}
- *
- * const SqlLive = TodoDatabase.sqlLayer();
- * ```
+ * Binding metadata used to create an Effect service from a Worker binding.
  */
-declare const Service$1: <Self>() => <Id extends string>(id: Id, definition: D1Definition) => BindingService<Self, Id, D1Database> & {
-  "~effect-cf/D1": "~effect-cf/D1";
-  definition: D1Definition;
-  sqlLayer: (options?: D1SqlLayerOptions) => Layer.Layer<D1Client.D1Client | SqlClient.SqlClient, Config.ConfigError | BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-};
-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$11 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;
+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 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";
+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>;
-declare class RpcArgumentEncodeError extends RpcArgumentEncodeError_base<{
-  readonly definition: string;
-  readonly method: string;
+/**
+ * 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 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";
+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>;
-declare class RpcSuccessDecodeError extends RpcSuccessDecodeError_base<{
-  readonly definition: string;
+/**
+ * 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;
 }
-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;
+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>;
 /**
- * Encodes package RPC errors into a plain `Error` envelope so their tags
- * survive Cloudflare RPC serialization, which drops custom error properties.
+ * 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 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> {
+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$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]>>;
+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$2>> = { [Index in keyof Args]: Schema.Json; };
+  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$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> {
+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$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$11: <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$10 as layer, makeClient$8 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$8: <Message extends ServiceFreeSchema$2>(definition: QueueBindingDefinition<Message>) => ((queue: QueueProducer<Schema.Codec.Encoded<Message>>) => QueueBindingClient<Message>);
-declare const layer$10: <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$11 as LayerOptions, Options$5 as Options, Queue$1 as Queue, Tag$11 as Tag, TagClass$10 as TagClass, implement$5 as implement, make$10 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>;
+declare namespace Definition$4 {
+  type Any = Definition$4<string, Methods$1>;
 }
-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 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;
 };
-interface TagClass$10<Self, Id extends string, Message extends ServiceFreeSchema$2> extends Context.ServiceClass<Self, `effect-cf/Queue/${Id}`, QueueBindingClient<Message>> {
+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 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 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>;
-  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$10: <Id extends string, Message extends ServiceFreeSchema$2>(id: Id, definition: {
-  readonly message: Message;
-}) => TagClass$10<Definition$6<Id, Message>, Id, Message>;
-declare const Tag$11: <Self>() => <Id extends string, Message extends ServiceFreeSchema$2>(id: Id, definition: {
-  readonly message: Message;
-}) => TagClass$10<Self, Id, Message>;
-declare const Queue$1: typeof Tag$11;
-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$10 as LayerOptions, Options$4 as Options, QueueBatch, QueueHandler, QueueMessage, QueueMessageDecodeError, QueueOptions, Tag$10 as Tag, TagClass$9 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;
+};
+/**
+ * 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 };
 }
-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 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>;
 }
-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;
+/**
+ * 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>;
 }
-type LayerOptions$10 = LayerOptions$11;
-type TagClass$9<Self, Id extends string, Message extends Definition$6.Any["message"]> = TagClass$10<Self, Id, Message>;
-declare const Tag$10: <Self>() => <Id extends string, Message extends Definition$6.Any["message"]>(id: Id, definition: {
-  readonly message: Message;
-}) => TagClass$9<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, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceFetcher, isServiceBindingClient, layer$9 as layer, makeClient$7 as makeClient, makeDirectMethods$1 as makeDirectMethods };
+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;
 }
-declare const TypeId$1: "effect-cf/ServiceBinding";
+type FetchWorkerOptions<RRuntime, REvent = never, EventLayerError = never> = Omit<WorkerOptions<RRuntime, REvent, EventLayerError, Record<never, never>>, "rpc"> & {
+  readonly rpc?: never;
+};
 /**
- * Minimum shape for a Cloudflare service binding.
+ * Cloudflare `WorkerEntrypoint` constructor produced by {@link make}.
  */
-interface ServiceFetcher {
-  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+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>;
 }
-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.
+ * 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")),
+ * });
+ * ```
  */
-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;
+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>;
 /**
- * Binding metadata used to create an Effect service from a Worker binding.
+ * 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.
  */
-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 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 };
 }
-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.
+ * Effect-friendly wrapper around Cloudflare `DurableObjectState`.
  */
-declare class ServiceBindingFetchError extends ServiceBindingFetchError_base<{
-  readonly binding: string;
-  readonly cause: unknown;
-}> {
-  get message(): string;
+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 namespace CloudflareOtlp_d_exports {
+  export { DurableObjectLayerOptions, LayerOptions$10 as LayerOptions, ResourceOptions, Serialization, Signal, WorkerLayerOptions, layer$10 as layer, layerDurableObject, layerJson, layerProtobuf, layerWorker };
 }
-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>;
+/** Telemetry signal groups supported by the Cloudflare OTLP layers. */
+type Signal = "logs" | "traces" | "metrics";
+/** OTLP payload serialization used by the Effect OTLP exporters. */
+type Serialization = "json" | "protobuf";
 /**
- * Failure raised when invoking an RPC method on a service binding.
+ * Resource metadata shared by Worker and Durable Object OTLP layers.
+ *
+ * Precedence follows Effect's `OtlpResource.fromConfig`: explicit
+ * `serviceName`/`serviceVersion` win over matching explicit `attributes`, and
+ * explicit attributes win over `OTEL_SERVICE_NAME`, `OTEL_SERVICE_VERSION`, and
+ * `OTEL_RESOURCE_ATTRIBUTES`. Omit an option to let operators set it from the
+ * environment.
  */
-declare class ServiceBindingRpcError extends ServiceBindingRpcError_base<{
-  readonly binding: string;
-  readonly method: string;
-  readonly cause: unknown;
-}> {
-  get message(): string;
+interface ResourceOptions {
+  /** Explicit service name. Takes precedence over OTEL environment variables. */
+  readonly serviceName?: string;
+  /** Explicit service version. Takes precedence over OTEL environment variables. */
+  readonly serviceVersion?: string;
+  /** Additional resource attributes attached to exported telemetry. */
+  readonly attributes?: Record<string, unknown>;
 }
-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>;
+/** Options shared by all Cloudflare OTLP telemetry layers. */
+interface LayerOptions$10 {
   /**
-   * 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);
+   * Telemetry signals to export. Defaults to logs, traces, and metrics.
    *
-   *   return value;
-   * });
-   * ```
+   * Each selected signal is still controlled by standard OTEL exporter config,
+   * such as `OTEL_TRACES_EXPORTER=otlp`.
    */
-  readonly rpc: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodCloudflareReturn<Api, Method>, ServiceBindingRpcError>;
+  readonly signals?: ReadonlyArray<Signal>;
+  /** OTLP payload serialization. Defaults to protobuf. */
+  readonly serialization?: Serialization;
+  /** Resource metadata forwarded to Effect's OTLP resource resolver. */
+  readonly resource?: ResourceOptions;
   /**
-   * 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);
+   * Explicit headers for every selected signal.
    *
-   *   return value;
-   * });
-   * ```
+   * When omitted, Effect reads `OTEL_EXPORTER_OTLP_HEADERS` and the
+   * signal-specific `OTEL_EXPORTER_OTLP_*_HEADERS` variables.
    */
-  readonly call: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError>;
+  readonly headers?: Headers$1.Input;
+  /** Exclude log records emitted for spans when exporting logs. */
+  readonly loggerExcludeLogSpans?: boolean;
+  /** Merge the OTLP logger with existing loggers instead of replacing them. */
+  readonly loggerMergeWithExisting?: boolean;
+  /** Custom trace context lookup used by the Effect OTLP tracer. */
+  readonly tracerContext?: <X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X;
+}
+/** Resource metadata specific to Cloudflare Workers. */
+interface WorkerLayerOptions extends LayerOptions$10 {
+  /** Cloudflare Worker name to attach as `cloudflare.worker.name`. */
+  readonly workerName?: string;
+}
+/** Resource metadata specific to Cloudflare Durable Objects. */
+interface DurableObjectLayerOptions extends LayerOptions$10 {
+  /** Durable Object class name to attach as `cloudflare.durable_object.class`. */
+  readonly className?: string;
   /**
-   * 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");
+   * Include the Durable Object id as `cloudflare.durable_object.id`.
    *
-   *     return yield* handle.read();
-   *   }),
-   * );
-   * ```
+   * This is disabled by default because object ids can be high-cardinality.
    */
-  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$7: <Api extends object, const Definition extends Definition$4.Any | undefined = undefined>(definition: ServiceBindingDefinition<Definition>) => ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition>);
-declare const layer$9: <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>;
+  readonly includeObjectId?: boolean;
+}
 /**
- * Creates a typed Effect service for a Worker service binding.
+ * Base OTLP telemetry layer for Cloudflare-compatible runtimes.
  *
- * 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
+ * Standard OpenTelemetry environment variables are resolved by Effect's OTLP
+ * layers. In Cloudflare Workers and Durable Objects, the current `env` object is
+ * installed as the primary `ConfigProvider`; outside Cloudflare, the ambient
+ * Effect `ConfigProvider` remains the fallback.
  *
- * @example
- * ```ts
- * const Counter = WorkerDefinition.make("Counter", {
- *   increment: WorkerDefinition.method({
- *     args: [Schema.Number],
- *     success: Schema.Number,
- *   }),
- * });
+ * The layer provides {@link OtlpExporter.Flusher} for draining buffered
+ * telemetry before the isolate freezes.
+ */
+declare const layer$10: (options?: LayerOptions$10) => Layer.Layer<OtlpExporter.Flusher>;
+/** Base OTLP telemetry layer forced to JSON serialization. */
+declare const layerJson: (options?: Omit<LayerOptions$10, "serialization">) => Layer.Layer<OtlpExporter.Flusher>;
+/** Base OTLP telemetry layer forced to protobuf serialization. */
+declare const layerProtobuf: (options?: Omit<LayerOptions$10, "serialization">) => Layer.Layer<OtlpExporter.Flusher>;
+/**
+ * OTLP layer with Cloudflare Worker resource attributes.
  *
- * const CounterLive = Counter.layer({ binding: "COUNTER" });
+ * Provide this layer at runtime scope for long-lived metrics aggregation, or at
+ * handler scope when traces/logs should flush as the Cloudflare event finishes.
+ */
+declare const layerWorker: (options?: WorkerLayerOptions) => Layer.Layer<OtlpExporter.Flusher>;
+/**
+ * OTLP layer with Cloudflare Durable Object resource attributes.
  *
- * const program = Effect.gen(function* () {
- *   const counter = yield* Counter;
- *   const next = yield* counter.increment(1);
- *   return next;
- * });
- * ```
+ * The layer reads {@link DurableObjectState} so it can optionally include the
+ * Durable Object id. Prefer leaving `includeObjectId` disabled unless the
+ * backend can tolerate high-cardinality resource attributes.
  */
-declare const Service: <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$1]: typeof TypeId$1;
-  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$9 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$9 as Tag, TagClass$8 as TagClass, Worker, implement$3 as implement, make$9 as make, method$1 as method };
+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 };
 }
-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;
+/** Named signal accepted by Cloudflare Container instances. */
+type ContainerSignal = "SIGKILL" | "SIGINT" | "SIGTERM";
+/** Named or numeric signal accepted by Container `stop()`. */
+type ContainerStopSignal = ContainerSignal | number;
+/** Per-instance Container startup configuration. */
+interface ContainerStartOptions {
+  readonly envVars?: Record<string, string>;
+  readonly entrypoint?: Array<string>;
+  readonly enableInternet?: boolean;
+  readonly labels?: Record<string, string>;
 }
-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 {};
+/** Serializable retry settings used while starting a Container. */
+interface ContainerWaitOptions {
+  readonly portToCheck: number;
+  readonly retries?: number;
+  readonly waitInterval?: number;
 }
-type Methods$1 = Record<string, Method$2.Any>;
+/** Serializable timeout settings used while waiting for Container ports. */
+interface ContainerReadinessOptions {
+  readonly instanceGetTimeoutMS?: number;
+  readonly portReadyTimeoutMS?: number;
+  readonly waitInterval?: number;
+}
+/** Options for starting a Container and waiting for its ports. */
+interface ContainerStartAndWaitForPortsOptions {
+  readonly startOptions?: ContainerStartOptions;
+  readonly ports?: number | Array<number>;
+  readonly cancellationOptions?: ContainerReadinessOptions;
+}
+/** Serializable state reported by a Cloudflare Container instance. */
+declare const ContainerState: Schema.Union<readonly [Schema.Struct<{
+  readonly lastChange: Schema.Finite;
+  readonly status: Schema.Literals<readonly ["running", "stopping", "stopped", "healthy"]>;
+}>, Schema.Struct<{
+  readonly lastChange: Schema.Finite;
+  readonly status: Schema.Literal<"stopped_with_code">;
+  readonly exitCode: Schema.optionalKey<Schema.Int>;
+}>]>;
+type ContainerState = typeof ContainerState.Type;
 /**
- * RPC contract for a Worker service.
+ * Native Container stub shape exposed by a Container namespace binding.
  *
- * Create with {@link make} and reuse to type both worker implementations and
- * service bindings in other workers.
+ * This is structural so using Container bindings does not make
+ * `@cloudflare/containers` a runtime dependency of effect-cf.
  */
-interface Definition$4<Id extends string = string, MethodsShape extends Methods$1 = Methods$1> {
-  readonly id: Id;
-  readonly methods: MethodsShape;
+interface ContainerStub {
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+  getState(): Promise<ContainerState>;
+  start(options?: ContainerStartOptions, waitOptions?: ContainerWaitOptions): Promise<void>;
+  startAndWaitForPorts(options?: ContainerStartAndWaitForPortsOptions): Promise<void>;
+  waitForPort(options: ContainerWaitOptions): Promise<number>;
+  stop(signal?: ContainerStopSignal): Promise<void>;
+  destroy(): Promise<void>;
+  setAllowedHosts(hosts: Array<string>): Promise<void>;
+  setDeniedHosts(hosts: Array<string>): Promise<void>;
+  allowHost(hostname: string): Promise<void>;
+  denyHost(hostname: string): Promise<void>;
+  removeAllowedHost(hostname: string): Promise<void>;
+  removeDeniedHost(hostname: string): Promise<void>;
 }
-declare namespace Definition$4 {
-  type Any = Definition$4<string, Methods$1>;
+/** Native Container namespace binding shape. */
+interface ContainerNamespaceResource {
+  getByName(name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions): ContainerStub;
 }
-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>;
+/** Exact native stub type produced by a Container namespace binding. */
+type ContainerStubOf<Namespace extends ContainerNamespaceResource> = ReturnType<Namespace["getByName"]>;
+/** Container namespace binding metadata. */
+interface ContainerNamespaceDefinition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+declare const ContainerOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "ContainerOperationError";
+} & Readonly<A>;
+/** Failure raised when invoking a named Container operation. */
+declare class ContainerOperationError extends ContainerOperationError_base<{
+  readonly binding: string;
+  readonly instance: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+/** Effect-wrapped client for one named Container instance. */
+interface ContainerInstanceClient<Stub extends ContainerStub = ContainerStub> {
+  readonly rawUnsafe: Effect.Effect<Stub, ContainerOperationError>;
+  readonly state: Effect.Effect<ContainerState, ContainerOperationError>;
+  readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<Response, ContainerOperationError>;
+  readonly start: (options?: ContainerStartOptions, waitOptions?: ContainerWaitOptions) => Effect.Effect<void, ContainerOperationError>;
+  readonly startAndWaitForPorts: (options?: ContainerStartAndWaitForPortsOptions) => Effect.Effect<void, ContainerOperationError>;
+  readonly waitForPort: (options: ContainerWaitOptions) => Effect.Effect<number, ContainerOperationError>;
+  readonly stop: (signal?: ContainerStopSignal) => Effect.Effect<void, ContainerOperationError>;
+  readonly destroy: Effect.Effect<void, ContainerOperationError>;
+  readonly setAllowedHosts: (hosts: ReadonlyArray<string>) => Effect.Effect<void, ContainerOperationError>;
+  readonly setDeniedHosts: (hosts: ReadonlyArray<string>) => Effect.Effect<void, ContainerOperationError>;
+  readonly allowHost: (hostname: string) => Effect.Effect<void, ContainerOperationError>;
+  readonly denyHost: (hostname: string) => Effect.Effect<void, ContainerOperationError>;
+  readonly removeAllowedHost: (hostname: string) => Effect.Effect<void, ContainerOperationError>;
+  readonly removeDeniedHost: (hostname: string) => Effect.Effect<void, ContainerOperationError>;
+}
+/** Effect client for a Container namespace binding. */
+interface ContainerNamespaceClient<Namespace extends ContainerNamespaceResource = ContainerNamespaceResource> {
+  readonly definition: ContainerNamespaceDefinition;
+  readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<ContainerInstanceClient<ContainerStubOf<Namespace>>, ContainerOperationError>;
+  readonly byName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => ContainerInstanceClient<ContainerStubOf<Namespace>>;
+  readonly rawUnsafe: Effect.Effect<Namespace>;
 }
+type ContainerNamespaceStaticClient<R, Namespace extends ContainerNamespaceResource = ContainerNamespaceResource> = {
+  readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<ContainerInstanceClient<ContainerStubOf<Namespace>>, ContainerOperationError, R>;
+  readonly byName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => {
+    readonly state: Effect.Effect<ContainerState, ContainerOperationError, R>;
+    readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<Response, ContainerOperationError, R>;
+    readonly start: (options?: ContainerStartOptions, waitOptions?: ContainerWaitOptions) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly startAndWaitForPorts: (options?: ContainerStartAndWaitForPortsOptions) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly waitForPort: (options: ContainerWaitOptions) => Effect.Effect<number, ContainerOperationError, R>;
+    readonly stop: (signal?: ContainerStopSignal) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly destroy: Effect.Effect<void, ContainerOperationError, R>;
+    readonly setAllowedHosts: (hosts: ReadonlyArray<string>) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly setDeniedHosts: (hosts: ReadonlyArray<string>) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly allowHost: (hostname: string) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly denyHost: (hostname: string) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly removeAllowedHost: (hostname: string) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly removeDeniedHost: (hostname: string) => Effect.Effect<void, ContainerOperationError, R>;
+    readonly rawUnsafe: Effect.Effect<ContainerStubOf<Namespace>, ContainerOperationError, R>;
+  };
+  readonly rawUnsafe: Effect.Effect<Namespace, never, R>;
+};
 type LayerOptions$9 = {
   readonly binding: string;
 };
-type TagClass$8<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>> & {
+interface TagClass$8<Self, Id extends string, Namespace extends ContainerNamespaceResource = ContainerNamespaceResource> extends Context.ServiceClass<Self, `effect-cf/Container/${Id}`, ContainerNamespaceClient<Namespace>>, ContainerNamespaceStaticClient<Self, Namespace> {
   readonly id: Id;
-  readonly methods: MethodsShape;
-  readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$3<ROut, Definition$4<Id, MethodsShape>, REvent, EventLayerError>) => WorkerClass<Handlers$1<ROut | REvent, Definition$4<Id, MethodsShape>>, ROut | REvent>;
   readonly layer: (options: LayerOptions$9) => 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$9: <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$8<Definition$4<Id, MethodsShape>, Id, MethodsShape>;
-declare const Tag$9: <Self>() => <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$8<Self, Id, MethodsShape>;
-declare const Worker: typeof Tag$9;
-/**
- * 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$9 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$9 as Tag, TagClass$8 as TagClass, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcHandler, WorkerRpcShape, implement$3 as implement, isWebSocketUpgrade, make$8 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>;
+declare const isContainerNamespaceResource: (value: unknown) => value is ContainerNamespaceResource;
+declare const makeClient$7: (definition: ContainerNamespaceDefinition) => <Namespace extends ContainerNamespaceResource>(namespace: Namespace) => ContainerNamespaceClient<Namespace>;
+declare const layer$9: <Self, Namespace extends ContainerNamespaceResource>(tag: Context.Service<Self, ContainerNamespaceClient<Namespace>>, definition: ContainerNamespaceDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make$9: <Id extends string>(id: Id) => TagClass$8<ContainerNamespaceService<Id>, Id, ContainerNamespaceResource>;
+declare const ContainerNamespaceServiceTypeId: unique symbol;
+/** Nominal service marker for Container namespaces created with {@link make}. */
+interface ContainerNamespaceService<Id extends string> {
+  readonly [ContainerNamespaceServiceTypeId]: {
+    readonly id: Id;
+  };
 }
-/**
- * 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>;
+/** Creates a typed Effect service for a Cloudflare Container namespace. */
+declare const Tag$9: <Self, Namespace extends ContainerNamespaceResource = ContainerNamespaceResource>() => <Id extends string>(id: Id) => TagClass$8<Self, Id, Namespace>;
+declare const ContainerNamespace: typeof Tag$9;
+declare namespace D1_d_exports {
+  export { D1Definition, D1Service, D1SqlLayerOptions, Service, TypeId$1 as TypeId, make$8 as make };
 }
-declare const 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;
+declare const TypeId$1: "~effect-cf/D1";
+type TypeId$1 = typeof TypeId$1;
+/** Typed D1 binding definition. */
+interface D1Definition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+/** Options forwarded to `@effect/sql-d1` when building a SQL client layer. */
+type D1SqlLayerOptions = Omit<D1Client.D1ClientConfig, "db">;
+declare const D1ServiceTypeId: unique symbol;
+/** Nominal service marker for D1 services created with {@link make}. */
+interface D1Service<Id extends string> {
+  readonly [D1ServiceTypeId]: {
+    readonly id: Id;
+  };
 }
-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}.
+ * Creates a typed D1 service tag plus Effect helpers.
  */
-interface FetchHandler<Env extends WorkerEnv = WorkerEnv> {
-  readonly fetch: (request: Request, env: Env, ctx: globalThis.ExecutionContext) => Promise<Response>;
-}
+declare const make$8: <Id extends string>(id: Id, definition: D1Definition) => BindingService<D1Service<Id>, Id, D1Database> & {
+  "~effect-cf/D1": "~effect-cf/D1";
+  definition: D1Definition;
+  sqlLayer: (options?: D1SqlLayerOptions) => Layer.Layer<D1Client.D1Client | SqlClient.SqlClient, Config.ConfigError | BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+};
 /**
- * Creates a Cloudflare worker class backed by a single managed Effect runtime.
+ * Builds a D1 service around a Cloudflare D1 database binding.
  *
- * 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.
+ * The returned service exposes the raw `D1Database` binding and `sqlLayer(...)`
+ * for providing `effect/unstable/sql` via `@effect/sql-d1`.
  *
  * @example
  * ```ts
- * export default Worker.make(Layer.empty, {
- *   fetch: Effect.succeed(new Response("ok")),
- * });
- * ```
- */
-declare function make$8<ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, fetch: WorkerHandler<ROut>): WorkerClass<Record<never, never>, ROut>;
-declare function make$8<ROut, LayerError, REvent = never, EventLayerError = never, const Rpc extends WorkerRpc<ROut | REvent> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptions<ROut, REvent, EventLayerError, Rpc>): WorkerClass<Rpc, ROut | REvent>;
-/**
- * Creates an `ExportedHandler`-compatible `{ fetch }` object backed by
- * {@link make}.
+ * class TodoDatabase extends D1.Service<TodoDatabase>()("TodoDatabase", {
+ *   binding: "TODO_DB",
+ * }) {}
  *
- * 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.
+ * const SqlLive = TodoDatabase.sqlLayer();
+ * ```
  */
-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 const Service: <Self>() => <Id extends string>(id: Id, definition: D1Definition) => BindingService<Self, Id, D1Database> & {
+  "~effect-cf/D1": "~effect-cf/D1";
+  definition: D1Definition;
+  sqlLayer: (options?: D1SqlLayerOptions) => Layer.Layer<D1Client.D1Client | SqlClient.SqlClient, Config.ConfigError | BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+};
 declare namespace DurableObjectNamespace_d_exports {
   export { DurableObjectFetchError, DurableObjectNamespaceBindingDefinition, DurableObjectNamespaceClient, DurableObjectNamespaceDefinition, DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient, DurableObjectRpcError, DurableObjectStubClient, isDurableObjectNamespaceClient, layer$8 as layer, makeClient$6 as makeClient, makeDirectMethods };
 }