effect-cf 0.11.0 → 0.13.0

package/dist/index.d.mts

@@ -1,8 +1,9 @@
 import { a as BindingService, c as WorkerConfig, i as BindingNotFoundError, l as WorkerEnv, o as BindingValidationError, s as Binding_d_exports, t as Hyperdrive_d_exports, u as WorkerEnvironment } from "./Hyperdrive-L6ldMlRF.mjs";
-import { Cause, Context, Data, DateTime, Duration, Effect, Layer, Option, Schema, Scope } from "effect";
+import { Cause, Config, Context, Data, DateTime, Duration, Effect, Layer, Option, Schema, Scope } from "effect";
+import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { OtlpMetrics } from "effect/unstable/observability";
 import { D1Client } from "@effect/sql-d1";
 import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, WorkflowEntrypoint, WorkflowEvent, WorkflowSleepDuration, WorkflowStep, WorkflowStepConfig, WorkflowStepContext, WorkflowStepEvent, WorkflowTimeoutDuration } from "cloudflare:workers";
-import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
 import * as RpcServer from "effect/unstable/rpc/RpcServer";
 import { SqliteClient } from "@effect/sql-sqlite-do";
@@ -11,981 +12,1182 @@ import * as _$effect_Types0 from "effect/Types";
 import * as _$effect_Cause0 from "effect/Cause";
 import * as _$effect_Layer0 from "effect/Layer";
 import * as _$effect_Scope0 from "effect/Scope";
+import * as Duration$1 from "effect/Duration";
+import * as Tracer from "effect/Tracer";
 import * as _$effect_Config0 from "effect/Config";
 
-//#region src/D1.d.ts
-declare namespace D1_d_exports {
-  export { D1Definition, D1Service, D1SqlLayerOptions, Service$1 as Service, make$10 as make };
+//#region src/DurableObjectStorage.d.ts
+declare namespace DurableObjectStorage_d_exports {
+  export { DurableObjectStorage, DurableObjectTransaction, SchemaBackedSyncKvStorage, SqlCursor, SqlStorage, SqlStorageValue, StorageOperationError, SyncKvDefinition, SyncKvStorage, fromDurableObjectStorage };
 }
-/** Typed D1 binding definition. */
-interface D1Definition {
-  /** Binding name as configured in `wrangler.jsonc`. */
-  readonly binding: string;
+/** Supported primitive value types for Durable Object SQL APIs. */
+type SqlStorageValue = globalThis.SqlStorageValue;
+declare const StorageOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.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;
+}> {}
+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>;
 }
-/** Options forwarded to `@effect/sql-d1` when building a SQL client layer. */
-type D1SqlLayerOptions = Omit<D1Client.D1ClientConfig, "db">;
-declare const D1ServiceTypeId: unique symbol;
-/** Nominal service marker for D1 services created with {@link make}. */
-interface D1Service<Id extends string> {
-  readonly [D1ServiceTypeId]: {
-    readonly id: Id;
-  };
+/**
+ * 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;
 }
 /**
- * Creates a typed D1 service tag plus Effect helpers.
+ * Schema pair used by `SyncKvStorage.schema(...)`.
  */
-declare const make$10: <Id extends string>(id: Id, definition: D1Definition) => BindingService<D1Service<Id>, Id, D1Database> & {
-  "effect-cf/D1": "effect-cf/D1";
-  definition: D1Definition;
-  sqlLayer: (options?: D1SqlLayerOptions) => Layer.Layer<D1Client.D1Client | _$effect_unstable_sql_SqlClient0.SqlClient, BindingNotFoundError | BindingValidationError | _$effect_Config0.ConfigError, WorkerEnvironment>;
-};
+interface SyncKvDefinition<Key, Value, EncodedValue> {
+  readonly key: Schema.Codec<Key, string>;
+  readonly value: Schema.Codec<Value, EncodedValue>;
+}
 /**
- * Builds a D1 service around a Cloudflare D1 database binding.
- *
- * The returned service exposes the raw `D1Database` binding and `sqlLayer(...)`
- * for providing `effect/unstable/sql` via `@effect/sql-d1`.
+ * 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
- * class TodoDatabase extends D1.Service<TodoDatabase>()("TodoDatabase", {
- *   binding: "TODO_DB",
- * }) {}
- *
- * const SqlLive = TodoDatabase.sqlLayer();
+ * 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;
+ * });
  * ```
  */
-declare const Service$1: <Self>() => <Id extends string>(id: Id, definition: D1Definition) => BindingService<Self, Id, D1Database> & {
-  "effect-cf/D1": "effect-cf/D1";
-  definition: D1Definition;
-  sqlLayer: (options?: D1SqlLayerOptions) => Layer.Layer<D1Client.D1Client | _$effect_unstable_sql_SqlClient0.SqlClient, BindingNotFoundError | BindingValidationError | _$effect_Config0.ConfigError, WorkerEnvironment | Exclude<Exclude<Self, _$effect_Scope0.Scope>, Self>>;
-};
-declare namespace Rpc_d_exports {
-  export { DisposableValue, MethodArgs, MethodKey, MethodReturn, Provider, Result, RpcStub, RpcTarget, Serializable, Stub, Stubable, Stubify, dispose, isDisposable, resolve, scoped };
+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;
 }
-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<T> = T extends Stubable ? Promise<Stub<T>> & Provider<T> : T extends Serializable<T> ? Promise<Stubify<T> & MaybeDisposable<T>> & MaybeProvider<T> : never;
-type MethodKey<Api> = { [Key in keyof Api]-?: Key extends string ? Api[Key] extends ((...args: Array<any>) => unknown) ? Key : never : never }[keyof Api];
-type MethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...args: infer Args) => unknown) ? Args : never;
-type MethodReturn<Api, Method extends keyof Api> = Api[Method] extends ((...args: Array<any>) => infer Return) ? Return : never;
-type DisposableValue = {
-  [Symbol.dispose](): void;
-};
-declare const isDisposable: (value: unknown) => value is DisposableValue;
-declare const dispose: (value: unknown) => Effect.Effect<void>;
-declare const resolve: <A>(value: A) => Effect.Effect<Awaited<A>, unknown>;
-declare const scoped: <A>(value: A) => Effect.Effect<Awaited<A>, unknown, Scope.Scope>;
-declare namespace RpcDefinition_d_exports {
-  export { Definition$9 as Definition, Method$5 as Method, Methods$4 as Methods, NoReservedMethods$4 as NoReservedMethods, ReservedMethodName$6 as ReservedMethodName, ReservedMethodNameError, RpcArgumentCountError, RpcArgumentDecodeError, RpcArgumentEncodeError, RpcReservedMethodNameError, RpcSuccessDecodeError, RpcSuccessEncodeError, ServiceFreeSchema$4 as ServiceFreeSchema, assertNoReservedMethodNames, assertNoReservedMethods, decodeArgs, decodeSuccess, encodeArgs, encodeSuccess, make$9 as make, method$4 as method, reservedMethodNames };
+/**
+ * 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 };
 }
-declare const RpcReservedMethodNameError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
-  readonly _tag: "RpcReservedMethodNameError";
-} & Readonly<A>;
-declare class RpcReservedMethodNameError extends RpcReservedMethodNameError_base<{
-  readonly definition: string;
-  readonly method: string;
-}> {}
-declare const RpcArgumentCountError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
-  readonly _tag: "RpcArgumentCountError";
-} & Readonly<A>;
-declare class RpcArgumentCountError extends RpcArgumentCountError_base<{
-  readonly definition: string;
-  readonly method: string;
-  readonly expected: number;
-  readonly actual: number;
-}> {}
-declare const RpcArgumentDecodeError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
-  readonly _tag: "RpcArgumentDecodeError";
-} & Readonly<A>;
-declare class RpcArgumentDecodeError extends RpcArgumentDecodeError_base<{
-  readonly definition: string;
-  readonly method: string;
-  readonly index: number;
-  readonly cause: unknown;
-}> {}
-declare const RpcArgumentEncodeError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
-  readonly _tag: "RpcArgumentEncodeError";
+/** Data supported by Cloudflare websocket `send`. */
+type DurableWebSocketSendData = string | ArrayBuffer | ArrayBufferView;
+declare const DurableWebSocketSendError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "DurableWebSocketSendError";
 } & Readonly<A>;
-declare class RpcArgumentEncodeError extends RpcArgumentEncodeError_base<{
-  readonly definition: string;
-  readonly method: string;
-  readonly index: number;
+/** Error raised when sending on a Durable Object websocket fails. */
+declare class DurableWebSocketSendError extends DurableWebSocketSendError_base<{
   readonly cause: unknown;
 }> {}
-declare const RpcSuccessDecodeError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
-  readonly _tag: "RpcSuccessDecodeError";
+declare const DurableWebSocketCloseError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "DurableWebSocketCloseError";
 } & Readonly<A>;
-declare class RpcSuccessDecodeError extends RpcSuccessDecodeError_base<{
-  readonly definition: string;
-  readonly method: string;
+/** Error raised when closing a Durable Object websocket fails. */
+declare class DurableWebSocketCloseError extends DurableWebSocketCloseError_base<{
   readonly cause: unknown;
 }> {}
-declare const RpcSuccessEncodeError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
-  readonly _tag: "RpcSuccessEncodeError";
+declare const DurableWebSocketAttachmentError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "DurableWebSocketAttachmentError";
 } & Readonly<A>;
-declare class RpcSuccessEncodeError extends RpcSuccessEncodeError_base<{
-  readonly definition: string;
-  readonly method: string;
+/** Error raised when serializing or deserializing a websocket attachment fails. */
+declare class DurableWebSocketAttachmentError extends DurableWebSocketAttachmentError_base<{
+  readonly operation: "serialize" | "deserialize";
   readonly cause: unknown;
 }> {}
-declare const reservedMethodNames: Set<string>;
-type ReservedMethodName$6 = "constructor" | "fetch" | "connect" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError" | "then" | "dup" | "dispose" | "serialize" | "deserialize";
-type ServiceFreeSchema$4 = Schema.Codec<any, any, never, never>;
-interface Method$5<Args extends ReadonlyArray<ServiceFreeSchema$4> = ReadonlyArray<ServiceFreeSchema$4>, Success extends ServiceFreeSchema$4 = ServiceFreeSchema$4> {
-  readonly args: Args;
-  readonly success: Success;
-}
-declare namespace Method$5 {
-  export type Any = Method$5<ReadonlyArray<ServiceFreeSchema$4>, ServiceFreeSchema$4>;
-  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$4>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$4, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$4>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
-  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$4>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$4, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$4>] ? [Schema.Codec.Encoded<Head>, ...EncodedArgsFromSchemas<Tail>] : Array<Schema.Codec.Encoded<Args[number]>>;
-  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
-  export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
-  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
-  export type EncodedSuccess<Self extends Any> = Schema.Codec.Encoded<Self["success"]>;
-  export {};
-}
-type Methods$4 = Record<string, Method$5.Any>;
-type NoReservedMethods$4<MethodsShape extends Methods$4, Reserved extends string = ReservedMethodName$6> = Extract<keyof MethodsShape, Reserved> extends never ? MethodsShape : never;
-interface Definition$9<Id extends string = string, MethodsShape extends Methods$4 = Methods$4> {
-  readonly id: Id;
-  readonly methods: MethodsShape;
-}
-declare namespace Definition$9 {
-  type Any = Definition$9<string, Methods$4>;
-  type ServerApi<Self extends Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$5.Args<Self["methods"][Key]>) => Promise<Method$5.Success<Self["methods"][Key]>> };
-  type Api<Self extends Any, Reserved extends string = never> = Provider<ServerApi<Self>, Reserved>;
-  type MethodNames<Self extends Any> = Extract<keyof Self["methods"], string>;
-}
-declare class ReservedMethodNameError extends Error {
-  readonly method: string;
-  readonly target: string;
-  constructor(target: string, method: string);
-}
-declare const assertNoReservedMethods: (target: string, methods: Record<string, unknown>, reserved: ReadonlySet<string>) => void;
-declare function method$4<Success extends ServiceFreeSchema$4>(definition: {
-  readonly success: Success;
-}): Method$5<readonly [], Success>;
-declare function method$4<const Args extends ReadonlyArray<ServiceFreeSchema$4>, Success extends ServiceFreeSchema$4>(definition: {
-  readonly args: Args;
-  readonly success: Success;
-}): Method$5<Args, Success>;
-declare const assertNoReservedMethodNames: (definition: Definition$9.Any) => Effect.Effect<void, RpcReservedMethodNameError>;
-declare const decodeArgs: <const Self extends Definition$9.Any, MethodName extends Definition$9.MethodNames<Self>>(definition: Self, methodName: MethodName, args: ReadonlyArray<unknown>) => Effect.Effect<Method$5.Args<Self["methods"][MethodName]>, RpcArgumentCountError | RpcArgumentDecodeError>;
-declare const encodeArgs: <const Self extends Definition$9.Any, MethodName extends Definition$9.MethodNames<Self>>(definition: Self, methodName: MethodName, args: Method$5.Args<Self["methods"][MethodName]>) => Effect.Effect<Method$5.EncodedArgs<Self["methods"][MethodName]>, RpcArgumentCountError | RpcArgumentEncodeError>;
-declare const encodeSuccess: <const Self extends Definition$9.Any, MethodName extends Definition$9.MethodNames<Self>>(definition: Self, methodName: MethodName, value: Method$5.Success<Self["methods"][MethodName]>) => Effect.Effect<Method$5.EncodedSuccess<Self["methods"][MethodName]>, RpcSuccessEncodeError>;
-declare const decodeSuccess: <const Self extends Definition$9.Any, MethodName extends Definition$9.MethodNames<Self>>(definition: Self, methodName: MethodName, value: unknown) => Effect.Effect<Method$5.Success<Self["methods"][MethodName]>, RpcSuccessDecodeError>;
-declare const make$9: <Id extends string, const MethodsShape extends Methods$4>(id: Id, methods: MethodsShape) => Definition$9<Id, MethodsShape>;
-declare namespace QueueBinding_d_exports {
-  export { MessageSendRequest, QueueBindingClient, QueueBindingDefinition, QueueMetrics, QueueOperationError, QueueProducer, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse, isQueue, layer$8 as layer, makeClient$6 as makeClient };
-}
-type QueueSendOptions = globalThis.QueueSendOptions;
-type QueueSendResponse = globalThis.QueueSendResponse;
-type QueueSendBatchOptions = globalThis.QueueSendBatchOptions;
-type QueueSendBatchResponse = globalThis.QueueSendBatchResponse;
-type QueueMetrics = globalThis.QueueMetrics;
-type MessageSendRequest<Body> = globalThis.MessageSendRequest<Body>;
-type QueueProducer<Body> = Pick<globalThis.Queue<Body>, "send"> & Partial<Pick<globalThis.Queue<Body>, "sendBatch" | "metrics">>;
-interface QueueBindingDefinition<Message extends ServiceFreeSchema$4> {
-  /** Binding name as configured in `wrangler.jsonc`. */
-  readonly binding: string;
-  /** Codec used to encode messages before sending them to Cloudflare Queues. */
-  readonly message: Message;
-}
-interface QueueBindingClient<Message extends ServiceFreeSchema$4> {
-  readonly send: (message: Schema.Schema.Type<Message>, options?: QueueSendOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError>;
-  readonly sendBatch: (messages: Iterable<MessageSendRequest<Schema.Schema.Type<Message>>>, options?: QueueSendBatchOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError>;
-  readonly metrics: () => Effect.Effect<QueueMetrics, QueueOperationError>;
-  readonly unsafeRaw: Effect.Effect<globalThis.Queue<Schema.Codec.Encoded<Message>>>;
-}
-declare const QueueOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.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$6: <Message extends ServiceFreeSchema$4>(definition: QueueBindingDefinition<Message>) => ((queue: QueueProducer<Schema.Codec.Encoded<Message>>) => QueueBindingClient<Message>);
-declare const layer$8: <Self, Message extends ServiceFreeSchema$4>(tag: Context.Service<Self, QueueBindingClient<Message>>, definition: QueueBindingDefinition<Message>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare namespace QueueDefinition_d_exports {
-  export { Definition$8 as Definition, Handler$3 as Handler, LayerOptions$11 as LayerOptions, Options$7 as Options, Queue$1 as Queue, Tag$11 as Tag, TagClass$10 as TagClass, implement$7 as implement, make$8 as make };
-}
-interface Definition$8<Id extends string = string, Message extends ServiceFreeSchema$4 = ServiceFreeSchema$4> {
-  readonly id: Id;
-  readonly message: Message;
-}
-declare namespace Definition$8 {
-  type Any = Definition$8<string, ServiceFreeSchema$4>;
-}
-type Handler$3<ROut, Self extends Definition$8.Any> = (batch: QueueBatch<Schema.Schema.Type<Self["message"]>>) => Effect.Effect<void, unknown, ExecutionContext | WorkerContext | WorkerEnvironment | Scope.Scope | ROut>;
-interface Options$7<ROut, Self extends Definition$8.Any> extends Omit<WorkerOptions<ROut, Record<never, never>>, "queue" | "rpc"> {
-  readonly queue: Handler$3<ROut, Self>;
-  readonly rpc?: never;
-}
-type LayerOptions$11 = {
-  readonly binding: string;
-};
-interface TagClass$10<Self, Id extends string, Message extends ServiceFreeSchema$4> extends Context.ServiceClass<Self, Id, QueueBindingClient<Message>> {
-  readonly id: Id;
-  readonly message: Message;
-  readonly make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$7<ROut, Definition$8<Id, Message>>) => WorkerClass<Record<never, never>, ROut>;
-  readonly layer: (options: LayerOptions$11) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-  readonly send: (message: Schema.Schema.Type<Message>, options?: QueueSendOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError, Self>;
-  readonly sendBatch: (messages: Iterable<MessageSendRequest<Schema.Schema.Type<Message>>>, options?: QueueSendBatchOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError, Self>;
-  readonly metrics: () => Effect.Effect<QueueMetrics, QueueOperationError, Self>;
-  readonly unsafeRaw: () => Effect.Effect<globalThis.Queue<Schema.Codec.Encoded<Message>>, never, Self>;
-}
-declare const make$8: <Id extends string, Message extends ServiceFreeSchema$4>(id: Id, definition: {
-  readonly message: Message;
-}) => TagClass$10<Definition$8<Id, Message>, Id, Message>;
-declare const Tag$11: <Self>() => <Id extends string, Message extends ServiceFreeSchema$4>(id: Id, definition: {
-  readonly message: Message;
-}) => TagClass$10<Self, Id, Message>;
-declare const Queue$1: <Self>() => <Id extends string, Message extends ServiceFreeSchema$4>(id: Id, definition: {
-  readonly message: Message;
-}) => TagClass$10<Self, Id, Message>;
-declare const implement$7: <ROut, const Self extends Definition$8.Any>(_definition: Self, handler: Handler$3<ROut, Self>) => Handler$3<ROut, Self>;
-declare namespace Queue_d_exports {
-  export { Definition$7 as Definition, Handler$2 as Handler, LayerOptions$10 as LayerOptions, Options$6 as Options, QueueBatch, QueueHandler, QueueMessage, QueueMessageDecodeError, QueueOptions, Tag$10 as Tag, TagClass$9 as TagClass, decodeBatch, fromMessage, fromMessageBatch, implement$6 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: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
-  readonly _tag: "QueueMessageDecodeError";
-} & Readonly<A>;
-declare class QueueMessageDecodeError extends QueueMessageDecodeError_base<{
-  readonly queue: string;
-  readonly messageId: string;
-  readonly index: number;
-  readonly cause: unknown;
-}> {}
-type RuntimeContext$2<ROut> = ExecutionContext | WorkerContext | WorkerEnvironment | ROut;
-type QueueHandlerContext<ROut> = RuntimeContext$2<ROut> | Scope.Scope;
-type QueueHandler<ROut, Body = unknown> = (batch: QueueBatch<Body>) => Effect.Effect<void, unknown, QueueHandlerContext<ROut>>;
-interface QueueOptions<ROut, Body = unknown> {
-  readonly queue: QueueHandler<ROut, Body>;
-}
-declare const fromMessage: <Body>(message: globalThis.Message<unknown>, body: Body) => {
-  raw: Message<unknown>;
-  id: string;
-  timestamp: Date;
-  body: Body;
-  attempts: number;
-  ack: Effect.Effect<void, never, never>;
-  retry: (options?: globalThis.QueueRetryOptions) => Effect.Effect<void, never, never>;
-};
-declare const fromMessageBatch: <Body>(batch: globalThis.MessageBatch<unknown>, messages: ReadonlyArray<QueueMessage<Body>>) => QueueBatch<Body>;
-declare const decodeBatch: <Body>(batch: globalThis.MessageBatch<unknown>, decodeBody: (body: unknown) => Effect.Effect<Body, unknown>) => Effect.Effect<QueueBatch<Body>, QueueMessageDecodeError>;
-type Definition$7<Id extends string = string, Message extends Definition$8.Any["message"] = Definition$8.Any["message"]> = Definition$8<Id, Message>;
-declare namespace Definition$7 {
-  type Any = Definition$8.Any;
-}
-type LayerOptions$10 = LayerOptions$11;
-type TagClass$9<Self, Id extends string, Message extends Definition$8.Any["message"]> = TagClass$10<Self, Id, Message>;
-declare const Tag$10: <Self>() => <Id extends string, Message extends Definition$8.Any["message"]>(id: Id, definition: {
-  readonly message: Message;
-}) => TagClass$9<Self, Id, Message>;
-declare const implement$6: <ROut, const Self extends Definition$8.Any>(_definition: Self, handler: Handler$3<ROut, Self>) => Handler$3<ROut, Self>;
-type Handler$2<ROut, Self extends Definition$8.Any> = Handler$3<ROut, Self>;
-type Options$6<ROut, Self extends Definition$8.Any> = Options$7<ROut, Self>;
-declare namespace WorkerDefinition_d_exports {
-  export { Api$3 as Api, Definition$6 as Definition, HandlerEffect$3 as HandlerEffect, Handlers$3 as Handlers, LayerOptions$9 as LayerOptions, Method$4 as Method, Methods$3 as Methods, NoReservedMethods$3 as NoReservedMethods, Options$5 as Options, ReservedMethodName$5 as ReservedMethodName, ServerApi$4 as ServerApi, ServiceFreeSchema$3 as ServiceFreeSchema, Tag$9 as Tag, TagClass$8 as TagClass, Worker, implement$5 as implement, make$7 as make, method$3 as method };
-}
-type ServiceFreeSchema$3 = Schema.Codec<any, any, never, never>;
-interface Method$4<Args extends ReadonlyArray<ServiceFreeSchema$3> = ReadonlyArray<ServiceFreeSchema$3>, Success extends ServiceFreeSchema$3 = ServiceFreeSchema$3> {
-  readonly args: Args;
-  readonly success: Success;
-}
-declare namespace Method$4 {
-  export type Any = Method$4<ReadonlyArray<ServiceFreeSchema$3>, ServiceFreeSchema$3>;
-  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$3>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$3, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$3>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
-  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$3>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$3, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$3>] ? [Schema.Codec.Encoded<Head>, ...EncodedArgsFromSchemas<Tail>] : Array<Schema.Codec.Encoded<Args[number]>>;
-  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
-  export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
-  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
-  export type EncodedSuccess<Self extends Any> = Schema.Codec.Encoded<Self["success"]>;
-  export {};
+/** 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>;
 }
-type Methods$3 = Record<string, Method$4.Any>;
+/** Wraps a native Cloudflare websocket in the Effect-native Durable Object API. */
+declare const fromWebSocket: <Attachment = unknown>(raw: WebSocket) => DurableWebSocket<Attachment>;
 /**
- * RPC contract for a Worker service.
- *
- * Create with {@link make} and reuse to type both worker implementations and
- * service bindings in other workers.
+ * Options for accepting an incoming websocket request in a Durable Object.
  */
-interface Definition$6<Id extends string = string, MethodsShape extends Methods$3 = Methods$3> {
-  readonly id: Id;
-  readonly methods: MethodsShape;
-}
-declare namespace Definition$6 {
-  type Any = Definition$6<string, Methods$3>;
+interface 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;
 }
-type ReservedMethodName$5 = ReservedMethodName$3;
-type NoReservedMethods$3<MethodsShape extends Methods$3> = Extract<keyof MethodsShape, ReservedMethodName$5> extends never ? MethodsShape : never;
-/**
- * Promise-based client API derived from a {@link Definition}.
- */
-type ServerApi$4<Self extends Definition$6.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$4.Args<Self["methods"][Key]>) => Promise<Method$4.Success<Self["methods"][Key]>> };
-type Api$3<Self extends Definition$6.Any> = Provider<ServerApi$4<Self>, ReservedMethodName$5>;
-/**
- * Effect handlers for each RPC method in a worker definition.
- */
-type Handlers$3<ROut, Self extends Definition$6.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$4.Args<Self["methods"][Key]>) => WorkerRpcHandler<ROut, Method$4.Success<Self["methods"][Key]>> };
 /**
- * Worker constructor options for a specific RPC definition.
+ * Result of a websocket upgrade accepted by {@link acceptUpgrade}.
  */
-interface Options$5<ROut, Self extends Definition$6.Any> extends Omit<WorkerOptions<ROut, Handlers$3<ROut, Self>>, "rpc"> {
-  readonly rpc: Handlers$3<ROut, Self>;
+interface AcceptedUpgrade<Attachment = unknown> {
+  readonly client: WebSocket;
+  readonly server: DurableWebSocket<Attachment>;
+  readonly response: Response;
 }
-type LayerOptions$9 = {
-  readonly binding: string;
-};
-type TagClass$8<Self, Id extends string, MethodsShape extends Methods$3> = Context.ServiceClass<Self, Id, ServiceBindingEffectClient<Api$3<Definition$6<Id, MethodsShape>>, Definition$6<Id, MethodsShape>>> & ServiceBindingStaticClient<Self, Api$3<Definition$6<Id, MethodsShape>>, Definition$6<Id, MethodsShape>> & {
-  readonly id: Id;
-  readonly methods: MethodsShape;
-  readonly make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$5<ROut, Definition$6<Id, MethodsShape>>) => WorkerClass<Handlers$3<ROut, Definition$6<Id, MethodsShape>>, ROut>;
-  readonly layer: (options: LayerOptions$9) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-};
-/**
- * Defines a single RPC method schema in a worker definition.
- */
-declare const method$3: {
-  <Success extends ServiceFreeSchema$3>(definition: {
-    readonly success: Success;
-  }): Method$4<readonly [], Success>;
-  <const Args extends readonly ServiceFreeSchema$3[], Success extends ServiceFreeSchema$3>(definition: {
-    readonly args: Args;
-    readonly success: Success;
-  }): Method$4<Args, Success>;
-};
-declare const make$7: <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$8<Definition$6<Id, MethodsShape>, Id, MethodsShape>;
-declare const Tag$9: <Self>() => <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$8<Self, Id, MethodsShape>;
-declare const Worker: <Self>() => <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$8<Self, Id, MethodsShape>;
-/**
- * Helper for implementing handlers with the exact method shape of a definition.
- */
-declare const implement$5: <ROut, const Self extends Definition$6.Any>(_definition: Self, handlers: Handlers$3<ROut, Self>) => Handlers$3<ROut, Self>;
 /**
- * Convenience alias for a single worker RPC handler Effect.
+ * Accepts a websocket upgrade and registers the server socket on `DurableObjectState`.
+ *
+ * @example
+ * ```ts
+ * const response = yield* DurableObjectWebSocket.acceptUpgrade({
+ *   tags: ["room:general"],
+ * });
+ *
+ * return response.response;
+ * ```
  */
-type HandlerEffect$3<ROut, Self extends Definition$6.Any, Key extends keyof Self["methods"]> = WorkerRpcHandler<ROut, Method$4.Success<Self["methods"][Key]>>;
-//#endregion
-//#region src/internal/RpcInvocation.d.ts
-type AnyArgs = Array<any>;
-type AsyncMethodKey<Api> = { [Key in keyof Api]-?: Key extends string ? Api[Key] extends ((...args: AnyArgs) => Promise<unknown>) ? Key : never : never }[keyof Api];
-type AsyncMethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...args: infer Args) => Promise<unknown>) ? Args : never;
-type AsyncMethodSuccess<Api, Method extends keyof Api> = Api[Method] extends ((...args: AnyArgs) => Promise<infer A>) ? A : never;
-type AsyncMethodCloudflareReturn<Api, Method extends keyof Api> = Result<AsyncMethodSuccess<Api, Method>>;
-declare namespace ServiceBinding_d_exports {
-  export { Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceFetcher, isServiceBindingClient, layer$7 as layer, makeClient$5 as makeClient, makeDirectMethods$1 as makeDirectMethods };
+declare const acceptUpgrade: <Attachment = unknown>(options?: AcceptUpgradeOptions<Attachment>) => Effect.Effect<AcceptedUpgrade<Attachment>, never, 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;
 }
-declare const TypeId$1: "effect-cf/ServiceBinding";
-/**
- * Minimum shape for a Cloudflare service binding.
- */
-interface ServiceFetcher {
-  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+interface RehydratedDurableWebSocket<Attachment> {
+  readonly socket: DurableWebSocket<Attachment>;
+  readonly attachment: Attachment;
 }
-type RpcClient$1<Api> = { readonly [Key in keyof Api as Key extends string ? Api[Key] extends ((...args: Array<any>) => unknown) ? Key : never : never]: Api[Key] };
-type ReservedMethodName$4 = ReservedMethodName$5 | "fetch";
-/**
- * Native Cloudflare service object including optional RPC methods.
- */
-type ServiceBindingClient<Api extends object> = ServiceFetcher & RpcClient$1<Provider<Api, ReservedMethodName$4>>;
-type ApiFromDefinition<Definition> = Definition extends Definition$6.Any ? ServerApi$4<Definition> : never;
-type ApiOrDefinition<Api extends object, Definition> = [Api] extends [never] ? ApiFromDefinition<Definition> : Api;
-/**
- * Binding metadata used to create an Effect service from a Worker binding.
- */
-interface ServiceBindingDefinition<Definition extends Definition$6.Any | undefined = undefined> {
-  /** Binding name as configured in `wrangler.jsonc`. */
-  readonly binding: string;
-  /** Optional RPC schema used for argument/result encoding. */
-  readonly definition?: Definition;
+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 DurableObjectState_d_exports {
+  export { DurableObjectState, DurableObjectStateService, fromDurableObjectState };
 }
-declare const ServiceBindingFetchError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.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;
-}> {}
-declare const ServiceBindingRpcError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
-  readonly _tag: "ServiceBindingRpcError";
-} & Readonly<A>;
 /**
- * Failure raised when invoking an RPC method on a service binding.
+ * Effect-friendly wrapper around Cloudflare `DurableObjectState`.
  */
-declare class ServiceBindingRpcError extends ServiceBindingRpcError_base<{
-  readonly binding: string;
-  readonly method: string;
-  readonly cause: unknown;
-}> {}
-type ServiceMethodKey<Api> = AsyncMethodKey<Api>;
-type ServiceMethodArgs<Api, Method extends keyof Api> = AsyncMethodArgs<Api, Method>;
-type ServiceMethodSuccess<Api, Method extends keyof Api> = AsyncMethodSuccess<Api, Method>;
-type ServiceMethodCloudflareReturn<Api, Method extends keyof Api> = AsyncMethodCloudflareReturn<Api, Method>;
-type ServiceCall<R, Api> = <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError, R>;
-type DefinitionDirectMethods<R, Definition extends Definition$6.Any> = { readonly [Method in Definition$9.MethodNames<Definition>]: (...args: Method$5.Args<Definition["methods"][Method]>) => Effect.Effect<Method$5.Success<Definition["methods"][Method]>, ServiceBindingRpcError, R> };
-type DirectMethods$1<R, Definition> = Definition extends Definition$6.Any ? DefinitionDirectMethods<R, Definition> : {};
-type ServiceBindingEffectClient<Api extends object, Definition extends Definition$6.Any | undefined = undefined> = DirectMethods$1<never, Definition> & {
-  /**
-   * 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>;
+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>;
   /**
-   * 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);
+   * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate.
    *
-   *   return value;
-   * });
-   * ```
+   * 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.
    */
-  readonly rpc: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodCloudflareReturn<Api, Method>, ServiceBindingRpcError>;
+  blockConcurrencyWhile<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
   /**
-   * 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);
+   * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate and lets
+   * Effect failures reject the callback.
    *
-   *   return value;
-   * });
-   * ```
+   * 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).
    */
-  readonly call: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError>;
+  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>>;
   /**
-   * 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();
-   *   }),
-   * );
-   * ```
+   * 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.
    */
-  readonly scopedCall: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, unknown, Scope.Scope>;
-};
-type ServiceBindingStaticClient<R, Api extends object, Definition extends Definition$6.Any | undefined = undefined> = DirectMethods$1<R, Definition> & {
-  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$5: <Api extends object, const Definition extends Definition$6.Any | undefined = undefined>(definition: ServiceBindingDefinition<Definition>) => ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition>);
-declare const layer$7: <Self, Api extends object, const Definition extends Definition$6.Any | undefined = undefined>(tag: Context.Service<Self, ServiceBindingEffectClient<Api, Definition>>, definition: ServiceBindingDefinition<Definition>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  abort(reason?: string): Effect.Effect<void>;
+}
+declare const DurableObjectState_base: Context.ServiceClass<DurableObjectState, "effect-cf/DurableObjectState", DurableObjectStateService>;
 /**
- * Creates a typed Effect service for a Worker service binding.
+ * Context tag for accessing the current Durable Object state service.
+ */
+declare class DurableObjectState extends DurableObjectState_base {}
+/**
+ * Wraps a native Cloudflare `DurableObjectState` as a {@link DurableObjectStateService}.
+ */
+declare const fromDurableObjectState: (state: globalThis.DurableObjectState) => DurableObjectStateService;
+declare namespace CloudflareOtlp_d_exports {
+  export { CloudflareOtlpSettings, DurableObjectResourceOptions, LayerOptions$12 as LayerOptions, ResourceOptions, Serialization, Settings, Signal, WorkerResourceOptions, durableObjectLayer, layer$9 as layer, layerJson, layerProtobuf, settingsConfig, settingsLayer, workerLayer };
+}
+/** Telemetry signal groups supported by the Cloudflare OTLP layers. */
+type Signal = "logs" | "traces" | "metrics";
+/** OTLP payload serialization used by the Effect OTLP exporters. */
+type Serialization = "json" | "protobuf";
+/**
+ * Resolved OpenTelemetry settings used by the Cloudflare OTLP layers.
  *
- * 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
+ * The default {@link settingsLayer} reads the standard OpenTelemetry
+ * environment variable names from `WorkerEnvironment`. Applications that use
+ * different binding names can provide {@link CloudflareOtlpSettings} directly
+ * with a custom layer.
+ */
+interface Settings {
+  /** Generic OTLP base endpoint, read from `OTEL_EXPORTER_OTLP_ENDPOINT`. */
+  readonly endpoint: Option.Option<string>;
+  /** Logs-specific OTLP endpoint, read from `OTEL_EXPORTER_OTLP_LOGS_ENDPOINT`. */
+  readonly logsEndpoint: Option.Option<string>;
+  /** Traces-specific OTLP endpoint, read from `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`. */
+  readonly tracesEndpoint: Option.Option<string>;
+  /** Metrics-specific OTLP endpoint, read from `OTEL_EXPORTER_OTLP_METRICS_ENDPOINT`. */
+  readonly metricsEndpoint: Option.Option<string>;
+  /** Comma-separated OTLP headers, read from `OTEL_EXPORTER_OTLP_HEADERS`. */
+  readonly headers: Option.Option<string>;
+  /** Logs-specific OTLP headers, read from `OTEL_EXPORTER_OTLP_LOGS_HEADERS`. */
+  readonly logsHeaders: Option.Option<string>;
+  /** Traces-specific OTLP headers, read from `OTEL_EXPORTER_OTLP_TRACES_HEADERS`. */
+  readonly tracesHeaders: Option.Option<string>;
+  /** Metrics-specific OTLP headers, read from `OTEL_EXPORTER_OTLP_METRICS_HEADERS`. */
+  readonly metricsHeaders: Option.Option<string>;
+  /** Service name, read from `OTEL_SERVICE_NAME`. */
+  readonly serviceName: Option.Option<string>;
+  /** Service version, read from the effect-cf convenience alias `OTEL_SERVICE_VERSION`. */
+  readonly serviceVersion: Option.Option<string>;
+  /** Resource attributes, read from `OTEL_RESOURCE_ATTRIBUTES`. */
+  readonly resourceAttributes: Option.Option<Record<string, string>>;
+}
+/**
+ * Supported OpenTelemetry environment configuration for Cloudflare OTLP export.
+ *
+ * This config intentionally uses the conventional `OTEL_*` variable names so
+ * deployments can share the same settings used by other OpenTelemetry SDKs.
+ * It covers the OTLP HTTP settings supported by the Effect OTLP layers:
+ *
+ * - `OTEL_EXPORTER_OTLP_ENDPOINT`
+ * - `OTEL_EXPORTER_OTLP_LOGS_ENDPOINT`
+ * - `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`
+ * - `OTEL_EXPORTER_OTLP_METRICS_ENDPOINT`
+ * - `OTEL_EXPORTER_OTLP_HEADERS`
+ * - `OTEL_EXPORTER_OTLP_LOGS_HEADERS`
+ * - `OTEL_EXPORTER_OTLP_TRACES_HEADERS`
+ * - `OTEL_EXPORTER_OTLP_METRICS_HEADERS`
+ * - `OTEL_SERVICE_NAME`
+ * - `OTEL_RESOURCE_ATTRIBUTES`
+ *
+ * `OTEL_SERVICE_VERSION` is also accepted as an effect-cf convenience alias.
+ * The standard OpenTelemetry way to configure service version is
+ * `OTEL_RESOURCE_ATTRIBUTES=service.version=...`.
+ *
+ * Consumers with non-standard binding names should map those names into
+ * {@link CloudflareOtlpSettings} rather than changing this config globally.
+ */
+declare const settingsConfig: Config.Config<{
+  endpoint: Option.Option<string>;
+  logsEndpoint: Option.Option<string>;
+  tracesEndpoint: Option.Option<string>;
+  metricsEndpoint: Option.Option<string>;
+  headers: Option.Option<string>;
+  logsHeaders: Option.Option<string>;
+  tracesHeaders: Option.Option<string>;
+  metricsHeaders: Option.Option<string>;
+  serviceName: Option.Option<string>;
+  serviceVersion: Option.Option<string>;
+  resourceAttributes: Option.Option<{
+    readonly [x: string]: string;
+  }>;
+}>;
+declare const CloudflareOtlpSettings_base: Context.ServiceClass<CloudflareOtlpSettings, "effect-cf/CloudflareOtlpSettings", Settings>;
+/**
+ * Service carrying already-resolved Cloudflare OTLP settings.
+ *
+ * Provide this service directly when an application needs to map custom
+ * Cloudflare binding names, compute settings dynamically, or override settings
+ * in tests. When this service is present, the OTLP layers use it instead of
+ * reading {@link settingsConfig}.
  *
  * @example
  * ```ts
- * const Counter = WorkerDefinition.make("Counter", {
- *   increment: WorkerDefinition.method({
- *     args: [Schema.Number],
- *     success: Schema.Number,
+ * const CustomOtlpSettings = Layer.effect(
+ *   CloudflareOtlp.CloudflareOtlpSettings,
+ *   Config.all({
+ *     ...CloudflareOtlp.settingsConfig,
+ *     endpoint: Config.string("MY_OTLP_ENDPOINT").pipe(Config.option),
  *   }),
- * });
+ * ).pipe(Layer.provide(WorkerConfig.layer));
+ * ```
+ */
+declare class CloudflareOtlpSettings extends CloudflareOtlpSettings_base {}
+/** Resource metadata shared by Worker and Durable Object OTLP layers. */
+interface ResourceOptions {
+  /** Explicit service name. Overrides `OTEL_SERVICE_NAME` when provided. */
+  readonly serviceName?: string;
+  /** Explicit service version. Overrides `OTEL_SERVICE_VERSION` when provided. */
+  readonly serviceVersion?: string;
+  /** Additional resource attributes attached to all exported telemetry. */
+  readonly attributes?: Record<string, unknown>;
+}
+/** Resource metadata specific to Cloudflare Workers. */
+interface WorkerResourceOptions extends ResourceOptions {
+  /** Cloudflare Worker name to attach as `cloudflare.worker.name`. */
+  readonly workerName?: string;
+}
+/** Resource metadata specific to Cloudflare Durable Objects. */
+interface DurableObjectResourceOptions extends ResourceOptions {
+  /** Durable Object class name to attach as `cloudflare.durable_object.class`. */
+  readonly className?: string;
+  /**
+   * Include the Durable Object id as `cloudflare.durable_object.id`.
+   *
+   * This is disabled by default because object ids can be high-cardinality.
+   */
+  readonly includeObjectId?: boolean;
+}
+/** Options shared by all Cloudflare OTLP telemetry layers. */
+interface LayerOptions$12 extends ResourceOptions {
+  /** Telemetry signals to export. Defaults to logs, traces, and metrics. */
+  readonly signals?: ReadonlyArray<Signal>;
+  /** OTLP payload serialization. Defaults to protobuf. */
+  readonly serialization?: Serialization;
+  /** Maximum batch size for log and trace exporters. */
+  readonly maxBatchSize?: number;
+  /** Maximum time to wait for exporter shutdown/flush when a scope closes. */
+  readonly shutdownTimeout?: Duration$1.Input;
+  /** Export interval for the logs exporter. */
+  readonly loggerExportInterval?: Duration$1.Input;
+  /** Exclude log records emitted for spans when exporting logs. */
+  readonly loggerExcludeLogSpans?: boolean;
+  /** Merge the OTLP logger with existing loggers instead of replacing them. */
+  readonly loggerMergeWithExisting?: boolean;
+  /** Export interval for the traces exporter. */
+  readonly tracerExportInterval?: Duration$1.Input;
+  /** Custom trace context lookup used by the Effect OTLP tracer. */
+  readonly tracerContext?: <X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X;
+  /** Export interval for the metrics exporter. */
+  readonly metricsExportInterval?: Duration$1.Input;
+  /** Aggregation temporality for exported metrics. */
+  readonly metricsTemporality?: OtlpMetrics.AggregationTemporality;
+}
+/**
+ * Layer that reads standard OpenTelemetry settings from the current Cloudflare
+ * `env` object.
  *
- * const CounterLive = Counter.layer({ binding: "COUNTER" });
+ * The layer depends on {@link WorkerEnvironment} and installs a
+ * Cloudflare-backed Effect `ConfigProvider`, so `settingsConfig` reads from
+ * Worker vars/secrets instead of Node process environment variables.
+ */
+declare const settingsLayer: Layer.Layer<CloudflareOtlpSettings, Config.ConfigError, WorkerEnvironment>;
+/**
+ * Base OTLP telemetry layer for Cloudflare-compatible runtimes.
  *
- * const program = Effect.gen(function* () {
- *   const counter = yield* Counter;
- *   const next = yield* counter.increment(1);
- *   return next;
- * });
- * ```
+ * The layer reads {@link CloudflareOtlpSettings} when provided. Otherwise it
+ * reads standard OpenTelemetry config from `WorkerEnvironment` when available,
+ * then falls back to the ambient Effect `ConfigProvider`.
+ *
+ * When only `OTEL_EXPORTER_OTLP_ENDPOINT` is configured, per-signal paths are
+ * derived by appending `/v1/logs`, `/v1/traces`, and `/v1/metrics`. Signal
+ * specific endpoints are used as-is, matching the OpenTelemetry OTLP exporter
+ * convention.
  */
-declare const Service: <Self, Api extends object = never>() => <Id extends string, const Definition extends Definition$6.Any | undefined = undefined>(id: Id, definition: ServiceBindingDefinition<Definition>) => BindingService<Self, Id, ServiceBindingEffectClient<ApiOrDefinition<Api, Definition>, Definition>> & DirectMethods$1<Self, Definition> & {
-  readonly [TypeId$1]: typeof TypeId$1;
-  readonly definition: ServiceBindingDefinition<Definition>;
-  readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<Response, ServiceBindingFetchError, Self>;
-  readonly rpc: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: ServiceMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<Result<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>, ServiceBindingRpcError, Self>;
-  readonly call: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: ServiceMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>, ServiceBindingRpcError, Self>;
-  readonly scopedCall: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: ServiceMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<Awaited<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>, unknown, Self | Scope.Scope>;
-};
-declare const makeDirectMethods$1: <R, Api, Definition extends Definition$6.Any | undefined>(rpcDefinition: Definition | undefined, call: ServiceCall<R, Api>) => DirectMethods$1<R, Definition>;
-declare namespace Worker_d_exports {
-  export { Api$2 as Api, Definition$5 as Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect$2 as HandlerEffect, Handlers$2 as Handlers, LayerOptions$8 as LayerOptions, Method$3 as Method, Methods$2 as Methods, NativeRequest, NoReservedMethods$2 as NoReservedMethods, Options$4 as Options, ReservedMethodName$3 as ReservedMethodName, RpcHandlers$1 as RpcHandlers, ServerApi$3 as ServerApi, ServiceFreeSchema$2 as ServiceFreeSchema, Tag$8 as Tag, TagClass$7 as TagClass, TagFactory$1 as TagFactory, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcHandler, WorkerRpcShape, implement$4 as implement, isWebSocketUpgrade, make$6 as make, makeFetchHandler, method$2 as method, renderHttpResponse };
+declare const layer$9: (options?: LayerOptions$12) => Layer.Layer<never, never, never>;
+/** Base OTLP telemetry layer forced to JSON serialization. */
+declare const layerJson: (options?: Omit<LayerOptions$12, "serialization">) => Layer.Layer<never, never, never>;
+/** Base OTLP telemetry layer forced to protobuf serialization. */
+declare const layerProtobuf: (options?: Omit<LayerOptions$12, "serialization">) => Layer.Layer<never, never, never>;
+/**
+ * OTLP layer with Cloudflare Worker resource attributes.
+ *
+ * Provide this layer at runtime scope for long-lived metrics aggregation, or at
+ * handler scope when traces/logs should flush as the Cloudflare event finishes.
+ */
+declare const workerLayer: (options?: LayerOptions$12 & WorkerResourceOptions) => Layer.Layer<never, never, never>;
+/**
+ * OTLP layer with Cloudflare Durable Object resource attributes.
+ *
+ * The layer reads {@link DurableObjectState} so it can optionally include the
+ * Durable Object id. Prefer leaving `includeObjectId` disabled unless the
+ * backend can tolerate high-cardinality resource attributes.
+ */
+declare const durableObjectLayer: (options?: LayerOptions$12 & DurableObjectResourceOptions) => Layer.Layer<never, never, DurableObjectState>;
+declare namespace D1_d_exports {
+  export { D1Definition, D1Service, D1SqlLayerOptions, Service$1 as Service, make$10 as make };
 }
-declare const ExecutionContext_base: Context.ServiceClass<ExecutionContext, "effect-cf/ExecutionContext", globalThis.ExecutionContext<unknown>>;
-declare class ExecutionContext extends ExecutionContext_base {}
-interface WorkerContextWaitUntilOptions<E, R> {
-  readonly mode?: "observe" | "propagate";
-  readonly onFailure?: (cause: Cause.Cause<E>) => Effect.Effect<void, never, R>;
+/** Typed D1 binding definition. */
+interface D1Definition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
 }
-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>;
+/** Options forwarded to `@effect/sql-d1` when building a SQL client layer. */
+type D1SqlLayerOptions = Omit<D1Client.D1ClientConfig, "db">;
+declare const D1ServiceTypeId: unique symbol;
+/** Nominal service marker for D1 services created with {@link make}. */
+interface D1Service<Id extends string> {
+  readonly [D1ServiceTypeId]: {
+    readonly id: Id;
+  };
 }
-declare const 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$3 = ReservedMethodName$6 | "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;
-type WorkerFetchSuccess = Response | HttpServerResponse.HttpServerResponse;
-type WorkerHandler<ROut, A = WorkerFetchSuccess> = Effect.Effect<A, unknown, WorkerFetchContext<ROut>>;
-type WorkerRpcHandler<ROut, A = unknown> = Effect.Effect<A, unknown, WorkerRpcContext<ROut>>;
-type WorkerRpc<ROut> = Record<string, (...args: Array<any>) => WorkerRpcHandler<ROut>>;
-type WorkerRpcShape<Rpc extends WorkerRpc<ROut>, ROut> = { readonly [Key in keyof Rpc]: Rpc[Key] extends ((...args: infer Args) => Effect.Effect<infer A, unknown, WorkerRpcContext<ROut>>) ? (...args: Args) => Promise<A> : never };
-type RpcHandlers$1<ROut, Api> = { readonly [Key in keyof Api as Key extends keyof WorkerEntrypoint ? never : Key extends string ? Key extends ReservedMethodName$3 ? never : [Api[Key]] extends [never] ? never : Api[Key] extends ((...args: Array<any>) => Promise<unknown>) ? Key : never : never]: Api[Key] extends ((...args: infer Args) => Promise<infer A>) ? (...args: Args) => WorkerRpcHandler<ROut, A> : never };
-interface WorkerOptions<ROut, Rpc extends WorkerRpc<ROut>> {
-  readonly fetch?: Effect.Effect<WorkerFetchSuccess, unknown, WorkerFetchContext<ROut>>;
-  readonly queue?: QueueHandler<ROut>;
-  readonly rpc?: Rpc;
+/**
+ * Creates a typed D1 service tag plus Effect helpers.
+ */
+declare const make$10: <Id extends string>(id: Id, definition: D1Definition) => BindingService<D1Service<Id>, Id, D1Database> & {
+  "effect-cf/D1": "effect-cf/D1";
+  definition: D1Definition;
+  sqlLayer: (options?: D1SqlLayerOptions) => Layer.Layer<D1Client.D1Client | _$effect_unstable_sql_SqlClient0.SqlClient, BindingNotFoundError | BindingValidationError | _$effect_Config0.ConfigError, WorkerEnvironment>;
+};
+/**
+ * Builds a D1 service around a Cloudflare D1 database binding.
+ *
+ * The returned service exposes the raw `D1Database` binding and `sqlLayer(...)`
+ * for providing `effect/unstable/sql` via `@effect/sql-d1`.
+ *
+ * @example
+ * ```ts
+ * class TodoDatabase extends D1.Service<TodoDatabase>()("TodoDatabase", {
+ *   binding: "TODO_DB",
+ * }) {}
+ *
+ * const SqlLive = TodoDatabase.sqlLayer();
+ * ```
+ */
+declare const Service$1: <Self>() => <Id extends string>(id: Id, definition: D1Definition) => BindingService<Self, Id, D1Database> & {
+  "effect-cf/D1": "effect-cf/D1";
+  definition: D1Definition;
+  sqlLayer: (options?: D1SqlLayerOptions) => Layer.Layer<D1Client.D1Client | _$effect_unstable_sql_SqlClient0.SqlClient, BindingNotFoundError | BindingValidationError | _$effect_Config0.ConfigError, WorkerEnvironment | Exclude<Exclude<Self, _$effect_Scope0.Scope>, Self>>;
+};
+declare namespace Rpc_d_exports {
+  export { DisposableValue, MethodArgs, MethodKey, MethodReturn, Provider, Result, RpcStub, RpcTarget, Serializable, Stub, Stubable, Stubify, dispose, isDisposable, resolve, scoped };
 }
-type FetchWorkerOptions<ROut> = Omit<WorkerOptions<ROut, Record<never, never>>, "rpc"> & {
-  readonly rpc?: never;
+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<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;
 };
-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>;
-interface FetchHandler<Env extends WorkerEnv = WorkerEnv> {
-  readonly fetch: (request: Request, env: Env, ctx: globalThis.ExecutionContext) => Promise<Response>;
+declare const isDisposable: (value: unknown) => value is DisposableValue;
+declare const dispose: (value: unknown) => Effect.Effect<void>;
+declare const resolve: <A>(value: A) => Effect.Effect<Awaited<A>, unknown>;
+declare const scoped: <A>(value: A) => Effect.Effect<Awaited<A>, unknown, Scope.Scope>;
+declare namespace RpcDefinition_d_exports {
+  export { Definition$9 as Definition, Method$5 as Method, Methods$4 as Methods, NoReservedMethods$4 as NoReservedMethods, ReservedMethodName$6 as ReservedMethodName, ReservedMethodNameError, RpcArgumentCountError, RpcArgumentDecodeError, RpcArgumentEncodeError, RpcReservedMethodNameError, RpcSuccessDecodeError, RpcSuccessEncodeError, ServiceFreeSchema$4 as ServiceFreeSchema, assertNoReservedMethodNames, assertNoReservedMethods, decodeArgs, decodeSuccess, encodeArgs, encodeSuccess, make$9 as make, method$4 as method, reservedMethodNames };
 }
-declare const renderHttpResponse: <A extends HttpServerResponse.HttpServerResponse, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Response, E, R>;
-declare function make$6<ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, fetch: WorkerHandler<ROut>): WorkerClass<Record<never, never>, ROut>;
-declare function make$6<ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptions<ROut, Rpc>): WorkerClass<Rpc, ROut>;
-declare const makeFetchHandler: <ROut, LayerError, Env extends WorkerEnv = WorkerEnv>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptions<ROut>) => FetchHandler<Env>;
-type ServiceFreeSchema$2 = Schema.Codec<any, any, never, never>;
-interface Method$3<Args extends ReadonlyArray<ServiceFreeSchema$2> = ReadonlyArray<ServiceFreeSchema$2>, Success extends ServiceFreeSchema$2 = ServiceFreeSchema$2> {
+declare const RpcReservedMethodNameError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "RpcReservedMethodNameError";
+} & Readonly<A>;
+declare class RpcReservedMethodNameError extends RpcReservedMethodNameError_base<{
+  readonly definition: string;
+  readonly method: string;
+}> {}
+declare const RpcArgumentCountError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "RpcArgumentCountError";
+} & Readonly<A>;
+declare class RpcArgumentCountError extends RpcArgumentCountError_base<{
+  readonly definition: string;
+  readonly method: string;
+  readonly expected: number;
+  readonly actual: number;
+}> {}
+declare const RpcArgumentDecodeError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "RpcArgumentDecodeError";
+} & Readonly<A>;
+declare class RpcArgumentDecodeError extends RpcArgumentDecodeError_base<{
+  readonly definition: string;
+  readonly method: string;
+  readonly index: number;
+  readonly cause: unknown;
+}> {}
+declare const RpcArgumentEncodeError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "RpcArgumentEncodeError";
+} & Readonly<A>;
+declare class RpcArgumentEncodeError extends RpcArgumentEncodeError_base<{
+  readonly definition: string;
+  readonly method: string;
+  readonly index: number;
+  readonly cause: unknown;
+}> {}
+declare const RpcSuccessDecodeError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "RpcSuccessDecodeError";
+} & Readonly<A>;
+declare class RpcSuccessDecodeError extends RpcSuccessDecodeError_base<{
+  readonly definition: string;
+  readonly method: string;
+  readonly cause: unknown;
+}> {}
+declare const RpcSuccessEncodeError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "RpcSuccessEncodeError";
+} & Readonly<A>;
+declare class RpcSuccessEncodeError extends RpcSuccessEncodeError_base<{
+  readonly definition: string;
+  readonly method: string;
+  readonly cause: unknown;
+}> {}
+declare const reservedMethodNames: Set<string>;
+type ReservedMethodName$6 = "constructor" | "fetch" | "connect" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError" | "then" | "dup" | "dispose" | "serialize" | "deserialize";
+type ServiceFreeSchema$4 = Schema.Codec<any, any, never, never>;
+interface Method$5<Args extends ReadonlyArray<ServiceFreeSchema$4> = ReadonlyArray<ServiceFreeSchema$4>, Success extends ServiceFreeSchema$4 = ServiceFreeSchema$4> {
   readonly args: Args;
   readonly success: Success;
 }
-declare namespace Method$3 {
-  export type Any = Method$3<ReadonlyArray<ServiceFreeSchema$2>, ServiceFreeSchema$2>;
-  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$2>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$2>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
+declare namespace Method$5 {
+  export type Any = Method$5<ReadonlyArray<ServiceFreeSchema$4>, ServiceFreeSchema$4>;
+  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$4>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$4, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$4>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
+  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$4>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$4, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$4>] ? [Schema.Codec.Encoded<Head>, ...EncodedArgsFromSchemas<Tail>] : Array<Schema.Codec.Encoded<Args[number]>>;
   export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
+  export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
   export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
+  export type EncodedSuccess<Self extends Any> = Schema.Codec.Encoded<Self["success"]>;
   export {};
 }
-type Methods$2 = Record<string, Method$3.Any>;
-type NoReservedMethods$2<MethodsShape extends Methods$2> = Extract<keyof MethodsShape, ReservedMethodName$3> extends never ? MethodsShape : never;
-interface Definition$5<Id extends string = string, MethodsShape extends Methods$2 = Methods$2> {
+type Methods$4 = Record<string, Method$5.Any>;
+type NoReservedMethods$4<MethodsShape extends Methods$4, Reserved extends string = ReservedMethodName$6> = Extract<keyof MethodsShape, Reserved> extends never ? MethodsShape : never;
+interface Definition$9<Id extends string = string, MethodsShape extends Methods$4 = Methods$4> {
   readonly id: Id;
   readonly methods: MethodsShape;
 }
-declare namespace Definition$5 {
-  type Any = Definition$5<string, Methods$2>;
+declare namespace Definition$9 {
+  type Any = Definition$9<string, Methods$4>;
+  type ServerApi<Self extends Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$5.Args<Self["methods"][Key]>) => Promise<Method$5.Success<Self["methods"][Key]>> };
+  type Api<Self extends Any, Reserved extends string = never> = Provider<ServerApi<Self>, Reserved>;
+  type MethodNames<Self extends Any> = Extract<keyof Self["methods"], string>;
 }
-type ServerApi$3<Self extends Definition$5.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$3.Args<Self["methods"][Key]>) => Promise<Method$3.Success<Self["methods"][Key]>> };
-type Api$2<Self extends Definition$5.Any> = Provider<ServerApi$3<Self>, ReservedMethodName$3>;
-type Handlers$2<ROut, Self extends Definition$5.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$3.Args<Self["methods"][Key]>) => WorkerRpcHandler<ROut, Method$3.Success<Self["methods"][Key]>> };
-interface Options$4<ROut, Self extends Definition$5.Any> extends Omit<WorkerOptions<ROut, Handlers$2<ROut, Self>>, "rpc"> {
-  readonly rpc: Handlers$2<ROut, Self>;
+declare class ReservedMethodNameError extends Error {
+  readonly method: string;
+  readonly target: string;
+  constructor(target: string, method: string);
 }
-type LayerOptions$8 = LayerOptions$9;
-type TagClass$7<Self, Id extends string, MethodsShape extends Methods$2> = Context.ServiceClass<Self, Id, ServiceBindingEffectClient<Api$2<Definition$5<Id, MethodsShape>>, Definition$5<Id, MethodsShape>>> & ServiceBindingStaticClient<Self, Api$2<Definition$5<Id, MethodsShape>>, Definition$5<Id, MethodsShape>> & {
+declare const assertNoReservedMethods: (target: string, methods: Record<string, unknown>, reserved: ReadonlySet<string>) => void;
+declare function method$4<Success extends ServiceFreeSchema$4>(definition: {
+  readonly success: Success;
+}): Method$5<readonly [], Success>;
+declare function method$4<const Args extends ReadonlyArray<ServiceFreeSchema$4>, Success extends ServiceFreeSchema$4>(definition: {
+  readonly args: Args;
+  readonly success: Success;
+}): Method$5<Args, Success>;
+declare const assertNoReservedMethodNames: (definition: Definition$9.Any) => Effect.Effect<void, RpcReservedMethodNameError>;
+declare const decodeArgs: <const Self extends Definition$9.Any, MethodName extends Definition$9.MethodNames<Self>>(definition: Self, methodName: MethodName, args: ReadonlyArray<unknown>) => Effect.Effect<Method$5.Args<Self["methods"][MethodName]>, RpcArgumentCountError | RpcArgumentDecodeError>;
+declare const encodeArgs: <const Self extends Definition$9.Any, MethodName extends Definition$9.MethodNames<Self>>(definition: Self, methodName: MethodName, args: Method$5.Args<Self["methods"][MethodName]>) => Effect.Effect<Method$5.EncodedArgs<Self["methods"][MethodName]>, RpcArgumentCountError | RpcArgumentEncodeError>;
+declare const encodeSuccess: <const Self extends Definition$9.Any, MethodName extends Definition$9.MethodNames<Self>>(definition: Self, methodName: MethodName, value: Method$5.Success<Self["methods"][MethodName]>) => Effect.Effect<Method$5.EncodedSuccess<Self["methods"][MethodName]>, RpcSuccessEncodeError>;
+declare const decodeSuccess: <const Self extends Definition$9.Any, MethodName extends Definition$9.MethodNames<Self>>(definition: Self, methodName: MethodName, value: unknown) => Effect.Effect<Method$5.Success<Self["methods"][MethodName]>, RpcSuccessDecodeError>;
+declare const make$9: <Id extends string, const MethodsShape extends Methods$4>(id: Id, methods: MethodsShape) => Definition$9<Id, MethodsShape>;
+declare namespace QueueBinding_d_exports {
+  export { MessageSendRequest, QueueBindingClient, QueueBindingDefinition, QueueMetrics, QueueOperationError, QueueProducer, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse, isQueue, layer$8 as layer, makeClient$6 as makeClient };
+}
+type QueueSendOptions = globalThis.QueueSendOptions;
+type QueueSendResponse = globalThis.QueueSendResponse;
+type QueueSendBatchOptions = globalThis.QueueSendBatchOptions;
+type QueueSendBatchResponse = globalThis.QueueSendBatchResponse;
+type QueueMetrics = globalThis.QueueMetrics;
+type MessageSendRequest<Body> = globalThis.MessageSendRequest<Body>;
+type QueueProducer<Body> = Pick<globalThis.Queue<Body>, "send"> & Partial<Pick<globalThis.Queue<Body>, "sendBatch" | "metrics">>;
+interface QueueBindingDefinition<Message extends ServiceFreeSchema$4> {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+  /** Codec used to encode messages before sending them to Cloudflare Queues. */
+  readonly message: Message;
+}
+interface QueueBindingClient<Message extends ServiceFreeSchema$4> {
+  readonly send: (message: Schema.Schema.Type<Message>, options?: QueueSendOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError>;
+  readonly sendBatch: (messages: Iterable<MessageSendRequest<Schema.Schema.Type<Message>>>, options?: QueueSendBatchOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError>;
+  readonly metrics: () => Effect.Effect<QueueMetrics, QueueOperationError>;
+  readonly unsafeRaw: Effect.Effect<globalThis.Queue<Schema.Codec.Encoded<Message>>>;
+}
+declare const QueueOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.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$6: <Message extends ServiceFreeSchema$4>(definition: QueueBindingDefinition<Message>) => ((queue: QueueProducer<Schema.Codec.Encoded<Message>>) => QueueBindingClient<Message>);
+declare const layer$8: <Self, Message extends ServiceFreeSchema$4>(tag: Context.Service<Self, QueueBindingClient<Message>>, definition: QueueBindingDefinition<Message>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare namespace QueueDefinition_d_exports {
+  export { Definition$8 as Definition, Handler$3 as Handler, LayerOptions$11 as LayerOptions, Options$7 as Options, Queue$1 as Queue, Tag$11 as Tag, TagClass$10 as TagClass, implement$7 as implement, make$8 as make };
+}
+interface Definition$8<Id extends string = string, Message extends ServiceFreeSchema$4 = ServiceFreeSchema$4> {
   readonly id: Id;
-  readonly methods: MethodsShape;
-  readonly make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$4<ROut, Definition$5<Id, MethodsShape>>) => WorkerClass<Handlers$2<ROut, Definition$5<Id, MethodsShape>>, ROut>;
-  readonly layer: (options: LayerOptions$8) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-};
-type TagFactory$1 = <Self>() => <Id extends string, const MethodsShape extends Methods$2>(id: Id, methods: MethodsShape & NoReservedMethods$2<MethodsShape>) => TagClass$7<Self, Id, MethodsShape>;
-declare const Tag$8: TagFactory$1;
-declare const method$2: {
-  <Success extends ServiceFreeSchema$2>(definition: {
-    readonly success: Success;
-  }): Method$3<readonly [], Success>;
-  <const Args extends readonly ServiceFreeSchema$2[], Success extends ServiceFreeSchema$2>(definition: {
-    readonly args: Args;
-    readonly success: Success;
-  }): Method$3<Args, Success>;
+  readonly message: Message;
+}
+declare namespace Definition$8 {
+  type Any = Definition$8<string, ServiceFreeSchema$4>;
+}
+type Handler$3<ROut, Self extends Definition$8.Any> = (batch: QueueBatch<Schema.Schema.Type<Self["message"]>>) => Effect.Effect<void, unknown, ExecutionContext | WorkerContext | WorkerEnvironment | Scope.Scope | ROut>;
+interface Options$7<ROut, Self extends Definition$8.Any> extends Omit<WorkerOptions<ROut, Record<never, never>>, "queue" | "rpc"> {
+  readonly queue: Handler$3<ROut, Self>;
+  readonly rpc?: never;
+}
+type LayerOptions$11 = {
+  readonly binding: string;
 };
-declare const implement$4: <ROut, const Self extends Definition$5.Any>(_definition: Self, handlers: Handlers$2<ROut, Self>) => Handlers$2<ROut, Self>;
-type HandlerEffect$2<ROut, Self extends Definition$5.Any, Key extends keyof Self["methods"]> = WorkerRpcHandler<ROut, Method$3.Success<Self["methods"][Key]>>;
-declare namespace DurableObjectStorage_d_exports {
-  export { DurableObjectStorage, DurableObjectTransaction, SchemaBackedSyncKvStorage, SqlCursor, SqlStorage, SqlStorageValue, StorageOperationError, SyncKvDefinition, SyncKvStorage, fromDurableObjectStorage };
+interface TagClass$10<Self, Id extends string, Message extends ServiceFreeSchema$4> extends Context.ServiceClass<Self, Id, QueueBindingClient<Message>> {
+  readonly id: Id;
+  readonly message: Message;
+  readonly make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$7<ROut, Definition$8<Id, Message>>) => WorkerClass<Record<never, never>, ROut>;
+  readonly layer: (options: LayerOptions$11) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly send: (message: Schema.Schema.Type<Message>, options?: QueueSendOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError, Self>;
+  readonly sendBatch: (messages: Iterable<MessageSendRequest<Schema.Schema.Type<Message>>>, options?: QueueSendBatchOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError, Self>;
+  readonly metrics: () => Effect.Effect<QueueMetrics, QueueOperationError, Self>;
+  readonly unsafeRaw: () => Effect.Effect<globalThis.Queue<Schema.Codec.Encoded<Message>>, never, Self>;
 }
-/** Supported primitive value types for Durable Object SQL APIs. */
-type SqlStorageValue = globalThis.SqlStorageValue;
-declare const StorageOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
-  readonly _tag: "StorageOperationError";
+declare const make$8: <Id extends string, Message extends ServiceFreeSchema$4>(id: Id, definition: {
+  readonly message: Message;
+}) => TagClass$10<Definition$8<Id, Message>, Id, Message>;
+declare const Tag$11: <Self>() => <Id extends string, Message extends ServiceFreeSchema$4>(id: Id, definition: {
+  readonly message: Message;
+}) => TagClass$10<Self, Id, Message>;
+declare const Queue$1: <Self>() => <Id extends string, Message extends ServiceFreeSchema$4>(id: Id, definition: {
+  readonly message: Message;
+}) => TagClass$10<Self, Id, Message>;
+declare const implement$7: <ROut, const Self extends Definition$8.Any>(_definition: Self, handler: Handler$3<ROut, Self>) => Handler$3<ROut, Self>;
+declare namespace Queue_d_exports {
+  export { Definition$7 as Definition, Handler$2 as Handler, LayerOptions$10 as LayerOptions, Options$6 as Options, QueueBatch, QueueHandler, QueueMessage, QueueMessageDecodeError, QueueOptions, Tag$10 as Tag, TagClass$9 as TagClass, decodeBatch, fromMessage, fromMessageBatch, implement$6 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: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "QueueMessageDecodeError";
 } & Readonly<A>;
-/** Error type used when a storage operation throws or rejects. */
-declare class StorageOperationError extends StorageOperationError_base<{
-  readonly operation: string;
+declare class QueueMessageDecodeError extends QueueMessageDecodeError_base<{
+  readonly queue: string;
+  readonly messageId: string;
+  readonly index: number;
   readonly cause: unknown;
 }> {}
-type StorageEffect<A> = Effect.Effect<A, StorageOperationError>;
+type RuntimeContext$2<ROut> = ExecutionContext | WorkerContext | WorkerEnvironment | ROut;
+type QueueHandlerContext<ROut> = RuntimeContext$2<ROut> | Scope.Scope;
+type QueueHandler<ROut, Body = unknown> = (batch: QueueBatch<Body>) => Effect.Effect<void, unknown, QueueHandlerContext<ROut>>;
+interface QueueOptions<ROut, Body = unknown> {
+  readonly queue: QueueHandler<ROut, Body>;
+}
+declare const fromMessage: <Body>(message: globalThis.Message<unknown>, body: Body) => {
+  raw: Message<unknown>;
+  id: string;
+  timestamp: Date;
+  body: Body;
+  attempts: number;
+  ack: Effect.Effect<void, never, never>;
+  retry: (options?: globalThis.QueueRetryOptions) => Effect.Effect<void, never, never>;
+};
+declare const fromMessageBatch: <Body>(batch: globalThis.MessageBatch<unknown>, messages: ReadonlyArray<QueueMessage<Body>>) => QueueBatch<Body>;
+declare const decodeBatch: <Body>(batch: globalThis.MessageBatch<unknown>, decodeBody: (body: unknown) => Effect.Effect<Body, unknown>) => Effect.Effect<QueueBatch<Body>, QueueMessageDecodeError>;
+type Definition$7<Id extends string = string, Message extends Definition$8.Any["message"] = Definition$8.Any["message"]> = Definition$8<Id, Message>;
+declare namespace Definition$7 {
+  type Any = Definition$8.Any;
+}
+type LayerOptions$10 = LayerOptions$11;
+type TagClass$9<Self, Id extends string, Message extends Definition$8.Any["message"]> = TagClass$10<Self, Id, Message>;
+declare const Tag$10: <Self>() => <Id extends string, Message extends Definition$8.Any["message"]>(id: Id, definition: {
+  readonly message: Message;
+}) => TagClass$9<Self, Id, Message>;
+declare const implement$6: <ROut, const Self extends Definition$8.Any>(_definition: Self, handler: Handler$3<ROut, Self>) => Handler$3<ROut, Self>;
+type Handler$2<ROut, Self extends Definition$8.Any> = Handler$3<ROut, Self>;
+type Options$6<ROut, Self extends Definition$8.Any> = Options$7<ROut, Self>;
+declare namespace WorkerDefinition_d_exports {
+  export { Api$3 as Api, Definition$6 as Definition, HandlerEffect$3 as HandlerEffect, Handlers$3 as Handlers, LayerOptions$9 as LayerOptions, Method$4 as Method, Methods$3 as Methods, NoReservedMethods$3 as NoReservedMethods, Options$5 as Options, ReservedMethodName$5 as ReservedMethodName, ServerApi$4 as ServerApi, ServiceFreeSchema$3 as ServiceFreeSchema, Tag$9 as Tag, TagClass$8 as TagClass, Worker, implement$5 as implement, make$7 as make, method$3 as method };
+}
+type ServiceFreeSchema$3 = Schema.Codec<any, any, never, never>;
+interface Method$4<Args extends ReadonlyArray<ServiceFreeSchema$3> = ReadonlyArray<ServiceFreeSchema$3>, Success extends ServiceFreeSchema$3 = ServiceFreeSchema$3> {
+  readonly args: Args;
+  readonly success: Success;
+}
+declare namespace Method$4 {
+  export type Any = Method$4<ReadonlyArray<ServiceFreeSchema$3>, ServiceFreeSchema$3>;
+  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$3>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$3, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$3>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
+  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$3>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$3, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$3>] ? [Schema.Codec.Encoded<Head>, ...EncodedArgsFromSchemas<Tail>] : Array<Schema.Codec.Encoded<Args[number]>>;
+  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
+  export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
+  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
+  export type EncodedSuccess<Self extends Any> = Schema.Codec.Encoded<Self["success"]>;
+  export {};
+}
+type Methods$3 = Record<string, Method$4.Any>;
 /**
- * Effect wrapper for Cloudflare SQL cursor operations.
+ * RPC contract for a Worker service.
+ *
+ * Create with {@link make} and reuse to type both worker implementations and
+ * service bindings in other workers.
  */
-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>;
+interface Definition$6<Id extends string = string, MethodsShape extends Methods$3 = Methods$3> {
+  readonly id: Id;
+  readonly methods: MethodsShape;
+}
+declare namespace Definition$6 {
+  type Any = Definition$6<string, Methods$3>;
 }
+type ReservedMethodName$5 = ReservedMethodName$3;
+type NoReservedMethods$3<MethodsShape extends Methods$3> = Extract<keyof MethodsShape, ReservedMethodName$5> extends never ? MethodsShape : never;
 /**
- * Effect wrapper for Durable Object SQLite APIs.
+ * Promise-based client API derived from a {@link Definition}.
+ */
+type ServerApi$4<Self extends Definition$6.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$4.Args<Self["methods"][Key]>) => Promise<Method$4.Success<Self["methods"][Key]>> };
+type Api$3<Self extends Definition$6.Any> = Provider<ServerApi$4<Self>, ReservedMethodName$5>;
+/**
+ * Effect handlers for each RPC method in a worker definition.
+ */
+type Handlers$3<ROut, Self extends Definition$6.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$4.Args<Self["methods"][Key]>) => WorkerRpcHandler<ROut, Method$4.Success<Self["methods"][Key]>> };
+/**
+ * Worker constructor options for a specific RPC definition.
  */
-interface 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;
+interface Options$5<ROut, Self extends Definition$6.Any, REvent = never, EventLayerError = never> extends Omit<WorkerOptions<ROut, REvent, EventLayerError, Handlers$3<ROut | REvent, Self>>, "rpc"> {
+  readonly rpc: Handlers$3<ROut | REvent, Self>;
 }
+type LayerOptions$9 = {
+  readonly binding: string;
+};
+type TagClass$8<Self, Id extends string, MethodsShape extends Methods$3> = Context.ServiceClass<Self, Id, ServiceBindingEffectClient<Api$3<Definition$6<Id, MethodsShape>>, Definition$6<Id, MethodsShape>>> & ServiceBindingStaticClient<Self, Api$3<Definition$6<Id, MethodsShape>>, Definition$6<Id, MethodsShape>> & {
+  readonly id: Id;
+  readonly methods: MethodsShape;
+  readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$5<ROut, Definition$6<Id, MethodsShape>, REvent, EventLayerError>) => WorkerClass<Handlers$3<ROut | REvent, Definition$6<Id, MethodsShape>>, ROut | REvent>;
+  readonly layer: (options: LayerOptions$9) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+};
 /**
- * Schema pair used by `SyncKvStorage.schema(...)`.
+ * Defines a single RPC method schema in a worker definition.
  */
-interface SyncKvDefinition<Key, Value, EncodedValue> {
-  readonly key: Schema.Codec<Key, string>;
-  readonly value: Schema.Codec<Value, EncodedValue>;
-}
+declare const method$3: {
+  <Success extends ServiceFreeSchema$3>(definition: {
+    readonly success: Success;
+  }): Method$4<readonly [], Success>;
+  <const Args extends readonly ServiceFreeSchema$3[], Success extends ServiceFreeSchema$3>(definition: {
+    readonly args: Args;
+    readonly success: Success;
+  }): Method$4<Args, Success>;
+};
+declare const make$7: <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$8<Definition$6<Id, MethodsShape>, Id, MethodsShape>;
+declare const Tag$9: <Self>() => <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$8<Self, Id, MethodsShape>;
+declare const Worker: <Self>() => <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$8<Self, Id, MethodsShape>;
 /**
- * Sync KV wrapper that transparently encodes keys/values through Effect Schema.
+ * Helper for implementing handlers with the exact method shape of a definition.
  */
-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>;
-}
+declare const implement$5: <ROut, const Self extends Definition$6.Any>(_definition: Self, handlers: Handlers$3<ROut, Self>) => Handlers$3<ROut, Self>;
 /**
- * Effect wrapper for synchronous KV attached to Durable Object SQLite storage.
+ * Convenience alias for a single worker RPC handler Effect.
  */
-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>;
+type HandlerEffect$3<ROut, Self extends Definition$6.Any, Key extends keyof Self["methods"]> = WorkerRpcHandler<ROut, Method$4.Success<Self["methods"][Key]>>;
+//#endregion
+//#region src/internal/RpcInvocation.d.ts
+type AnyArgs = Array<any>;
+type AsyncMethodKey<Api> = { [Key in keyof Api]-?: Key extends string ? Api[Key] extends ((...args: AnyArgs) => Promise<unknown>) ? Key : never : never }[keyof Api];
+type AsyncMethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...args: infer Args) => Promise<unknown>) ? Args : never;
+type AsyncMethodSuccess<Api, Method extends keyof Api> = Api[Method] extends ((...args: AnyArgs) => Promise<infer A>) ? A : never;
+type AsyncMethodCloudflareReturn<Api, Method extends keyof Api> = Result<AsyncMethodSuccess<Api, Method>>;
+declare namespace ServiceBinding_d_exports {
+  export { Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceFetcher, isServiceBindingClient, layer$7 as layer, makeClient$5 as makeClient, makeDirectMethods$1 as makeDirectMethods };
 }
+declare const TypeId$1: "effect-cf/ServiceBinding";
 /**
- * Effect wrapper around Cloudflare transaction callbacks.
+ * Minimum shape for a Cloudflare service binding.
  */
-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>;
+interface ServiceFetcher {
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
 }
+type RpcClient$1<Api> = { readonly [Key in keyof Api as Key extends string ? Api[Key] extends ((...args: Array<any>) => unknown) ? Key : never : never]: Api[Key] };
+type ReservedMethodName$4 = ReservedMethodName$5 | "fetch";
 /**
- * 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;
- * });
- * ```
+ * Native Cloudflare service object including optional RPC methods.
  */
-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;
-}
+type ServiceBindingClient<Api extends object> = ServiceFetcher & RpcClient$1<Provider<Api, ReservedMethodName$4>>;
+type ApiFromDefinition<Definition> = Definition extends Definition$6.Any ? ServerApi$4<Definition> : never;
+type ApiOrDefinition<Api extends object, Definition> = [Api] extends [never] ? ApiFromDefinition<Definition> : Api;
 /**
- * Wraps native Cloudflare storage APIs as Effect-returning helpers.
+ * Binding metadata used to create an Effect service from a Worker binding.
  */
-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 };
+interface ServiceBindingDefinition<Definition extends Definition$6.Any | undefined = undefined> {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+  /** Optional RPC schema used for argument/result encoding. */
+  readonly definition?: Definition;
 }
-/** Data supported by Cloudflare websocket `send`. */
-type DurableWebSocketSendData = string | ArrayBuffer | ArrayBufferView;
-declare const DurableWebSocketSendError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.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;
-}> {}
-declare const DurableWebSocketCloseError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
-  readonly _tag: "DurableWebSocketCloseError";
+declare const ServiceBindingFetchError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "ServiceBindingFetchError";
 } & Readonly<A>;
-/** Error raised when closing a Durable Object websocket fails. */
-declare class DurableWebSocketCloseError extends DurableWebSocketCloseError_base<{
+/**
+ * Failure raised when calling `fetch` on a service binding.
+ */
+declare class ServiceBindingFetchError extends ServiceBindingFetchError_base<{
+  readonly binding: string;
   readonly cause: unknown;
 }> {}
-declare const DurableWebSocketAttachmentError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
-  readonly _tag: "DurableWebSocketAttachmentError";
+declare const ServiceBindingRpcError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "ServiceBindingRpcError";
 } & 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;
-}> {}
-/** 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}.
+ * Failure raised when invoking an RPC method on a service binding.
  */
-interface AcceptedUpgrade<Attachment = unknown> {
-  readonly client: WebSocket;
-  readonly server: DurableWebSocket<Attachment>;
-  readonly response: Response;
-}
+declare class ServiceBindingRpcError extends ServiceBindingRpcError_base<{
+  readonly binding: string;
+  readonly method: string;
+  readonly cause: unknown;
+}> {}
+type ServiceMethodKey<Api> = AsyncMethodKey<Api>;
+type ServiceMethodArgs<Api, Method extends keyof Api> = AsyncMethodArgs<Api, Method>;
+type ServiceMethodSuccess<Api, Method extends keyof Api> = AsyncMethodSuccess<Api, Method>;
+type ServiceMethodCloudflareReturn<Api, Method extends keyof Api> = AsyncMethodCloudflareReturn<Api, Method>;
+type ServiceCall<R, Api> = <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError, R>;
+type DefinitionDirectMethods<R, Definition extends Definition$6.Any> = { readonly [Method in Definition$9.MethodNames<Definition>]: (...args: Method$5.Args<Definition["methods"][Method]>) => Effect.Effect<Method$5.Success<Definition["methods"][Method]>, ServiceBindingRpcError, R> };
+type DirectMethods$1<R, Definition> = Definition extends Definition$6.Any ? DefinitionDirectMethods<R, Definition> : {};
+type ServiceBindingEffectClient<Api extends object, Definition extends Definition$6.Any | undefined = undefined> = DirectMethods$1<never, Definition> & {
+  /**
+   * Forwards an HTTP request to the bound Worker service.
+   *
+   * Use this when the service binding is acting as an HTTP origin rather than a
+   * Cloudflare RPC target.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect";
+   *
+   * const program = Effect.gen(function* () {
+   *   const api = yield* ApiWorker;
+   *   return yield* api.fetch(new Request("https://internal.example/users"));
+   * });
+   * ```
+   */
+  readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, ServiceBindingFetchError>;
+  /**
+   * Invokes a Worker RPC method and returns Cloudflare's raw RPC result.
+   *
+   * This preserves Cloudflare RPC behavior such as promise-like pipelining and
+   * transferable / disposable result objects. It does not resolve the returned
+   * promise-like value and it does not decode definition-backed success schemas.
+   *
+   * Most application code should use {@link call} instead.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect";
+   *
+   * const program = Effect.gen(function* () {
+   *   const counter = yield* CounterService;
+   *
+   *   const result = yield* counter.rpc("increment", 41);
+   *   const value = yield* Effect.promise(() => result);
+   *
+   *   return value;
+   * });
+   * ```
+   */
+  readonly rpc: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodCloudflareReturn<Api, Method>, ServiceBindingRpcError>;
+  /**
+   * Invokes a Worker RPC method, resolves Cloudflare's RPC result, and decodes
+   * the success value when the binding was created from a definition.
+   *
+   * This is the normal choice when application code wants the final typed value.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect";
+   *
+   * const program = Effect.gen(function* () {
+   *   const counter = yield* CounterService;
+   *   const value = yield* counter.call("increment", 41);
+   *
+   *   return value;
+   * });
+   * ```
+   */
+  readonly call: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError>;
+  /**
+   * Invokes a Worker RPC method in the current `Scope`, resolves Cloudflare's RPC
+   * result, decodes definition-backed success values, and disposes the resolved
+   * result when the scope closes if it implements `Symbol.dispose`.
+   *
+   * Use this for RPC methods that return Cloudflare RPC resources or other
+   * disposable objects whose lifetime should be tied to an Effect scope.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect";
+   *
+   * const program = Effect.scoped(
+   *   Effect.gen(function* () {
+   *     const files = yield* FileService;
+   *     const handle = yield* files.scopedCall("open", "report.csv");
+   *
+   *     return yield* handle.read();
+   *   }),
+   * );
+   * ```
+   */
+  readonly scopedCall: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, unknown, Scope.Scope>;
+};
+type ServiceBindingStaticClient<R, Api extends object, Definition extends Definition$6.Any | undefined = undefined> = DirectMethods$1<R, Definition> & {
+  readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, ServiceBindingFetchError, R>;
+  readonly rpc: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodCloudflareReturn<Api, Method>, ServiceBindingRpcError, R>;
+  readonly call: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError, R>;
+  readonly scopedCall: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, unknown, Scope.Scope | R>;
+};
+declare const isServiceBindingClient: <Api extends object>(value: unknown) => value is ServiceBindingClient<Api>;
+declare const makeClient$5: <Api extends object, const Definition extends Definition$6.Any | undefined = undefined>(definition: ServiceBindingDefinition<Definition>) => ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition>);
+declare const layer$7: <Self, Api extends object, const Definition extends Definition$6.Any | undefined = undefined>(tag: Context.Service<Self, ServiceBindingEffectClient<Api, Definition>>, definition: ServiceBindingDefinition<Definition>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 /**
- * Accepts a websocket upgrade and registers the server socket on `DurableObjectState`.
+ * 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 response = yield* DurableObjectWebSocket.acceptUpgrade({
- *   tags: ["room:general"],
+ * const Counter = WorkerDefinition.make("Counter", {
+ *   increment: WorkerDefinition.method({
+ *     args: [Schema.Number],
+ *     success: Schema.Number,
+ *   }),
  * });
  *
- * return response.response;
+ * 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 acceptUpgrade: <Attachment = unknown>(options?: AcceptUpgradeOptions<Attachment>) => Effect.Effect<AcceptedUpgrade<Attachment>, never, 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>;
+declare const Service: <Self, Api extends object = never>() => <Id extends string, const Definition extends Definition$6.Any | undefined = undefined>(id: Id, definition: ServiceBindingDefinition<Definition>) => BindingService<Self, Id, ServiceBindingEffectClient<ApiOrDefinition<Api, Definition>, Definition>> & DirectMethods$1<Self, Definition> & {
+  readonly [TypeId$1]: typeof TypeId$1;
+  readonly definition: ServiceBindingDefinition<Definition>;
+  readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<Response, ServiceBindingFetchError, Self>;
+  readonly rpc: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: ServiceMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<Result<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>, ServiceBindingRpcError, Self>;
+  readonly call: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: ServiceMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>, ServiceBindingRpcError, Self>;
+  readonly scopedCall: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: ServiceMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<Awaited<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>, unknown, Self | Scope.Scope>;
+};
+declare const makeDirectMethods$1: <R, Api, Definition extends Definition$6.Any | undefined>(rpcDefinition: Definition | undefined, call: ServiceCall<R, Api>) => DirectMethods$1<R, Definition>;
+declare namespace Worker_d_exports {
+  export { Api$2 as Api, Definition$5 as Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect$2 as HandlerEffect, Handlers$2 as Handlers, LayerOptions$8 as LayerOptions, Method$3 as Method, Methods$2 as Methods, NativeRequest, NoReservedMethods$2 as NoReservedMethods, Options$4 as Options, ReservedMethodName$3 as ReservedMethodName, RpcHandlers$1 as RpcHandlers, ServerApi$3 as ServerApi, ServiceFreeSchema$2 as ServiceFreeSchema, Tag$8 as Tag, TagClass$7 as TagClass, TagFactory$1 as TagFactory, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcHandler, WorkerRpcShape, implement$4 as implement, isWebSocketUpgrade, make$6 as make, makeFetchHandler, method$2 as method, renderHttpResponse };
 }
-/** 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>;
+declare const ExecutionContext_base: Context.ServiceClass<ExecutionContext, "effect-cf/ExecutionContext", globalThis.ExecutionContext<unknown>>;
+declare class ExecutionContext extends ExecutionContext_base {}
+interface WorkerContextWaitUntilOptions<E, R> {
+  readonly mode?: "observe" | "propagate";
+  readonly onFailure?: (cause: Cause.Cause<E>) => Effect.Effect<void, never, 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 DurableObjectState_d_exports {
-  export { DurableObjectState, DurableObjectStateService, fromDurableObjectState };
+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>;
 }
-/**
- * Effect-friendly wrapper around Cloudflare `DurableObjectState`.
- */
-interface DurableObjectStateService {
-  /** Underlying Cloudflare state instance. */
-  readonly raw: globalThis.DurableObjectState;
-  /** Durable Object id for the current instance. */
-  readonly id: globalThis.DurableObjectId;
-  /** Wrapped storage API. */
-  readonly storage: DurableObjectStorage;
-  /** Registers background work with Cloudflare's lifecycle. */
-  waitUntil(promise: Promise<unknown>): Effect.Effect<void>;
-  /**
-   * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate.
-   *
-   * Cloudflare resets a Durable Object if the callback throws/rejects, or if the
-   * callback exceeds the platform timeout (currently documented as 30 seconds).
-   * This safe default resolves the callback with the Effect `Exit` for typed
-   * Effect failures and resumes that `Exit` afterward, so typed failures remain
-   * ordinary Effect failures instead of resetting the Durable Object. Defects
-   * and interruptions still reject the callback.
-   */
-  blockConcurrencyWhile<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
+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$3 = ReservedMethodName$6 | "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;
+type WorkerFetchSuccess = Response | HttpServerResponse.HttpServerResponse;
+type WorkerHandler<ROut, A = WorkerFetchSuccess> = Effect.Effect<A, unknown, WorkerFetchContext<ROut>>;
+type WorkerRpcHandler<ROut, A = unknown> = Effect.Effect<A, unknown, WorkerRpcContext<ROut>>;
+type WorkerRpc<ROut> = Record<string, (...args: Array<any>) => WorkerRpcHandler<ROut>>;
+type WorkerRpcShape<Rpc extends WorkerRpc<ROut>, ROut> = { readonly [Key in keyof Rpc]: Rpc[Key] extends ((...args: infer Args) => Effect.Effect<infer A, unknown, WorkerRpcContext<ROut>>) ? (...args: Args) => Promise<A> : never };
+type RpcHandlers$1<ROut, Api> = { readonly [Key in keyof Api as Key extends keyof WorkerEntrypoint ? never : Key extends string ? Key extends ReservedMethodName$3 ? never : [Api[Key]] extends [never] ? never : Api[Key] extends ((...args: Array<any>) => Promise<unknown>) ? Key : never : never]: Api[Key] extends ((...args: infer Args) => Promise<infer A>) ? (...args: Args) => WorkerRpcHandler<ROut, A> : never };
+interface WorkerOptions<RRuntime, REvent = never, EventLayerError = never, Rpc extends WorkerRpc<RRuntime | REvent> = Record<never, never>> {
   /**
-   * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate and lets
-   * Effect failures reject the callback.
+   * Layer provided around each Cloudflare event handled by this Worker.
    *
-   * 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.
+   * 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.
    */
-  abort(reason?: string): Effect.Effect<void>;
+  readonly eventLayer?: Layer.Layer<REvent, EventLayerError, WorkerBaseContext<RRuntime>>;
+  readonly fetch?: Effect.Effect<WorkerFetchSuccess, unknown, WorkerFetchContext<RRuntime | REvent>>;
+  readonly queue?: QueueHandler<RRuntime | REvent>;
+  readonly rpc?: Rpc;
 }
-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;
+type FetchWorkerOptions<RRuntime, REvent = never, EventLayerError = never> = Omit<WorkerOptions<RRuntime, REvent, EventLayerError, Record<never, never>>, "rpc"> & {
+  readonly rpc?: never;
+};
+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>;
+interface FetchHandler<Env extends WorkerEnv = WorkerEnv> {
+  readonly fetch: (request: Request, env: Env, ctx: globalThis.ExecutionContext) => Promise<Response>;
+}
+declare const renderHttpResponse: <A extends HttpServerResponse.HttpServerResponse, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Response, E, R>;
+declare function make$6<ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, fetch: WorkerHandler<ROut>): WorkerClass<Record<never, never>, ROut>;
+declare function make$6<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>;
+declare const makeFetchHandler: <ROut, LayerError, REvent = never, EventLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptions<ROut, REvent, EventLayerError>) => FetchHandler<Env>;
+type ServiceFreeSchema$2 = Schema.Codec<any, any, never, never>;
+interface Method$3<Args extends ReadonlyArray<ServiceFreeSchema$2> = ReadonlyArray<ServiceFreeSchema$2>, Success extends ServiceFreeSchema$2 = ServiceFreeSchema$2> {
+  readonly args: Args;
+  readonly success: Success;
+}
+declare namespace Method$3 {
+  export type Any = Method$3<ReadonlyArray<ServiceFreeSchema$2>, ServiceFreeSchema$2>;
+  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$2>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$2>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
+  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
+  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
+  export {};
+}
+type Methods$2 = Record<string, Method$3.Any>;
+type NoReservedMethods$2<MethodsShape extends Methods$2> = Extract<keyof MethodsShape, ReservedMethodName$3> extends never ? MethodsShape : never;
+interface Definition$5<Id extends string = string, MethodsShape extends Methods$2 = Methods$2> {
+  readonly id: Id;
+  readonly methods: MethodsShape;
+}
+declare namespace Definition$5 {
+  type Any = Definition$5<string, Methods$2>;
+}
+type ServerApi$3<Self extends Definition$5.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$3.Args<Self["methods"][Key]>) => Promise<Method$3.Success<Self["methods"][Key]>> };
+type Api$2<Self extends Definition$5.Any> = Provider<ServerApi$3<Self>, ReservedMethodName$3>;
+type Handlers$2<ROut, Self extends Definition$5.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$3.Args<Self["methods"][Key]>) => WorkerRpcHandler<ROut, Method$3.Success<Self["methods"][Key]>> };
+interface Options$4<ROut, Self extends Definition$5.Any, REvent = never, EventLayerError = never> extends Omit<WorkerOptions<ROut, REvent, EventLayerError, Handlers$2<ROut | REvent, Self>>, "rpc"> {
+  readonly rpc: Handlers$2<ROut | REvent, Self>;
+}
+type LayerOptions$8 = LayerOptions$9;
+type TagClass$7<Self, Id extends string, MethodsShape extends Methods$2> = Context.ServiceClass<Self, Id, ServiceBindingEffectClient<Api$2<Definition$5<Id, MethodsShape>>, Definition$5<Id, MethodsShape>>> & ServiceBindingStaticClient<Self, Api$2<Definition$5<Id, MethodsShape>>, Definition$5<Id, MethodsShape>> & {
+  readonly id: Id;
+  readonly methods: MethodsShape;
+  readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$4<ROut, Definition$5<Id, MethodsShape>, REvent, EventLayerError>) => WorkerClass<Handlers$2<ROut | REvent, Definition$5<Id, MethodsShape>>, ROut | REvent>;
+  readonly layer: (options: LayerOptions$8) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+};
+type TagFactory$1 = <Self>() => <Id extends string, const MethodsShape extends Methods$2>(id: Id, methods: MethodsShape & NoReservedMethods$2<MethodsShape>) => TagClass$7<Self, Id, MethodsShape>;
+declare const Tag$8: TagFactory$1;
+declare const method$2: {
+  <Success extends ServiceFreeSchema$2>(definition: {
+    readonly success: Success;
+  }): Method$3<readonly [], Success>;
+  <const Args extends readonly ServiceFreeSchema$2[], Success extends ServiceFreeSchema$2>(definition: {
+    readonly args: Args;
+    readonly success: Success;
+  }): Method$3<Args, Success>;
+};
+declare const implement$4: <ROut, const Self extends Definition$5.Any>(_definition: Self, handlers: Handlers$2<ROut, Self>) => Handlers$2<ROut, Self>;
+type HandlerEffect$2<ROut, Self extends Definition$5.Any, Key extends keyof Self["methods"]> = WorkerRpcHandler<ROut, Method$3.Success<Self["methods"][Key]>>;
 declare namespace DurableObjectNamespace_d_exports {
   export { DurableObjectFetchError, DurableObjectNamespaceBindingDefinition, DurableObjectNamespaceClient, DurableObjectNamespaceDefinition, DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient, DurableObjectRpcError, DurableObjectStubClient, isDurableObjectNamespaceClient, layer$6 as layer, makeClient$4 as makeClient, makeDirectMethods };
 }
@@ -1236,8 +1438,8 @@ type Handlers$1<ROut, Self extends Definition$4.Any> = { readonly [Key in keyof
 /**
  * Durable Object constructor options for a specific RPC definition.
  */
-interface Options$3<ROut, Self extends Definition$4.Any> extends Omit<DurableObjectOptions<ROut, Handlers$1<ROut, Self>>, "rpc"> {
-  readonly rpc: Handlers$1<ROut, Self>;
+interface Options$3<ROut, Self extends Definition$4.Any, REvent = never, EventLayerError = never> extends Omit<DurableObjectOptions<ROut, REvent, EventLayerError, Handlers$1<ROut | REvent, Self>>, "rpc"> {
+  readonly rpc: Handlers$1<ROut | REvent, Self>;
 }
 type LayerOptions$7 = {
   readonly binding: string;
@@ -1245,7 +1447,7 @@ type LayerOptions$7 = {
 type TagClass$6<Self, Id extends string, MethodsShape extends Methods$1> = Context.ServiceClass<Self, Id, DurableObjectNamespaceEffectClient<Api$1<Definition$4<Id, MethodsShape>>, Definition$4<Id, MethodsShape>>> & DurableObjectNamespaceStaticClient<Self, Api$1<Definition$4<Id, MethodsShape>>, Definition$4<Id, MethodsShape>> & {
   readonly id: Id;
   readonly methods: MethodsShape;
-  readonly make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options: Options$3<ROut, Definition$4<Id, MethodsShape>>) => DurableObjectClass<Handlers$1<ROut, Definition$4<Id, MethodsShape>>, ROut>;
+  readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options: Options$3<ROut, Definition$4<Id, MethodsShape>, REvent, EventLayerError>) => DurableObjectClass<Handlers$1<ROut | REvent, Definition$4<Id, MethodsShape>>, ROut | REvent>;
   readonly layer: (options: LayerOptions$7) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
 /**
@@ -1290,7 +1492,15 @@ type RpcHandlers<ROut, Api> = { readonly [Key in keyof Api as Key extends keyof
 /**
  * Options for creating a Durable Object class backed by Effect handlers.
  */
-interface DurableObjectOptions<ROut, Rpc extends DurableObjectRpc<ROut>> {
+interface DurableObjectOptions<RRuntime, REvent = never, EventLayerError = never, Rpc extends DurableObjectRpc<RRuntime | REvent> = Record<never, never>> {
+  /**
+   * Layer provided around each Cloudflare event handled by this Durable Object.
+   *
+   * The layer is built inside the event's Effect scope and finalized when the
+   * event effect completes. It is not applied to `initialize`, which is an
+   * instance-load lifecycle hook rather than a platform event.
+   */
+  readonly eventLayer?: Layer.Layer<REvent, EventLayerError, DurableObjectState | WorkerEnvironment | RRuntime>;
   /**
    * Effect run when Cloudflare loads this Durable Object instance into memory.
    *
@@ -1299,11 +1509,11 @@ interface DurableObjectOptions<ROut, Rpc extends DurableObjectRpc<ROut>> {
    * the same Durable Object id again after eviction or restart; use Durable
    * Object storage if work must happen only once per id.
    */
-  readonly initialize?: Effect.Effect<void, unknown, HandlerContext<ROut>>;
+  readonly initialize?: Effect.Effect<void, unknown, HandlerContext<RRuntime>>;
   /** Optional RPC methods exposed as Durable Object instance methods. */
   readonly rpc?: Rpc;
   /** Optional fetch handler for HTTP/WebSocket requests. */
-  readonly fetch?: Effect.Effect<Response, unknown, FetchContext<ROut>>;
+  readonly fetch?: Effect.Effect<Response, unknown, FetchContext<RRuntime | REvent>>;
   /**
    * Optional logical alarm processing effect.
    *
@@ -1311,11 +1521,11 @@ interface DurableObjectOptions<ROut, Rpc extends DurableObjectRpc<ROut>> {
    * `DurableObjectAlarm.processDue(...)` so the reusable scheduler stays inside
    * the Durable Object's single managed runtime boundary.
    */
-  readonly alarms?: Effect.Effect<unknown, unknown, HandlerContext<ROut>>;
-  readonly alarm?: (alarmInfo?: globalThis.AlarmInvocationInfo) => Effect.Effect<void, unknown, HandlerContext<ROut>>;
-  readonly webSocketMessage?: (socket: DurableWebSocket, message: string | ArrayBuffer) => Effect.Effect<void, unknown, HandlerContext<ROut>>;
-  readonly webSocketClose?: (socket: DurableWebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, unknown, HandlerContext<ROut>>;
-  readonly webSocketError?: (socket: DurableWebSocket, error: unknown) => Effect.Effect<void, unknown, HandlerContext<ROut>>;
+  readonly alarms?: Effect.Effect<unknown, unknown, HandlerContext<RRuntime | REvent>>;
+  readonly alarm?: (alarmInfo?: globalThis.AlarmInvocationInfo) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
+  readonly webSocketMessage?: (socket: DurableWebSocket, message: string | ArrayBuffer) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
+  readonly webSocketClose?: (socket: DurableWebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
+  readonly webSocketError?: (socket: DurableWebSocket, error: unknown) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
 }
 /**
  * Cloudflare `DurableObject` constructor produced by {@link make}.
@@ -1324,7 +1534,7 @@ type DurableObjectClass<Rpc extends DurableObjectRpc<ROut>, ROut> = new (state:
 /**
  * Creates a Durable Object class backed by a single managed Effect runtime.
  */
-declare const make$4: <ROut, LayerError, const Rpc extends DurableObjectRpc<ROut> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options?: DurableObjectOptions<ROut, Rpc>) => DurableObjectClass<Rpc, ROut>;
+declare const make$4: <ROut, LayerError, REvent = never, EventLayerError = never, const Rpc extends DurableObjectRpc<ROut | REvent> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options?: DurableObjectOptions<ROut, REvent, EventLayerError, Rpc>) => DurableObjectClass<Rpc, ROut | REvent>;
 type ServiceFreeSchema = Schema.Codec<any, any, never, never>;
 interface Method$1<Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema = ServiceFreeSchema> {
   readonly args: Args;
@@ -1351,13 +1561,13 @@ type LayerOptions$6 = LayerOptions$7;
 type ServerApi$1<Self extends Definition$3.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$1.Args<Self["methods"][Key]>) => Promise<Method$1.Success<Self["methods"][Key]>> };
 type Api<Self extends Definition$3.Any> = Provider<ServerApi$1<Self>, ReservedMethodName>;
 type Handlers<ROut, Self extends Definition$3.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$1.Args<Self["methods"][Key]>) => DurableObjectHandler<ROut, Method$1.Success<Self["methods"][Key]>> };
-interface Options$2<ROut, Self extends Definition$3.Any> extends Omit<DurableObjectOptions<ROut, Handlers<ROut, Self>>, "rpc"> {
-  readonly rpc: Handlers<ROut, Self>;
+interface Options$2<ROut, Self extends Definition$3.Any, REvent = never, EventLayerError = never> extends Omit<DurableObjectOptions<ROut, REvent, EventLayerError, Handlers<ROut | REvent, Self>>, "rpc"> {
+  readonly rpc: Handlers<ROut | REvent, Self>;
 }
 type TagClass$5<Self, Id extends string, MethodsShape extends Methods> = Context.ServiceClass<Self, Id, DurableObjectNamespaceEffectClient<Api<Definition$3<Id, MethodsShape>>, Definition$3<Id, MethodsShape>>> & DurableObjectNamespaceStaticClient<Self, Api<Definition$3<Id, MethodsShape>>, Definition$3<Id, MethodsShape>> & {
   readonly id: Id;
   readonly methods: MethodsShape;
-  readonly make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options: Options$2<ROut, Definition$3<Id, MethodsShape>>) => DurableObjectClass<Handlers<ROut, Definition$3<Id, MethodsShape>>, ROut>;
+  readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options: Options$2<ROut, Definition$3<Id, MethodsShape>, REvent, EventLayerError>) => DurableObjectClass<Handlers<ROut | REvent, Definition$3<Id, MethodsShape>>, ROut | REvent>;
   readonly layer: (options: LayerOptions$6) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
 type TagFactory = <Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape>) => TagClass$5<Self, Id, MethodsShape>;
@@ -2188,4 +2398,4 @@ declare const implement: <ROut, const Self extends Definition$1.Any>(_definition
 type Handler<ROut, Self extends Definition$1.Any> = Handler$1<ROut, Self>;
 type Options<ROut, Self extends Definition$1.Any> = Options$1<ROut, Self>;
 //#endregion
-export { Binding_d_exports as Binding, D1_d_exports as D1, DurableObject_d_exports as DurableObject, DurableObjectAlarm_d_exports as DurableObjectAlarm, DurableObjectDefinition_d_exports as DurableObjectDefinition, DurableObjectNamespace_d_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_d_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_d_exports as DurableObjectSqlite, DurableObjectState_d_exports as DurableObjectState, DurableObjectStorage_d_exports as DurableObjectStorage, DurableObjectWebSocket_d_exports as DurableObjectWebSocket, Hyperdrive_d_exports as Hyperdrive, Images_d_exports as Images, Kv_d_exports as Kv, Queue_d_exports as Queue, QueueBinding_d_exports as QueueBinding, QueueDefinition_d_exports as QueueDefinition, R2_d_exports as R2, Rpc_d_exports as Rpc, RpcDefinition_d_exports as RpcDefinition, ServiceBinding_d_exports as ServiceBinding, Worker_d_exports as Worker, WorkerConfig, WorkerDefinition_d_exports as WorkerDefinition, type WorkerEnv, WorkerEnvironment, Workflow_d_exports as Workflow, WorkflowBinding_d_exports as WorkflowBinding, WorkflowDefinition_d_exports as WorkflowDefinition };
+export { Binding_d_exports as Binding, CloudflareOtlp_d_exports as CloudflareOtlp, D1_d_exports as D1, DurableObject_d_exports as DurableObject, DurableObjectAlarm_d_exports as DurableObjectAlarm, DurableObjectDefinition_d_exports as DurableObjectDefinition, DurableObjectNamespace_d_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_d_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_d_exports as DurableObjectSqlite, DurableObjectState_d_exports as DurableObjectState, DurableObjectStorage_d_exports as DurableObjectStorage, DurableObjectWebSocket_d_exports as DurableObjectWebSocket, Hyperdrive_d_exports as Hyperdrive, Images_d_exports as Images, Kv_d_exports as Kv, Queue_d_exports as Queue, QueueBinding_d_exports as QueueBinding, QueueDefinition_d_exports as QueueDefinition, R2_d_exports as R2, Rpc_d_exports as Rpc, RpcDefinition_d_exports as RpcDefinition, ServiceBinding_d_exports as ServiceBinding, Worker_d_exports as Worker, WorkerConfig, WorkerDefinition_d_exports as WorkerDefinition, type WorkerEnv, WorkerEnvironment, Workflow_d_exports as Workflow, WorkflowBinding_d_exports as WorkflowBinding, WorkflowDefinition_d_exports as WorkflowDefinition };