effect-cf 0.10.0 → 0.12.0

package/dist/index.mjs

@@ -1,64 +1,19 @@
 import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
-import { a as WorkerConfig, i as layer$8, n as Binding_exports, o as WorkerEnvironment, r as Service$2, t as Hyperdrive_exports } from "./Hyperdrive-89hg_Fck.mjs";
-import { Cause, Clock, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Layer, ManagedRuntime, Option, Queue, Schema } from "effect";
-import { D1Client } from "@effect/sql-d1";
+import { a as WorkerConfig, i as layer$10, n as Binding_exports, o as WorkerEnvironment, r as Service$2, t as Hyperdrive_exports } from "./Hyperdrive-89hg_Fck.mjs";
+import { Cause, Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Layer, ManagedRuntime, Option, Queue, Schema } from "effect";
+import { FetchHttpClient, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { Otlp, OtlpLogger, OtlpMetrics, OtlpSerialization, OtlpTracer } from "effect/unstable/observability";
 import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, WorkflowEntrypoint } from "cloudflare:workers";
-import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { D1Client } from "@effect/sql-d1";
 import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
 import * as RpcServer from "effect/unstable/rpc/RpcServer";
-//#region src/D1.ts
-var D1_exports = /* @__PURE__ */ __exportAll({
-	Service: () => Service$1,
-	make: () => make$10
-});
-const TypeId$2 = "effect-cf/D1";
-const expectedD1Database = "D1 database binding with prepare(), batch(), and exec()";
-const isD1Database = (value) => {
-	if (typeof value !== "object" || value === null) return false;
-	const resource = value;
-	return typeof resource.prepare === "function" && typeof resource.batch === "function" && typeof resource.exec === "function";
-};
-/**
-* Creates a typed D1 service tag plus Effect helpers.
-*/
-const make$10 = (id, definition) => Service$1()(id, definition);
-/**
-* 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();
-* ```
-*/
-const Service$1 = () => (id, definition) => {
-	const tag = Service$2()(id, definition.binding, isD1Database, void 0, { expected: expectedD1Database });
-	const sqlLayer = (options) => Layer.unwrap(Effect.gen(function* () {
-		const db = yield* tag;
-		return D1Client.layer({
-			...options,
-			db
-		});
-	})).pipe(Layer.provide(tag.layer));
-	return Object.assign(tag, {
-		[TypeId$2]: TypeId$2,
-		definition,
-		sqlLayer
-	});
-};
-//#endregion
+import { SqliteClient } from "@effect/sql-sqlite-do";
 //#region src/QueueBinding.ts
 var QueueBinding_exports = /* @__PURE__ */ __exportAll({
 	QueueOperationError: () => QueueOperationError,
 	isQueue: () => isQueue,
-	layer: () => layer$7,
+	layer: () => layer$9,
 	makeClient: () => makeClient$6
 });
 const expectedQueueProducer = "Queue producer binding with send(); optional sendBatch()/metrics()";
@@ -114,30 +69,30 @@ const makeClient$6 = (definition) => {
 		unsafeRaw: Effect.succeed(queue)
 	});
 };
-const layer$7 = (tag, definition) => layer$8(tag, definition.binding, (value) => isQueue(value), makeClient$6(definition), { expected: expectedQueueProducer });
+const layer$9 = (tag, definition) => layer$10(tag, definition.binding, (value) => isQueue(value), makeClient$6(definition), { expected: expectedQueueProducer });
 //#endregion
 //#region src/QueueDefinition.ts
 var QueueDefinition_exports = /* @__PURE__ */ __exportAll({
 	Queue: () => Queue$1,
 	Tag: () => Tag$10,
 	implement: () => implement$7,
-	make: () => make$9
+	make: () => make$10
 });
 const makeDefinition$4 = (id, definition) => {
 	const queueDefinition = {
 		id,
 		message: definition.message
 	};
-	return Object.assign(queueDefinition, { make: (layer, options) => make$6(layer, {
+	return Object.assign(queueDefinition, { make: (layer, options) => make$7(layer, {
 		...options,
 		queue: wrapHandler$1(queueDefinition, options.queue)
 	}) });
 };
-const make$9 = (id, definition) => Tag$10()(id, definition);
+const make$10 = (id, definition) => Tag$10()(id, definition);
 const Tag$10 = () => (id, definition) => {
 	const queueDefinition = makeDefinition$4(id, definition);
 	const tag = Context.Service()(id);
-	const layer = (binding) => layer$7(tag, {
+	const layer = (binding) => layer$9(tag, {
 		...binding,
 		message: definition.message
 	});
@@ -232,7 +187,7 @@ var RpcDefinition_exports = /* @__PURE__ */ __exportAll({
 	decodeSuccess: () => decodeSuccess,
 	encodeArgs: () => encodeArgs,
 	encodeSuccess: () => encodeSuccess,
-	make: () => make$8,
+	make: () => make$9,
 	method: () => method$4,
 	reservedMethodNames: () => reservedMethodNames$4
 });
@@ -335,7 +290,7 @@ const decodeSuccess = (definition, methodName, value) => {
 		cause
 	})));
 };
-const make$8 = (id, methods) => {
+const make$9 = (id, methods) => {
 	const definition = {
 		id,
 		methods
@@ -389,15 +344,15 @@ const invokeRpcMethod = (target, method, args, makeError) => Effect.gen(function
 //#endregion
 //#region src/ServiceBinding.ts
 var ServiceBinding_exports = /* @__PURE__ */ __exportAll({
-	Service: () => Service,
+	Service: () => Service$1,
 	ServiceBindingFetchError: () => ServiceBindingFetchError,
 	ServiceBindingRpcError: () => ServiceBindingRpcError,
 	isServiceBindingClient: () => isServiceBindingClient,
-	layer: () => layer$6,
+	layer: () => layer$8,
 	makeClient: () => makeClient$5,
 	makeDirectMethods: () => makeDirectMethods$1
 });
-const TypeId$1 = "effect-cf/ServiceBinding";
+const TypeId$2 = "effect-cf/ServiceBinding";
 const expectedServiceBinding = "Worker service binding with fetch()";
 /**
 * Failure raised when calling `fetch` on a service binding.
@@ -457,7 +412,7 @@ const makeClient$5 = (definition) => {
 		});
 	};
 };
-const layer$6 = (tag, definition) => layer$8(tag, definition.binding, (value) => isServiceBindingClient(value), makeClient$5(definition), { expected: expectedServiceBinding });
+const layer$8 = (tag, definition) => layer$10(tag, definition.binding, (value) => isServiceBindingClient(value), makeClient$5(definition), { expected: expectedServiceBinding });
 /**
 * Creates a typed Effect service for a Worker service binding.
 *
@@ -487,7 +442,7 @@ const layer$6 = (tag, definition) => layer$8(tag, definition.binding, (value) =>
 * });
 * ```
 */
-const Service = () => (id, definition) => {
+const Service$1 = () => (id, definition) => {
 	const tag = Service$2()(id, definition.binding, (value) => isServiceBindingClient(value), makeClient$5(definition));
 	const fetch = (input, init) => Effect.gen(function* () {
 		return yield* (yield* tag).fetch(input, init);
@@ -503,7 +458,7 @@ const Service = () => (id, definition) => {
 	});
 	const directMethods = makeDirectMethods$1(definition.definition, call);
 	return Object.assign(tag, directMethods, {
-		[TypeId$1]: TypeId$1,
+		[TypeId$2]: TypeId$2,
 		definition,
 		fetch,
 		rpc,
@@ -522,7 +477,7 @@ var WorkerDefinition_exports = /* @__PURE__ */ __exportAll({
 	Tag: () => Tag$8,
 	Worker: () => Worker,
 	implement: () => implement$5,
-	make: () => make$7,
+	make: () => make$8,
 	method: () => method$3
 });
 const reservedMethodNames$3 = new Set([
@@ -560,13 +515,13 @@ const method$3 = method$4;
 */
 const makeDefinition$3 = (id, methods) => {
 	assertNoReservedMethods("Worker", methods, reservedMethodNames$3);
-	const definition = make$8(id, methods);
-	return Object.assign(definition, { make: (layer, options) => make$6(layer, {
+	const definition = make$9(id, methods);
+	return Object.assign(definition, { make: (layer, options) => make$7(layer, {
 		...options,
 		rpc: wrapHandlers$1(definition, options.rpc)
 	}) });
 };
-const make$7 = (id, methods) => Tag$8()(id, methods);
+const make$8 = (id, methods) => Tag$8()(id, methods);
 const Tag$8 = () => (id, methods) => {
 	const definition = makeDefinition$3(id, methods);
 	const tag = Context.Service()(id);
@@ -574,7 +529,7 @@ const Tag$8 = () => (id, methods) => {
 		...binding,
 		definition
 	});
-	const layer = (binding) => layer$6(tag, bindingDefinition(binding));
+	const layer = (binding) => layer$8(tag, bindingDefinition(binding));
 	const fetch = (input, init) => Effect.gen(function* () {
 		return yield* (yield* tag).fetch(input, init);
 	});
@@ -659,7 +614,7 @@ var Worker_exports = /* @__PURE__ */ __exportAll({
 	WorkerContext: () => WorkerContext,
 	implement: () => implement$4,
 	isWebSocketUpgrade: () => isWebSocketUpgrade,
-	make: () => make$6,
+	make: () => make$7,
 	makeFetchHandler: () => makeFetchHandler,
 	method: () => method$2,
 	renderHttpResponse: () => renderHttpResponse
@@ -688,7 +643,7 @@ const RunSymbol$1 = Symbol.for("effect-cf/Worker/run");
 const renderHttpResponse = (effect) => Effect.flatMap(effect, (response) => Effect.map(Effect.context(), (context) => HttpServerResponse.toWeb(response, { context })));
 const renderFetchSuccess = (effect) => Effect.flatMap(effect, (response) => response instanceof Response ? Effect.succeed(response) : Effect.map(Effect.context(), (context) => HttpServerResponse.toWeb(response, { context })));
 const isWorkerOptions = (options) => typeof options === "object" && options !== null && ("fetch" in options || "queue" in options || "rpc" in options);
-function make$6(layer, optionsOrFetch) {
+function make$7(layer, optionsOrFetch) {
 	const options = isWorkerOptions(optionsOrFetch) ? optionsOrFetch : { fetch: optionsOrFetch };
 	class EffectWorker extends WorkerEntrypoint {
 		runtime;
@@ -719,7 +674,7 @@ function make$6(layer, optionsOrFetch) {
 	return assumeEntrypointClass(EffectWorker);
 }
 const makeFetchHandler = (layer, options) => {
-	const WorkerClass = make$6(layer, options);
+	const WorkerClass = make$7(layer, options);
 	return { fetch: (request, env, ctx) => Promise.resolve(new WorkerClass(ctx, env).fetch(request)) };
 };
 const Tag$7 = Tag$8;
@@ -1020,7 +975,7 @@ var DurableObjectNamespace_exports = /* @__PURE__ */ __exportAll({
 	DurableObjectFetchError: () => DurableObjectFetchError,
 	DurableObjectRpcError: () => DurableObjectRpcError,
 	isDurableObjectNamespaceClient: () => isDurableObjectNamespaceClient,
-	layer: () => layer$5,
+	layer: () => layer$7,
 	makeClient: () => makeClient$4,
 	makeDirectMethods: () => makeDirectMethods
 });
@@ -1102,7 +1057,7 @@ const makeClient$4 = (definition) => {
 		});
 	};
 };
-const layer$5 = (tag, definition) => layer$8(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$4(definition), { expected: expectedDurableObjectNamespace });
+const layer$7 = (tag, definition) => layer$10(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$4(definition), { expected: expectedDurableObjectNamespace });
 const makeDirectMethods = (rpcDefinition, helpers) => {
 	const methods = {};
 	if (rpcDefinition !== void 0) {
@@ -1129,7 +1084,7 @@ var DurableObjectDefinition_exports = /* @__PURE__ */ __exportAll({
 	DurableObject: () => DurableObject$1,
 	Tag: () => Tag$6,
 	implement: () => implement$3,
-	make: () => make$5,
+	make: () => make$6,
 	method: () => method$1
 });
 const reservedMethodNames$1 = new Set([
@@ -1160,13 +1115,13 @@ const method$1 = method$4;
 */
 const makeDefinition$2 = (id, methods) => {
 	assertNoReservedMethods("Durable Object", methods, reservedMethodNames$1);
-	const definition = make$8(id, methods);
-	return Object.assign(definition, { make: (layer, options) => make$4(layer, {
+	const definition = make$9(id, methods);
+	return Object.assign(definition, { make: (layer, options) => make$5(layer, {
 		...options,
 		rpc: wrapHandlers(definition, options.rpc)
 	}) });
 };
-const make$5 = (id, methods) => Tag$6()(id, methods);
+const make$6 = (id, methods) => Tag$6()(id, methods);
 const Tag$6 = () => (id, methods) => {
 	const definition = makeDefinition$2(id, methods);
 	const tag = Context.Service()(id);
@@ -1174,7 +1129,7 @@ const Tag$6 = () => (id, methods) => {
 		...binding,
 		definition
 	});
-	const layer = (binding) => layer$5(tag, bindingDefinition(binding));
+	const layer = (binding) => layer$7(tag, bindingDefinition(binding));
 	const newUniqueId = Effect.fnUntraced(function* (options) {
 		return yield* (yield* tag).newUniqueId(options);
 	});
@@ -1252,7 +1207,7 @@ const implement$3 = (_definition, handlers) => handlers;
 var DurableObject_exports = /* @__PURE__ */ __exportAll({
 	Tag: () => Tag$5,
 	implement: () => implement$2,
-	make: () => make$4,
+	make: () => make$5,
 	method: () => method
 });
 const reservedMethodNames = new Set([
@@ -1268,7 +1223,7 @@ const RunSymbol = Symbol.for("effect-cf/DurableObject/run");
 /**
 * Creates a Durable Object class backed by a single managed Effect runtime.
 */
-const make$4 = (layer, options = {}) => {
+const make$5 = (layer, options = {}) => {
 	class EffectDurableObject extends DurableObject {
 		runtime;
 		constructor(state, env) {
@@ -1313,6 +1268,378 @@ const Tag$5 = Tag$6;
 const method = method$1;
 const implement$2 = implement$3;
 //#endregion
+//#region src/CloudflareOtlp.ts
+var CloudflareOtlp_exports = /* @__PURE__ */ __exportAll({
+	CloudflareOtlpSettings: () => CloudflareOtlpSettings,
+	durableObjectLayer: () => durableObjectLayer,
+	instrumentDurableObjectOptions: () => instrumentDurableObjectOptions,
+	instrumentWorkerOptions: () => instrumentWorkerOptions,
+	layer: () => layer$6,
+	layerJson: () => layerJson,
+	layerProtobuf: () => layerProtobuf,
+	settingsConfig: () => settingsConfig,
+	settingsLayer: () => settingsLayer,
+	workerLayer: () => workerLayer
+});
+/**
+* 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.
+*/
+const settingsConfig = Config.all({
+	endpoint: Config.string("OTEL_EXPORTER_OTLP_ENDPOINT").pipe(Config.option),
+	logsEndpoint: Config.string("OTEL_EXPORTER_OTLP_LOGS_ENDPOINT").pipe(Config.option),
+	tracesEndpoint: Config.string("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT").pipe(Config.option),
+	metricsEndpoint: Config.string("OTEL_EXPORTER_OTLP_METRICS_ENDPOINT").pipe(Config.option),
+	headers: Config.string("OTEL_EXPORTER_OTLP_HEADERS").pipe(Config.option),
+	logsHeaders: Config.string("OTEL_EXPORTER_OTLP_LOGS_HEADERS").pipe(Config.option),
+	tracesHeaders: Config.string("OTEL_EXPORTER_OTLP_TRACES_HEADERS").pipe(Config.option),
+	metricsHeaders: Config.string("OTEL_EXPORTER_OTLP_METRICS_HEADERS").pipe(Config.option),
+	serviceName: Config.string("OTEL_SERVICE_NAME").pipe(Config.option),
+	serviceVersion: Config.string("OTEL_SERVICE_VERSION").pipe(Config.option),
+	resourceAttributes: Config.schema(Config.Record(Schema.String, Schema.String), "OTEL_RESOURCE_ATTRIBUTES").pipe(Config.option)
+});
+/**
+* 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));
+* ```
+*/
+var CloudflareOtlpSettings = class extends Context.Service()("effect-cf/CloudflareOtlpSettings") {};
+const allSignals = [
+	"logs",
+	"traces",
+	"metrics"
+];
+const optionToUndefined = (option) => Option.isSome(option) ? option.value : void 0;
+const nonEmptyStringOption = (option) => Option.flatMap(option, (value) => {
+	const trimmed = value.trim();
+	return trimmed === "" ? Option.none() : Option.some(trimmed);
+});
+const nonEmptyRecordOption = (option) => Option.filter(option, (value) => Object.keys(value).length > 0);
+const normalizeSettings = (settings) => ({
+	endpoint: nonEmptyStringOption(settings.endpoint),
+	logsEndpoint: nonEmptyStringOption(settings.logsEndpoint),
+	tracesEndpoint: nonEmptyStringOption(settings.tracesEndpoint),
+	metricsEndpoint: nonEmptyStringOption(settings.metricsEndpoint),
+	headers: nonEmptyStringOption(settings.headers),
+	logsHeaders: nonEmptyStringOption(settings.logsHeaders),
+	tracesHeaders: nonEmptyStringOption(settings.tracesHeaders),
+	metricsHeaders: nonEmptyStringOption(settings.metricsHeaders),
+	serviceName: nonEmptyStringOption(settings.serviceName),
+	serviceVersion: nonEmptyStringOption(settings.serviceVersion),
+	resourceAttributes: nonEmptyRecordOption(settings.resourceAttributes)
+});
+/**
+* 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.
+*/
+const settingsLayer = Layer.effect(CloudflareOtlpSettings, settingsConfig.pipe(Config.map(normalizeSettings))).pipe(Layer.provide(WorkerConfig.layer));
+const selectedSignals = (signals) => new Set(signals ?? allSignals);
+const withDefinedAttributes = (attributes) => {
+	const out = {};
+	for (const [key, value] of Object.entries(attributes)) if (value !== void 0) out[key] = value;
+	return out;
+};
+const parseHeaders = (input) => {
+	if (Option.isNone(input) || input.value.trim() === "") return;
+	const headers = {};
+	for (const part of input.value.split(",")) {
+		const index = part.indexOf("=");
+		if (index <= 0) continue;
+		const key = part.slice(0, index).trim();
+		const value = part.slice(index + 1).trim();
+		if (key !== "") headers[decodeHeaderComponent(key)] = decodeHeaderComponent(value);
+	}
+	return headers;
+};
+const mergeHeaders = (common, signalSpecific) => {
+	const commonHeaders = parseHeaders(common);
+	const signalHeaders = parseHeaders(signalSpecific);
+	if (commonHeaders === void 0 && signalHeaders === void 0) return;
+	return {
+		...commonHeaders,
+		...signalHeaders
+	};
+};
+const decodeHeaderComponent = (value) => {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+};
+const appendOtlpPath = (baseUrl, path) => `${baseUrl.replace(/\/+$/, "")}${path}`;
+const makeResource = (settings, options, runtimeAttributes) => ({
+	serviceName: options.serviceName ?? optionToUndefined(settings.serviceName),
+	serviceVersion: options.serviceVersion ?? optionToUndefined(settings.serviceVersion),
+	attributes: {
+		...optionToUndefined(settings.resourceAttributes),
+		...withDefinedAttributes(runtimeAttributes),
+		...options.attributes
+	}
+});
+const commonOtlpOptions = (settings, options, runtimeAttributes) => ({
+	resource: makeResource(settings, options, runtimeAttributes),
+	maxBatchSize: options.maxBatchSize,
+	loggerExportInterval: options.loggerExportInterval,
+	loggerExcludeLogSpans: options.loggerExcludeLogSpans,
+	loggerMergeWithExisting: options.loggerMergeWithExisting,
+	tracerExportInterval: options.tracerExportInterval,
+	tracerContext: options.tracerContext,
+	metricsExportInterval: options.metricsExportInterval,
+	metricsTemporality: options.metricsTemporality,
+	shutdownTimeout: options.shutdownTimeout
+});
+const serializationLayer = (serialization) => serialization === "json" ? OtlpSerialization.layerJson : OtlpSerialization.layerProtobuf;
+const resolveSettings = Effect.gen(function* () {
+	const settings = yield* Effect.serviceOption(CloudflareOtlpSettings);
+	if (Option.isSome(settings)) return normalizeSettings(settings.value);
+	const env = yield* Effect.serviceOption(WorkerEnvironment);
+	if (Option.isSome(env)) return normalizeSettings(yield* settingsConfig.pipe(Effect.provide(ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env.value))))));
+	return normalizeSettings(yield* settingsConfig);
+});
+const mergeSignalLayers = (layers) => {
+	if (layers.length === 0) return Layer.empty;
+	let merged = layers[0];
+	for (let index = 1; index < layers.length; index++) merged = Layer.mergeAll(merged, layers[index]);
+	return merged;
+};
+const emptyLayer = Layer.empty;
+const makeLayerFromSettings = (options = {}, runtimeAttributes = {}) => Layer.unwrap(Effect.map(resolveSettings, (settings) => {
+	const signals = selectedSignals(options.signals);
+	const endpoint = optionToUndefined(settings.endpoint);
+	const logsEndpoint = optionToUndefined(settings.logsEndpoint);
+	const tracesEndpoint = optionToUndefined(settings.tracesEndpoint);
+	const metricsEndpoint = optionToUndefined(settings.metricsEndpoint);
+	const hasSpecificEndpoint = logsEndpoint !== void 0 || tracesEndpoint !== void 0 || metricsEndpoint !== void 0;
+	const hasSpecificHeaders = Option.isSome(settings.logsHeaders) || Option.isSome(settings.tracesHeaders) || Option.isSome(settings.metricsHeaders);
+	const common = commonOtlpOptions(settings, options, runtimeAttributes);
+	if (endpoint !== void 0 && !hasSpecificEndpoint && !hasSpecificHeaders && signals.size === 3) return Otlp.layer({
+		baseUrl: endpoint,
+		headers: parseHeaders(settings.headers),
+		...common
+	}).pipe(Layer.provide(serializationLayer(options.serialization)), Layer.provide(FetchHttpClient.layer));
+	const layers = [];
+	if (signals.has("logs")) {
+		const url = logsEndpoint ?? (endpoint === void 0 ? void 0 : appendOtlpPath(endpoint, "/v1/logs"));
+		if (url !== void 0) layers.push(OtlpLogger.layer({
+			url,
+			resource: common.resource,
+			headers: mergeHeaders(settings.headers, settings.logsHeaders),
+			exportInterval: common.loggerExportInterval,
+			maxBatchSize: common.maxBatchSize,
+			shutdownTimeout: common.shutdownTimeout,
+			excludeLogSpans: common.loggerExcludeLogSpans,
+			mergeWithExisting: common.loggerMergeWithExisting
+		}).pipe(Layer.provide(serializationLayer(options.serialization)), Layer.provide(FetchHttpClient.layer)));
+	}
+	if (signals.has("traces")) {
+		const url = tracesEndpoint ?? (endpoint === void 0 ? void 0 : appendOtlpPath(endpoint, "/v1/traces"));
+		if (url !== void 0) layers.push(OtlpTracer.layer({
+			url,
+			resource: common.resource,
+			headers: mergeHeaders(settings.headers, settings.tracesHeaders),
+			exportInterval: common.tracerExportInterval,
+			maxBatchSize: common.maxBatchSize,
+			context: common.tracerContext,
+			shutdownTimeout: common.shutdownTimeout
+		}).pipe(Layer.provide(serializationLayer(options.serialization)), Layer.provide(FetchHttpClient.layer)));
+	}
+	if (signals.has("metrics")) {
+		const url = metricsEndpoint ?? (endpoint === void 0 ? void 0 : appendOtlpPath(endpoint, "/v1/metrics"));
+		if (url !== void 0) layers.push(OtlpMetrics.layer({
+			url,
+			resource: common.resource,
+			headers: mergeHeaders(settings.headers, settings.metricsHeaders),
+			exportInterval: common.metricsExportInterval,
+			shutdownTimeout: common.shutdownTimeout,
+			temporality: common.metricsTemporality
+		}).pipe(Layer.provide(serializationLayer(options.serialization)), Layer.provide(FetchHttpClient.layer)));
+	}
+	return mergeSignalLayers(layers);
+}).pipe(Effect.catch((error) => Effect.logWarning("CloudflareOtlp disabled because OTLP configuration is invalid", { error: String(error) }).pipe(Effect.as(emptyLayer)))));
+const makeLayer = (options = {}, runtimeAttributes = {}) => makeLayerFromSettings(options, runtimeAttributes);
+/**
+* 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.
+*/
+const layer$6 = (options = {}) => makeLayer(options);
+/** Base OTLP telemetry layer forced to JSON serialization. */
+const layerJson = (options = {}) => layer$6({
+	...options,
+	serialization: "json"
+});
+/** Base OTLP telemetry layer forced to protobuf serialization. */
+const layerProtobuf = (options = {}) => layer$6({
+	...options,
+	serialization: "protobuf"
+});
+/**
+* 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.
+*/
+const workerLayer = (options = {}) => makeLayer(options, {
+	"cloudflare.resource_type": "worker",
+	"cloudflare.worker.name": options.workerName
+});
+/**
+* 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.
+*/
+const durableObjectLayer = (options = {}) => Layer.unwrap(Effect.map(DurableObjectState, (state) => makeLayer(options, {
+	"cloudflare.resource_type": "durable_object",
+	"cloudflare.durable_object.class": options.className,
+	"cloudflare.durable_object.id": options.includeObjectId ? state.id.toString() : void 0
+})));
+const provideRpcLayer = (rpc, layer) => {
+	if (rpc === void 0) return;
+	return new Proxy(rpc, { get(target, property, receiver) {
+		const handler = Reflect.get(target, property, receiver);
+		if (typeof handler !== "function") return handler;
+		return (...args) => Effect.suspend(() => Reflect.apply(handler, receiver, args)).pipe(Effect.provide(layer));
+	} });
+};
+/**
+* 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.
+*/
+const instrumentWorkerOptions = (options) => (handlers) => {
+	const telemetryLayer = workerLayer(options);
+	const queue = handlers.queue;
+	return {
+		...handlers,
+		fetch: handlers.fetch === void 0 ? void 0 : handlers.fetch.pipe(Effect.provide(telemetryLayer)),
+		queue: queue === void 0 ? void 0 : (batch) => queue(batch).pipe(Effect.provide(telemetryLayer)),
+		rpc: provideRpcLayer(handlers.rpc, telemetryLayer)
+	};
+};
+/**
+* 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.
+*/
+const instrumentDurableObjectOptions = (options) => (handlers) => {
+	const telemetryLayer = durableObjectLayer(options);
+	const alarm = handlers.alarm;
+	const webSocketMessage = handlers.webSocketMessage;
+	const webSocketClose = handlers.webSocketClose;
+	const webSocketError = handlers.webSocketError;
+	return {
+		...handlers,
+		initialize: handlers.initialize === void 0 ? void 0 : handlers.initialize.pipe(Effect.provide(telemetryLayer)),
+		fetch: handlers.fetch === void 0 ? void 0 : handlers.fetch.pipe(Effect.provide(telemetryLayer)),
+		alarms: handlers.alarms === void 0 ? void 0 : handlers.alarms.pipe(Effect.provide(telemetryLayer)),
+		alarm: alarm === void 0 ? void 0 : (alarmInfo) => alarm(alarmInfo).pipe(Effect.provide(telemetryLayer)),
+		webSocketMessage: webSocketMessage === void 0 ? void 0 : (socket, message) => webSocketMessage(socket, message).pipe(Effect.provide(telemetryLayer)),
+		webSocketClose: webSocketClose === void 0 ? void 0 : (socket, code, reason, wasClean) => webSocketClose(socket, code, reason, wasClean).pipe(Effect.provide(telemetryLayer)),
+		webSocketError: webSocketError === void 0 ? void 0 : (socket, error) => webSocketError(socket, error).pipe(Effect.provide(telemetryLayer)),
+		rpc: provideRpcLayer(handlers.rpc, telemetryLayer)
+	};
+};
+//#endregion
+//#region src/D1.ts
+var D1_exports = /* @__PURE__ */ __exportAll({
+	Service: () => Service,
+	make: () => make$4
+});
+const TypeId$1 = "effect-cf/D1";
+const expectedD1Database = "D1 database binding with prepare(), batch(), and exec()";
+const isD1Database = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const resource = value;
+	return typeof resource.prepare === "function" && typeof resource.batch === "function" && typeof resource.exec === "function";
+};
+/**
+* Creates a typed D1 service tag plus Effect helpers.
+*/
+const make$4 = (id, definition) => Service()(id, definition);
+/**
+* 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();
+* ```
+*/
+const Service = () => (id, definition) => {
+	const tag = Service$2()(id, definition.binding, isD1Database, void 0, { expected: expectedD1Database });
+	const sqlLayer = (options) => Layer.unwrap(Effect.gen(function* () {
+		const db = yield* tag;
+		return D1Client.layer({
+			...options,
+			db
+		});
+	})).pipe(Layer.provide(tag.layer));
+	return Object.assign(tag, {
+		[TypeId$1]: TypeId$1,
+		definition,
+		sqlLayer
+	});
+};
+//#endregion
 //#region src/DurableObjectAlarm.ts
 var DurableObjectAlarm_exports = /* @__PURE__ */ __exportAll({
 	DurableObjectAlarm: () => DurableObjectAlarm,
@@ -1638,7 +1965,7 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 //#region src/DurableObjectRpcWebSocket.ts
 var DurableObjectRpcWebSocket_exports = /* @__PURE__ */ __exportAll({
 	DurableObjectRpcWebSocket: () => DurableObjectRpcWebSocket,
-	layer: () => layer$4
+	layer: () => layer$5
 });
 const defaultAttachmentKey = "effectCloudflareRpcClientId";
 const defaultTag = "effect-cf-rpc";
@@ -1649,7 +1976,7 @@ var DurableObjectRpcWebSocket = class extends Context.Service()("effect-cf/Durab
 /**
 * Builds a layer that bridges Durable Object websocket events to `RpcServer.Protocol`.
 */
-const layer$4 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
+const layer$5 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 	const tag = options.tag ?? defaultTag;
 	const attachmentKey = options.attachmentKey ?? defaultAttachmentKey;
 	const durableObjectState = yield* DurableObjectState;
@@ -1761,6 +2088,27 @@ const writeAttachment = (socket, key, clientId) => {
 	});
 };
 //#endregion
+//#region src/DurableObjectSqlite.ts
+var DurableObjectSqlite_exports = /* @__PURE__ */ __exportAll({ layer: () => layer$4 });
+/**
+* Provides `effect/unstable/sql` from the current Durable Object SQLite storage.
+*
+* @example
+* ```ts
+* const RoomLayer = Layer.mergeAll(
+*   DurableObjectSqlite.layer(),
+*   OtherRoomServices,
+* );
+* ```
+*/
+const layer$4 = (options) => Layer.unwrap(Effect.gen(function* () {
+	const state = yield* DurableObjectState;
+	return SqliteClient.layer({
+		...options,
+		db: state.raw.storage.sql
+	});
+}));
+//#endregion
 //#region src/Images.ts
 var Images_exports = /* @__PURE__ */ __exportAll({
 	ImagesOperationError: () => ImagesOperationError,
@@ -1857,7 +2205,7 @@ const makeClient$3 = (definition) => (images) => {
 		unsafeRaw: Effect.succeed(images)
 	};
 };
-const layer$3 = (tag, definition) => layer$8(tag, definition.binding, isImagesBinding, makeClient$3(definition), { expected: expectedImagesBinding });
+const layer$3 = (tag, definition) => layer$10(tag, definition.binding, isImagesBinding, makeClient$3(definition), { expected: expectedImagesBinding });
 const make$3 = (id) => Tag$4()(id);
 const Tag$4 = () => (id) => {
 	const tag = Context.Service()(id);
@@ -1952,7 +2300,7 @@ const makeClient$2 = (definition) => {
 		unsafeRaw: Effect.succeed(kv)
 	});
 };
-const layer$2 = (tag, definition) => layer$8(tag, definition.binding, isKvNamespace, makeClient$2(definition), { expected: expectedKvNamespace });
+const layer$2 = (tag, definition) => layer$10(tag, definition.binding, isKvNamespace, makeClient$2(definition), { expected: expectedKvNamespace });
 const makeDefinition$1 = (id, definition) => {
 	const kvDefinition = {
 		id,
@@ -2069,7 +2417,7 @@ const makeClient$1 = (definition) => {
 		};
 	};
 };
-const layer$1 = (tag, definition) => layer$8(tag, definition.binding, isR2Bucket, makeClient$1(definition), { expected: expectedR2Bucket });
+const layer$1 = (tag, definition) => layer$10(tag, definition.binding, isR2Bucket, makeClient$1(definition), { expected: expectedR2Bucket });
 const make$2 = (id) => Tag$2()(id);
 const Tag$2 = () => (id) => {
 	const tag = Context.Service()(id);
@@ -2155,7 +2503,7 @@ const makeClient = (definition) => {
 		unsafeRaw: Effect.succeed(workflow)
 	});
 };
-const layer = (tag, definition) => layer$8(tag, definition.binding, (value) => isWorkflow(value), makeClient(definition), { expected: expectedWorkflow });
+const layer = (tag, definition) => layer$10(tag, definition.binding, (value) => isWorkflow(value), makeClient(definition), { expected: expectedWorkflow });
 //#endregion
 //#region src/WorkflowDefinition.ts
 var WorkflowDefinition_exports = /* @__PURE__ */ __exportAll({
@@ -2176,7 +2524,7 @@ const make$1 = (id, definition) => Tag$1()(id, definition);
 const Tag$1 = () => (id, definition) => {
 	const workflowDefinition = makeDefinition(id, definition);
 	const tag = Context.Service()(id);
-	const layer$9 = (binding) => layer(tag, {
+	const layer$11 = (binding) => layer(tag, {
 		...binding,
 		payload: definition.payload,
 		result: definition.result
@@ -2198,7 +2546,7 @@ const Tag$1 = () => (id, definition) => {
 		payload: workflowDefinition.payload,
 		result: workflowDefinition.result,
 		make: workflowDefinition.make,
-		layer: layer$9,
+		layer: layer$11,
 		create,
 		createBatch,
 		get,
@@ -2289,4 +2637,4 @@ const waitForEvent = (name, options) => Effect.flatMap(WorkflowStep$1, (workflow
 const Tag = Tag$1;
 const implement = implement$1;
 //#endregion
-export { Binding_exports as Binding, D1_exports as D1, DurableObject_exports as DurableObject, DurableObjectAlarm_exports as DurableObjectAlarm, DurableObjectDefinition_exports as DurableObjectDefinition, DurableObjectNamespace_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_exports as DurableObjectRpcWebSocket, DurableObjectState_exports as DurableObjectState, DurableObjectStorage_exports as DurableObjectStorage, DurableObjectWebSocket_exports as DurableObjectWebSocket, Hyperdrive_exports as Hyperdrive, Images_exports as Images, Kv_exports as Kv, Queue_exports as Queue, QueueBinding_exports as QueueBinding, QueueDefinition_exports as QueueDefinition, R2_exports as R2, Rpc_exports as Rpc, RpcDefinition_exports as RpcDefinition, ServiceBinding_exports as ServiceBinding, Worker_exports as Worker, WorkerConfig, WorkerDefinition_exports as WorkerDefinition, WorkerEnvironment, Workflow_exports as Workflow, WorkflowBinding_exports as WorkflowBinding, WorkflowDefinition_exports as WorkflowDefinition };
+export { Binding_exports as Binding, CloudflareOtlp_exports as CloudflareOtlp, D1_exports as D1, DurableObject_exports as DurableObject, DurableObjectAlarm_exports as DurableObjectAlarm, DurableObjectDefinition_exports as DurableObjectDefinition, DurableObjectNamespace_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_exports as DurableObjectSqlite, DurableObjectState_exports as DurableObjectState, DurableObjectStorage_exports as DurableObjectStorage, DurableObjectWebSocket_exports as DurableObjectWebSocket, Hyperdrive_exports as Hyperdrive, Images_exports as Images, Kv_exports as Kv, Queue_exports as Queue, QueueBinding_exports as QueueBinding, QueueDefinition_exports as QueueDefinition, R2_exports as R2, Rpc_exports as Rpc, RpcDefinition_exports as RpcDefinition, ServiceBinding_exports as ServiceBinding, Worker_exports as Worker, WorkerConfig, WorkerDefinition_exports as WorkerDefinition, WorkerEnvironment, Workflow_exports as Workflow, WorkflowBinding_exports as WorkflowBinding, WorkflowDefinition_exports as WorkflowDefinition };