effect-cf 0.33.0 → 0.35.0

package/dist/{DurableObjectState-BpRjz6-q.d.mts → DurableObjectState-DpYdNZgT.d.mts}

@@ -1,16 +1,14 @@
-import { c as WorkerEnvironment, n as BindingService, r as BindingValidationError, s as WorkerEnv, t as BindingNotFoundError } from "./Binding-xJJJPmiD.mjs";
-import { Cause, Context, Duration, Effect, Layer, Option, Predicate, Schema, Scope } from "effect";
+import { c as WorkerEnvironment, n as BindingService, r as BindingValidationError, s as WorkerEnv, t as BindingNotFoundError } from "./Binding-DKcLrQCM.mjs";
+import { Cause, Context, Duration, Effect, Layer, Option, Predicate, Schema, Scope, Tracer } from "effect";
 import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import { RpcStub, RpcTarget, WorkerEntrypoint } from "cloudflare:workers";
 declare namespace DurableObjectStorage_d_exports {
   export { DurableObjectStorage, DurableObjectTransaction, SchemaBackedSyncKvStorage, SqlCursor, SqlStorage, SqlStorageValue, StorageOperationError, SyncKvDefinition, SyncKvStorage, fromDurableObjectStorage };
 }
-/** Supported primitive value types for Durable Object SQL APIs. */
 type SqlStorageValue = globalThis.SqlStorageValue;
-declare const StorageOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+declare const StorageOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
   readonly _tag: "StorageOperationError";
 } & Readonly<A>;
-/** Error type used when a storage operation throws or rejects. */
 declare class StorageOperationError extends StorageOperationError_base<{
   readonly operation: string;
   readonly cause: unknown;
@@ -18,9 +16,6 @@ declare class StorageOperationError extends StorageOperationError_base<{
   get message(): string;
 }
 type StorageEffect<A> = Effect.Effect<A, StorageOperationError>;
-/**
- * Effect wrapper for Cloudflare SQL cursor operations.
- */
 interface SqlCursor<T extends Record<string, SqlStorageValue>> {
   next(): StorageEffect<{
     done?: false;
@@ -36,17 +31,10 @@ interface SqlCursor<T extends Record<string, SqlStorageValue>> {
   readonly rowsRead: StorageEffect<number>;
   readonly rowsWritten: StorageEffect<number>;
 }
-/**
- * Effect wrapper for Durable Object SQLite APIs.
- */
 interface SqlStorage {
-  /** Executes a SQL statement and returns a typed cursor. */
   exec<T extends Record<string, SqlStorageValue>>(query: string, ...bindings: Array<SqlStorageValue>): StorageEffect<SqlCursor<T>>;
   readonly databaseSize: number;
 }
-/**
- * Schema pair used by `SyncKvStorage.schema(...)`.
- */
 interface SyncKvDefinition<Key, Value, EncodedValue> {
   readonly key: Schema.Codec<Key, string>;
   readonly value: Schema.Codec<Value, EncodedValue>;
@@ -60,9 +48,6 @@ interface SchemaBackedSyncKvStorage<Key, Value> {
   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>;
@@ -84,23 +69,9 @@ interface DurableObjectTransaction {
   rollback(): StorageEffect<void>;
   getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
   setAlarm(scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-  /** Schedules the alarm after a delay measured by the Effect clock. */
   setAlarmAfter(delay: Duration.Input, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
   deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
 }
-/**
- * Effect wrapper around Cloudflare Durable Object storage.
- *
- * @example
- * ```ts
- * const program = Effect.gen(function* () {
- *   const state = yield* DurableObjectState;
- *   yield* state.storage.put("counter", 1);
- *   const value = yield* state.storage.get<number>("counter");
- *   return value;
- * });
- * ```
- */
 interface DurableObjectStorage {
   get<T = unknown>(key: string, options?: globalThis.DurableObjectGetOptions): StorageEffect<T | undefined>;
   put<T>(key: string, value: T, options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
@@ -112,7 +83,6 @@ interface DurableObjectStorage {
   deleteAll(options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
   getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
   setAlarm(scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-  /** Schedules the alarm after a delay measured by the Effect clock. */
   setAlarmAfter(delay: Duration.Input, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
   deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
   /**
@@ -129,26 +99,21 @@ interface DurableObjectStorage {
   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. */
+  /** Requires SQLite-backed Durable Object storage. */
   getCurrentBookmark(): StorageEffect<string>;
-  /** SQLite-backed Durable Object storage point-in-time recovery API only. */
+  /** Requires SQLite-backed Durable Object storage. */
   onNextSessionRestoreBookmark(bookmark: string): StorageEffect<string>;
   readonly sql: SqlStorage;
   readonly kv: SyncKvStorage;
 }
-/**
- * Wraps native Cloudflare storage APIs as Effect-returning helpers.
- */
 declare const fromDurableObjectStorage: (storage: globalThis.DurableObjectStorage) => DurableObjectStorage;
 declare namespace DurableObjectWebSocket_d_exports {
   export { AcceptUpgradeOptions, AcceptedUpgrade, AttachmentInvalidPolicy, AttachmentRehydrateOptions, DurableWebSocket, DurableWebSocketAttachment, DurableWebSocketAttachmentError, DurableWebSocketCloseError, DurableWebSocketHandlers, DurableWebSocketSendData, DurableWebSocketSendError, RehydratedDurableWebSocket, acceptUpgrade, attachment, fromWebSocket, handlers };
 }
-/** Data supported by Cloudflare websocket `send`. */
 type DurableWebSocketSendData = string | ArrayBuffer | ArrayBufferView;
 declare const DurableWebSocketSendError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "DurableWebSocketSendError";
 } & Readonly<A>;
-/** Error raised when sending on a Durable Object websocket fails. */
 declare class DurableWebSocketSendError extends DurableWebSocketSendError_base<{
   readonly cause: unknown;
 }> {
@@ -157,7 +122,6 @@ declare class DurableWebSocketSendError extends DurableWebSocketSendError_base<{
 declare const DurableWebSocketCloseError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "DurableWebSocketCloseError";
 } & Readonly<A>;
-/** Error raised when closing a Durable Object websocket fails. */
 declare class DurableWebSocketCloseError extends DurableWebSocketCloseError_base<{
   readonly cause: unknown;
 }> {
@@ -173,56 +137,30 @@ declare class DurableWebSocketAttachmentError extends DurableWebSocketAttachment
 }> {
   get message(): string;
 }
-/** Effect-native wrapper around a hibernatable Durable Object websocket. */
 interface DurableWebSocket<Attachment = unknown> {
-  /** Underlying Cloudflare websocket. */
   readonly raw: WebSocket;
-  /** Sends a message through the socket. */
   send(data: DurableWebSocketSendData): Effect.Effect<void, DurableWebSocketSendError>;
-  /** Closes the socket. */
   close(code?: number, reason?: string): Effect.Effect<void, DurableWebSocketCloseError>;
   /** Serializes hibernation attachment metadata onto the socket. */
-  serializeAttachment<A = Attachment>(value: A): Effect.Effect<void, DurableWebSocketAttachmentError>;
+  serializeAttachment<A extends Attachment = Attachment>(value: A): Effect.Effect<void, DurableWebSocketAttachmentError>;
   /** Deserializes hibernation attachment metadata from the socket. */
   readonly deserializeAttachment: Effect.Effect<unknown, DurableWebSocketAttachmentError>;
 }
-/** Wraps a native Cloudflare websocket in the Effect-native Durable Object API. */
 declare const fromWebSocket: <Attachment = unknown>(raw: WebSocket) => DurableWebSocket<Attachment>;
-/**
- * Options for accepting an incoming websocket request in a Durable Object.
- */
 interface AcceptUpgradeOptions<Attachment = unknown> {
-  /** Optional websocket tags for Durable Object hibernation filtering. */
   readonly tags?: ReadonlyArray<string> | undefined;
   /** Optional attachment serialized onto the server socket. */
   readonly attachment?: Attachment | undefined;
 }
-/**
- * Result of a websocket upgrade accepted by {@link acceptUpgrade}.
- */
 interface AcceptedUpgrade<Attachment = unknown> {
   readonly client: WebSocket;
   readonly server: DurableWebSocket<Attachment>;
   readonly response: Response;
 }
-/**
- * Accepts a websocket upgrade and registers the server socket on `DurableObjectState`.
- *
- * @example
- * ```ts
- * const response = yield* DurableObjectWebSocket.acceptUpgrade({
- *   tags: ["room:general"],
- * });
- *
- * return response.response;
- * ```
- */
 declare const acceptUpgrade: <Attachment = unknown>(options?: AcceptUpgradeOptions<Attachment> | undefined) => Effect.Effect<AcceptedUpgrade<Attachment>, DurableWebSocketAttachmentError, DurableObjectState>;
 type AttachmentInvalidPolicy = "ignore" | "ignore-and-close" | "fail";
 interface AttachmentRehydrateOptions {
-  /** Optional Durable Object websocket tag filter. */
   readonly tag?: string | undefined;
-  /** Invalid attachment behavior. Defaults to skipping invalid sockets. */
   readonly onInvalid?: AttachmentInvalidPolicy | undefined;
 }
 interface RehydratedDurableWebSocket<Attachment> {
@@ -235,14 +173,12 @@ interface DurableWebSocketAttachment<Attachment, Encoded> {
   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, cause: 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;
@@ -337,10 +273,10 @@ declare const isWireError: (error: WireValue) => error is WireError;
  * survive Cloudflare RPC serialization, which drops custom error properties.
  */
 declare const encodeWireError: (error: WireValue) => WireValue;
-/** Restores package RPC errors from the {@link encodeWireError} envelope. */
 declare const decodeWireError: (cause: WireValue) => WireValue;
+declare const reservedMethodNameValues: readonly ["constructor", "fetch", "connect", "alarm", "webSocketMessage", "webSocketClose", "webSocketError", "then", "dup", "dispose", "serialize", "deserialize"];
 declare const reservedMethodNames: Set<string>;
-type ReservedMethodName$3 = "constructor" | "fetch" | "connect" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError" | "then" | "dup" | "dispose" | "serialize" | "deserialize";
+type ReservedMethodName$3 = (typeof reservedMethodNameValues)[number];
 type ServiceFreeSchema$1 = Schema.Codec<any, any, never, never>;
 interface Method$2<Args extends ReadonlyArray<ServiceFreeSchema$1> = ReadonlyArray<ServiceFreeSchema$1>, Success extends ServiceFreeSchema$1 = ServiceFreeSchema$1> {
   readonly args: Args;
@@ -349,7 +285,6 @@ interface Method$2<Args extends ReadonlyArray<ServiceFreeSchema$1> = ReadonlyArr
 declare namespace Method$2 {
   export type Any = Method$2<ReadonlyArray<ServiceFreeSchema$1>, ServiceFreeSchema$1>;
   type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$1>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$1>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
-  /** Method schemas cross the wire through their canonical JSON codec. */
   type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$1>> = { [Index in keyof Args]: Schema.Json; };
   export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
   export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
@@ -395,9 +330,7 @@ type MessageSendRequest<Body> = CloudflareMessageSendRequest<Body>;
 type QueueProducer<Body> = Pick<CloudflareQueue<Body>, "send"> & Partial<Pick<CloudflareQueue<Body>, "sendBatch" | "metrics">>;
 type QueueCandidate = Parameters<typeof Predicate.isUnknown>[0];
 interface QueueBindingDefinition<Message extends ServiceFreeSchema$1> {
-  /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
-  /** Codec used to encode messages before sending them to Cloudflare Queues. */
   readonly message: Message;
 }
 interface QueueBindingClient<Message extends ServiceFreeSchema$1> {
@@ -515,6 +448,53 @@ declare const Tag$1: <Self>() => <Id extends string, Message extends Definition$
 declare const implement$1: typeof implement$2;
 type Handler<ROut, Self extends Definition$2.Any> = Handler$1<ROut, Self>;
 type Options$1<ROut, Self extends Definition$2.Any> = Options$2<ROut, Self>;
+declare namespace RpcTracing_d_exports {
+  export { ReceiverOptions, RpcInvocationInfo, RpcTraceContext, withRpcClientSpan, withRpcServerSpan, withRpcTraceContext };
+}
+/**
+ * Live native RPC metadata. Opted-in receivers reserve a valid trailing value
+ * with this tag for transport context; do not use it as a final domain argument.
+ * Never store this in durable messages or envelopes.
+ */
+declare const RpcTraceContext: Schema.Struct<{
+  readonly _tag: Schema.Literal<"effect-cf/RpcTraceContext/v1">;
+  readonly traceId: Schema.String;
+  readonly spanId: Schema.String;
+  readonly sampled: Schema.Boolean;
+}>;
+type RpcTraceContext = typeof RpcTraceContext.Type;
+interface ReceiverOptions {
+  /** Stable service name, never an instance id or capability URL. */
+  readonly service: string;
+}
+/** Per-invocation metadata passed to Worker and DurableObject RunSymbol overrides. */
+interface RpcInvocationInfo {
+  readonly service: string;
+  readonly method: string;
+  /** Native arguments with valid, opted-in trace metadata removed. Do not log them. */
+  readonly args: ReadonlyArray<unknown>;
+  /**
+   * Set after a definition-backed receiver decodes its arguments, before its
+   * handler runs. Absent before decoding and when decoding fails. Do not log it.
+   */
+  readonly decodedArgs?: ReadonlyArray<unknown>;
+  readonly parent?: RpcTraceContext;
+}
+/**
+ * Appends the current live parent only for a receiver that has opted in.
+ * Call this inside the CLIENT span, immediately before the native invocation.
+ * With no valid propagating parent, the original argument array is returned.
+ */
+declare const withRpcTraceContext: (args: readonly unknown[]) => Effect.Effect<readonly unknown[], never, never>;
+/** Wrap the whole call, including native result resolution and success decoding. */
+declare const withRpcClientSpan: <A, E, R>(effect: Effect.Effect<A, E, R>, binding: string, method: string) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>;
+/**
+ * Optional application instrumentation for the entire receiver effect.
+ * Use in a RunSymbol override to include argument decode, handler and encode.
+ * Records stable service/method attributes and failure status, not argument or
+ * error payloads. The original typed failure still propagates to the caller.
+ */
+declare const withRpcServerSpan: <A, E, R>(effect: Effect.Effect<A, E, R>, invocation: RpcInvocationInfo) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>;
 //#endregion
 //#region src/internal/RpcInvocation.d.ts
 type AnyArgs = Array<any>;
@@ -526,28 +506,22 @@ declare namespace ServiceBinding_d_exports {
   export { Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceFetcher, isServiceBindingClient, layer, makeClient, makeDirectMethods };
 }
 declare const TypeId: "effect-cf/ServiceBinding";
-/**
- * Minimum shape for a Cloudflare service binding.
- */
 interface ServiceFetcher {
   fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
 }
 type RpcClient<Api> = { readonly [Key in keyof Api as Key extends string ? Api[Key] extends ((...args: Array<any>) => any) ? Key : never : never]: Api[Key]; };
 type ReservedMethodName$2 = ReservedMethodName$1 | "fetch";
-/**
- * Native Cloudflare service object including optional RPC methods.
- */
 type ServiceBindingClient<Api extends object> = ServiceFetcher & RpcClient<Provider<Api, ReservedMethodName$2>>;
 type ApiFromDefinition<Definition$12> = Definition$12 extends Definition.Any ? ServerApi$1<Definition$12> : 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$8 extends Definition.Any | undefined = undefined> {
-  /** Binding name as configured in `wrangler.jsonc`. */
+interface ServiceBindingDefinition<Definition$7 extends Definition.Any | undefined = undefined> {
   readonly binding: string;
-  /** Optional RPC schema used for argument/result encoding. */
-  readonly definition?: Definition$8;
+  readonly definition?: Definition$7;
+  /** Append live trace context only when the receiver also enables rpcTracing. */
+  readonly rpcTracing?: boolean;
 }
 declare const ServiceBindingFetchError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "ServiceBindingFetchError";
@@ -579,25 +553,9 @@ type ServiceMethodArgs<Api, Method extends keyof Api> = AsyncMethodArgs<Api, Met
 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$11 extends Definition.Any> = { readonly [Method in Definition$3.MethodNames<Definition$11>]: (...args: Method$2.Args<Definition$11["methods"][Method]>) => Effect.Effect<Method$2.Success<Definition$11["methods"][Method]>, ServiceBindingRpcError, R>; };
-type DirectMethods<R, Definition$10> = Definition$10 extends Definition.Any ? DefinitionDirectMethods<R, Definition$10> : {};
-type ServiceBindingEffectClient<Api extends object, Definition$4 extends Definition.Any | undefined = undefined> = DirectMethods<never, Definition$4> & {
-  /**
-   * 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"));
-   * });
-   * ```
-   */
+type DefinitionDirectMethods<R, Definition$4 extends Definition.Any> = { readonly [Method in Definition$3.MethodNames<Definition$4>]: (...args: Method$2.Args<Definition$4["methods"][Method]>) => Effect.Effect<Method$2.Success<Definition$4["methods"][Method]>, ServiceBindingRpcError, R>; };
+type DirectMethods<R, Definition$13> = Definition$13 extends Definition.Any ? DefinitionDirectMethods<R, Definition$13> : {};
+type ServiceBindingEffectClient<Api extends object, Definition$8 extends Definition.Any | undefined = undefined> = DirectMethods<never, Definition$8> & {
   readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, ServiceBindingFetchError>;
   /**
    * Invokes a Worker RPC method and returns Cloudflare's raw RPC result.
@@ -607,20 +565,6 @@ type ServiceBindingEffectClient<Api extends object, Definition$4 extends Definit
    * 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>;
   /**
@@ -628,18 +572,6 @@ type ServiceBindingEffectClient<Api extends object, Definition$4 extends Definit
    * 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>;
   /**
@@ -649,71 +581,28 @@ type ServiceBindingEffectClient<Api extends object, Definition$4 extends Definit
    *
    * 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>;
+  readonly scopedCall: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, ServiceBindingRpcError, Scope.Scope>;
 };
 type ServiceBindingStaticClient<R, Api extends object, Definition$5 extends Definition.Any | undefined = undefined> = DirectMethods<R, Definition$5> & {
   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>;
+  readonly scopedCall: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, ServiceBindingRpcError, Scope.Scope | R>;
 };
 type ServiceBindingValue = Schema.Schema.Type<typeof Schema.Unknown>;
 declare const isServiceBindingClient: <Api extends object>(value: ServiceBindingValue) => value is ServiceBindingClient<Api>;
-declare const makeClient: <Api extends object, const Definition$13 extends Definition.Any | undefined = undefined>(definition: ServiceBindingDefinition<Definition$13>) => ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition$13>);
-declare const layer: <Self, Api extends object, const Definition$6 extends Definition.Any | undefined = undefined>(tag: Context.Service<Self, ServiceBindingEffectClient<Api, Definition$6>>, definition: ServiceBindingDefinition<Definition$6>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-/**
- * Creates a typed Effect service for a Worker service binding.
- *
- * Returned value includes:
- * - a Context tag for dependency injection
- * - `fetch(...)` for raw HTTP forwarding
- * - `rpc(...)` for raw Cloudflare RPC results
- * - `call(...)` for resolved and decoded RPC results
- * - `scopedCall(...)` for scoped and decoded disposable RPC results
- * - direct RPC methods when `definition` is provided
- *
- * @example
- * ```ts
- * const Counter = WorkerDefinition.make("Counter", {
- *   increment: WorkerDefinition.method({
- *     args: [Schema.Number],
- *     success: Schema.Number,
- *   }),
- * });
- *
- * const CounterLive = Counter.layer({ binding: "COUNTER" });
- *
- * const program = Effect.gen(function* () {
- *   const counter = yield* Counter;
- *   const next = yield* counter.increment(1);
- *   return next;
- * });
- * ```
- */
-declare const Service: <Self, Api extends object = never>() => <Id extends string, const Definition$9 extends Definition.Any | undefined = undefined>(id: Id, definition: ServiceBindingDefinition<Definition$9>) => BindingService<Self, Id, ServiceBindingEffectClient<ApiOrDefinition<Api, Definition$9>, Definition$9>> & DirectMethods<Self, Definition$9> & {
+declare const makeClient: <Api extends object, const Definition$10 extends Definition.Any | undefined = undefined>(definition: ServiceBindingDefinition<Definition$10>) => ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition$10>);
+declare const layer: <Self, Api extends object, const Definition$11 extends Definition.Any | undefined = undefined>(tag: Context.Service<Self, ServiceBindingEffectClient<Api, Definition$11>>, definition: ServiceBindingDefinition<Definition$11>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const Service: <Self, Api extends object = never>() => <Id extends string, const Definition$6 extends Definition.Any | undefined = undefined>(id: Id, definition: ServiceBindingDefinition<Definition$6>) => BindingService<Self, Id, ServiceBindingEffectClient<ApiOrDefinition<Api, Definition$6>, Definition$6>> & DirectMethods<Self, Definition$6> & {
   readonly [TypeId]: typeof TypeId;
-  readonly definition: ServiceBindingDefinition<Definition$9>;
+  readonly definition: ServiceBindingDefinition<Definition$6>;
   readonly fetch: (input: URL | RequestInfo<unknown, CfProperties<unknown>>, init?: RequestInit<CfProperties<unknown>> | undefined) => Effect.Effect<Response, ServiceBindingFetchError, Self>;
-  readonly rpc: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition$9>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$9>, Method>) => Effect.Effect<Result$1<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$9>, Method>>, ServiceBindingRpcError, Self>;
-  readonly call: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition$9>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$9>, Method>) => Effect.Effect<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$9>, Method>, ServiceBindingRpcError, Self>;
-  readonly scopedCall: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition$9>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$9>, Method>) => Effect.Effect<Awaited<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$9>, Method>>, unknown, Self | Scope.Scope>;
+  readonly rpc: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition$6>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$6>, Method>) => Effect.Effect<Result$1<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$6>, Method>>, ServiceBindingRpcError, Self>;
+  readonly call: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition$6>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$6>, Method>) => Effect.Effect<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$6>, Method>, ServiceBindingRpcError, Self>;
+  readonly scopedCall: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition$6>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$6>, Method>) => Effect.Effect<Awaited<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$6>, Method>>, ServiceBindingRpcError, Self | Scope.Scope>;
 };
-declare const makeDirectMethods: <R, Api, Definition$7 extends Definition.Any | undefined>(rpcDefinition: Definition$7 | undefined, call: ServiceCall<R, Api>) => DirectMethods<R, Definition$7>;
+declare const makeDirectMethods: <R, Api, Definition$9 extends Definition.Any | undefined>(rpcDefinition: Definition$9 | undefined, call: ServiceCall<R, Api>) => DirectMethods<R, Definition$9>;
 declare namespace WorkerDefinition_d_exports {
   export { Api, Definition, HandlerEffect, Handlers, LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options, ReservedMethodName$1 as ReservedMethodName, ServerApi$1 as ServerApi, ServiceFreeSchema, Tag, TagClass, Worker, implement, make$1 as make, method };
 }
@@ -725,7 +614,6 @@ interface Method$1<Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray
 declare namespace Method$1 {
   export type Any = Method$1<ReadonlyArray<ServiceFreeSchema>, ServiceFreeSchema>;
   type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends ReadonlyArray<ServiceFreeSchema>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
-  /** Method schemas cross the wire through their canonical JSON codec. */
   type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = { [Index in keyof Args]: Schema.Json; };
   export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
   export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
@@ -770,6 +658,7 @@ type EventLayerOptions<ROut, REvent, EventLayerError> = [REvent] extends [never]
 type Options<ROut, Self extends Definition.Any, REvent = never, EventLayerError = never> = BaseOptions<ROut, Self, REvent, EventLayerError> & EventLayerOptions<ROut, REvent, EventLayerError>;
 type LayerOptions = {
   readonly binding: string;
+  readonly rpcTracing?: boolean;
 };
 type TagClass<Self, Id extends string, MethodDefinitions extends Methods> = Context.ServiceClass<Self, Id, ServiceBindingEffectClient<Api<Definition<Id, MethodDefinitions>>, Definition<Id, MethodDefinitions>>> & ServiceBindingStaticClient<Self, Api<Definition<Id, MethodDefinitions>>, Definition<Id, MethodDefinitions>> & {
   readonly id: Id;
@@ -806,16 +695,10 @@ declare const implement: <ROut, const Self extends Definition.Any>(_definition:
  */
 type HandlerEffect<ROut, Self extends Definition.Any, Key extends keyof Self["methods"]> = WorkerRpcHandler<ROut, Method$1.Success<Self["methods"][Key]>>;
 declare namespace Worker_d_exports {
-  export { Api, Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect, Handlers, LayerOptions, Method$1 as Method, Methods, NativeRequest, NoReservedMethods, Options, ReservedMethodName, RpcHandlers, ServerApi$1 as ServerApi, ServiceFreeSchema, Tag, TagClass, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcContract, WorkerRpcHandler, WorkerRpcContract as WorkerRpcShape, implement, isWebSocketUpgrade, make, makeFetchHandler, method };
+  export { Api, Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect, Handlers, LayerOptions, Method$1 as Method, Methods, NativeRequest, NoReservedMethods, Options, ReservedMethodName, RpcHandlers, RunOptions, RunSymbol, ServerApi$1 as ServerApi, ServiceFreeSchema, Tag, TagClass, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcContract, WorkerRpcHandler, WorkerRpcContract as WorkerRpcShape, implement, isWebSocketUpgrade, make, makeFetchHandler, method };
 }
 declare const ExecutionContext_base: Context.ServiceClass<ExecutionContext, "effect-cf/ExecutionContext", globalThis.ExecutionContext<unknown>>;
-/**
- * Access to Cloudflare's native `ExecutionContext`.
- */
 declare class ExecutionContext extends ExecutionContext_base {}
-/**
- * Options for {@link WorkerContextService.waitUntil}.
- */
 interface WorkerContextWaitUntilOptions<E, R> {
   /**
    * Failure mode for the background effect: `"observe"` (default) logs or
@@ -823,53 +706,32 @@ interface WorkerContextWaitUntilOptions<E, R> {
    * native `waitUntil` promise.
    */
   readonly mode?: "observe" | "propagate";
-  /** Custom failure handler for the background effect. */
   readonly onFailure?: (cause: Cause.Cause<E>) => Effect.Effect<void, never, R>;
 }
-/**
- * Effect wrapper around `ExecutionContext` background APIs.
- */
 interface WorkerContextService {
   readonly raw: globalThis.ExecutionContext;
   waitUntil<A, E, R, R2 = never>(effect: Effect.Effect<A, E, R>, options?: WorkerContextWaitUntilOptions<E, R2>): Effect.Effect<void, never, R | R2>;
   waitUntilPropagating<A, E, R, R2 = never>(effect: Effect.Effect<A, E, R>, options?: Omit<WorkerContextWaitUntilOptions<E, R2>, "mode">): Effect.Effect<void, never, R | R2>;
   readonly passThroughOnException: Effect.Effect<void>;
-  /** Abort the current stateless Worker invocation (`ExecutionContext.abort`). */
   abort(reason?: string): Effect.Effect<void>;
 }
 declare const WorkerContext_base: Context.ServiceClass<WorkerContext, "effect-cf/WorkerContext", WorkerContextService>;
-/**
- * Service used inside handlers to schedule background work via `waitUntil`.
- *
- * @example
- * ```ts
- * const handler = Effect.gen(function* () {
- *   const ctx = yield* Worker.WorkerContext;
- *   yield* ctx.waitUntil(Effect.log("flush analytics"));
- *   return new Response("ok");
- * });
- * ```
- */
 declare class WorkerContext extends WorkerContext_base {}
 declare const NativeRequest_base: Context.ServiceClass<NativeRequest, "effect-cf/NativeRequest", Request<unknown, CfProperties<unknown>>>;
-/**
- * Access to the incoming `Request` currently handled by a worker or Durable Object fetch.
- */
 declare class NativeRequest extends NativeRequest_base {}
-/**
- * Returns `true` when the request is a websocket upgrade request.
- */
 declare const isWebSocketUpgrade: (request: Request) => boolean;
 type ReservedMethodName = ReservedMethodName$3 | "fetch" | "connect" | "queue" | "scheduled" | "tail" | "tailStream" | "test" | "trace" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError";
 type WorkerBaseContext<ROut> = ExecutionContext | WorkerContext | WorkerEnvironment | ROut;
 type WorkerFetchContext<ROut> = WorkerBaseContext<ROut> | NativeRequest | HttpServerRequest.HttpServerRequest | Scope.Scope;
 type WorkerRpcContext<ROut> = WorkerBaseContext<ROut> | Scope.Scope;
+/** Override to instrument the whole event, then call super[RunSymbol]. */
+declare const RunSymbol: unique symbol;
 declare const FetchSymbol: unique symbol;
-/**
- * Successful result of a worker fetch handler: either a native `Response`
- * (returned to Cloudflare untouched) or an Effect `HttpServerResponse`
- * (rendered through the Effect HTTP pipeline).
- */
+/** Metadata available before an event effect or its event layer starts. */
+interface RunOptions {
+  readonly event?: "fetch" | "rpc" | "queue";
+  readonly rpc?: RpcInvocationInfo;
+}
 type WorkerFetchSuccess = Response | HttpServerResponse.HttpServerResponse;
 /**
  * Effect type for `fetch` handlers executed by {@link make}.
@@ -885,22 +747,19 @@ type WorkerRpcHandler<ROut, A = unknown> = Effect.Effect<A, unknown, WorkerRpcCo
 type WorkerRpc<ROut> = Record<string, (...args: Array<any>) => WorkerRpcHandler<ROut>>;
 type WorkerRpcContract<Rpc extends WorkerRpc<ROut>, ROut> = { readonly [Key in keyof Rpc]: Rpc[Key] extends ((...args: infer Args) => Effect.Effect<infer A, unknown, WorkerRpcContext<ROut>>) ? (...args: Args) => Promise<A> : never; };
 type RpcHandlers<ROut, Api> = { readonly [Key in keyof Api as Key extends keyof WorkerEntrypoint ? never : Key extends string ? Key extends ReservedMethodName ? never : [Api[Key]] extends [never] ? never : Api[Key] extends ((...args: Array<any>) => Promise<any>) ? Key : never : never]: Api[Key] extends ((...args: infer Args) => Promise<infer A>) ? (...args: Args) => WorkerRpcHandler<ROut, A> : never; };
-/**
- * Options for creating a worker class with Effect handlers.
- */
 interface WorkerOptions<RRuntime, REvent = never, EventLayerError = never, Rpc extends WorkerRpc<RRuntime | REvent> = Record<never, never>> {
   /**
    * Layer provided around each Cloudflare event handled by this Worker.
    *
-   * The layer is built inside the event's Effect scope and finalized when the
-   * event effect completes. Use this for event-scoped resources such as OTLP
-   * trace/log exporters. Worker fetch and RPC handlers schedule a best-effort
-   * flush capped at two seconds; queue handlers do not flush automatically.
+   * The layer is built inside the event's Effect scope. For fetch handlers that
+   * return an Effect `HttpServerResponse` stream, its scope remains open until
+   * the response body finishes or is canceled. Native `Response` values pass
+   * through unchanged, so their body streams do not carry this scoped-lifetime
+   * guarantee. Fetch, queue, and RPC handlers schedule a best-effort telemetry
+   * flush capped at two seconds.
    */
   readonly eventLayer?: Layer.Layer<REvent, EventLayerError, WorkerBaseContext<RRuntime>>;
-  /** Main request handler. */
   readonly fetch?: Effect.Effect<WorkerFetchSuccess, unknown, WorkerFetchContext<RRuntime | REvent>>;
-  /** Queue consumer handler invoked per message batch. */
   readonly queue?: QueueHandler<RRuntime | REvent>;
   /**
    * Optional RPC methods exposed as class instance methods.
@@ -910,6 +769,8 @@ interface WorkerOptions<RRuntime, REvent = never, EventLayerError = never, Rpc e
    * flush silently settles within two seconds even if the exporter does not.
    */
   readonly rpc?: Rpc;
+  /** Accept live native trace metadata. The client must also enable rpcTracing. */
+  readonly rpcTracing?: ReceiverOptions;
 }
 type WorkerOptionsWithEventLayer<RRuntime, REvent, EventLayerError, Rpc extends WorkerRpc<RRuntime | REvent> = Record<never, never>> = Omit<WorkerOptions<RRuntime, REvent, EventLayerError, Rpc>, "eventLayer"> & {
   readonly eventLayer: Layer.Layer<REvent, EventLayerError, WorkerBaseContext<RRuntime>>;
@@ -926,6 +787,7 @@ type FetchWorkerOptionsWithEventLayer<RRuntime, REvent, EventLayerError> = Omit<
 type WorkerClass<Rpc extends WorkerRpc<ROut>, ROut> = new (ctx: globalThis.ExecutionContext, env: WorkerEnv) => WorkerEntrypoint<WorkerEnv> & {
   fetch(request: Request): Promise<Response>;
   queue(batch: globalThis.MessageBatch): Promise<void>;
+  [RunSymbol]<A, E>(effect: Effect.Effect<A, E, WorkerRpcContext<ROut>>, options?: RunOptions): Promise<A>;
   [FetchSymbol](request: Request, requestContext: globalThis.ExecutionContext): Promise<Response>;
 } & WorkerRpcContract<Rpc, ROut>;
 /**
@@ -935,19 +797,10 @@ interface FetchHandler<Env extends WorkerEnv = WorkerEnv> {
   readonly fetch: (request: Request, env: Env, ctx: globalThis.ExecutionContext) => Promise<Response>;
 }
 /**
- * Creates a Cloudflare worker class backed by a single managed Effect runtime.
- *
- * The runtime layer is built when Cloudflare constructs the class and reused
- * for every event the instance handles. Layer finalizers do not run when the
- * isolate is evicted; Cloudflare provides no shutdown hook. Use `eventLayer`
- * for resources that must be finalized per event.
- *
- * @example
- * ```ts
- * export default Worker.make(Layer.empty, {
- *   fetch: Effect.succeed(new Response("ok")),
- * });
- * ```
+ * Cloudflare creates a new `WorkerEntrypoint` instance for each native
+ * invocation, so this base layer is not shared across invocations. Its managed
+ * runtime has no deterministic disposal point in this adapter; use
+ * `eventLayer` for resources whose finalizers must run with an event.
  */
 declare function make<ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, fetch: WorkerHandler<ROut>): WorkerClass<Record<never, never>, ROut>;
 declare function make<ROut, LayerError, REvent, EventLayerError = never, const Rpc extends WorkerRpc<ROut | REvent> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptionsWithEventLayer<ROut, REvent, EventLayerError, Rpc>): WorkerClass<Rpc, ROut | REvent>;
@@ -956,12 +809,13 @@ declare function make<ROut, LayerError, REvent extends never = never, EventLayer
  * Creates an `ExportedHandler`-compatible `{ fetch }` object backed by
  * {@link make}.
  *
- * The Effect runtime is cached per `env` identity, so the user layer builds
- * once per isolate instead of once per request. `ExecutionContext`-backed
- * services (`Worker.ExecutionContext`, `Worker.WorkerContext`) are still
- * provided fresh for every request. Layer finalizers do not run when the
- * isolate is evicted; Cloudflare provides no shutdown hook. Use `eventLayer`
- * for resources that must be finalized per event.
+ * The Effect runtime is cached per `env` identity, so the base layer builds
+ * once for that cached handler. Request handlers and `eventLayer` receive fresh
+ * `ExecutionContext` and `WorkerContext` services. A service constructed by the
+ * cached base layer from either context instead captures the first request's
+ * value, so construct invocation-bound services in `eventLayer`. Cloudflare
+ * provides no isolate shutdown hook, so cached base-layer finalizers are not
+ * guaranteed to run.
  */
 declare function makeFetchHandler<ROut, LayerError, REvent, EventLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptionsWithEventLayer<ROut, REvent, EventLayerError>): FetchHandler<Env>;
 declare function makeFetchHandler<ROut, LayerError, REvent extends never = never, EventLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptions<ROut, REvent, EventLayerError>): FetchHandler<Env>;
@@ -972,13 +826,9 @@ declare namespace DurableObjectState_d_exports {
  * Effect-friendly wrapper around Cloudflare `DurableObjectState`.
  */
 interface DurableObjectStateService {
-  /** Underlying Cloudflare state instance. */
   readonly raw: globalThis.DurableObjectState;
-  /** Durable Object id for the current instance. */
   readonly id: globalThis.DurableObjectId;
-  /** Wrapped storage API. */
   readonly storage: DurableObjectStorage;
-  /** Registers background work with Cloudflare's lifecycle. */
   waitUntil(promise: Promise<unknown>): Effect.Effect<void>;
   /**
    * Runs a background Effect via Cloudflare's `waitUntil` with the caller's
@@ -1007,21 +857,13 @@ interface DurableObjectStateService {
    * 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
@@ -1033,13 +875,7 @@ interface DurableObjectStateService {
   abort(reason?: string, options?: globalThis.DurableObjectAbortOptions): Effect.Effect<void>;
 }
 declare const DurableObjectState_base: Context.ServiceClass<DurableObjectState, "effect-cf/DurableObjectState", DurableObjectStateService>;
-/**
- * Context tag for accessing the current Durable Object state service.
- */
 declare class DurableObjectState extends DurableObjectState_base {}
-/**
- * Wraps a native Cloudflare `DurableObjectState` as a {@link DurableObjectStateService}.
- */
 declare const fromDurableObjectState: (state: globalThis.DurableObjectState) => DurableObjectStateService;
 //#endregion
-export { StorageOperationError as A, Rpc_d_exports as C, DurableWebSocket as D, DurableObjectWebSocket_d_exports as E, DurableWebSocketAttachmentError as O, Provider as S, AcceptedUpgrade as T, Definition$3 as _, NativeRequest as a, RpcDefinition_d_exports as b, WorkerDefinition_d_exports as c, AsyncMethodCloudflareReturn as d, AsyncMethodKey as f, QueueBinding_d_exports as g, QueueDefinition_d_exports as h, ExecutionContext as i, DurableObjectStorage_d_exports as k, ServiceBinding_d_exports as l, Queue_d_exports as m, DurableObjectStateService as n, WorkerContext as o, AsyncMethodSuccess as p, DurableObjectState_d_exports as r, Worker_d_exports as s, DurableObjectState as t, AsyncMethodArgs as u, Method$2 as v, AcceptUpgradeOptions as w, ServiceFreeSchema$1 as x, ReservedMethodName$3 as y };
+export { DurableWebSocket as A, RpcDefinition_d_exports as C, AcceptUpgradeOptions as D, Rpc_d_exports as E, DurableObjectStorage_d_exports as M, StorageOperationError as N, AcceptedUpgrade as O, ReservedMethodName$3 as S, Provider as T, Queue_d_exports as _, NativeRequest as a, Definition$3 as b, WorkerDefinition_d_exports as c, AsyncMethodCloudflareReturn as d, AsyncMethodKey as f, RpcTracing_d_exports as g, RpcInvocationInfo as h, ExecutionContext as i, DurableWebSocketAttachmentError as j, DurableObjectWebSocket_d_exports as k, ServiceBinding_d_exports as l, ReceiverOptions as m, DurableObjectStateService as n, WorkerContext as o, AsyncMethodSuccess as p, DurableObjectState_d_exports as r, Worker_d_exports as s, DurableObjectState as t, AsyncMethodArgs as u, QueueDefinition_d_exports as v, ServiceFreeSchema$1 as w, Method$2 as x, QueueBinding_d_exports as y };