effect-cf 0.23.1 → 0.24.0

package/dist/WorkflowBinding-BECGNTzu.d.mts

@@ -0,0 +1,1081 @@
+import { c as WorkerEnvironment, n as BindingService, r as BindingValidationError, s as WorkerEnv, t as BindingNotFoundError } from "./Binding-Bq_FPzlt.mjs";
+import { Cause, Context, Effect, Layer, Option, Schema, Scope } from "effect";
+import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { RpcStub, RpcTarget, WorkerEntrypoint } from "cloudflare:workers";
+declare namespace DurableObjectStorage_d_exports {
+  export { DurableObjectStorage, DurableObjectTransaction, SchemaBackedSyncKvStorage, SqlCursor, SqlStorage, SqlStorageValue, StorageOperationError, SyncKvDefinition, SyncKvStorage, fromDurableObjectStorage };
+}
+/** Supported primitive value types for Durable Object SQL APIs. */
+type SqlStorageValue = globalThis.SqlStorageValue;
+declare const StorageOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "StorageOperationError";
+} & Readonly<A>;
+/** Error type used when a storage operation throws or rejects. */
+declare class StorageOperationError extends StorageOperationError_base<{
+  readonly operation: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+type StorageEffect<A> = Effect.Effect<A, StorageOperationError>;
+/**
+ * Effect wrapper for Cloudflare SQL cursor operations.
+ */
+interface SqlCursor<T extends Record<string, SqlStorageValue>> {
+  next(): StorageEffect<{
+    done?: false;
+    value: T;
+  } | {
+    done: true;
+    value?: never;
+  }>;
+  toArray(): StorageEffect<Array<T>>;
+  one(): StorageEffect<T>;
+  raw<U extends Array<SqlStorageValue>>(): StorageEffect<IterableIterator<U>>;
+  readonly columnNames: Array<string>;
+  readonly rowsRead: StorageEffect<number>;
+  readonly rowsWritten: StorageEffect<number>;
+}
+/**
+ * Effect wrapper for Durable Object SQLite APIs.
+ */
+interface SqlStorage {
+  /** Executes a SQL statement and returns a typed cursor. */
+  exec<T extends Record<string, SqlStorageValue>>(query: string, ...bindings: Array<SqlStorageValue>): StorageEffect<SqlCursor<T>>;
+  readonly databaseSize: number;
+}
+/**
+ * Schema pair used by `SyncKvStorage.schema(...)`.
+ */
+interface SyncKvDefinition<Key, Value, EncodedValue> {
+  readonly key: Schema.Codec<Key, string>;
+  readonly value: Schema.Codec<Value, EncodedValue>;
+}
+/**
+ * Sync KV wrapper that transparently encodes keys/values through Effect Schema.
+ */
+interface SchemaBackedSyncKvStorage<Key, Value> {
+  get(key: Key): Effect.Effect<Option.Option<Value>, unknown>;
+  put(key: Key, value: Value): Effect.Effect<void, unknown>;
+  delete(key: Key): Effect.Effect<boolean, unknown>;
+  list(options?: globalThis.SyncKvListOptions): Effect.Effect<Array<[Key, Value]>, unknown>;
+}
+/**
+ * Effect wrapper for synchronous KV attached to Durable Object SQLite storage.
+ */
+interface SyncKvStorage {
+  get<T = unknown>(key: string): StorageEffect<T | undefined>;
+  put<T>(key: string, value: T): StorageEffect<void>;
+  delete(key: string): StorageEffect<boolean>;
+  list<T = unknown>(options?: globalThis.SyncKvListOptions): StorageEffect<Array<[string, T]>>;
+  schema<Key, Value, EncodedValue>(definition: SyncKvDefinition<Key, Value, EncodedValue>): SchemaBackedSyncKvStorage<Key, Value>;
+}
+/**
+ * Effect wrapper around Cloudflare transaction callbacks.
+ */
+interface DurableObjectTransaction {
+  get<T = unknown>(key: string, options?: globalThis.DurableObjectGetOptions): StorageEffect<T | undefined>;
+  get<T = unknown>(keys: Array<string>, options?: globalThis.DurableObjectGetOptions): StorageEffect<Map<string, T>>;
+  list<T = unknown>(options?: globalThis.DurableObjectListOptions): StorageEffect<Map<string, T>>;
+  put<T>(key: string, value: T, options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
+  put<T>(entries: Record<string, T>, options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
+  delete(key: string, options?: globalThis.DurableObjectPutOptions): StorageEffect<boolean>;
+  delete(keys: Array<string>, options?: globalThis.DurableObjectPutOptions): StorageEffect<number>;
+  rollback(): StorageEffect<void>;
+  getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
+  setAlarm(scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
+  deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
+}
+/**
+ * Effect wrapper around Cloudflare Durable Object storage.
+ *
+ * @example
+ * ```ts
+ * const program = Effect.gen(function* () {
+ *   const state = yield* DurableObjectState;
+ *   yield* state.storage.put("counter", 1);
+ *   const value = yield* state.storage.get<number>("counter");
+ *   return value;
+ * });
+ * ```
+ */
+interface DurableObjectStorage {
+  get<T = unknown>(key: string, options?: globalThis.DurableObjectGetOptions): StorageEffect<T | undefined>;
+  put<T>(key: string, value: T, options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
+  delete(key: string, options?: globalThis.DurableObjectPutOptions): StorageEffect<boolean>;
+  /**
+   * Deletes all stored data. On compatibility dates before 2026-02-24, Cloudflare
+   * documents that active alarms must be deleted separately with `deleteAlarm()`.
+   */
+  deleteAll(options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
+  getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
+  setAlarm(scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
+  deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
+  /**
+   * SQLite-backed Durable Object storage only.
+   *
+   * The callback Effect must complete synchronously. If it requires asynchronous
+   * work, use `transaction` instead so Cloudflare can run the async transaction
+   * callback under the platform's transaction contract.
+   */
+  transactionSync<A, E, R>(closure: () => Effect.Effect<A, E, R>): Effect.Effect<A, E | StorageOperationError, R>;
+  /**
+   * Runs an async transaction and exposes a typed transaction wrapper.
+   */
+  transaction<A, E, R>(closure: (txn: DurableObjectTransaction) => Effect.Effect<A, E, R>): Effect.Effect<A, E | StorageOperationError, R>;
+  /** Flushes pending writes to disk. */
+  sync(): StorageEffect<void>;
+  /** SQLite-backed Durable Object storage point-in-time recovery API only. */
+  getCurrentBookmark(): StorageEffect<string>;
+  /** SQLite-backed Durable Object storage point-in-time recovery API only. */
+  onNextSessionRestoreBookmark(bookmark: string): StorageEffect<string>;
+  readonly sql: SqlStorage;
+  readonly kv: SyncKvStorage;
+}
+/**
+ * Wraps native Cloudflare storage APIs as Effect-returning helpers.
+ */
+declare const fromDurableObjectStorage: (storage: globalThis.DurableObjectStorage) => DurableObjectStorage;
+declare namespace DurableObjectWebSocket_d_exports {
+  export { AcceptUpgradeOptions, AcceptedUpgrade, AttachmentInvalidPolicy, AttachmentRehydrateOptions, DurableWebSocket, DurableWebSocketAttachment, DurableWebSocketAttachmentError, DurableWebSocketCloseError, DurableWebSocketHandlers, DurableWebSocketSendData, DurableWebSocketSendError, RehydratedDurableWebSocket, acceptUpgrade, attachment, fromWebSocket, handlers };
+}
+/** Data supported by Cloudflare websocket `send`. */
+type DurableWebSocketSendData = string | ArrayBuffer | ArrayBufferView;
+declare const DurableWebSocketSendError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "DurableWebSocketSendError";
+} & Readonly<A>;
+/** Error raised when sending on a Durable Object websocket fails. */
+declare class DurableWebSocketSendError extends DurableWebSocketSendError_base<{
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+declare const DurableWebSocketCloseError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "DurableWebSocketCloseError";
+} & Readonly<A>;
+/** Error raised when closing a Durable Object websocket fails. */
+declare class DurableWebSocketCloseError extends DurableWebSocketCloseError_base<{
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+declare const DurableWebSocketAttachmentError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "DurableWebSocketAttachmentError";
+} & Readonly<A>;
+/** Error raised when serializing or deserializing a websocket attachment fails. */
+declare class DurableWebSocketAttachmentError extends DurableWebSocketAttachmentError_base<{
+  readonly operation: "serialize" | "deserialize";
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+/** Effect-native wrapper around a hibernatable Durable Object websocket. */
+interface DurableWebSocket<Attachment = unknown> {
+  /** Underlying Cloudflare websocket. */
+  readonly raw: WebSocket;
+  /** Sends a message through the socket. */
+  send(data: DurableWebSocketSendData): Effect.Effect<void, DurableWebSocketSendError>;
+  /** Closes the socket. */
+  close(code?: number, reason?: string): Effect.Effect<void, DurableWebSocketCloseError>;
+  /** Serializes hibernation attachment metadata onto the socket. */
+  serializeAttachment<A = Attachment>(value: A): Effect.Effect<void, DurableWebSocketAttachmentError>;
+  /** Deserializes hibernation attachment metadata from the socket. */
+  readonly deserializeAttachment: Effect.Effect<unknown, DurableWebSocketAttachmentError>;
+}
+/** Wraps a native Cloudflare websocket in the Effect-native Durable Object API. */
+declare const fromWebSocket: <Attachment = unknown>(raw: WebSocket) => DurableWebSocket<Attachment>;
+/**
+ * Options for accepting an incoming websocket request in a Durable Object.
+ */
+interface AcceptUpgradeOptions<Attachment = unknown> {
+  /** Optional websocket tags for Durable Object hibernation filtering. */
+  readonly tags?: ReadonlyArray<string> | undefined;
+  /** Optional attachment serialized onto the server socket. */
+  readonly attachment?: Attachment | undefined;
+}
+/**
+ * Result of a websocket upgrade accepted by {@link acceptUpgrade}.
+ */
+interface AcceptedUpgrade<Attachment = unknown> {
+  readonly client: WebSocket;
+  readonly server: DurableWebSocket<Attachment>;
+  readonly response: Response;
+}
+/**
+ * Accepts a websocket upgrade and registers the server socket on `DurableObjectState`.
+ *
+ * @example
+ * ```ts
+ * const response = yield* DurableObjectWebSocket.acceptUpgrade({
+ *   tags: ["room:general"],
+ * });
+ *
+ * return response.response;
+ * ```
+ */
+declare const acceptUpgrade: <Attachment = unknown>(options?: AcceptUpgradeOptions<Attachment> | undefined) => Effect.Effect<AcceptedUpgrade<Attachment>, DurableWebSocketAttachmentError, DurableObjectState>;
+type AttachmentInvalidPolicy = "ignore" | "ignore-and-close" | "fail";
+interface AttachmentRehydrateOptions {
+  /** Optional Durable Object websocket tag filter. */
+  readonly tag?: string | undefined;
+  /** Invalid attachment behavior. Defaults to skipping invalid sockets. */
+  readonly onInvalid?: AttachmentInvalidPolicy | undefined;
+}
+interface RehydratedDurableWebSocket<Attachment> {
+  readonly socket: DurableWebSocket<Attachment>;
+  readonly attachment: Attachment;
+}
+interface DurableWebSocketAttachment<Attachment, Encoded> {
+  serialize(socket: DurableWebSocket<unknown>, value: Attachment): Effect.Effect<void, DurableWebSocketAttachmentError>;
+  deserialize(socket: DurableWebSocket<unknown>): Effect.Effect<Option.Option<Attachment>, DurableWebSocketAttachmentError>;
+  rehydrate(options?: AttachmentRehydrateOptions): Effect.Effect<Array<RehydratedDurableWebSocket<Attachment>>, DurableWebSocketAttachmentError, DurableObjectState>;
+  readonly schema: Schema.Codec<Attachment, Encoded, never, never>;
+}
+/** Creates typed attachment helpers for accepted and rehydrated sockets. */
+declare const attachment: <const AttachmentSchema extends Schema.Codec<any, any, never, never>>(schema: AttachmentSchema) => DurableWebSocketAttachment<Schema.Schema.Type<AttachmentSchema>, Schema.Codec.Encoded<AttachmentSchema>>;
+interface DurableWebSocketHandlers<R = never, E = unknown> {
+  readonly message?: (socket: DurableWebSocket, message: string | ArrayBuffer) => Effect.Effect<void, E, R>;
+  readonly close?: (socket: DurableWebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, E, R>;
+  readonly error?: (socket: DurableWebSocket, error: unknown) => Effect.Effect<void, E, R>;
+}
+/** Maps compact websocket lifecycle handler names to `DurableObject.make` options. */
+declare const handlers: <R = never, E = unknown>(options: DurableWebSocketHandlers<R, E>) => {
+  webSocketMessage: ((socket: DurableWebSocket, message: string | ArrayBuffer) => Effect.Effect<void, E, R>) | undefined;
+  webSocketClose: ((socket: DurableWebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, E, R>) | undefined;
+  webSocketError: ((socket: DurableWebSocket, error: unknown) => Effect.Effect<void, E, R>) | undefined;
+};
+declare namespace Rpc_d_exports {
+  export { DisposableValue, MethodArgs, MethodKey, MethodReturn, Provider, Result$1 as Result, RpcStub, RpcTarget, Serializable, Stub, Stubable, Stubify, dispose, isDisposable, resolve, scoped };
+}
+type Stubable = Rpc.Stubable;
+type Stub<T extends Stubable> = Rpc.Stub<T>;
+type Provider<T extends object, Reserved extends string = never> = Rpc.Provider<T, Reserved>;
+type BaseType = void | undefined | null | boolean | number | bigint | string | TypedArray | ArrayBuffer | DataView | Date | Error | RegExp | ReadableStream<Uint8Array> | WritableStream<Uint8Array> | Request | Response | Headers;
+type Serializable<T> = BaseType | Map<T extends Map<infer Key, unknown> ? Serializable<Key> : never, T extends Map<unknown, infer Value> ? Serializable<Value> : never> | Set<T extends Set<infer Value> ? Serializable<Value> : never> | ReadonlyArray<T extends ReadonlyArray<infer Value> ? Serializable<Value> : never> | { [Key in keyof T]: Key extends number | string ? Serializable<T[Key]> : never; } | Stub<Stubable> | Stubable;
+type Stubify<T> = T extends Stubable ? Stub<T> : T extends Map<infer Key, infer Value> ? Map<Stubify<Key>, Stubify<Value>> : T extends Set<infer Value> ? Set<Stubify<Value>> : T extends Array<infer Value> ? Array<Stubify<Value>> : T extends ReadonlyArray<infer Value> ? ReadonlyArray<Stubify<Value>> : T extends BaseType ? T : T extends {
+  [key: string | number]: unknown;
+} ? { [Key in keyof T]: Stubify<T[Key]>; } : T;
+type MaybeProvider<T> = T extends object ? Provider<T> : unknown;
+type MaybeDisposable<T> = T extends object ? Disposable : unknown;
+type Result$1<T> = T extends Stubable ? Promise<Stub<T>> & Provider<T> : T extends Serializable<T> ? Promise<Stubify<T> & MaybeDisposable<T>> & MaybeProvider<T> : never;
+type MethodKey<Api> = { [Key in keyof Api]-?: Key extends string ? Api[Key] extends ((...args: Array<any>) => unknown) ? Key : never : never; }[keyof Api];
+type MethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...args: infer Args) => unknown) ? Args : never;
+type MethodReturn<Api, Method extends keyof Api> = Api[Method] extends ((...args: Array<any>) => infer Return) ? Return : never;
+type DisposableValue = {
+  [Symbol.dispose](): void;
+};
+declare const isDisposable: (value: unknown) => value is DisposableValue;
+declare const dispose: (value: unknown) => Effect.Effect<void>;
+declare const resolve: <A>(value: A) => Effect.Effect<Awaited<A>, unknown>;
+declare const scoped: <A>(value: A) => Effect.Effect<Awaited<A>, unknown, Scope.Scope>;
+declare namespace RpcDefinition_d_exports {
+  export { Definition$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;
+declare const isWireError: (error: unknown) => error is WireError;
+/**
+ * Encodes package RPC errors into a plain `Error` envelope so their tags
+ * survive Cloudflare RPC serialization, which drops custom error properties.
+ */
+declare const encodeWireError: (error: unknown) => unknown;
+/** Restores package RPC errors from the {@link encodeWireError} envelope. */
+declare const decodeWireError: (cause: unknown) => unknown;
+declare const reservedMethodNames: Set<string>;
+type ReservedMethodName$3 = "constructor" | "fetch" | "connect" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError" | "then" | "dup" | "dispose" | "serialize" | "deserialize";
+type ServiceFreeSchema$1 = Schema.Codec<any, any, never, never>;
+interface Method$2<Args extends ReadonlyArray<ServiceFreeSchema$1> = ReadonlyArray<ServiceFreeSchema$1>, Success extends ServiceFreeSchema$1 = ServiceFreeSchema$1> {
+  readonly args: Args;
+  readonly success: Success;
+}
+declare namespace Method$2 {
+  export type Any = Method$2<ReadonlyArray<ServiceFreeSchema$1>, ServiceFreeSchema$1>;
+  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$1>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$1>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
+  /** Method schemas cross the wire through their canonical JSON codec. */
+  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$1>> = { [Index in keyof Args]: Schema.Json; };
+  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
+  export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
+  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
+  export type EncodedSuccess<Self extends Any> = Schema.Json;
+  export {};
+}
+type Methods$1 = Record<string, Method$2.Any>;
+type NoReservedMethods$1<MethodsShape extends Methods$1, Reserved extends string = ReservedMethodName$3> = Extract<keyof MethodsShape, Reserved> extends never ? MethodsShape : never;
+interface Definition$3<Id extends string = string, MethodsShape extends Methods$1 = Methods$1> {
+  readonly id: Id;
+  readonly methods: MethodsShape;
+}
+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>;
+}
+declare const assertNoReservedMethods: (target: string, methods: Record<string, unknown>, 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: unknown) => Effect.Effect<Method$2.Success<Self["methods"][MethodName]>, RpcSuccessDecodeError>;
+declare const make$3: <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape) => Definition$3<Id, MethodsShape>;
+declare namespace QueueBinding_d_exports {
+  export { MessageSendRequest, QueueBindingClient, QueueBindingDefinition, QueueMetrics, QueueOperationError, QueueProducer, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse, isQueue, layer$2 as layer, makeClient$2 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$1> {
+  /** 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$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<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$2: <Message extends ServiceFreeSchema$1>(definition: QueueBindingDefinition<Message>) => ((queue: QueueProducer<Schema.Codec.Encoded<Message>>) => QueueBindingClient<Message>);
+declare const layer$2: <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, 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<globalThis.Queue<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 QueueHandler<ROut, Body = unknown> = (batch: QueueBatch<Body>) => Effect.Effect<void, unknown, QueueHandlerContext<ROut>>;
+interface QueueOptions<ROut, Body = unknown> {
+  readonly queue: QueueHandler<ROut, Body>;
+}
+declare const fromMessage: <Body>(message: globalThis.Message<unknown>, body: Body) => {
+  raw: Message<unknown>;
+  id: string;
+  timestamp: Date;
+  body: Body;
+  attempts: number;
+  ack: Effect.Effect<void, never, never>;
+  retry: (options?: globalThis.QueueRetryOptions) => Effect.Effect<void, never, never>;
+};
+declare const fromMessageBatch: <Body>(batch: globalThis.MessageBatch<unknown>, messages: ReadonlyArray<QueueMessage<Body>>) => QueueBatch<Body>;
+declare const decodeBatch: <Body>(batch: globalThis.MessageBatch<unknown>, decodeBody: (body: unknown) => Effect.Effect<Body, unknown>) => Effect.Effect<QueueBatch<Body>, QueueMessageDecodeError>;
+type Definition$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>;
+//#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$1 as layer, makeClient$1 as makeClient, makeDirectMethods };
+}
+declare const TypeId: "effect-cf/ServiceBinding";
+/**
+ * Minimum shape for a Cloudflare service binding.
+ */
+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>) => unknown) ? Key : never : never]: Api[Key]; };
+type ReservedMethodName$2 = ReservedMethodName$1 | "fetch";
+/**
+ * Native Cloudflare service object including optional RPC methods.
+ */
+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$9 extends Definition.Any | undefined = undefined> {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+  /** Optional RPC schema used for argument/result encoding. */
+  readonly definition?: Definition$9;
+}
+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$13 extends Definition.Any> = { readonly [Method in Definition$3.MethodNames<Definition$13>]: (...args: Method$2.Args<Definition$13["methods"][Method]>) => Effect.Effect<Method$2.Success<Definition$13["methods"][Method]>, ServiceBindingRpcError, R>; };
+type DirectMethods<R, Definition$10> = Definition$10 extends Definition.Any ? DefinitionDirectMethods<R, Definition$10> : {};
+type ServiceBindingEffectClient<Api extends object, Definition$6 extends Definition.Any | undefined = undefined> = DirectMethods<never, Definition$6> & {
+  /**
+   * 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$7 extends Definition.Any | undefined = undefined> = DirectMethods<R, Definition$7> & {
+  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$1: <Api extends object, const Definition$8 extends Definition.Any | undefined = undefined>(definition: ServiceBindingDefinition<Definition$8>) => ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition$8>);
+declare const layer$1: <Self, Api extends object, const Definition$12 extends Definition.Any | undefined = undefined>(tag: Context.Service<Self, ServiceBindingEffectClient<Api, Definition$12>>, definition: ServiceBindingDefinition<Definition$12>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+/**
+ * Creates a typed Effect service for a Worker service binding.
+ *
+ * Returned value includes:
+ * - a Context tag for dependency injection
+ * - `fetch(...)` for raw HTTP forwarding
+ * - `rpc(...)` for raw Cloudflare RPC results
+ * - `call(...)` for resolved and decoded RPC results
+ * - `scopedCall(...)` for scoped and decoded disposable RPC results
+ * - direct RPC methods when `definition` is provided
+ *
+ * @example
+ * ```ts
+ * const Counter = WorkerDefinition.make("Counter", {
+ *   increment: WorkerDefinition.method({
+ *     args: [Schema.Number],
+ *     success: Schema.Number,
+ *   }),
+ * });
+ *
+ * const CounterLive = Counter.layer({ binding: "COUNTER" });
+ *
+ * const program = Effect.gen(function* () {
+ *   const counter = yield* Counter;
+ *   const next = yield* counter.increment(1);
+ *   return next;
+ * });
+ * ```
+ */
+declare const Service: <Self, Api extends object = never>() => <Id extends string, const Definition$5 extends Definition.Any | undefined = undefined>(id: Id, definition: ServiceBindingDefinition<Definition$5>) => BindingService<Self, Id, ServiceBindingEffectClient<ApiOrDefinition<Api, Definition$5>, Definition$5>> & DirectMethods<Self, Definition$5> & {
+  readonly [TypeId]: typeof TypeId;
+  readonly definition: ServiceBindingDefinition<Definition$5>;
+  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$5>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$5>, Method>) => Effect.Effect<Result$1<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$5>, Method>>, ServiceBindingRpcError, Self>;
+  readonly call: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition$5>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$5>, Method>) => Effect.Effect<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$5>, Method>, ServiceBindingRpcError, Self>;
+  readonly scopedCall: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition$5>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$5>, Method>) => Effect.Effect<Awaited<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$5>, Method>>, unknown, Self | Scope.Scope>;
+};
+declare const makeDirectMethods: <R, Api, Definition$11 extends Definition.Any | undefined>(rpcDefinition: Definition$11 | undefined, call: ServiceCall<R, Api>) => DirectMethods<R, Definition$11>;
+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]>>;
+  /** Method schemas cross the wire through their canonical JSON codec. */
+  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = { [Index in keyof Args]: Schema.Json; };
+  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
+  export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
+  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
+  export type EncodedSuccess<Self extends Any> = Schema.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, MethodsShape extends Methods = Methods> {
+  readonly id: Id;
+  readonly methods: MethodsShape;
+}
+declare namespace Definition {
+  type Any = Definition<string, Methods>;
+}
+type ReservedMethodName$1 = ReservedMethodName;
+type NoReservedMethods<MethodsShape extends Methods> = Extract<keyof MethodsShape, ReservedMethodName$1> extends never ? MethodsShape : 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]>>; };
+/**
+ * Worker constructor options for a specific RPC definition.
+ */
+interface Options<ROut, Self extends Definition.Any, REvent = never, EventLayerError = never> extends Omit<WorkerOptions<ROut, REvent, EventLayerError, Handlers<ROut | REvent, Self>>, "rpc"> {
+  readonly rpc: Handlers<ROut | REvent, Self>;
+}
+type LayerOptions = {
+  readonly binding: string;
+};
+type TagClass<Self, Id extends string, MethodsShape extends Methods> = Context.ServiceClass<Self, Id, ServiceBindingEffectClient<Api<Definition<Id, MethodsShape>>, Definition<Id, MethodsShape>>> & ServiceBindingStaticClient<Self, Api<Definition<Id, MethodsShape>>, Definition<Id, MethodsShape>> & {
+  readonly id: Id;
+  readonly methods: MethodsShape;
+  readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options<ROut, Definition<Id, MethodsShape>, REvent, EventLayerError>) => WorkerClass<Handlers<ROut | REvent, Definition<Id, MethodsShape>>, 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 MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape>) => TagClass<Definition<Id, MethodsShape>, Id, MethodsShape>;
+declare const Tag: <Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape>) => TagClass<Self, Id, MethodsShape>;
+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, ServerApi$1 as ServerApi, ServiceFreeSchema, Tag, TagClass, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcHandler, WorkerRpcShape, implement, isWebSocketUpgrade, make, makeFetchHandler, method };
+}
+declare const ExecutionContext_base: Context.ServiceClass<ExecutionContext, "effect-cf/ExecutionContext", globalThis.ExecutionContext<unknown>>;
+/**
+ * Access to Cloudflare's native `ExecutionContext`.
+ */
+declare class ExecutionContext extends ExecutionContext_base {}
+/**
+ * Options for {@link WorkerContextService.waitUntil}.
+ */
+interface WorkerContextWaitUntilOptions<E, R> {
+  /**
+   * Failure mode for the background effect: `"observe"` (default) logs or
+   * routes the failure to `onFailure`, while `"propagate"` also rejects the
+   * native `waitUntil` promise.
+   */
+  readonly mode?: "observe" | "propagate";
+  /** Custom failure handler for the background effect. */
+  readonly onFailure?: (cause: Cause.Cause<E>) => Effect.Effect<void, never, R>;
+}
+/**
+ * Effect wrapper around `ExecutionContext` background APIs.
+ */
+interface WorkerContextService {
+  readonly raw: globalThis.ExecutionContext;
+  waitUntil<A, E, R, R2 = never>(effect: Effect.Effect<A, E, R>, options?: WorkerContextWaitUntilOptions<E, R2>): Effect.Effect<void, never, R | R2>;
+  waitUntilPropagating<A, E, R, R2 = never>(effect: Effect.Effect<A, E, R>, options?: Omit<WorkerContextWaitUntilOptions<E, R2>, "mode">): Effect.Effect<void, never, R | R2>;
+  readonly passThroughOnException: Effect.Effect<void>;
+}
+declare const WorkerContext_base: Context.ServiceClass<WorkerContext, "effect-cf/WorkerContext", WorkerContextService>;
+/**
+ * Service used inside handlers to schedule background work via `waitUntil`.
+ *
+ * @example
+ * ```ts
+ * const handler = Effect.gen(function* () {
+ *   const ctx = yield* Worker.WorkerContext;
+ *   yield* ctx.waitUntil(Effect.log("flush analytics"));
+ *   return new Response("ok");
+ * });
+ * ```
+ */
+declare class WorkerContext extends WorkerContext_base {}
+declare const NativeRequest_base: Context.ServiceClass<NativeRequest, "effect-cf/NativeRequest", Request<unknown, CfProperties<unknown>>>;
+/**
+ * Access to the incoming `Request` currently handled by a worker or Durable Object fetch.
+ */
+declare class NativeRequest extends NativeRequest_base {}
+/**
+ * Returns `true` when the request is a websocket upgrade request.
+ */
+declare const isWebSocketUpgrade: (request: Request) => boolean;
+type ReservedMethodName = 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;
+/**
+ * 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<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<unknown>) ? Key : never : never]: Api[Key] extends ((...args: infer Args) => Promise<infer A>) ? (...args: Args) => WorkerRpcHandler<ROut, A> : never; };
+/**
+ * Options for creating a worker class with Effect handlers.
+ */
+interface WorkerOptions<RRuntime, REvent = never, EventLayerError = never, Rpc extends WorkerRpc<RRuntime | REvent> = Record<never, never>> {
+  /**
+   * Layer provided around each Cloudflare event handled by this Worker.
+   *
+   * The layer is built inside the event's Effect scope and finalized when the
+   * event effect completes. Use this for event-scoped resources such as OTLP
+   * trace/log exporters that should flush at event completion.
+   */
+  readonly eventLayer?: Layer.Layer<REvent, EventLayerError, WorkerBaseContext<RRuntime>>;
+  /** Main request handler. */
+  readonly fetch?: Effect.Effect<WorkerFetchSuccess, unknown, WorkerFetchContext<RRuntime | REvent>>;
+  /** Queue consumer handler invoked per message batch. */
+  readonly queue?: QueueHandler<RRuntime | REvent>;
+  /** Optional RPC methods exposed as class instance methods. */
+  readonly rpc?: Rpc;
+}
+type FetchWorkerOptions<RRuntime, REvent = never, EventLayerError = never> = Omit<WorkerOptions<RRuntime, REvent, EventLayerError, Record<never, never>>, "rpc"> & {
+  readonly rpc?: never;
+};
+/**
+ * Cloudflare `WorkerEntrypoint` constructor produced by {@link make}.
+ */
+type WorkerClass<Rpc extends WorkerRpc<ROut>, ROut> = new (ctx: globalThis.ExecutionContext, env: WorkerEnv) => WorkerEntrypoint<WorkerEnv> & {
+  fetch(request: Request): Promise<Response>;
+  queue(batch: globalThis.MessageBatch): Promise<void>;
+} & WorkerRpcShape<Rpc, ROut>;
+/**
+ * `ExportedHandler`-compatible fetch object produced by {@link makeFetchHandler}.
+ */
+interface FetchHandler<Env extends WorkerEnv = WorkerEnv> {
+  readonly fetch: (request: Request, env: Env, ctx: globalThis.ExecutionContext) => Promise<Response>;
+}
+/**
+ * Creates a Cloudflare worker class backed by a single managed Effect runtime.
+ *
+ * The runtime layer is built when Cloudflare constructs the class and reused
+ * for every event the instance handles. Layer finalizers do not run when the
+ * isolate is evicted; Cloudflare provides no shutdown hook. Use `eventLayer`
+ * for resources that must be finalized per event.
+ *
+ * @example
+ * ```ts
+ * export default Worker.make(Layer.empty, {
+ *   fetch: Effect.succeed(new Response("ok")),
+ * });
+ * ```
+ */
+declare function make<ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, fetch: WorkerHandler<ROut>): WorkerClass<Record<never, never>, ROut>;
+declare function make<ROut, LayerError, REvent = never, EventLayerError = never, const Rpc extends WorkerRpc<ROut | REvent> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptions<ROut, REvent, EventLayerError, Rpc>): WorkerClass<Rpc, ROut | REvent>;
+/**
+ * Creates an `ExportedHandler`-compatible `{ fetch }` object backed by
+ * {@link make}.
+ *
+ * The Effect runtime is cached per `env` identity, so the user layer builds
+ * once per isolate instead of once per request. `ExecutionContext`-backed
+ * services (`Worker.ExecutionContext`, `Worker.WorkerContext`) are still
+ * provided fresh for every request. Layer finalizers do not run when the
+ * isolate is evicted; Cloudflare provides no shutdown hook. Use `eventLayer`
+ * for resources that must be finalized per event.
+ */
+declare const makeFetchHandler: <ROut, LayerError, REvent = never, EventLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptions<ROut, REvent, EventLayerError>) => FetchHandler<Env>;
+declare namespace DurableObjectState_d_exports {
+  export { DurableObjectState, DurableObjectStateService, fromDurableObjectState };
+}
+/**
+ * Effect-friendly wrapper around Cloudflare `DurableObjectState`.
+ */
+interface DurableObjectStateService {
+  /** Underlying Cloudflare state instance. */
+  readonly raw: globalThis.DurableObjectState;
+  /** Durable Object id for the current instance. */
+  readonly id: globalThis.DurableObjectId;
+  /** Wrapped storage API. */
+  readonly storage: DurableObjectStorage;
+  /** Registers background work with Cloudflare's lifecycle. */
+  waitUntil(promise: Promise<unknown>): Effect.Effect<void>;
+  /**
+   * Runs a background Effect via Cloudflare's `waitUntil` with the caller's
+   * Effect context, mirroring `WorkerContext.waitUntil` failure modes:
+   * `"observe"` (default) logs or routes failures to `onFailure`, while
+   * `"propagate"` also rejects the native `waitUntil` promise.
+   */
+  waitUntil<A, E, R, R2 = never>(effect: Effect.Effect<A, E, R>, options?: WorkerContextWaitUntilOptions<E, R2>): Effect.Effect<void, never, R | R2>;
+  /**
+   * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate.
+   *
+   * Cloudflare resets a Durable Object if the callback throws/rejects, or if the
+   * callback exceeds the platform timeout (currently documented as 30 seconds).
+   * This safe default resolves the callback with the Effect `Exit` for typed
+   * Effect failures and resumes that `Exit` afterward, so typed failures remain
+   * ordinary Effect failures instead of resetting the Durable Object. Defects
+   * and interruptions still reject the callback.
+   */
+  blockConcurrencyWhile<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
+  /**
+   * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate and lets
+   * Effect failures reject the callback.
+   *
+   * Use this only when Cloudflare's reset-on-throw behavior is intentional. The
+   * platform also resets the Durable Object if the callback exceeds the
+   * documented timeout (currently 30 seconds).
+   */
+  blockConcurrencyWhileOrReset<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
+  /** Accepts a websocket connection for hibernation-capable Durable Objects. */
+  acceptWebSocket(ws: DurableWebSocket, tags?: Array<string>): Effect.Effect<void>;
+  /** Lists active sockets, optionally filtered by tag. */
+  getWebSockets(tag?: string): Effect.Effect<Array<DurableWebSocket>>;
+  /** Configures automatic request/response handling for sockets. */
+  setWebSocketAutoResponse(pair?: WebSocketRequestResponsePair): Effect.Effect<void>;
+  /** Gets the configured websocket auto-response pair. */
+  getWebSocketAutoResponse: Effect.Effect<WebSocketRequestResponsePair | null>;
+  /** Timestamp of the last automatic websocket response for a socket. */
+  getWebSocketAutoResponseTimestamp(ws: DurableWebSocket): Effect.Effect<Date | null>;
+  /** Sets the timeout for hibernatable websocket events. */
+  setHibernatableWebSocketEventTimeout(timeoutMs?: number): Effect.Effect<void>;
+  /** Gets the timeout for hibernatable websocket events. */
+  getHibernatableWebSocketEventTimeout: Effect.Effect<number | null>;
+  /** Reads tags attached to a websocket. */
+  getTags(ws: DurableWebSocket): Effect.Effect<Array<string>>;
+  /**
+   * Forcibly resets the Durable Object. Cloudflare logs an uncaught Error using
+   * the optional reason, and the method is not available in `wrangler dev` local
+   * development according to the Durable Object State docs.
+   */
+  abort(reason?: string): Effect.Effect<void>;
+}
+declare const DurableObjectState_base: Context.ServiceClass<DurableObjectState, "effect-cf/DurableObjectState", DurableObjectStateService>;
+/**
+ * Context tag for accessing the current Durable Object state service.
+ */
+declare class DurableObjectState extends DurableObjectState_base {}
+/**
+ * Wraps a native Cloudflare `DurableObjectState` as a {@link DurableObjectStateService}.
+ */
+declare const fromDurableObjectState: (state: globalThis.DurableObjectState) => DurableObjectStateService;
+declare namespace WorkflowBinding_d_exports {
+  export { WorkflowBindingClient, WorkflowBindingDefinition, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowInstanceEvent, WorkflowInstanceRestartOptions, WorkflowInstanceStatus, WorkflowInstanceStatusName, WorkflowOperationError, WorkflowResultDecodeError, isWorkflow, layer, makeClient };
+}
+type WorkflowInstanceCreateOptions<Payload> = Omit<CloudflareWorkflowInstanceCreateOptions<Payload>, "params">;
+type WorkflowInstanceCreateBatchOptions<Payload, EncodedPayload = unknown> = ReadonlyArray<{
+  readonly payload: Payload;
+} & WorkflowInstanceCreateOptions<EncodedPayload>>;
+interface WorkflowInstanceRestartOptions {
+  readonly from?: {
+    readonly name?: string;
+    readonly count?: number;
+    readonly type?: string;
+  };
+}
+type WorkflowInstanceStatusName = CloudflareInstanceStatus["status"];
+interface WorkflowInstanceStatus<Result> {
+  readonly status: WorkflowInstanceStatusName;
+  readonly output: Option.Option<Result>;
+  readonly error: Option.Option<{
+    readonly name: string;
+    readonly message: string;
+  }>;
+}
+interface WorkflowInstance<Result> {
+  readonly raw: CloudflareWorkflowInstance;
+  readonly id: string;
+  readonly pause: Effect.Effect<void, WorkflowOperationError>;
+  readonly resume: Effect.Effect<void, WorkflowOperationError>;
+  readonly terminate: Effect.Effect<void, WorkflowOperationError>;
+  readonly restart: (options?: WorkflowInstanceRestartOptions) => Effect.Effect<void, WorkflowOperationError>;
+  readonly status: Effect.Effect<WorkflowInstanceStatus<Result>, WorkflowOperationError | WorkflowResultDecodeError>;
+  readonly sendEvent: (event: WorkflowInstanceEvent) => Effect.Effect<void, WorkflowOperationError>;
+}
+interface WorkflowInstanceEvent {
+  readonly type: string;
+  readonly payload: unknown;
+}
+interface WorkflowBindingDefinition<Payload extends ServiceFreeSchema$1, Result extends ServiceFreeSchema$1> {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+  /** Codec used to encode payloads passed to `Workflow.create`. */
+  readonly payload: Payload;
+  /** Codec used to decode completed workflow status output. */
+  readonly result: Result;
+}
+interface WorkflowBindingClient<Payload extends ServiceFreeSchema$1, Result extends ServiceFreeSchema$1> {
+  readonly create: (payload: Schema.Schema.Type<Payload>, options?: WorkflowInstanceCreateOptions<Schema.Codec.Encoded<Payload>>) => Effect.Effect<WorkflowInstance<Schema.Schema.Type<Result>>, WorkflowOperationError | Schema.SchemaError>;
+  readonly createBatch: (batch: WorkflowInstanceCreateBatchOptions<Schema.Schema.Type<Payload>, Schema.Codec.Encoded<Payload>>) => Effect.Effect<ReadonlyArray<WorkflowInstance<Schema.Schema.Type<Result>>>, WorkflowOperationError | Schema.SchemaError>;
+  readonly get: (instanceId: string) => Effect.Effect<WorkflowInstance<Schema.Schema.Type<Result>>, WorkflowOperationError>;
+  readonly rawUnsafe: Effect.Effect<CloudflareWorkflow<Schema.Codec.Encoded<Payload>>>;
+}
+declare const WorkflowOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "WorkflowOperationError";
+} & Readonly<A>;
+declare class WorkflowOperationError extends WorkflowOperationError_base<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+declare const WorkflowResultDecodeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "WorkflowResultDecodeError";
+} & Readonly<A>;
+declare class WorkflowResultDecodeError extends WorkflowResultDecodeError_base<{
+  readonly binding: string;
+  readonly instanceId: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+declare const isWorkflow: <Payload>(value: unknown) => value is CloudflareWorkflow<Payload>;
+declare const makeClient: <Payload extends ServiceFreeSchema$1, Result extends ServiceFreeSchema$1>(definition: WorkflowBindingDefinition<Payload, Result>) => ((workflow: CloudflareWorkflow<Schema.Codec.Encoded<Payload>>) => WorkflowBindingClient<Payload, Result>);
+declare const layer: <Self, Payload extends ServiceFreeSchema$1, Result extends ServiceFreeSchema$1>(tag: Context.Service<Self, WorkflowBindingClient<Payload, Result>>, definition: WorkflowBindingDefinition<Payload, Result>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+//#endregion
+export { Rpc_d_exports as A, QueueBinding_d_exports as C, RpcDefinition_d_exports as D, ReservedMethodName$3 as E, DurableWebSocket as M, DurableObjectStorage_d_exports as N, ServiceFreeSchema$1 as O, StorageOperationError as P, QueueDefinition_d_exports as S, Method$2 as T, AsyncMethodArgs as _, WorkflowInstanceCreateOptions as a, AsyncMethodSuccess as b, DurableObjectState as c, ExecutionContext as d, NativeRequest as f, ServiceBinding_d_exports as g, WorkerDefinition_d_exports as h, WorkflowInstanceCreateBatchOptions as i, DurableObjectWebSocket_d_exports as j, Provider as k, DurableObjectStateService as l, Worker_d_exports as m, WorkflowBinding_d_exports as n, WorkflowInstanceStatusName as o, WorkerContext as p, WorkflowInstance as r, WorkflowOperationError as s, WorkflowBindingClient as t, DurableObjectState_d_exports as u, AsyncMethodCloudflareReturn as v, Definition$3 as w, Queue_d_exports as x, AsyncMethodKey as y };