effect-cf 0.11.0 → 0.13.0

package/dist/index.mjs

@@ -1,13 +1,576 @@
 import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
-import { a as WorkerConfig, i as layer$9, 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 { 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 { D1Client } from "@effect/sql-d1";
 import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, WorkflowEntrypoint } from "cloudflare:workers";
-import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
 import * as RpcServer from "effect/unstable/rpc/RpcServer";
 import { SqliteClient } from "@effect/sql-sqlite-do";
+//#region src/DurableObjectStorage.ts
+var DurableObjectStorage_exports = /* @__PURE__ */ __exportAll({
+	StorageOperationError: () => StorageOperationError,
+	fromDurableObjectStorage: () => fromDurableObjectStorage
+});
+/** Error type used when a storage operation throws or rejects. */
+var StorageOperationError = class extends Data.TaggedError("StorageOperationError") {};
+const storageError = (operation, cause) => new StorageOperationError({
+	operation,
+	cause
+});
+const tryStorageSync = (operation, evaluate) => Effect.try({
+	try: evaluate,
+	catch: (cause) => storageError(operation, cause)
+});
+const tryStoragePromise = (operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => storageError(operation, cause)
+});
+const fromSqlCursor = (cursor) => ({
+	next: () => tryStorageSync("sql.next", () => cursor.next()),
+	toArray: () => tryStorageSync("sql.toArray", () => cursor.toArray()),
+	one: () => tryStorageSync("sql.one", () => cursor.one()),
+	raw: () => tryStorageSync("sql.raw", () => cursor.raw()),
+	get columnNames() {
+		return cursor.columnNames;
+	},
+	rowsRead: tryStorageSync("sql.rowsRead", () => cursor.rowsRead),
+	rowsWritten: tryStorageSync("sql.rowsWritten", () => cursor.rowsWritten)
+});
+const fromSqlStorage = (sql) => ({
+	exec: (query, ...bindings) => tryStorageSync("sql.exec", () => fromSqlCursor(sql.exec(query, ...bindings))),
+	get databaseSize() {
+		return sql.databaseSize;
+	}
+});
+const schemaBackedSyncKvStorage = (kv, definition) => {
+	const encodeKey = Schema.encodeEffect(definition.key);
+	const decodeKey = Schema.decodeUnknownEffect(definition.key);
+	const encodeValue = Schema.encodeEffect(definition.value);
+	const decodeValue = Schema.decodeUnknownEffect(definition.value);
+	return {
+		get: (key) => Effect.gen(function* () {
+			const encodedKey = yield* encodeKey(key);
+			const encodedValue = yield* tryStorageSync("kv.get", () => kv.get(encodedKey));
+			if (encodedValue === void 0) return Option.none();
+			return yield* decodeValue(encodedValue).pipe(Effect.map(Option.some));
+		}),
+		put: (key, value) => Effect.gen(function* () {
+			const encodedKey = yield* encodeKey(key);
+			const encodedValue = yield* encodeValue(value);
+			yield* tryStorageSync("kv.put", () => kv.put(encodedKey, encodedValue));
+		}),
+		delete: (key) => Effect.gen(function* () {
+			const encodedKey = yield* encodeKey(key);
+			return yield* tryStorageSync("kv.delete", () => kv.delete(encodedKey));
+		}),
+		list: (options) => Effect.gen(function* () {
+			const entries = Array.from(yield* tryStorageSync("kv.list", () => kv.list(options)));
+			const decoded = [];
+			for (const [key, value] of entries) decoded.push([yield* decodeKey(key), yield* decodeValue(value)]);
+			return decoded;
+		})
+	};
+};
+const fromSyncKvStorage = (kv) => ({
+	get: (key) => tryStorageSync("kv.get", () => kv.get(key)),
+	put: (key, value) => tryStorageSync("kv.put", () => kv.put(key, value)),
+	delete: (key) => tryStorageSync("kv.delete", () => kv.delete(key)),
+	list: (options) => tryStorageSync("kv.list", () => Array.from(kv.list(options))),
+	schema: (definition) => schemaBackedSyncKvStorage(kv, definition)
+});
+const fromDurableObjectTransaction = (txn) => ({
+	get: (keyOrKeys, options) => Array.isArray(keyOrKeys) ? tryStoragePromise("transaction.get", () => txn.get(keyOrKeys, options)) : tryStoragePromise("transaction.get", () => txn.get(keyOrKeys, options)),
+	list: (options) => tryStoragePromise("transaction.list", () => txn.list(options)),
+	put: (keyOrEntries, valueOrOptions, maybeOptions) => tryStoragePromise("transaction.put", () => typeof keyOrEntries === "string" ? txn.put(keyOrEntries, valueOrOptions, maybeOptions) : txn.put(keyOrEntries, valueOrOptions)),
+	delete: (keyOrKeys, options) => Array.isArray(keyOrKeys) ? tryStoragePromise("transaction.delete", () => txn.delete(keyOrKeys, options)) : tryStoragePromise("transaction.delete", () => txn.delete(keyOrKeys, options)),
+	rollback: () => tryStorageSync("transaction.rollback", () => txn.rollback()),
+	getAlarm: (options) => tryStoragePromise("transaction.getAlarm", () => txn.getAlarm(options)),
+	setAlarm: (scheduledTime, options) => tryStoragePromise("transaction.setAlarm", () => txn.setAlarm(scheduledTime, options)),
+	deleteAlarm: (options) => tryStoragePromise("transaction.deleteAlarm", () => txn.deleteAlarm(options))
+});
+/**
+* Wraps native Cloudflare storage APIs as Effect-returning helpers.
+*/
+const fromDurableObjectStorage = (storage) => ({
+	get: (key, options) => tryStoragePromise("get", () => storage.get(key, options)),
+	put: (key, value, options) => tryStoragePromise("put", () => storage.put(key, value, options)),
+	delete: (key, options) => tryStoragePromise("delete", () => storage.delete(key, options)),
+	deleteAll: (options) => tryStoragePromise("deleteAll", () => storage.deleteAll(options)),
+	getAlarm: (options) => tryStoragePromise("getAlarm", () => storage.getAlarm(options)),
+	setAlarm: (scheduledTime, options) => tryStoragePromise("setAlarm", () => storage.setAlarm(scheduledTime, options)),
+	deleteAlarm: (options) => tryStoragePromise("deleteAlarm", () => storage.deleteAlarm(options)),
+	transactionSync: (closure) => Effect.context().pipe(Effect.flatMap((context) => Effect.suspend(() => {
+		try {
+			return Effect.succeed(storage.transactionSync(() => {
+				const exit = Effect.runSyncExitWith(context)(closure());
+				if (Exit.isSuccess(exit)) return exit.value;
+				throw exit;
+			}));
+		} catch (cause) {
+			if (Exit.isExit(cause) && Exit.isFailure(cause)) return Effect.failCause(cause.cause);
+			return Effect.fail(storageError("transactionSync", cause));
+		}
+	}))),
+	transaction: (closure) => Effect.context().pipe(Effect.flatMap((context) => Effect.callback((resume) => {
+		storage.transaction(async (txn) => {
+			const exit = await Effect.runPromiseExitWith(context)(closure(fromDurableObjectTransaction(txn)));
+			if (Exit.isSuccess(exit)) return exit.value;
+			throw exit;
+		}).then((value) => resume(Effect.succeed(value)), (cause) => {
+			if (Exit.isExit(cause) && Exit.isFailure(cause)) resume(Effect.failCause(cause.cause));
+			else resume(Effect.fail(storageError("transaction", cause)));
+		});
+	}))),
+	sync: () => tryStoragePromise("sync", () => storage.sync()),
+	getCurrentBookmark: () => tryStoragePromise("getCurrentBookmark", () => storage.getCurrentBookmark()),
+	onNextSessionRestoreBookmark: (bookmark) => tryStoragePromise("onNextSessionRestoreBookmark", () => storage.onNextSessionRestoreBookmark(bookmark)),
+	sql: fromSqlStorage(storage.sql),
+	kv: fromSyncKvStorage(storage.kv)
+});
+//#endregion
+//#region src/DurableObjectWebSocket.ts
+var DurableObjectWebSocket_exports = /* @__PURE__ */ __exportAll({
+	DurableWebSocketAttachmentError: () => DurableWebSocketAttachmentError,
+	DurableWebSocketCloseError: () => DurableWebSocketCloseError,
+	DurableWebSocketSendError: () => DurableWebSocketSendError,
+	acceptUpgrade: () => acceptUpgrade,
+	attachment: () => attachment,
+	fromWebSocket: () => fromWebSocket,
+	handlers: () => handlers
+});
+/** Error raised when sending on a Durable Object websocket fails. */
+var DurableWebSocketSendError = class extends Data.TaggedError("DurableWebSocketSendError") {};
+/** Error raised when closing a Durable Object websocket fails. */
+var DurableWebSocketCloseError = class extends Data.TaggedError("DurableWebSocketCloseError") {};
+/** Error raised when serializing or deserializing a websocket attachment fails. */
+var DurableWebSocketAttachmentError = class extends Data.TaggedError("DurableWebSocketAttachmentError") {};
+const wrappers = /* @__PURE__ */ new WeakMap();
+/** Wraps a native Cloudflare websocket in the Effect-native Durable Object API. */
+const fromWebSocket = (raw) => {
+	const existing = wrappers.get(raw);
+	if (existing !== void 0) return existing;
+	const socket = {
+		raw,
+		send: (data) => Effect.try({
+			try: () => raw.send(data),
+			catch: (cause) => new DurableWebSocketSendError({ cause })
+		}),
+		close: (code, reason) => Effect.try({
+			try: () => raw.close(code, reason),
+			catch: (cause) => new DurableWebSocketCloseError({ cause })
+		}),
+		serializeAttachment: (value) => Effect.try({
+			try: () => raw.serializeAttachment(value),
+			catch: (cause) => new DurableWebSocketAttachmentError({
+				operation: "serialize",
+				cause
+			})
+		}),
+		deserializeAttachment: Effect.try({
+			try: () => raw.deserializeAttachment(),
+			catch: (cause) => new DurableWebSocketAttachmentError({
+				operation: "deserialize",
+				cause
+			})
+		})
+	};
+	wrappers.set(raw, socket);
+	return socket;
+};
+/**
+* Accepts a websocket upgrade and registers the server socket on `DurableObjectState`.
+*
+* @example
+* ```ts
+* const response = yield* DurableObjectWebSocket.acceptUpgrade({
+*   tags: ["room:general"],
+* });
+*
+* return response.response;
+* ```
+*/
+const acceptUpgrade = (options = {}) => Effect.gen(function* () {
+	const state = yield* DurableObjectState;
+	const pair = new WebSocketPair();
+	const client = pair[0];
+	const server = fromWebSocket(pair[1]);
+	if (options.attachment !== void 0) server.raw.serializeAttachment(options.attachment);
+	yield* state.acceptWebSocket(server, options.tags === void 0 ? void 0 : [...options.tags]);
+	return {
+		client,
+		server,
+		response: new Response(null, {
+			status: 101,
+			webSocket: client
+		})
+	};
+});
+/** Creates typed attachment helpers for accepted and rehydrated sockets. */
+const attachment = (schema) => {
+	const serialize = (socket, value) => Schema.encodeEffect(schema)(value).pipe(Effect.mapError((cause) => new DurableWebSocketAttachmentError({
+		operation: "serialize",
+		cause
+	})), Effect.flatMap((encoded) => socket.serializeAttachment(encoded)));
+	const deserialize = (socket) => Effect.gen(function* () {
+		const value = yield* socket.deserializeAttachment;
+		if (value == null) return Option.none();
+		return Option.some(yield* Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError((cause) => new DurableWebSocketAttachmentError({
+			operation: "deserialize",
+			cause
+		}))));
+	});
+	const rehydrate = (options = {}) => Effect.gen(function* () {
+		const sockets = yield* (yield* DurableObjectState).getWebSockets(options.tag);
+		const restored = [];
+		const onInvalid = options.onInvalid ?? "ignore";
+		for (const socket of sockets) {
+			const decoded = yield* deserialize(socket).pipe(Effect.match({
+				onFailure: (error) => ({
+					_tag: "Failure",
+					error
+				}),
+				onSuccess: (value) => ({
+					_tag: "Success",
+					value
+				})
+			}));
+			if (decoded._tag === "Success" && Option.isSome(decoded.value)) {
+				restored.push({
+					socket,
+					attachment: decoded.value.value
+				});
+				continue;
+			}
+			if (decoded._tag === "Failure" && onInvalid === "fail") return yield* Effect.fail(decoded.error);
+			if (decoded._tag === "Failure" && onInvalid === "ignore-and-close") yield* socket.close(1008, "invalid websocket attachment").pipe(Effect.ignore);
+		}
+		return restored;
+	});
+	return {
+		serialize,
+		deserialize,
+		rehydrate,
+		schema
+	};
+};
+/** Maps compact websocket lifecycle handler names to `DurableObject.make` options. */
+const handlers = (options) => ({
+	webSocketMessage: options.message,
+	webSocketClose: options.close,
+	webSocketError: options.error
+});
+//#endregion
+//#region src/DurableObjectState.ts
+var DurableObjectState_exports = /* @__PURE__ */ __exportAll({
+	DurableObjectState: () => DurableObjectState,
+	fromDurableObjectState: () => fromDurableObjectState
+});
+/**
+* Context tag for accessing the current Durable Object state service.
+*/
+var DurableObjectState = class extends Context.Service()("effect-cf/DurableObjectState") {};
+/**
+* Wraps a native Cloudflare `DurableObjectState` as a {@link DurableObjectStateService}.
+*/
+const fromDurableObjectState = (state) => ({
+	raw: state,
+	id: state.id,
+	storage: fromDurableObjectStorage(state.storage),
+	waitUntil: (promise) => Effect.sync(() => state.waitUntil(promise)),
+	blockConcurrencyWhile: (effect) => Effect.context().pipe(Effect.flatMap((context) => Effect.promise(() => state.blockConcurrencyWhile(() => runPromiseExitPreservingTypedFailures(Effect.provideContext(effect, context))))), Effect.flatten),
+	blockConcurrencyWhileOrReset: (effect) => Effect.context().pipe(Effect.flatMap((context) => Effect.promise(() => state.blockConcurrencyWhile(() => Effect.runPromise(Effect.provideContext(effect, context)))))),
+	acceptWebSocket: (ws, tags) => Effect.sync(() => state.acceptWebSocket(ws.raw, tags)),
+	getWebSockets: (tag) => Effect.sync(() => state.getWebSockets(tag).map((socket) => fromWebSocket(socket))),
+	setWebSocketAutoResponse: (pair) => Effect.sync(() => state.setWebSocketAutoResponse(pair)),
+	getWebSocketAutoResponse: Effect.sync(() => state.getWebSocketAutoResponse()),
+	getWebSocketAutoResponseTimestamp: (ws) => Effect.sync(() => state.getWebSocketAutoResponseTimestamp(ws.raw)),
+	setHibernatableWebSocketEventTimeout: (timeoutMs) => Effect.sync(() => state.setHibernatableWebSocketEventTimeout(timeoutMs)),
+	getHibernatableWebSocketEventTimeout: Effect.sync(() => state.getHibernatableWebSocketEventTimeout()),
+	getTags: (ws) => Effect.sync(() => state.getTags(ws.raw)),
+	abort: (reason) => Effect.sync(() => state.abort(reason))
+});
+const runPromiseExitPreservingTypedFailures = async (effect) => {
+	const exit = await Effect.runPromiseExit(effect);
+	if (Exit.isFailure(exit) && (Cause.hasDies(exit.cause) || Cause.hasInterrupts(exit.cause))) throw Cause.squash(exit.cause);
+	return exit;
+};
+//#endregion
+//#region src/CloudflareOtlp.ts
+var CloudflareOtlp_exports = /* @__PURE__ */ __exportAll({
+	CloudflareOtlpSettings: () => CloudflareOtlpSettings,
+	durableObjectLayer: () => durableObjectLayer,
+	layer: () => layer$9,
+	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$9 = (options = {}) => makeLayer(options);
+/** Base OTLP telemetry layer forced to JSON serialization. */
+const layerJson = (options = {}) => layer$9({
+	...options,
+	serialization: "json"
+});
+/** Base OTLP telemetry layer forced to protobuf serialization. */
+const layerProtobuf = (options = {}) => layer$9({
+	...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
+})));
+//#endregion
 //#region src/D1.ts
 var D1_exports = /* @__PURE__ */ __exportAll({
 	Service: () => Service$1,
@@ -115,7 +678,7 @@ const makeClient$6 = (definition) => {
 		unsafeRaw: Effect.succeed(queue)
 	});
 };
-const layer$8 = (tag, definition) => layer$9(tag, definition.binding, (value) => isQueue(value), makeClient$6(definition), { expected: expectedQueueProducer });
+const layer$8 = (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({
@@ -458,7 +1021,7 @@ const makeClient$5 = (definition) => {
 		});
 	};
 };
-const layer$7 = (tag, definition) => layer$9(tag, definition.binding, (value) => isServiceBindingClient(value), makeClient$5(definition), { expected: expectedServiceBinding });
+const layer$7 = (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.
 *
@@ -501,175 +1064,32 @@ const Service = () => (id, definition) => {
 	});
 	const scopedCall = (method, ...args) => Effect.gen(function* () {
 		return yield* (yield* tag).scopedCall(method, ...args);
-	});
-	const directMethods = makeDirectMethods$1(definition.definition, call);
-	return Object.assign(tag, directMethods, {
-		[TypeId$1]: TypeId$1,
-		definition,
-		fetch,
-		rpc,
-		call,
-		scopedCall
-	});
-};
-const makeDirectMethods$1 = (rpcDefinition, call) => {
-	const methods = {};
-	if (rpcDefinition !== void 0) for (const methodName of Object.keys(rpcDefinition.methods)) methods[methodName] = (...args) => call(methodName, ...args);
-	return methods;
-};
-//#endregion
-//#region src/WorkerDefinition.ts
-var WorkerDefinition_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$8,
-	Worker: () => Worker,
-	implement: () => implement$5,
-	make: () => make$7,
-	method: () => method$3
-});
-const reservedMethodNames$3 = new Set([
-	"constructor",
-	"dup",
-	"fetch",
-	"connect",
-	"queue",
-	"scheduled",
-	"tail",
-	"tailStream",
-	"test",
-	"trace",
-	"alarm",
-	"webSocketMessage",
-	"webSocketClose",
-	"webSocketError"
-]);
-/**
-* Defines a single RPC method schema in a worker definition.
-*/
-const method$3 = method$4;
-/**
-* Creates a typed worker RPC definition plus helpers for implementation and bindings.
-*
-* @example
-* ```ts
-* const CounterWorker = WorkerDefinition.make("CounterWorker", {
-*   increment: WorkerDefinition.method({
-*     args: [Schema.Number],
-*     success: Schema.Number,
-*   }),
-* });
-* ```
-*/
-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, {
-		...options,
-		rpc: wrapHandlers$1(definition, options.rpc)
-	}) });
-};
-const make$7 = (id, methods) => Tag$8()(id, methods);
-const Tag$8 = () => (id, methods) => {
-	const definition = makeDefinition$3(id, methods);
-	const tag = Context.Service()(id);
-	const bindingDefinition = (binding) => ({
-		...binding,
-		definition
-	});
-	const layer = (binding) => layer$7(tag, bindingDefinition(binding));
-	const fetch = (input, init) => Effect.gen(function* () {
-		return yield* (yield* tag).fetch(input, init);
-	});
-	const rpc = (method, ...args) => Effect.gen(function* () {
-		return yield* (yield* tag).rpc(method, ...args);
-	});
-	const call = (method, ...args) => Effect.gen(function* () {
-		return yield* (yield* tag).call(method, ...args);
-	});
-	const scopedCall = (method, ...args) => Effect.gen(function* () {
-		return yield* (yield* tag).scopedCall(method, ...args);
-	});
-	const directMethods = makeDirectMethods$1(definition, call);
-	return Object.assign(tag, directMethods, {
-		id: definition.id,
-		methods: definition.methods,
-		make: definition.make,
-		layer,
-		fetch,
-		rpc,
-		call,
-		scopedCall
-	});
-};
-const Worker = Tag$8;
-const wrapHandlers$1 = (definition, handlers) => {
-	const wrapped = {};
-	for (const key of Object.keys(definition.methods)) {
-		const handler = handlers[key];
-		wrapped[key] = (...args) => Effect.gen(function* () {
-			return yield* encodeSuccess(definition, key, yield* handler(...yield* decodeArgs(definition, key, args)));
-		});
-	}
-	return wrapped;
-};
-/**
-* Helper for implementing handlers with the exact method shape of a definition.
-*/
-const implement$5 = (_definition, handlers) => handlers;
-//#endregion
-//#region src/internal/Entrypoint.ts
-const provideEntrypointServices = (layer, services) => layer.pipe(Layer.provideMerge(services));
-const defineEntrypointRpcMethods = (target, prototype, rpc, reservedMethodNames, run) => {
-	const methods = rpc ?? {};
-	assertNoReservedMethods(target, methods, reservedMethodNames);
-	for (const [key, method] of Object.entries(methods)) Object.defineProperty(prototype, key, {
-		enumerable: true,
-		value(...args) {
-			return run(this, Effect.suspend(() => method(...args)));
-		}
-	});
-};
-const assumeEntrypointClass = (entrypoint) => entrypoint;
-//#endregion
-//#region src/internal/WorkerContext.ts
-const causeError = (cause) => new Error(Cause.pretty(cause));
-const failureHandler = (cause, options) => (options?.onFailure?.(cause) ?? Effect.logError("WorkerContext.waitUntil failed", Cause.pretty(cause))).pipe(Effect.catchCause((handlerCause) => Effect.logError("WorkerContext.waitUntil failure handler failed", Cause.pretty(cause), Cause.pretty(handlerCause))));
-const fromExecutionContext = (ctx, runPromiseExit) => {
-	const schedule = (effect, options, mode) => Effect.context().pipe(Effect.flatMap((context) => Effect.sync(() => {
-		const runHandler = (cause) => runPromiseExit(Effect.scoped(Effect.provideContext(failureHandler(cause, options), context))).then((exit) => {
-			if (Exit.isFailure(exit)) console.error("WorkerContext.waitUntil failure handler failed", Cause.pretty(exit.cause));
-		});
-		ctx.waitUntil(runPromiseExit(Effect.scoped(Effect.provideContext(effect, context))).then(async (exit) => {
-			if (Exit.isSuccess(exit)) return;
-			await runHandler(exit.cause);
-			if (mode === "propagate") throw causeError(exit.cause);
-		}));
-	})));
-	return {
-		raw: ctx,
-		waitUntil: (effect, options) => schedule(effect, options, options?.mode ?? "observe"),
-		waitUntilPropagating: (effect, options) => schedule(effect, options, "propagate"),
-		passThroughOnException: Effect.sync(() => ctx.passThroughOnException())
-	};
+	});
+	const directMethods = makeDirectMethods$1(definition.definition, call);
+	return Object.assign(tag, directMethods, {
+		[TypeId$1]: TypeId$1,
+		definition,
+		fetch,
+		rpc,
+		call,
+		scopedCall
+	});
+};
+const makeDirectMethods$1 = (rpcDefinition, call) => {
+	const methods = {};
+	if (rpcDefinition !== void 0) for (const methodName of Object.keys(rpcDefinition.methods)) methods[methodName] = (...args) => call(methodName, ...args);
+	return methods;
 };
 //#endregion
-//#region src/Worker.ts
-var Worker_exports = /* @__PURE__ */ __exportAll({
-	ExecutionContext: () => ExecutionContext,
-	NativeRequest: () => NativeRequest,
-	Tag: () => Tag$7,
-	WorkerContext: () => WorkerContext,
-	implement: () => implement$4,
-	isWebSocketUpgrade: () => isWebSocketUpgrade,
-	make: () => make$6,
-	makeFetchHandler: () => makeFetchHandler,
-	method: () => method$2,
-	renderHttpResponse: () => renderHttpResponse
+//#region src/WorkerDefinition.ts
+var WorkerDefinition_exports = /* @__PURE__ */ __exportAll({
+	Tag: () => Tag$8,
+	Worker: () => Worker,
+	implement: () => implement$5,
+	make: () => make$7,
+	method: () => method$3
 });
-var ExecutionContext = class extends Context.Service()("effect-cf/ExecutionContext") {};
-var WorkerContext = class extends Context.Service()("effect-cf/WorkerContext") {};
-var NativeRequest = class extends Context.Service()("effect-cf/NativeRequest") {};
-const isWebSocketUpgrade = (request) => request.headers.get("Upgrade")?.toLowerCase() === "websocket";
-const reservedMethodNames$2 = new Set([
+const reservedMethodNames$3 = new Set([
 	"constructor",
 	"dup",
 	"fetch",
@@ -685,336 +1105,191 @@ const reservedMethodNames$2 = new Set([
 	"webSocketClose",
 	"webSocketError"
 ]);
-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) {
-	const options = isWorkerOptions(optionsOrFetch) ? optionsOrFetch : { fetch: optionsOrFetch };
-	class EffectWorker extends WorkerEntrypoint {
-		runtime;
-		constructor(ctx, env) {
-			super(ctx, env);
-			let runWaitUntilEffect = () => Promise.reject(/* @__PURE__ */ new Error("WorkerContext runtime is not initialized"));
-			const runtimeLayer = provideEntrypointServices(layer, Layer.mergeAll(Layer.succeed(ExecutionContext, ctx), ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env))), Layer.succeed(WorkerContext, fromExecutionContext(ctx, (effect) => runWaitUntilEffect(effect))), Layer.succeed(WorkerEnvironment, env)));
-			this.runtime = ManagedRuntime.make(runtimeLayer);
-			runWaitUntilEffect = (effect) => this.runtime.runPromiseExit(effect);
-		}
-		[RunSymbol$1](effect) {
-			return this.runtime.runPromise(Effect.scoped(effect));
-		}
-		fetch(request) {
-			const fetchHandler = options.fetch;
-			if (fetchHandler === void 0) return Promise.resolve(new Response("Not Found", { status: 404 }));
-			const requestServices = Layer.mergeAll(Layer.succeed(NativeRequest, request), Layer.succeed(HttpServerRequest.HttpServerRequest, HttpServerRequest.fromWeb(request)));
-			return this[RunSymbol$1](renderFetchSuccess(fetchHandler).pipe(Effect.provide(requestServices)));
-		}
-		queue(batch) {
-			const queueHandler = options.queue;
-			if (queueHandler === void 0) return Promise.resolve();
-			const messages = batch.messages.map((message) => fromMessage(message, message.body));
-			return this[RunSymbol$1](queueHandler(fromMessageBatch(batch, messages)));
-		}
-	}
-	defineEntrypointRpcMethods("Worker", EffectWorker.prototype, options.rpc, reservedMethodNames$2, (self, effect) => self[RunSymbol$1](effect));
-	return assumeEntrypointClass(EffectWorker);
-}
-const makeFetchHandler = (layer, options) => {
-	const WorkerClass = make$6(layer, options);
-	return { fetch: (request, env, ctx) => Promise.resolve(new WorkerClass(ctx, env).fetch(request)) };
-};
-const Tag$7 = Tag$8;
-const method$2 = method$3;
-const implement$4 = implement$5;
-//#endregion
-//#region src/DurableObjectStorage.ts
-var DurableObjectStorage_exports = /* @__PURE__ */ __exportAll({
-	StorageOperationError: () => StorageOperationError,
-	fromDurableObjectStorage: () => fromDurableObjectStorage
-});
-/** Error type used when a storage operation throws or rejects. */
-var StorageOperationError = class extends Data.TaggedError("StorageOperationError") {};
-const storageError = (operation, cause) => new StorageOperationError({
-	operation,
-	cause
-});
-const tryStorageSync = (operation, evaluate) => Effect.try({
-	try: evaluate,
-	catch: (cause) => storageError(operation, cause)
-});
-const tryStoragePromise = (operation, evaluate) => Effect.tryPromise({
-	try: evaluate,
-	catch: (cause) => storageError(operation, cause)
-});
-const fromSqlCursor = (cursor) => ({
-	next: () => tryStorageSync("sql.next", () => cursor.next()),
-	toArray: () => tryStorageSync("sql.toArray", () => cursor.toArray()),
-	one: () => tryStorageSync("sql.one", () => cursor.one()),
-	raw: () => tryStorageSync("sql.raw", () => cursor.raw()),
-	get columnNames() {
-		return cursor.columnNames;
-	},
-	rowsRead: tryStorageSync("sql.rowsRead", () => cursor.rowsRead),
-	rowsWritten: tryStorageSync("sql.rowsWritten", () => cursor.rowsWritten)
-});
-const fromSqlStorage = (sql) => ({
-	exec: (query, ...bindings) => tryStorageSync("sql.exec", () => fromSqlCursor(sql.exec(query, ...bindings))),
-	get databaseSize() {
-		return sql.databaseSize;
-	}
-});
-const schemaBackedSyncKvStorage = (kv, definition) => {
-	const encodeKey = Schema.encodeEffect(definition.key);
-	const decodeKey = Schema.decodeUnknownEffect(definition.key);
-	const encodeValue = Schema.encodeEffect(definition.value);
-	const decodeValue = Schema.decodeUnknownEffect(definition.value);
-	return {
-		get: (key) => Effect.gen(function* () {
-			const encodedKey = yield* encodeKey(key);
-			const encodedValue = yield* tryStorageSync("kv.get", () => kv.get(encodedKey));
-			if (encodedValue === void 0) return Option.none();
-			return yield* decodeValue(encodedValue).pipe(Effect.map(Option.some));
-		}),
-		put: (key, value) => Effect.gen(function* () {
-			const encodedKey = yield* encodeKey(key);
-			const encodedValue = yield* encodeValue(value);
-			yield* tryStorageSync("kv.put", () => kv.put(encodedKey, encodedValue));
-		}),
-		delete: (key) => Effect.gen(function* () {
-			const encodedKey = yield* encodeKey(key);
-			return yield* tryStorageSync("kv.delete", () => kv.delete(encodedKey));
-		}),
-		list: (options) => Effect.gen(function* () {
-			const entries = Array.from(yield* tryStorageSync("kv.list", () => kv.list(options)));
-			const decoded = [];
-			for (const [key, value] of entries) decoded.push([yield* decodeKey(key), yield* decodeValue(value)]);
-			return decoded;
-		})
-	};
-};
-const fromSyncKvStorage = (kv) => ({
-	get: (key) => tryStorageSync("kv.get", () => kv.get(key)),
-	put: (key, value) => tryStorageSync("kv.put", () => kv.put(key, value)),
-	delete: (key) => tryStorageSync("kv.delete", () => kv.delete(key)),
-	list: (options) => tryStorageSync("kv.list", () => Array.from(kv.list(options))),
-	schema: (definition) => schemaBackedSyncKvStorage(kv, definition)
-});
-const fromDurableObjectTransaction = (txn) => ({
-	get: (keyOrKeys, options) => Array.isArray(keyOrKeys) ? tryStoragePromise("transaction.get", () => txn.get(keyOrKeys, options)) : tryStoragePromise("transaction.get", () => txn.get(keyOrKeys, options)),
-	list: (options) => tryStoragePromise("transaction.list", () => txn.list(options)),
-	put: (keyOrEntries, valueOrOptions, maybeOptions) => tryStoragePromise("transaction.put", () => typeof keyOrEntries === "string" ? txn.put(keyOrEntries, valueOrOptions, maybeOptions) : txn.put(keyOrEntries, valueOrOptions)),
-	delete: (keyOrKeys, options) => Array.isArray(keyOrKeys) ? tryStoragePromise("transaction.delete", () => txn.delete(keyOrKeys, options)) : tryStoragePromise("transaction.delete", () => txn.delete(keyOrKeys, options)),
-	rollback: () => tryStorageSync("transaction.rollback", () => txn.rollback()),
-	getAlarm: (options) => tryStoragePromise("transaction.getAlarm", () => txn.getAlarm(options)),
-	setAlarm: (scheduledTime, options) => tryStoragePromise("transaction.setAlarm", () => txn.setAlarm(scheduledTime, options)),
-	deleteAlarm: (options) => tryStoragePromise("transaction.deleteAlarm", () => txn.deleteAlarm(options))
-});
 /**
-* Wraps native Cloudflare storage APIs as Effect-returning helpers.
+* Defines a single RPC method schema in a worker definition.
 */
-const fromDurableObjectStorage = (storage) => ({
-	get: (key, options) => tryStoragePromise("get", () => storage.get(key, options)),
-	put: (key, value, options) => tryStoragePromise("put", () => storage.put(key, value, options)),
-	delete: (key, options) => tryStoragePromise("delete", () => storage.delete(key, options)),
-	deleteAll: (options) => tryStoragePromise("deleteAll", () => storage.deleteAll(options)),
-	getAlarm: (options) => tryStoragePromise("getAlarm", () => storage.getAlarm(options)),
-	setAlarm: (scheduledTime, options) => tryStoragePromise("setAlarm", () => storage.setAlarm(scheduledTime, options)),
-	deleteAlarm: (options) => tryStoragePromise("deleteAlarm", () => storage.deleteAlarm(options)),
-	transactionSync: (closure) => Effect.context().pipe(Effect.flatMap((context) => Effect.suspend(() => {
-		try {
-			return Effect.succeed(storage.transactionSync(() => {
-				const exit = Effect.runSyncExitWith(context)(closure());
-				if (Exit.isSuccess(exit)) return exit.value;
-				throw exit;
-			}));
-		} catch (cause) {
-			if (Exit.isExit(cause) && Exit.isFailure(cause)) return Effect.failCause(cause.cause);
-			return Effect.fail(storageError("transactionSync", cause));
-		}
-	}))),
-	transaction: (closure) => Effect.context().pipe(Effect.flatMap((context) => Effect.callback((resume) => {
-		storage.transaction(async (txn) => {
-			const exit = await Effect.runPromiseExitWith(context)(closure(fromDurableObjectTransaction(txn)));
-			if (Exit.isSuccess(exit)) return exit.value;
-			throw exit;
-		}).then((value) => resume(Effect.succeed(value)), (cause) => {
-			if (Exit.isExit(cause) && Exit.isFailure(cause)) resume(Effect.failCause(cause.cause));
-			else resume(Effect.fail(storageError("transaction", cause)));
-		});
-	}))),
-	sync: () => tryStoragePromise("sync", () => storage.sync()),
-	getCurrentBookmark: () => tryStoragePromise("getCurrentBookmark", () => storage.getCurrentBookmark()),
-	onNextSessionRestoreBookmark: (bookmark) => tryStoragePromise("onNextSessionRestoreBookmark", () => storage.onNextSessionRestoreBookmark(bookmark)),
-	sql: fromSqlStorage(storage.sql),
-	kv: fromSyncKvStorage(storage.kv)
-});
-//#endregion
-//#region src/DurableObjectWebSocket.ts
-var DurableObjectWebSocket_exports = /* @__PURE__ */ __exportAll({
-	DurableWebSocketAttachmentError: () => DurableWebSocketAttachmentError,
-	DurableWebSocketCloseError: () => DurableWebSocketCloseError,
-	DurableWebSocketSendError: () => DurableWebSocketSendError,
-	acceptUpgrade: () => acceptUpgrade,
-	attachment: () => attachment,
-	fromWebSocket: () => fromWebSocket,
-	handlers: () => handlers
-});
-/** Error raised when sending on a Durable Object websocket fails. */
-var DurableWebSocketSendError = class extends Data.TaggedError("DurableWebSocketSendError") {};
-/** Error raised when closing a Durable Object websocket fails. */
-var DurableWebSocketCloseError = class extends Data.TaggedError("DurableWebSocketCloseError") {};
-/** Error raised when serializing or deserializing a websocket attachment fails. */
-var DurableWebSocketAttachmentError = class extends Data.TaggedError("DurableWebSocketAttachmentError") {};
-const wrappers = /* @__PURE__ */ new WeakMap();
-/** Wraps a native Cloudflare websocket in the Effect-native Durable Object API. */
-const fromWebSocket = (raw) => {
-	const existing = wrappers.get(raw);
-	if (existing !== void 0) return existing;
-	const socket = {
-		raw,
-		send: (data) => Effect.try({
-			try: () => raw.send(data),
-			catch: (cause) => new DurableWebSocketSendError({ cause })
-		}),
-		close: (code, reason) => Effect.try({
-			try: () => raw.close(code, reason),
-			catch: (cause) => new DurableWebSocketCloseError({ cause })
-		}),
-		serializeAttachment: (value) => Effect.try({
-			try: () => raw.serializeAttachment(value),
-			catch: (cause) => new DurableWebSocketAttachmentError({
-				operation: "serialize",
-				cause
-			})
-		}),
-		deserializeAttachment: Effect.try({
-			try: () => raw.deserializeAttachment(),
-			catch: (cause) => new DurableWebSocketAttachmentError({
-				operation: "deserialize",
-				cause
-			})
-		})
-	};
-	wrappers.set(raw, socket);
-	return socket;
-};
+const method$3 = method$4;
 /**
-* Accepts a websocket upgrade and registers the server socket on `DurableObjectState`.
+* Creates a typed worker RPC definition plus helpers for implementation and bindings.
 *
 * @example
 * ```ts
-* const response = yield* DurableObjectWebSocket.acceptUpgrade({
-*   tags: ["room:general"],
+* const CounterWorker = WorkerDefinition.make("CounterWorker", {
+*   increment: WorkerDefinition.method({
+*     args: [Schema.Number],
+*     success: Schema.Number,
+*   }),
 * });
-*
-* return response.response;
 * ```
 */
-const acceptUpgrade = (options = {}) => Effect.gen(function* () {
-	const state = yield* DurableObjectState;
-	const pair = new WebSocketPair();
-	const client = pair[0];
-	const server = fromWebSocket(pair[1]);
-	if (options.attachment !== void 0) server.raw.serializeAttachment(options.attachment);
-	yield* state.acceptWebSocket(server, options.tags === void 0 ? void 0 : [...options.tags]);
-	return {
-		client,
-		server,
-		response: new Response(null, {
-			status: 101,
-			webSocket: client
-		})
-	};
-});
-/** Creates typed attachment helpers for accepted and rehydrated sockets. */
-const attachment = (schema) => {
-	const serialize = (socket, value) => Schema.encodeEffect(schema)(value).pipe(Effect.mapError((cause) => new DurableWebSocketAttachmentError({
-		operation: "serialize",
-		cause
-	})), Effect.flatMap((encoded) => socket.serializeAttachment(encoded)));
-	const deserialize = (socket) => Effect.gen(function* () {
-		const value = yield* socket.deserializeAttachment;
-		if (value == null) return Option.none();
-		return Option.some(yield* Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError((cause) => new DurableWebSocketAttachmentError({
-			operation: "deserialize",
-			cause
-		}))));
+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, {
+		...options,
+		rpc: wrapHandlers$1(definition, options.rpc)
+	}) });
+};
+const make$7 = (id, methods) => Tag$8()(id, methods);
+const Tag$8 = () => (id, methods) => {
+	const definition = makeDefinition$3(id, methods);
+	const tag = Context.Service()(id);
+	const bindingDefinition = (binding) => ({
+		...binding,
+		definition
 	});
-	const rehydrate = (options = {}) => Effect.gen(function* () {
-		const sockets = yield* (yield* DurableObjectState).getWebSockets(options.tag);
-		const restored = [];
-		const onInvalid = options.onInvalid ?? "ignore";
-		for (const socket of sockets) {
-			const decoded = yield* deserialize(socket).pipe(Effect.match({
-				onFailure: (error) => ({
-					_tag: "Failure",
-					error
-				}),
-				onSuccess: (value) => ({
-					_tag: "Success",
-					value
-				})
-			}));
-			if (decoded._tag === "Success" && Option.isSome(decoded.value)) {
-				restored.push({
-					socket,
-					attachment: decoded.value.value
-				});
-				continue;
-			}
-			if (decoded._tag === "Failure" && onInvalid === "fail") return yield* Effect.fail(decoded.error);
-			if (decoded._tag === "Failure" && onInvalid === "ignore-and-close") yield* socket.close(1008, "invalid websocket attachment").pipe(Effect.ignore);
+	const layer = (binding) => layer$7(tag, bindingDefinition(binding));
+	const fetch = (input, init) => Effect.gen(function* () {
+		return yield* (yield* tag).fetch(input, init);
+	});
+	const rpc = (method, ...args) => Effect.gen(function* () {
+		return yield* (yield* tag).rpc(method, ...args);
+	});
+	const call = (method, ...args) => Effect.gen(function* () {
+		return yield* (yield* tag).call(method, ...args);
+	});
+	const scopedCall = (method, ...args) => Effect.gen(function* () {
+		return yield* (yield* tag).scopedCall(method, ...args);
+	});
+	const directMethods = makeDirectMethods$1(definition, call);
+	return Object.assign(tag, directMethods, {
+		id: definition.id,
+		methods: definition.methods,
+		make: definition.make,
+		layer,
+		fetch,
+		rpc,
+		call,
+		scopedCall
+	});
+};
+const Worker = Tag$8;
+const wrapHandlers$1 = (definition, handlers) => {
+	const wrapped = {};
+	for (const key of Object.keys(definition.methods)) {
+		const handler = handlers[key];
+		wrapped[key] = (...args) => Effect.gen(function* () {
+			return yield* encodeSuccess(definition, key, yield* handler(...yield* decodeArgs(definition, key, args)));
+		});
+	}
+	return wrapped;
+};
+/**
+* Helper for implementing handlers with the exact method shape of a definition.
+*/
+const implement$5 = (_definition, handlers) => handlers;
+//#endregion
+//#region src/internal/Entrypoint.ts
+const provideEntrypointServices = (layer, services) => layer.pipe(Layer.provideMerge(services));
+const defineEntrypointRpcMethods = (target, prototype, rpc, reservedMethodNames, run) => {
+	const methods = rpc ?? {};
+	assertNoReservedMethods(target, methods, reservedMethodNames);
+	for (const [key, method] of Object.entries(methods)) Object.defineProperty(prototype, key, {
+		enumerable: true,
+		value(...args) {
+			return run(this, Effect.suspend(() => method(...args)));
 		}
-		return restored;
 	});
+};
+const assumeEntrypointClass = (entrypoint) => entrypoint;
+//#endregion
+//#region src/internal/WorkerContext.ts
+const causeError = (cause) => new Error(Cause.pretty(cause));
+const failureHandler = (cause, options) => (options?.onFailure?.(cause) ?? Effect.logError("WorkerContext.waitUntil failed", Cause.pretty(cause))).pipe(Effect.catchCause((handlerCause) => Effect.logError("WorkerContext.waitUntil failure handler failed", Cause.pretty(cause), Cause.pretty(handlerCause))));
+const fromExecutionContext = (ctx, runPromiseExit) => {
+	const schedule = (effect, options, mode) => Effect.context().pipe(Effect.flatMap((context) => Effect.sync(() => {
+		const runHandler = (cause) => runPromiseExit(Effect.scoped(Effect.provideContext(failureHandler(cause, options), context))).then((exit) => {
+			if (Exit.isFailure(exit)) console.error("WorkerContext.waitUntil failure handler failed", Cause.pretty(exit.cause));
+		});
+		ctx.waitUntil(runPromiseExit(Effect.scoped(Effect.provideContext(effect, context))).then(async (exit) => {
+			if (Exit.isSuccess(exit)) return;
+			await runHandler(exit.cause);
+			if (mode === "propagate") throw causeError(exit.cause);
+		}));
+	})));
 	return {
-		serialize,
-		deserialize,
-		rehydrate,
-		schema
+		raw: ctx,
+		waitUntil: (effect, options) => schedule(effect, options, options?.mode ?? "observe"),
+		waitUntilPropagating: (effect, options) => schedule(effect, options, "propagate"),
+		passThroughOnException: Effect.sync(() => ctx.passThroughOnException())
 	};
 };
-/** Maps compact websocket lifecycle handler names to `DurableObject.make` options. */
-const handlers = (options) => ({
-	webSocketMessage: options.message,
-	webSocketClose: options.close,
-	webSocketError: options.error
-});
 //#endregion
-//#region src/DurableObjectState.ts
-var DurableObjectState_exports = /* @__PURE__ */ __exportAll({
-	DurableObjectState: () => DurableObjectState,
-	fromDurableObjectState: () => fromDurableObjectState
-});
-/**
-* Context tag for accessing the current Durable Object state service.
-*/
-var DurableObjectState = class extends Context.Service()("effect-cf/DurableObjectState") {};
-/**
-* Wraps a native Cloudflare `DurableObjectState` as a {@link DurableObjectStateService}.
-*/
-const fromDurableObjectState = (state) => ({
-	raw: state,
-	id: state.id,
-	storage: fromDurableObjectStorage(state.storage),
-	waitUntil: (promise) => Effect.sync(() => state.waitUntil(promise)),
-	blockConcurrencyWhile: (effect) => Effect.context().pipe(Effect.flatMap((context) => Effect.promise(() => state.blockConcurrencyWhile(() => runPromiseExitPreservingTypedFailures(Effect.provideContext(effect, context))))), Effect.flatten),
-	blockConcurrencyWhileOrReset: (effect) => Effect.context().pipe(Effect.flatMap((context) => Effect.promise(() => state.blockConcurrencyWhile(() => Effect.runPromise(Effect.provideContext(effect, context)))))),
-	acceptWebSocket: (ws, tags) => Effect.sync(() => state.acceptWebSocket(ws.raw, tags)),
-	getWebSockets: (tag) => Effect.sync(() => state.getWebSockets(tag).map((socket) => fromWebSocket(socket))),
-	setWebSocketAutoResponse: (pair) => Effect.sync(() => state.setWebSocketAutoResponse(pair)),
-	getWebSocketAutoResponse: Effect.sync(() => state.getWebSocketAutoResponse()),
-	getWebSocketAutoResponseTimestamp: (ws) => Effect.sync(() => state.getWebSocketAutoResponseTimestamp(ws.raw)),
-	setHibernatableWebSocketEventTimeout: (timeoutMs) => Effect.sync(() => state.setHibernatableWebSocketEventTimeout(timeoutMs)),
-	getHibernatableWebSocketEventTimeout: Effect.sync(() => state.getHibernatableWebSocketEventTimeout()),
-	getTags: (ws) => Effect.sync(() => state.getTags(ws.raw)),
-	abort: (reason) => Effect.sync(() => state.abort(reason))
+//#region src/Worker.ts
+var Worker_exports = /* @__PURE__ */ __exportAll({
+	ExecutionContext: () => ExecutionContext,
+	NativeRequest: () => NativeRequest,
+	Tag: () => Tag$7,
+	WorkerContext: () => WorkerContext,
+	implement: () => implement$4,
+	isWebSocketUpgrade: () => isWebSocketUpgrade,
+	make: () => make$6,
+	makeFetchHandler: () => makeFetchHandler,
+	method: () => method$2,
+	renderHttpResponse: () => renderHttpResponse
 });
-const runPromiseExitPreservingTypedFailures = async (effect) => {
-	const exit = await Effect.runPromiseExit(effect);
-	if (Exit.isFailure(exit) && (Cause.hasDies(exit.cause) || Cause.hasInterrupts(exit.cause))) throw Cause.squash(exit.cause);
-	return exit;
+var ExecutionContext = class extends Context.Service()("effect-cf/ExecutionContext") {};
+var WorkerContext = class extends Context.Service()("effect-cf/WorkerContext") {};
+var NativeRequest = class extends Context.Service()("effect-cf/NativeRequest") {};
+const isWebSocketUpgrade = (request) => request.headers.get("Upgrade")?.toLowerCase() === "websocket";
+const reservedMethodNames$2 = new Set([
+	"constructor",
+	"dup",
+	"fetch",
+	"connect",
+	"queue",
+	"scheduled",
+	"tail",
+	"tailStream",
+	"test",
+	"trace",
+	"alarm",
+	"webSocketMessage",
+	"webSocketClose",
+	"webSocketError"
+]);
+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 && ("eventLayer" in options || "fetch" in options || "queue" in options || "rpc" in options);
+function make$6(layer, optionsOrFetch) {
+	const options = isWorkerOptions(optionsOrFetch) ? optionsOrFetch : { fetch: optionsOrFetch };
+	class EffectWorker extends WorkerEntrypoint {
+		runtime;
+		constructor(ctx, env) {
+			super(ctx, env);
+			let runWaitUntilEffect = () => Promise.reject(/* @__PURE__ */ new Error("WorkerContext runtime is not initialized"));
+			const runtimeLayer = provideEntrypointServices(layer, Layer.mergeAll(Layer.succeed(ExecutionContext, ctx), ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env))), Layer.succeed(WorkerContext, fromExecutionContext(ctx, (effect) => runWaitUntilEffect(effect))), Layer.succeed(WorkerEnvironment, env)));
+			this.runtime = ManagedRuntime.make(runtimeLayer);
+			runWaitUntilEffect = (effect) => this.runtime.runPromiseExit(effect);
+		}
+		[RunSymbol$1](effect, runOptions = {}) {
+			const effectWithEventLayer = runOptions.eventLayer === false || options.eventLayer === void 0 ? effect : effect.pipe(Effect.provide(options.eventLayer, { local: true }));
+			return this.runtime.runPromise(Effect.scoped(effectWithEventLayer));
+		}
+		fetch(request) {
+			const fetchHandler = options.fetch;
+			if (fetchHandler === void 0) return Promise.resolve(new Response("Not Found", { status: 404 }));
+			const requestServices = Layer.mergeAll(Layer.succeed(NativeRequest, request), Layer.succeed(HttpServerRequest.HttpServerRequest, HttpServerRequest.fromWeb(request)));
+			return this[RunSymbol$1](renderFetchSuccess(fetchHandler).pipe(Effect.provide(requestServices)));
+		}
+		queue(batch) {
+			const queueHandler = options.queue;
+			if (queueHandler === void 0) return Promise.resolve();
+			const messages = batch.messages.map((message) => fromMessage(message, message.body));
+			return this[RunSymbol$1](queueHandler(fromMessageBatch(batch, messages)));
+		}
+	}
+	defineEntrypointRpcMethods("Worker", EffectWorker.prototype, options.rpc, reservedMethodNames$2, (self, effect) => self[RunSymbol$1](effect));
+	return assumeEntrypointClass(EffectWorker);
+}
+const makeFetchHandler = (layer, options) => {
+	const WorkerClass = make$6(layer, options);
+	return { fetch: (request, env, ctx) => Promise.resolve(new WorkerClass(ctx, env).fetch(request)) };
 };
+const Tag$7 = Tag$8;
+const method$2 = method$3;
+const implement$4 = implement$5;
 //#endregion
 //#region src/DurableObjectNamespace.ts
 var DurableObjectNamespace_exports = /* @__PURE__ */ __exportAll({
@@ -1103,7 +1378,7 @@ const makeClient$4 = (definition) => {
 		});
 	};
 };
-const layer$6 = (tag, definition) => layer$9(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$4(definition), { expected: expectedDurableObjectNamespace });
+const layer$6 = (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) {
@@ -1277,10 +1552,11 @@ const make$4 = (layer, options = {}) => {
 			const runtimeLayer = provideEntrypointServices(layer, Layer.mergeAll(Layer.succeed(DurableObjectState, fromDurableObjectState(state)), Layer.succeed(WorkerEnvironment, env)));
 			this.runtime = ManagedRuntime.make(runtimeLayer);
 			const initialize = options.initialize;
-			if (initialize !== void 0) state.waitUntil(this[RunSymbol](initialize));
+			if (initialize !== void 0) state.waitUntil(this[RunSymbol](initialize, { eventLayer: false }));
 		}
-		[RunSymbol](effect) {
-			return this.runtime.runPromise(Effect.scoped(effect));
+		[RunSymbol](effect, runOptions = {}) {
+			const effectWithEventLayer = runOptions.eventLayer === false || options.eventLayer === void 0 ? effect : effect.pipe(Effect.provide(options.eventLayer, { local: true }));
+			return this.runtime.runPromise(Effect.scoped(effectWithEventLayer));
 		}
 		fetch(request) {
 			const fetchHandler = options.fetch;
@@ -1879,7 +2155,7 @@ const makeClient$3 = (definition) => (images) => {
 		unsafeRaw: Effect.succeed(images)
 	};
 };
-const layer$3 = (tag, definition) => layer$9(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);
@@ -1974,7 +2250,7 @@ const makeClient$2 = (definition) => {
 		unsafeRaw: Effect.succeed(kv)
 	});
 };
-const layer$2 = (tag, definition) => layer$9(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,
@@ -2091,7 +2367,7 @@ const makeClient$1 = (definition) => {
 		};
 	};
 };
-const layer$1 = (tag, definition) => layer$9(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);
@@ -2177,7 +2453,7 @@ const makeClient = (definition) => {
 		unsafeRaw: Effect.succeed(workflow)
 	});
 };
-const layer = (tag, definition) => layer$9(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({
@@ -2198,7 +2474,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$10 = (binding) => layer(tag, {
+	const layer$11 = (binding) => layer(tag, {
 		...binding,
 		payload: definition.payload,
 		result: definition.result
@@ -2220,7 +2496,7 @@ const Tag$1 = () => (id, definition) => {
 		payload: workflowDefinition.payload,
 		result: workflowDefinition.result,
 		make: workflowDefinition.make,
-		layer: layer$10,
+		layer: layer$11,
 		create,
 		createBatch,
 		get,
@@ -2311,4 +2587,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, 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 };
+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 };