effect-cf 0.39.1 → 0.40.1

package/dist/Worker-gV4mDqIs.d.mts

@@ -1,641 +0,0 @@
-import { c as WorkerEnvironment, n as BindingService, r as BindingValidationError, s as WorkerEnv, t as BindingNotFoundError } from "./Binding-DKcLrQCM.mjs";
-import { Cause, Context, Effect, Layer, Predicate, Schema, Scope, Tracer } from "effect";
-import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
-import { RpcStub, RpcTarget, WorkerEntrypoint } from "cloudflare:workers";
-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 Record<string | number, infer _Value> ? { [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>) => any) ? Key : never : never; }[keyof Api];
-type MethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...args: infer Args) => any) ? Args : never;
-type MethodReturn<Api, Method extends keyof Api> = Api[Method] extends ((...args: Array<any>) => infer Return) ? Return : never;
-type DisposableValue = {
-  [Symbol.dispose](): void;
-};
-type RpcBoundaryValue = Schema.Schema.Type<typeof Schema.Unknown>;
-declare const isDisposable: (value: RpcBoundaryValue) => value is DisposableValue;
-declare const dispose: (value: RpcBoundaryValue) => 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$3 as Definition, Method$2 as Method, Methods$1 as Methods, NoReservedMethods$1 as NoReservedMethods, ReservedMethodName$3 as ReservedMethodName, RpcArgumentCountError, RpcArgumentDecodeError, RpcArgumentEncodeError, RpcReservedMethodNameError, RpcSuccessDecodeError, RpcSuccessEncodeError, ServiceFreeSchema$1 as ServiceFreeSchema, WireError, assertNoReservedMethods, decodeArgs, decodeSuccess, decodeWireError, encodeArgs, encodeSuccess, encodeWireError, isWireError, make$3 as make, method$1 as method, reservedMethodNames };
-}
-declare const RpcReservedMethodNameError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "RpcReservedMethodNameError";
-} & Readonly<A>;
-declare class RpcReservedMethodNameError extends RpcReservedMethodNameError_base<{
-  readonly definition: string;
-  readonly method: string;
-}> {
-  get message(): string;
-}
-declare const RpcArgumentCountError_base: Schema.Class<RpcArgumentCountError, Schema.TaggedStruct<"RpcArgumentCountError", {
-  readonly definition: Schema.String;
-  readonly method: Schema.String;
-  readonly expected: Schema.Number;
-  readonly actual: Schema.Number;
-}>, import("effect/Cause").YieldableError>;
-declare class RpcArgumentCountError extends RpcArgumentCountError_base {
-  get message(): string;
-}
-declare const RpcArgumentDecodeError_base: Schema.Class<RpcArgumentDecodeError, Schema.TaggedStruct<"RpcArgumentDecodeError", {
-  readonly definition: Schema.String;
-  readonly method: Schema.String;
-  readonly cause: Schema.Defect;
-}>, import("effect/Cause").YieldableError>;
-declare class RpcArgumentDecodeError extends RpcArgumentDecodeError_base {
-  get message(): string;
-}
-declare const RpcArgumentEncodeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "RpcArgumentEncodeError";
-} & Readonly<A>;
-declare class RpcArgumentEncodeError extends RpcArgumentEncodeError_base<{
-  readonly definition: string;
-  readonly method: string;
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-declare const RpcSuccessDecodeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "RpcSuccessDecodeError";
-} & Readonly<A>;
-declare class RpcSuccessDecodeError extends RpcSuccessDecodeError_base<{
-  readonly definition: string;
-  readonly method: string;
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-declare const RpcSuccessEncodeError_base: Schema.Class<RpcSuccessEncodeError, Schema.TaggedStruct<"RpcSuccessEncodeError", {
-  readonly definition: Schema.String;
-  readonly method: Schema.String;
-  readonly cause: Schema.Defect;
-}>, import("effect/Cause").YieldableError>;
-declare class RpcSuccessEncodeError extends RpcSuccessEncodeError_base {
-  get message(): string;
-}
-/** Errors raised server-side that must survive the Cloudflare RPC wire. */
-type WireError = RpcArgumentCountError | RpcArgumentDecodeError | RpcSuccessEncodeError;
-type WireValue = Schema.Schema.Type<typeof Schema.Unknown>;
-declare const isWireError: (error: WireValue) => error is WireError;
-/**
- * Encodes package RPC errors into a plain `Error` envelope so their tags
- * survive Cloudflare RPC serialization, which drops custom error properties.
- */
-declare const encodeWireError: (error: WireValue) => WireValue;
-declare const decodeWireError: (cause: WireValue) => WireValue;
-declare const reservedMethodNameValues: readonly ["constructor", "fetch", "connect", "alarm", "webSocketMessage", "webSocketClose", "webSocketError", "then", "dup", "dispose", "serialize", "deserialize"];
-declare const reservedMethodNames: Set<string>;
-type ReservedMethodName$3 = (typeof reservedMethodNameValues)[number];
-type ServiceFreeSchema$1 = Schema.Codec<any, any, never, never>;
-interface Method$2<Args extends ReadonlyArray<ServiceFreeSchema$1> = ReadonlyArray<ServiceFreeSchema$1>, Success extends ServiceFreeSchema$1 = ServiceFreeSchema$1> {
-  readonly args: Args;
-  readonly success: Success;
-}
-declare namespace Method$2 {
-  export type Any = Method$2<ReadonlyArray<ServiceFreeSchema$1>, ServiceFreeSchema$1>;
-  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$1>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$1>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
-  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$1>> = { [Index in keyof Args]: Schema.Json; };
-  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
-  export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
-  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
-  export type EncodedSuccess<_Self extends Any> = Schema.Json;
-  export {};
-}
-type Methods$1 = Record<string, Method$2.Any>;
-type NoReservedMethods$1<MethodDefinitions extends Methods$1, Reserved extends string = ReservedMethodName$3> = Extract<keyof MethodDefinitions, Reserved> extends never ? MethodDefinitions : never;
-interface Definition$3<Id extends string = string, MethodDefinitions extends Methods$1 = Methods$1> {
-  readonly id: Id;
-  readonly methods: MethodDefinitions;
-}
-declare namespace Definition$3 {
-  type Any = Definition$3<string, Methods$1>;
-  type ServerApi<Self extends Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$2.Args<Self["methods"][Key]>) => Promise<Method$2.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>;
-}
-type ReservedMethodValue = Schema.Schema.Type<typeof Schema.Unknown>;
-declare const assertNoReservedMethods: <MethodDefinitions extends Readonly<Record<string, ReservedMethodValue>>>(target: string, methods: MethodDefinitions, reserved: ReadonlySet<string>) => void;
-declare function method$1<Success extends ServiceFreeSchema$1>(definition: {
-  readonly success: Success;
-}): Method$2<readonly [], Success>;
-declare function method$1<const Args extends ReadonlyArray<ServiceFreeSchema$1>, Success extends ServiceFreeSchema$1>(definition: {
-  readonly args: Args;
-  readonly success: Success;
-}): Method$2<Args, Success>;
-declare const decodeArgs: <const Self extends Definition$3.Any, MethodName extends Definition$3.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$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [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$3.Any, MethodName extends Definition$3.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$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [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$1[]) ? { [Index in keyof T_1]: Schema.Json; } : never, RpcArgumentCountError | RpcArgumentEncodeError, never>;
-declare const encodeSuccess: <const Self extends Definition$3.Any, MethodName extends Definition$3.MethodNames<Self>>(definition: Self, methodName: MethodName, value: Method$2.Success<Self["methods"][MethodName]>) => Effect.Effect<Method$2.EncodedSuccess<Self["methods"][MethodName]>, RpcSuccessEncodeError>;
-declare const decodeSuccess: <const Self extends Definition$3.Any, MethodName extends Definition$3.MethodNames<Self>>(definition: Self, methodName: MethodName, value: WireValue) => Effect.Effect<Method$2.Success<Self["methods"][MethodName]>, RpcSuccessDecodeError>;
-declare const make$3: <Id extends string, const MethodDefinitions extends Methods$1>(id: Id, methods: MethodDefinitions) => Definition$3<Id, MethodDefinitions>;
-declare namespace QueueBinding_d_exports {
-  export { MessageSendRequest, QueueBindingClient, QueueBindingDefinition, QueueMetrics, QueueOperationError, QueueProducer, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse, isQueue, layer$1 as layer, makeClient$1 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">>;
-type QueueCandidate = Parameters<typeof Predicate.isUnknown>[0];
-interface QueueBindingDefinition<Message extends ServiceFreeSchema$1> {
-  readonly binding: string;
-  readonly message: Message;
-}
-interface QueueBindingClient<Message extends ServiceFreeSchema$1> {
-  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<QueueProducer<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: QueueCandidate) => value is QueueProducer<Body>;
-declare const makeClient$1: <Message extends ServiceFreeSchema$1>(definition: QueueBindingDefinition<Message>) => ((queue: QueueProducer<Schema.Codec.Encoded<Message>>) => QueueBindingClient<Message>);
-declare const layer$1: <Self, Message extends ServiceFreeSchema$1>(tag: Context.Service<Self, QueueBindingClient<Message>>, definition: QueueBindingDefinition<Message>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare namespace QueueDefinition_d_exports {
-  export { Definition$2 as Definition, Handler$1 as Handler, LayerOptions$2 as LayerOptions, Options$2 as Options, Queue$1 as Queue, Tag$2 as Tag, TagClass$2 as TagClass, implement$2 as implement, make$2 as make };
-}
-interface Definition$2<Id extends string = string, Message extends ServiceFreeSchema$1 = ServiceFreeSchema$1> {
-  readonly id: Id;
-  readonly message: Message;
-}
-declare namespace Definition$2 {
-  type Any = Definition$2<string, ServiceFreeSchema$1>;
-}
-type Handler$1<ROut, Self extends Definition$2.Any> = (batch: QueueBatch<Schema.Schema.Type<Self["message"]>>) => Effect.Effect<void, unknown, ExecutionContext | WorkerContext | WorkerEnvironment | Scope.Scope | ROut>;
-interface Options$2<ROut, Self extends Definition$2.Any> extends Omit<WorkerOptions<ROut, never, never, Record<never, never>>, "queue" | "rpc"> {
-  readonly queue: Handler$1<ROut, Self>;
-  readonly rpc?: never;
-}
-type LayerOptions$2 = {
-  readonly binding: string;
-};
-interface TagClass$2<Self, Id extends string, Message extends ServiceFreeSchema$1> 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$2<ROut, Definition$2<Id, Message>>) => WorkerClass<Record<never, never>, ROut>;
-  readonly layer: (options: LayerOptions$2) => 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<QueueProducer<Schema.Codec.Encoded<Message>>, never, Self>;
-}
-declare const make$2: <Id extends string, Message extends ServiceFreeSchema$1>(id: Id, definition: {
-  readonly message: Message;
-}) => TagClass$2<Definition$2<Id, Message>, Id, Message>;
-declare const Tag$2: <Self>() => <Id extends string, Message extends ServiceFreeSchema$1>(id: Id, definition: {
-  readonly message: Message;
-}) => TagClass$2<Self, Id, Message>;
-declare const Queue$1: typeof Tag$2;
-declare const implement$2: <ROut, const Self extends Definition$2.Any>(_definition: Self, handler: Handler$1<ROut, Self>) => Handler$1<ROut, Self>;
-declare namespace Queue_d_exports {
-  export { Definition$1 as Definition, Handler, LayerOptions$1 as LayerOptions, Options$1 as Options, QueueBatch, QueueHandler, QueueMessage, QueueMessageDecodeError, QueueOptions, Tag$1 as Tag, TagClass$1 as TagClass, decodeBatch, fromMessage, fromMessageBatch, implement$1 as implement };
-}
-interface QueueMessage<Body> {
-  readonly raw: globalThis.Message<unknown>;
-  readonly id: string;
-  readonly timestamp: Date;
-  readonly body: Body;
-  readonly attempts: number;
-  readonly ack: Effect.Effect<void>;
-  readonly retry: (options?: globalThis.QueueRetryOptions) => Effect.Effect<void>;
-}
-interface QueueBatch<Body> {
-  readonly raw: globalThis.MessageBatch<unknown>;
-  readonly messages: ReadonlyArray<QueueMessage<Body>>;
-  readonly queue: string;
-  readonly metadata: globalThis.MessageBatchMetadata;
-  readonly ackAll: Effect.Effect<void>;
-  readonly retryAll: (options?: globalThis.QueueRetryOptions) => Effect.Effect<void>;
-}
-declare const QueueMessageDecodeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "QueueMessageDecodeError";
-} & Readonly<A>;
-declare class QueueMessageDecodeError extends QueueMessageDecodeError_base<{
-  readonly queue: string;
-  readonly messageId: string;
-  readonly index: number;
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-type RuntimeContext<ROut> = ExecutionContext | WorkerContext | WorkerEnvironment | ROut;
-type QueueHandlerContext<ROut> = RuntimeContext<ROut> | Scope.Scope;
-type EncodedQueueBody = globalThis.Message<unknown>["body"];
-type QueueHandler<ROut, Body = unknown> = (batch: QueueBatch<Body>) => Effect.Effect<void, unknown, QueueHandlerContext<ROut>>;
-interface QueueOptions<ROut, Body = unknown> {
-  readonly queue: QueueHandler<ROut, Body>;
-}
-declare const fromMessage: <Body>(message: globalThis.Message<unknown>, body: Body) => {
-  raw: Message<unknown>;
-  id: string;
-  timestamp: Date;
-  body: Body;
-  attempts: number;
-  ack: Effect.Effect<void, never, never>;
-  retry: (options?: globalThis.QueueRetryOptions) => Effect.Effect<void, never, never>;
-};
-declare const fromMessageBatch: <Body>(batch: globalThis.MessageBatch<unknown>, messages: ReadonlyArray<QueueMessage<Body>>) => QueueBatch<Body>;
-declare const decodeBatch: <Body>(batch: globalThis.MessageBatch<unknown>, decodeBody: (body: EncodedQueueBody) => Effect.Effect<Body, unknown>) => Effect.Effect<QueueBatch<Body>, QueueMessageDecodeError>;
-type Definition$1<Id extends string = string, Message extends Definition$2.Any["message"] = Definition$2.Any["message"]> = Definition$2<Id, Message>;
-declare namespace Definition$1 {
-  type Any = Definition$2.Any;
-}
-type LayerOptions$1 = LayerOptions$2;
-type TagClass$1<Self, Id extends string, Message extends Definition$2.Any["message"]> = TagClass$2<Self, Id, Message>;
-declare const Tag$1: <Self>() => <Id extends string, Message extends Definition$2.Any["message"]>(id: Id, definition: {
-  readonly message: Message;
-}) => TagClass$1<Self, Id, Message>;
-declare const implement$1: typeof implement$2;
-type Handler<ROut, Self extends Definition$2.Any> = Handler$1<ROut, Self>;
-type Options$1<ROut, Self extends Definition$2.Any> = Options$2<ROut, Self>;
-declare namespace RpcTracing_d_exports {
-  export { ReceiverOptions, RpcInvocationInfo, RpcTraceContext, withRpcClientSpan, withRpcServerSpan, withRpcTraceContext };
-}
-/**
- * Live native RPC metadata. Opted-in receivers reserve a valid trailing value
- * with this tag for transport context; do not use it as a final domain argument.
- * Never store this in durable messages or envelopes.
- */
-declare const RpcTraceContext: Schema.Struct<{
-  readonly _tag: Schema.Literal<"effect-cf/RpcTraceContext/v1">;
-  readonly traceId: Schema.String;
-  readonly spanId: Schema.String;
-  readonly sampled: Schema.Boolean;
-}>;
-type RpcTraceContext = typeof RpcTraceContext.Type;
-interface ReceiverOptions {
-  /** Stable service name, never an instance id or capability URL. */
-  readonly service: string;
-}
-/** Per-invocation metadata passed to Worker and DurableObject RunSymbol overrides. */
-interface RpcInvocationInfo {
-  readonly service: string;
-  readonly method: string;
-  /** Native arguments with valid, opted-in trace metadata removed. Do not log them. */
-  readonly args: ReadonlyArray<unknown>;
-  /**
-   * Set after a definition-backed receiver decodes its arguments, before its
-   * handler runs. Absent before decoding and when decoding fails. Do not log it.
-   */
-  readonly decodedArgs?: ReadonlyArray<unknown>;
-  readonly parent?: RpcTraceContext;
-}
-/**
- * Appends the current live parent only for a receiver that has opted in.
- * Call this inside the CLIENT span, immediately before the native invocation.
- * With no valid propagating parent, the original argument array is returned.
- */
-declare const withRpcTraceContext: (args: readonly unknown[]) => Effect.Effect<readonly unknown[], never, never>;
-/** Wrap the whole call, including native result resolution and success decoding. */
-declare const withRpcClientSpan: <A, E, R>(effect: Effect.Effect<A, E, R>, binding: string, method: string) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>;
-/**
- * Optional application instrumentation for the entire receiver effect.
- * Use in a RunSymbol override to include argument decode, handler and encode.
- * Records stable service/method attributes and failure status, not argument or
- * error payloads. The original typed failure still propagates to the caller.
- */
-declare const withRpcServerSpan: <A, E, R>(effect: Effect.Effect<A, E, R>, invocation: RpcInvocationInfo) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>;
-//#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<any>) ? Key : never : never; }[keyof Api];
-type AsyncMethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...args: infer Args) => Promise<any>) ? 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, makeClient, makeDirectMethods };
-}
-declare const TypeId: "effect-cf/ServiceBinding";
-interface ServiceFetcher {
-  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
-}
-type RpcClient<Api> = { readonly [Key in keyof Api as Key extends string ? Api[Key] extends ((...args: Array<any>) => any) ? Key : never : never]: Api[Key]; };
-type ReservedMethodName$2 = ReservedMethodName$1 | "fetch";
-type ServiceBindingClient<Api extends object> = ServiceFetcher & RpcClient<Provider<Api, ReservedMethodName$2>>;
-type ApiFromDefinition<Definition$4> = Definition$4 extends Definition.Any ? ServerApi$1<Definition$4> : never;
-type ApiOrDefinition<Api extends object, Definition> = [Api] extends [never] ? ApiFromDefinition<Definition> : Api;
-/**
- * Binding metadata used to create an Effect service from a Worker binding.
- */
-interface ServiceBindingDefinition<Definition$5 extends Definition.Any | undefined = undefined> {
-  readonly binding: string;
-  readonly definition?: Definition$5;
-  /** Append live trace context only when the receiver also enables rpcTracing. */
-  readonly rpcTracing?: boolean;
-}
-declare const ServiceBindingFetchError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "ServiceBindingFetchError";
-} & Readonly<A>;
-/**
- * Failure raised when calling `fetch` on a service binding.
- */
-declare class ServiceBindingFetchError extends ServiceBindingFetchError_base<{
-  readonly binding: string;
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-declare const ServiceBindingRpcError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "ServiceBindingRpcError";
-} & Readonly<A>;
-/**
- * Failure raised when invoking an RPC method on a service binding.
- */
-declare class ServiceBindingRpcError extends ServiceBindingRpcError_base<{
-  readonly binding: string;
-  readonly method: string;
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-type ServiceMethodKey<Api> = AsyncMethodKey<Api>;
-type ServiceMethodArgs<Api, Method extends keyof Api> = AsyncMethodArgs<Api, Method>;
-type ServiceMethodSuccess<Api, Method extends keyof Api> = AsyncMethodSuccess<Api, Method>;
-type ServiceMethodCloudflareReturn<Api, Method extends keyof Api> = AsyncMethodCloudflareReturn<Api, Method>;
-type ServiceCall<R, Api> = <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError, R>;
-type DefinitionDirectMethods<R, Definition$9 extends Definition.Any> = { readonly [Method in Definition$3.MethodNames<Definition$9>]: (...args: Method$2.Args<Definition$9["methods"][Method]>) => Effect.Effect<Method$2.Success<Definition$9["methods"][Method]>, ServiceBindingRpcError, R>; };
-type DirectMethods<R, Definition$12> = Definition$12 extends Definition.Any ? DefinitionDirectMethods<R, Definition$12> : {};
-type ServiceBindingEffectClient<Api extends object, Definition$10 extends Definition.Any | undefined = undefined> = DirectMethods<never, Definition$10> & {
-  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.
-   */
-  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.
-   */
-  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.
-   */
-  readonly scopedCall: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, ServiceBindingRpcError, Scope.Scope>;
-};
-type ServiceBindingStaticClient<R, Api extends object, Definition$11 extends Definition.Any | undefined = undefined> = DirectMethods<R, Definition$11> & {
-  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>>, ServiceBindingRpcError, Scope.Scope | R>;
-};
-type ServiceBindingValue = Schema.Schema.Type<typeof Schema.Unknown>;
-declare const isServiceBindingClient: <Api extends object>(value: ServiceBindingValue) => value is ServiceBindingClient<Api>;
-declare const makeClient: <Api extends object, const Definition$6 extends Definition.Any | undefined = undefined>(definition: ServiceBindingDefinition<Definition$6>) => ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition$6>);
-declare const layer: <Self, Api extends object, const Definition$13 extends Definition.Any | undefined = undefined>(tag: Context.Service<Self, ServiceBindingEffectClient<Api, Definition$13>>, definition: ServiceBindingDefinition<Definition$13>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const Service: <Self, Api extends object = never>() => <Id extends string, const Definition$8 extends Definition.Any | undefined = undefined>(id: Id, definition: ServiceBindingDefinition<Definition$8>) => BindingService<Self, Id, ServiceBindingEffectClient<ApiOrDefinition<Api, Definition$8>, Definition$8>> & DirectMethods<Self, Definition$8> & {
-  readonly [TypeId]: typeof TypeId;
-  readonly definition: ServiceBindingDefinition<Definition$8>;
-  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$8>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$8>, Method>) => Effect.Effect<Result$1<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$8>, Method>>, ServiceBindingRpcError, Self>;
-  readonly call: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition$8>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$8>, Method>) => Effect.Effect<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$8>, Method>, ServiceBindingRpcError, Self>;
-  readonly scopedCall: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition$8>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$8>, Method>) => Effect.Effect<Awaited<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$8>, Method>>, ServiceBindingRpcError, Self | Scope.Scope>;
-};
-declare const makeDirectMethods: <R, Api, Definition$7 extends Definition.Any | undefined>(rpcDefinition: Definition$7 | undefined, call: ServiceCall<R, Api>) => DirectMethods<R, Definition$7>;
-declare namespace WorkerDefinition_d_exports {
-  export { Api, Definition, HandlerEffect, Handlers, LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options, ReservedMethodName$1 as ReservedMethodName, ServerApi$1 as ServerApi, ServiceFreeSchema, Tag, TagClass, Worker, implement, make$1 as make, method };
-}
-type ServiceFreeSchema = Schema.Codec<any, any, never, never>;
-interface Method$1<Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema = ServiceFreeSchema> {
-  readonly args: Args;
-  readonly success: Success;
-}
-declare namespace Method$1 {
-  export type Any = Method$1<ReadonlyArray<ServiceFreeSchema>, ServiceFreeSchema>;
-  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends ReadonlyArray<ServiceFreeSchema>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
-  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = { [Index in keyof Args]: Schema.Json; };
-  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
-  export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
-  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
-  export type EncodedSuccess<_Self extends Any> = Schema.Json;
-  export {};
-}
-type Methods = Record<string, Method$1.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<Id extends string = string, MethodDefinitions extends Methods = Methods> {
-  readonly id: Id;
-  readonly methods: MethodDefinitions;
-}
-declare namespace Definition {
-  type Any = Definition<string, Methods>;
-}
-type ReservedMethodName$1 = ReservedMethodName;
-type NoReservedMethods<MethodDefinitions extends Methods> = Extract<keyof MethodDefinitions, ReservedMethodName$1> extends never ? MethodDefinitions : never;
-/**
- * Promise-based client API derived from a {@link Definition}.
- */
-type ServerApi$1<Self extends Definition.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$1.Args<Self["methods"][Key]>) => Promise<Method$1.Success<Self["methods"][Key]>>; };
-type Api<Self extends Definition.Any> = Provider<ServerApi$1<Self>, ReservedMethodName$1>;
-/**
- * Effect handlers for each RPC method in a worker definition.
- */
-type Handlers<ROut, Self extends Definition.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$1.Args<Self["methods"][Key]>) => WorkerRpcHandler<ROut, Method$1.Success<Self["methods"][Key]>>; };
-type BaseOptions<ROut, Self extends Definition.Any, REvent, EventLayerError> = Omit<WorkerOptions<ROut, REvent, EventLayerError, Handlers<ROut | REvent, Self>>, "eventLayer" | "rpc"> & {
-  readonly rpc: Handlers<ROut | REvent, Self>;
-};
-type EventLayerOptions<ROut, REvent, EventLayerError> = [REvent] extends [never] ? Pick<WorkerOptions<ROut, never, EventLayerError>, "eventLayer"> : {
-  readonly eventLayer: NonNullable<WorkerOptions<ROut, REvent, EventLayerError>["eventLayer"]>;
-};
-/**
- * Worker constructor options for a specific RPC definition.
- */
-type Options<ROut, Self extends Definition.Any, REvent = never, EventLayerError = never> = BaseOptions<ROut, Self, REvent, EventLayerError> & EventLayerOptions<ROut, REvent, EventLayerError>;
-type LayerOptions = {
-  readonly binding: string;
-  readonly rpcTracing?: boolean;
-};
-type TagClass<Self, Id extends string, MethodDefinitions extends Methods> = Context.ServiceClass<Self, Id, ServiceBindingEffectClient<Api<Definition<Id, MethodDefinitions>>, Definition<Id, MethodDefinitions>>> & ServiceBindingStaticClient<Self, Api<Definition<Id, MethodDefinitions>>, Definition<Id, MethodDefinitions>> & {
-  readonly id: Id;
-  readonly methods: MethodDefinitions;
-  readonly make: {
-    <ROut, LayerError, REvent, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options<ROut, Definition<Id, MethodDefinitions>, REvent, EventLayerError> & {
-      readonly eventLayer: NonNullable<WorkerOptions<ROut, REvent, EventLayerError>["eventLayer"]>;
-    }): WorkerClass<Handlers<ROut | REvent, Definition<Id, MethodDefinitions>>, ROut | REvent>;
-    <ROut, LayerError, REvent extends never = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options<ROut, Definition<Id, MethodDefinitions>, REvent, EventLayerError>): WorkerClass<Handlers<ROut | REvent, Definition<Id, MethodDefinitions>>, ROut | REvent>;
-  };
-  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-};
-/**
- * Defines a single RPC method schema in a worker definition.
- */
-declare const method: {
-  <Success extends ServiceFreeSchema>(definition: {
-    readonly success: Success;
-  }): Method$1<readonly [], Success>;
-  <const Args extends ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema>(definition: {
-    readonly args: Args;
-    readonly success: Success;
-  }): Method$1<Args, Success>;
-};
-declare const make$1: <Id extends string, const MethodDefinitions extends Methods>(id: Id, methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>) => TagClass<Definition<Id, MethodDefinitions>, Id, MethodDefinitions>;
-declare const Tag: <Self>() => <Id extends string, const MethodDefinitions extends Methods>(id: Id, methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>) => TagClass<Self, Id, MethodDefinitions>;
-declare const Worker: typeof Tag;
-/**
- * Helper for implementing handlers with the exact method shape of a definition.
- */
-declare const implement: <ROut, const Self extends Definition.Any>(_definition: Self, handlers: Handlers<ROut, Self>) => Handlers<ROut, Self>;
-/**
- * Convenience alias for a single worker RPC handler Effect.
- */
-type HandlerEffect<ROut, Self extends Definition.Any, Key extends keyof Self["methods"]> = WorkerRpcHandler<ROut, Method$1.Success<Self["methods"][Key]>>;
-declare namespace Worker_d_exports {
-  export { Api, Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect, Handlers, LayerOptions, Method$1 as Method, Methods, NativeRequest, NoReservedMethods, Options, ReservedMethodName, RpcHandlers, RunOptions, RunSymbol, ServerApi$1 as ServerApi, ServiceFreeSchema, Tag, TagClass, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcContract, WorkerRpcHandler, WorkerRpcContract as WorkerRpcShape, implement, isWebSocketUpgrade, make, makeFetchHandler, method };
-}
-declare const ExecutionContext_base: Context.ServiceClass<ExecutionContext, "effect-cf/ExecutionContext", globalThis.ExecutionContext<unknown>>;
-declare class ExecutionContext extends ExecutionContext_base {}
-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";
-  readonly onFailure?: (cause: Cause.Cause<E>) => Effect.Effect<void, never, R>;
-}
-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>;
-  abort(reason?: string): Effect.Effect<void>;
-}
-declare const WorkerContext_base: Context.ServiceClass<WorkerContext, "effect-cf/WorkerContext", WorkerContextService>;
-declare class WorkerContext extends WorkerContext_base {}
-declare const NativeRequest_base: Context.ServiceClass<NativeRequest, "effect-cf/NativeRequest", Request<unknown, CfProperties<unknown>>>;
-declare class NativeRequest extends NativeRequest_base {}
-declare const isWebSocketUpgrade: (request: Request) => boolean;
-type ReservedMethodName = ReservedMethodName$3 | "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;
-/** Override to instrument the whole event, then call super[RunSymbol]. */
-declare const RunSymbol: unique symbol;
-declare const FetchSymbol: unique symbol;
-/** Metadata available before an event effect or its event layer starts. */
-interface RunOptions {
-  readonly event?: "fetch" | "rpc" | "queue";
-  readonly rpc?: RpcInvocationInfo;
-}
-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 WorkerRpcContract<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<ROut, Api> = { readonly [Key in keyof Api as Key extends keyof WorkerEntrypoint ? never : Key extends string ? Key extends ReservedMethodName ? never : [Api[Key]] extends [never] ? never : Api[Key] extends ((...args: Array<any>) => Promise<any>) ? Key : never : never]: Api[Key] extends ((...args: infer Args) => Promise<infer A>) ? (...args: Args) => WorkerRpcHandler<ROut, A> : never; };
-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. For fetch handlers that
-   * return an Effect `HttpServerResponse` stream, its scope remains open until
-   * the response body finishes or is canceled. Native `Response` values pass
-   * through unchanged, so their body streams do not carry this scoped-lifetime
-   * guarantee. Fetch, queue, and RPC handlers schedule a best-effort telemetry
-   * flush capped at two seconds.
-   */
-  readonly eventLayer?: Layer.Layer<REvent, EventLayerError, WorkerBaseContext<RRuntime>>;
-  readonly fetch?: Effect.Effect<WorkerFetchSuccess, unknown, WorkerFetchContext<RRuntime | REvent>>;
-  readonly queue?: QueueHandler<RRuntime | REvent>;
-  /**
-   * Optional RPC methods exposed as class instance methods.
-   *
-   * After every invocation, the configured OTLP flusher is scheduled through
-   * `WorkerContext.waitUntil`, including when the handler fails. The scheduled
-   * flush silently settles within two seconds even if the exporter does not.
-   */
-  readonly rpc?: Rpc;
-  /** Accept live native trace metadata. The client must also enable rpcTracing. */
-  readonly rpcTracing?: ReceiverOptions;
-}
-type WorkerOptionsWithEventLayer<RRuntime, REvent, EventLayerError, Rpc extends WorkerRpc<RRuntime | REvent> = Record<never, never>> = Omit<WorkerOptions<RRuntime, REvent, EventLayerError, Rpc>, "eventLayer"> & {
-  readonly eventLayer: Layer.Layer<REvent, EventLayerError, WorkerBaseContext<RRuntime>>;
-};
-type FetchWorkerOptions<RRuntime, REvent = never, EventLayerError = never> = Omit<WorkerOptions<RRuntime, REvent, EventLayerError, Record<never, never>>, "rpc"> & {
-  readonly rpc?: never;
-};
-type FetchWorkerOptionsWithEventLayer<RRuntime, REvent, EventLayerError> = Omit<FetchWorkerOptions<RRuntime, REvent, EventLayerError>, "eventLayer"> & {
-  readonly eventLayer: Layer.Layer<REvent, EventLayerError, WorkerBaseContext<RRuntime>>;
-};
-/**
- * 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>;
-  [RunSymbol]<A, E>(effect: Effect.Effect<A, E, WorkerRpcContext<ROut>>, options?: RunOptions): Promise<A>;
-  [FetchSymbol](request: Request, requestContext: globalThis.ExecutionContext): Promise<Response>;
-} & WorkerRpcContract<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>;
-}
-/**
- * Cloudflare creates a new `WorkerEntrypoint` instance for each native
- * invocation, so this base layer is not shared across invocations. Its managed
- * runtime has no deterministic disposal point in this adapter; use
- * `eventLayer` for resources whose finalizers must run with an event.
- */
-declare function make<ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, fetch: WorkerHandler<ROut>): WorkerClass<Record<never, never>, ROut>;
-declare function make<ROut, LayerError, REvent, EventLayerError = never, const Rpc extends WorkerRpc<ROut | REvent> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptionsWithEventLayer<ROut, REvent, EventLayerError, Rpc>): WorkerClass<Rpc, ROut | REvent>;
-declare function make<ROut, LayerError, REvent extends never = never, EventLayerError = never, const Rpc extends WorkerRpc<ROut | REvent> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptions<ROut, REvent, EventLayerError, Rpc>): WorkerClass<Rpc, ROut | REvent>;
-/**
- * Creates an `ExportedHandler`-compatible `{ fetch }` object backed by
- * {@link make}.
- *
- * The Effect runtime is cached per `env` identity, so the base layer builds
- * once for that cached handler. Request handlers and `eventLayer` receive fresh
- * `ExecutionContext` and `WorkerContext` services. A service constructed by the
- * cached base layer from either context instead captures the first request's
- * value, so construct invocation-bound services in `eventLayer`. Cloudflare
- * provides no isolate shutdown hook, so cached base-layer finalizers are not
- * guaranteed to run.
- */
-declare function makeFetchHandler<ROut, LayerError, REvent, EventLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptionsWithEventLayer<ROut, REvent, EventLayerError>): FetchHandler<Env>;
-declare function makeFetchHandler<ROut, LayerError, REvent extends never = never, EventLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptions<ROut, REvent, EventLayerError>): FetchHandler<Env>;
-//#endregion
-export { Provider as C, ServiceFreeSchema$1 as S, QueueBinding_d_exports as _, Worker_d_exports as a, ReservedMethodName$3 as b, AsyncMethodArgs as c, AsyncMethodSuccess as d, ReceiverOptions as f, QueueDefinition_d_exports as g, Queue_d_exports as h, WorkerContextWaitUntilOptions as i, AsyncMethodCloudflareReturn as l, RpcTracing_d_exports as m, NativeRequest as n, WorkerDefinition_d_exports as o, RpcInvocationInfo as p, WorkerContext as r, ServiceBinding_d_exports as s, ExecutionContext as t, AsyncMethodKey as u, Definition$3 as v, Rpc_d_exports as w, RpcDefinition_d_exports as x, Method$2 as y };