effect-cf 0.11.0 → 0.12.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # effect-cf
 
+## 0.12.0
+
+### Minor Changes
+
+- [#37](https://github.com/danieljvdm/effect-cf/pull/37) [`4936579`](https://github.com/danieljvdm/effect-cf/commit/4936579eed9b2ad690f3fece468cc435e5bbf8e8) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Add Cloudflare OTLP layers for Effect logs, traces, and metrics in Workers and Durable Objects.
+
 ## 0.11.0
 
 ### Minor Changes

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 { D1Client } from "@effect/sql-d1";
-import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, WorkflowEntrypoint, WorkflowEvent, WorkflowSleepDuration, WorkflowStep, WorkflowStepConfig, WorkflowStepContext, WorkflowStepEvent, WorkflowTimeoutDuration } from "cloudflare:workers";
+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 { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, WorkflowEntrypoint, WorkflowEvent, WorkflowSleepDuration, WorkflowStep, WorkflowStepConfig, WorkflowStepContext, WorkflowStepEvent, WorkflowTimeoutDuration } from "cloudflare:workers";
+import { D1Client } from "@effect/sql-d1";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
 import * as RpcServer from "effect/unstable/rpc/RpcServer";
 import { SqliteClient } from "@effect/sql-sqlite-do";
@@ -11,54 +12,11 @@ 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 };
-}
-/** Typed D1 binding definition. */
-interface D1Definition {
-  /** Binding name as configured in `wrangler.jsonc`. */
-  readonly binding: string;
-}
-/** Options forwarded to `@effect/sql-d1` when building a SQL client layer. */
-type D1SqlLayerOptions = Omit<D1Client.D1ClientConfig, "db">;
-declare const D1ServiceTypeId: unique symbol;
-/** Nominal service marker for D1 services created with {@link make}. */
-interface D1Service<Id extends string> {
-  readonly [D1ServiceTypeId]: {
-    readonly id: Id;
-  };
-}
-/**
- * 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>>;
-};
+//#region src/Rpc.d.ts
 declare namespace Rpc_d_exports {
   export { DisposableValue, MethodArgs, MethodKey, MethodReturn, Provider, Result, RpcStub, RpcTarget, Serializable, Stub, Stubable, Stubify, dispose, isDisposable, resolve, scoped };
 }
@@ -84,7 +42,7 @@ 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 };
+  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$10 as make, method$4 as method, reservedMethodNames };
 }
 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";
@@ -183,9 +141,9 @@ declare const decodeArgs: <const Self extends Definition$9.Any, MethodName exten
 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 const make$10: <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 };
+  export { MessageSendRequest, QueueBindingClient, QueueBindingDefinition, QueueMetrics, QueueOperationError, QueueProducer, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse, isQueue, layer$9 as layer, makeClient$6 as makeClient };
 }
 type QueueSendOptions = globalThis.QueueSendOptions;
 type QueueSendResponse = globalThis.QueueSendResponse;
@@ -217,9 +175,9 @@ declare class QueueOperationError extends QueueOperationError_base<{
 }> {}
 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 const layer$9: <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 };
+  export { Definition$8 as Definition, Handler$3 as Handler, LayerOptions$12 as LayerOptions, Options$7 as Options, Queue$1 as Queue, Tag$11 as Tag, TagClass$10 as TagClass, implement$7 as implement, make$9 as make };
 }
 interface Definition$8<Id extends string = string, Message extends ServiceFreeSchema$4 = ServiceFreeSchema$4> {
   readonly id: Id;
@@ -233,20 +191,20 @@ interface Options$7<ROut, Self extends Definition$8.Any> extends Omit<WorkerOpti
   readonly queue: Handler$3<ROut, Self>;
   readonly rpc?: never;
 }
-type LayerOptions$11 = {
+type LayerOptions$12 = {
   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 layer: (options: LayerOptions$12) => 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: {
+declare const make$9: <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: {
@@ -257,7 +215,7 @@ declare const Queue$1: <Self>() => <Id extends string, Message extends ServiceFr
 }) => 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 };
+  export { Definition$7 as Definition, Handler$2 as Handler, LayerOptions$11 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>;
@@ -306,7 +264,7 @@ type Definition$7<Id extends string = string, Message extends Definition$8.Any["
 declare namespace Definition$7 {
   type Any = Definition$8.Any;
 }
-type LayerOptions$10 = LayerOptions$11;
+type LayerOptions$11 = LayerOptions$12;
 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;
@@ -315,7 +273,7 @@ declare const implement$6: <ROut, const Self extends Definition$8.Any>(_definiti
 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 };
+  export { Api$3 as Api, Definition$6 as Definition, HandlerEffect$3 as HandlerEffect, Handlers$3 as Handlers, LayerOptions$10 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$8 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> {
@@ -363,14 +321,14 @@ type Handlers$3<ROut, Self extends Definition$6.Any> = { readonly [Key in keyof
 interface Options$5<ROut, Self extends Definition$6.Any> extends Omit<WorkerOptions<ROut, Handlers$3<ROut, Self>>, "rpc"> {
   readonly rpc: Handlers$3<ROut, Self>;
 }
-type LayerOptions$9 = {
+type LayerOptions$10 = {
   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>;
+  readonly layer: (options: LayerOptions$10) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
 /**
  * Defines a single RPC method schema in a worker definition.
@@ -384,7 +342,7 @@ declare const method$3: {
     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 make$8: <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>;
 /**
@@ -403,7 +361,7 @@ type AsyncMethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...a
 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 };
+  export { Service$1 as Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceFetcher, isServiceBindingClient, layer$8 as layer, makeClient$5 as makeClient, makeDirectMethods$1 as makeDirectMethods };
 }
 declare const TypeId$1: "effect-cf/ServiceBinding";
 /**
@@ -550,7 +508,7 @@ type ServiceBindingStaticClient<R, Api extends object, Definition extends Defini
 };
 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>;
+declare const layer$8: <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>;
 /**
  * Creates a typed Effect service for a Worker service binding.
  *
@@ -580,7 +538,7 @@ declare const layer$7: <Self, Api extends object, const Definition extends Defin
  * });
  * ```
  */
-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> & {
+declare const Service$1: <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>;
@@ -590,7 +548,7 @@ declare const Service: <Self, Api extends object = never>() => <Id extends strin
 };
 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 };
+  export { Api$2 as Api, Definition$5 as Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect$2 as HandlerEffect, Handlers$2 as Handlers, LayerOptions$9 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$7 as make, makeFetchHandler, method$2 as method, renderHttpResponse };
 }
 declare const ExecutionContext_base: Context.ServiceClass<ExecutionContext, "effect-cf/ExecutionContext", globalThis.ExecutionContext<unknown>>;
 declare class ExecutionContext extends ExecutionContext_base {}
@@ -635,8 +593,8 @@ 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, const Rpc extends WorkerRpc<ROut> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptions<ROut, Rpc>): WorkerClass<Rpc, ROut>;
+declare function make$7<ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, fetch: WorkerHandler<ROut>): WorkerClass<Record<never, never>, ROut>;
+declare function make$7<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> {
@@ -665,12 +623,12 @@ type Handlers$2<ROut, Self extends Definition$5.Any> = { readonly [Key in keyof
 interface Options$4<ROut, Self extends Definition$5.Any> extends Omit<WorkerOptions<ROut, Handlers$2<ROut, Self>>, "rpc"> {
   readonly rpc: Handlers$2<ROut, Self>;
 }
-type LayerOptions$8 = LayerOptions$9;
+type LayerOptions$9 = LayerOptions$10;
 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>(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>;
+  readonly layer: (options: LayerOptions$9) => 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;
@@ -987,7 +945,7 @@ declare class DurableObjectState extends DurableObjectState_base {}
  */
 declare const fromDurableObjectState: (state: globalThis.DurableObjectState) => DurableObjectStateService;
 declare namespace DurableObjectNamespace_d_exports {
-  export { DurableObjectFetchError, DurableObjectNamespaceBindingDefinition, DurableObjectNamespaceClient, DurableObjectNamespaceDefinition, DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient, DurableObjectRpcError, DurableObjectStubClient, isDurableObjectNamespaceClient, layer$6 as layer, makeClient$4 as makeClient, makeDirectMethods };
+  export { DurableObjectFetchError, DurableObjectNamespaceBindingDefinition, DurableObjectNamespaceClient, DurableObjectNamespaceDefinition, DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient, DurableObjectRpcError, DurableObjectStubClient, isDurableObjectNamespaceClient, layer$7 as layer, makeClient$4 as makeClient, makeDirectMethods };
 }
 interface DurableObjectFetcher {
   fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
@@ -1186,7 +1144,7 @@ type DurableObjectNamespaceStaticClient<R, Api extends object, Definition extend
 };
 declare const isDurableObjectNamespaceClient: <Api extends object>(value: unknown) => value is DurableObjectNamespaceClient<Api>;
 declare const makeClient$4: <Api extends object, const Definition extends Definition$4.Any | undefined = undefined>(definition: DurableObjectNamespaceBindingDefinition<Definition>) => ((namespace: DurableObjectNamespaceClient<Api>) => DurableObjectNamespaceEffectClient<Api, Definition>);
-declare const layer$6: <Self, Api extends object, const Definition extends Definition$4.Any | undefined = undefined>(tag: Context.Service<Self, DurableObjectNamespaceEffectClient<Api, Definition>>, definition: DurableObjectNamespaceBindingDefinition<Definition>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const layer$7: <Self, Api extends object, const Definition extends Definition$4.Any | undefined = undefined>(tag: Context.Service<Self, DurableObjectNamespaceEffectClient<Api, Definition>>, definition: DurableObjectNamespaceBindingDefinition<Definition>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const makeDirectMethods: <R, Api extends object, Definition extends Definition$4.Any | undefined>(rpcDefinition: Definition | undefined, helpers: {
   readonly call: StubCall<R, Api>;
   readonly fetch: (stub: DurableObjectStubClient<Api>, input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
@@ -1194,7 +1152,7 @@ declare const makeDirectMethods: <R, Api extends object, Definition extends Defi
   readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
 }) => DirectMethods<R, Api, Definition>;
 declare namespace DurableObjectDefinition_d_exports {
-  export { Api$1 as Api, Definition$4 as Definition, DurableObject$1 as DurableObject, HandlerEffect$1 as HandlerEffect, Handlers$1 as Handlers, LayerOptions$7 as LayerOptions, Method$2 as Method, Methods$1 as Methods, NoReservedMethods$1 as NoReservedMethods, Options$3 as Options, ReservedMethodName$1 as ReservedMethodName, ServerApi$2 as ServerApi, ServiceFreeSchema$1 as ServiceFreeSchema, Tag$7 as Tag, TagClass$6 as TagClass, implement$3 as implement, make$5 as make, method$1 as method };
+  export { Api$1 as Api, Definition$4 as Definition, DurableObject$1 as DurableObject, HandlerEffect$1 as HandlerEffect, Handlers$1 as Handlers, LayerOptions$8 as LayerOptions, Method$2 as Method, Methods$1 as Methods, NoReservedMethods$1 as NoReservedMethods, Options$3 as Options, ReservedMethodName$1 as ReservedMethodName, ServerApi$2 as ServerApi, ServiceFreeSchema$1 as ServiceFreeSchema, Tag$7 as Tag, TagClass$6 as TagClass, implement$3 as implement, make$6 as make, method$1 as method };
 }
 type ServiceFreeSchema$1 = Schema.Codec<any, any, never, never>;
 interface Method$2<Args extends ReadonlyArray<ServiceFreeSchema$1> = ReadonlyArray<ServiceFreeSchema$1>, Success extends ServiceFreeSchema$1 = ServiceFreeSchema$1> {
@@ -1239,14 +1197,14 @@ type Handlers$1<ROut, Self extends Definition$4.Any> = { readonly [Key in keyof
 interface Options$3<ROut, Self extends Definition$4.Any> extends Omit<DurableObjectOptions<ROut, Handlers$1<ROut, Self>>, "rpc"> {
   readonly rpc: Handlers$1<ROut, Self>;
 }
-type LayerOptions$7 = {
+type LayerOptions$8 = {
   readonly binding: string;
 };
 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 layer: (options: LayerOptions$7) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$8) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
 /**
  * Defines a single RPC method schema in a Durable Object definition.
@@ -1260,7 +1218,7 @@ declare const method$1: {
     readonly success: Success;
   }): Method$2<Args, Success>;
 };
-declare const make$5: <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$6<Definition$4<Id, MethodsShape>, Id, MethodsShape>;
+declare const make$6: <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$6<Definition$4<Id, MethodsShape>, Id, MethodsShape>;
 declare const Tag$7: <Self>() => <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$6<Self, Id, MethodsShape>;
 declare const DurableObject$1: <Self>() => <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$6<Self, Id, MethodsShape>;
 /**
@@ -1272,7 +1230,7 @@ declare const implement$3: <ROut, const Self extends Definition$4.Any>(_definiti
  */
 type HandlerEffect$1<ROut, Self extends Definition$4.Any, Key extends keyof Self["methods"]> = DurableObjectHandler<ROut, Method$2.Success<Self["methods"][Key]>>;
 declare namespace DurableObject_d_exports {
-  export { Api, Definition$3 as Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcShape, HandlerEffect, Handlers, LayerOptions$6 as LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options$2 as Options, ReservedMethodName, RpcHandlers, ServerApi$1 as ServerApi, ServiceFreeSchema, Tag$6 as Tag, TagClass$5 as TagClass, TagFactory, implement$2 as implement, make$4 as make, method };
+  export { Api, Definition$3 as Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcShape, HandlerEffect, Handlers, LayerOptions$7 as LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options$2 as Options, ReservedMethodName, RpcHandlers, ServerApi$1 as ServerApi, ServiceFreeSchema, Tag$6 as Tag, TagClass$5 as TagClass, TagFactory, implement$2 as implement, make$5 as make, method };
 }
 type RuntimeContext$1<ROut> = DurableObjectState | WorkerEnvironment | ROut;
 type HandlerContext<ROut> = RuntimeContext$1<ROut> | Scope.Scope;
@@ -1324,7 +1282,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$5: <ROut, LayerError, const Rpc extends DurableObjectRpc<ROut> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options?: DurableObjectOptions<ROut, Rpc>) => DurableObjectClass<Rpc, ROut>;
 type ServiceFreeSchema = Schema.Codec<any, any, never, never>;
 interface Method$1<Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema = ServiceFreeSchema> {
   readonly args: Args;
@@ -1347,7 +1305,7 @@ interface Definition$3<Id extends string = string, MethodsShape extends Methods
 declare namespace Definition$3 {
   type Any = Definition$3<string, Methods>;
 }
-type LayerOptions$6 = LayerOptions$7;
+type LayerOptions$7 = LayerOptions$8;
 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]>> };
@@ -1358,7 +1316,7 @@ type TagClass$5<Self, Id extends string, MethodsShape extends Methods> = Context
   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 layer: (options: LayerOptions$6) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$7) => 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>;
 declare const Tag$6: TagFactory;
@@ -1373,6 +1331,258 @@ declare const method: {
 };
 declare const implement$2: <ROut, const Self extends Definition$3.Any>(_definition: Self, handlers: Handlers<ROut, Self>) => Handlers<ROut, Self>;
 type HandlerEffect<ROut, Self extends Definition$3.Any, Key extends keyof Self["methods"]> = DurableObjectHandler<ROut, Method$1.Success<Self["methods"][Key]>>;
+declare namespace CloudflareOtlp_d_exports {
+  export { CloudflareOtlpSettings, DurableObjectResourceOptions, LayerOptions$6 as LayerOptions, ResourceOptions, Serialization, Settings, Signal, WorkerResourceOptions, durableObjectLayer, instrumentDurableObjectOptions, instrumentWorkerOptions, layer$6 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.
+ *
+ * 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 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$6 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.
+ *
+ * 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.
+ *
+ * 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 layer$6: (options?: LayerOptions$6) => Layer.Layer<never, never, never>;
+/** Base OTLP telemetry layer forced to JSON serialization. */
+declare const layerJson: (options?: Omit<LayerOptions$6, "serialization">) => Layer.Layer<never, never, never>;
+/** Base OTLP telemetry layer forced to protobuf serialization. */
+declare const layerProtobuf: (options?: Omit<LayerOptions$6, "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$6 & 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$6 & DurableObjectResourceOptions) => Layer.Layer<never, never, DurableObjectState>;
+/**
+ * Instrument Worker lifecycle handlers with event-scoped OTLP telemetry.
+ *
+ * Each defined handler is provided with {@link workerLayer}. Because Worker
+ * handlers run inside `Effect.scoped`, the exporter scope closes and flushes at
+ * the end of each Cloudflare event.
+ */
+declare const instrumentWorkerOptions: (options?: LayerOptions$6 & WorkerResourceOptions) => <ROut, Rpc extends WorkerRpc<ROut>>(handlers: WorkerOptions<ROut, Rpc>) => WorkerOptions<ROut | WorkerEnvironment | CloudflareOtlpSettings, Rpc>;
+/**
+ * Instrument Durable Object lifecycle handlers with event-scoped OTLP telemetry.
+ *
+ * Each defined handler is provided with {@link durableObjectLayer}. Because
+ * Durable Object handlers run inside `Effect.scoped`, the exporter scope closes
+ * and flushes at the end of each Cloudflare event.
+ */
+declare const instrumentDurableObjectOptions: (options?: LayerOptions$6 & DurableObjectResourceOptions) => <ROut, Rpc extends DurableObjectRpc<ROut>>(handlers: DurableObjectOptions<ROut, Rpc>) => DurableObjectOptions<ROut | WorkerEnvironment | DurableObjectState | CloudflareOtlpSettings, Rpc>;
+declare namespace D1_d_exports {
+  export { D1Definition, D1Service, D1SqlLayerOptions, Service, make$4 as make };
+}
+/** Typed D1 binding definition. */
+interface D1Definition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+/** Options forwarded to `@effect/sql-d1` when building a SQL client layer. */
+type D1SqlLayerOptions = Omit<D1Client.D1ClientConfig, "db">;
+declare const D1ServiceTypeId: unique symbol;
+/** Nominal service marker for D1 services created with {@link make}. */
+interface D1Service<Id extends string> {
+  readonly [D1ServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+/**
+ * Creates a typed D1 service tag plus Effect helpers.
+ */
+declare const make$4: <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: <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 DurableObjectAlarm_d_exports {
   export { AlarmDefinitionConfig, AlarmDefinitionEntry, AlarmDefinitionPayload, AlarmDefinitions, AlarmFailurePolicy, AlarmPayload, AlarmPayloadSchema, AlarmRef, AlarmRetryPolicy, AlarmScheduler, DefinedAlarmEvent, DefinedAlarmHandlers, DurableObjectAlarm, DurableObjectAlarmError, DurableObjectAlarmEvent, InvalidAlarmPayloadError, InvalidAlarmRefError, InvalidProcessDueAlarmsOptionsError, InvalidRepeatEveryError, ProcessDueAlarmsFailure, ProcessDueAlarmsFailureAction, ProcessDueAlarmsHandler, ProcessDueAlarmsMode, ProcessDueAlarmsOptions, ProcessDueAlarmsResult, ScheduleAlarmInput, StoredAlarmDecodeError, define, process, processDue };
 }
@@ -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 };