effect-cf 0.12.0 → 0.13.0

package/dist/index.mjs

@@ -3,1192 +3,1168 @@ import { a as WorkerConfig, i as layer$10, n as Binding_exports, o as WorkerEnvi
 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 { D1Client } from "@effect/sql-d1";
+import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, WorkflowEntrypoint } from "cloudflare:workers";
 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/QueueBinding.ts
-var QueueBinding_exports = /* @__PURE__ */ __exportAll({
-	QueueOperationError: () => QueueOperationError,
-	isQueue: () => isQueue,
-	layer: () => layer$9,
-	makeClient: () => makeClient$6
+//#region src/DurableObjectStorage.ts
+var DurableObjectStorage_exports = /* @__PURE__ */ __exportAll({
+	StorageOperationError: () => StorageOperationError,
+	fromDurableObjectStorage: () => fromDurableObjectStorage
 });
-const expectedQueueProducer = "Queue producer binding with send(); optional sendBatch()/metrics()";
-var QueueOperationError = class extends Data.TaggedError("QueueOperationError") {};
-const tryQueuePromise = (binding, operation, evaluate) => Effect.tryPromise({
+/** 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) => new QueueOperationError({
-		binding,
-		operation,
-		cause,
-		message: `Cloudflare queue binding "${binding}" operation "${operation}" failed`
-	})
+	catch: (cause) => storageError(operation, cause)
 });
-const isQueue = (value) => {
-	if (typeof value !== "object" || value === null) return false;
-	return typeof value.send === "function";
-};
-const makeClient$6 = (definition) => {
-	const encodeMessage = Schema.encodeEffect(definition.message);
-	return (queue) => ({
-		send: Effect.fnUntraced(function* (message, options) {
-			const encoded = yield* encodeMessage(message);
-			yield* tryQueuePromise(definition.binding, "send", () => queue.send(encoded, options));
+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));
 		}),
-		sendBatch: Effect.fnUntraced(function* (messages, options) {
-			const encodedMessages = [];
-			for (const message of messages) encodedMessages.push({
-				...message,
-				body: yield* encodeMessage(message.body)
-			});
-			const sendBatch = queue.sendBatch;
-			if (sendBatch !== void 0) {
-				yield* tryQueuePromise(definition.binding, "sendBatch", () => sendBatch.call(queue, encodedMessages, options));
-				return;
-			}
-			yield* tryQueuePromise(definition.binding, "sendBatch", async () => {
-				for (const message of encodedMessages) await queue.send(message.body, {
-					contentType: message.contentType,
-					delaySeconds: message.delaySeconds ?? options?.delaySeconds
-				});
-			});
+		put: (key, value) => Effect.gen(function* () {
+			const encodedKey = yield* encodeKey(key);
+			const encodedValue = yield* encodeValue(value);
+			yield* tryStorageSync("kv.put", () => kv.put(encodedKey, encodedValue));
 		}),
-		metrics: () => {
-			const metrics = queue.metrics;
-			if (metrics === void 0) return Effect.fail(new QueueOperationError({
-				binding: definition.binding,
-				operation: "metrics",
-				cause: /* @__PURE__ */ new Error(`Queue binding "${definition.binding}" does not provide metrics()`),
-				message: `Cloudflare queue binding "${definition.binding}" does not provide metrics()`
-			}));
-			return tryQueuePromise(definition.binding, "metrics", () => metrics.call(queue));
-		},
-		unsafeRaw: Effect.succeed(queue)
-	});
-};
-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$10
-});
-const makeDefinition$4 = (id, definition) => {
-	const queueDefinition = {
-		id,
-		message: definition.message
+		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;
+		})
 	};
-	return Object.assign(queueDefinition, { make: (layer, options) => make$7(layer, {
-		...options,
-		queue: wrapHandler$1(queueDefinition, options.queue)
-	}) });
-};
-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$9(tag, {
-		...binding,
-		message: definition.message
-	});
-	const send = Effect.fnUntraced(function* (message, options) {
-		yield* (yield* tag).send(message, options);
-	});
-	const sendBatch = Effect.fnUntraced(function* (messages, options) {
-		yield* (yield* tag).sendBatch(messages, options);
-	});
-	const metrics = Effect.fnUntraced(function* () {
-		return yield* (yield* tag).metrics();
-	});
-	const unsafeRaw = Effect.fnUntraced(function* () {
-		return yield* (yield* tag).unsafeRaw;
-	});
-	return Object.assign(tag, {
-		id: queueDefinition.id,
-		message: queueDefinition.message,
-		make: queueDefinition.make,
-		layer,
-		send,
-		sendBatch,
-		metrics,
-		unsafeRaw
-	});
-};
-const Queue$1 = Tag$10;
-const wrapHandler$1 = (definition, handler) => {
-	const decodeBody = Schema.decodeUnknownEffect(definition.message);
-	return (batch) => Effect.gen(function* () {
-		yield* handler(yield* decodeBatch(batch.raw, decodeBody));
-	});
 };
-const implement$7 = (_definition, handler) => handler;
-//#endregion
-//#region src/Queue.ts
-var Queue_exports = /* @__PURE__ */ __exportAll({
-	QueueMessageDecodeError: () => QueueMessageDecodeError,
-	Tag: () => Tag$9,
-	decodeBatch: () => decodeBatch,
-	fromMessage: () => fromMessage,
-	fromMessageBatch: () => fromMessageBatch,
-	implement: () => implement$6
+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)
 });
-var QueueMessageDecodeError = class extends Data.TaggedError("QueueMessageDecodeError") {};
-const fromMessage = (message, body) => ({
-	raw: message,
-	id: message.id,
-	timestamp: message.timestamp,
-	body,
-	attempts: message.attempts,
-	ack: Effect.sync(() => message.ack()),
-	retry: (options) => Effect.sync(() => message.retry(options))
+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))
 });
-const fromMessageBatch = (batch, messages) => ({
-	raw: batch,
-	messages,
-	queue: batch.queue,
-	metadata: batch.metadata,
-	ackAll: Effect.sync(() => batch.ackAll()),
-	retryAll: (options) => Effect.sync(() => batch.retryAll(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)
 });
-const decodeBatch = (batch, decodeBody) => Effect.gen(function* () {
-	const messages = [];
-	for (let index = 0; index < batch.messages.length; index++) {
-		const message = batch.messages[index];
-		const body = yield* decodeBody(message.body).pipe(Effect.mapError((cause) => new QueueMessageDecodeError({
-			queue: batch.queue,
-			messageId: message.id,
-			index,
-			cause
-		})));
-		messages.push(fromMessage(message, body));
-	}
-	return fromMessageBatch(batch, messages);
-});
-const Tag$9 = Tag$10;
-const implement$6 = implement$7;
 //#endregion
-//#region src/RpcDefinition.ts
-var RpcDefinition_exports = /* @__PURE__ */ __exportAll({
-	ReservedMethodNameError: () => ReservedMethodNameError,
-	RpcArgumentCountError: () => RpcArgumentCountError,
-	RpcArgumentDecodeError: () => RpcArgumentDecodeError,
-	RpcArgumentEncodeError: () => RpcArgumentEncodeError,
-	RpcReservedMethodNameError: () => RpcReservedMethodNameError,
-	RpcSuccessDecodeError: () => RpcSuccessDecodeError,
-	RpcSuccessEncodeError: () => RpcSuccessEncodeError,
-	assertNoReservedMethodNames: () => assertNoReservedMethodNames,
-	assertNoReservedMethods: () => assertNoReservedMethods,
-	decodeArgs: () => decodeArgs,
-	decodeSuccess: () => decodeSuccess,
-	encodeArgs: () => encodeArgs,
-	encodeSuccess: () => encodeSuccess,
-	make: () => make$9,
-	method: () => method$4,
-	reservedMethodNames: () => reservedMethodNames$4
+//#region src/DurableObjectWebSocket.ts
+var DurableObjectWebSocket_exports = /* @__PURE__ */ __exportAll({
+	DurableWebSocketAttachmentError: () => DurableWebSocketAttachmentError,
+	DurableWebSocketCloseError: () => DurableWebSocketCloseError,
+	DurableWebSocketSendError: () => DurableWebSocketSendError,
+	acceptUpgrade: () => acceptUpgrade,
+	attachment: () => attachment,
+	fromWebSocket: () => fromWebSocket,
+	handlers: () => handlers
 });
-var RpcReservedMethodNameError = class extends Data.TaggedError("RpcReservedMethodNameError") {};
-var RpcArgumentCountError = class extends Data.TaggedError("RpcArgumentCountError") {};
-var RpcArgumentDecodeError = class extends Data.TaggedError("RpcArgumentDecodeError") {};
-var RpcArgumentEncodeError = class extends Data.TaggedError("RpcArgumentEncodeError") {};
-var RpcSuccessDecodeError = class extends Data.TaggedError("RpcSuccessDecodeError") {};
-var RpcSuccessEncodeError = class extends Data.TaggedError("RpcSuccessEncodeError") {};
-const reservedMethodNames$4 = new Set([
-	"constructor",
-	"fetch",
-	"connect",
-	"alarm",
-	"webSocketMessage",
-	"webSocketClose",
-	"webSocketError",
-	"then",
-	"dup",
-	"dispose",
-	"serialize",
-	"deserialize"
-]);
-var ReservedMethodNameError = class extends Error {
-	method;
-	target;
-	constructor(target, method) {
-		super(`${target} RPC method "${method}" is reserved by Cloudflare Workers RPC`);
-		this.name = "ReservedMethodNameError";
-		this.target = target;
-		this.method = method;
-	}
-};
-const assertNoReservedMethods = (target, methods, reserved) => {
-	for (const method of Object.keys(methods)) if (reserved.has(method)) throw new ReservedMethodNameError(target, method);
+/** 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;
 };
-function method$4(definition) {
+/**
+* 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 {
-		args: definition.args ?? [],
-		success: definition.success
+		client,
+		server,
+		response: new Response(null, {
+			status: 101,
+			webSocket: client
+		})
 	};
-}
-const assertNoReservedMethodNames = (definition) => Effect.forEach(Object.keys(definition.methods), (method) => reservedMethodNames$4.has(method) ? Effect.fail(new RpcReservedMethodNameError({
-	definition: definition.id,
-	method
-})) : Effect.void).pipe(Effect.asVoid);
-const decodeArgs = (definition, methodName, args) => Effect.gen(function* () {
-	const methodDefinition = definition.methods[methodName];
-	if (args.length !== methodDefinition.args.length) return yield* Effect.fail(new RpcArgumentCountError({
-		definition: definition.id,
-		method: methodName,
-		expected: methodDefinition.args.length,
-		actual: args.length
-	}));
-	const decoded = [];
-	for (let index = 0; index < methodDefinition.args.length; index++) {
-		const schema = methodDefinition.args[index];
-		decoded.push(yield* Schema.decodeUnknownEffect(schema)(args[index]).pipe(Effect.mapError((cause) => new RpcArgumentDecodeError({
-			definition: definition.id,
-			method: methodName,
-			index,
-			cause
-		}))));
-	}
-	return decoded;
 });
-const encodeArgs = (definition, methodName, args) => Effect.gen(function* () {
-	const methodDefinition = definition.methods[methodName];
-	if (args.length !== methodDefinition.args.length) return yield* Effect.fail(new RpcArgumentCountError({
-		definition: definition.id,
-		method: methodName,
-		expected: methodDefinition.args.length,
-		actual: args.length
-	}));
-	const encoded = [];
-	for (let index = 0; index < methodDefinition.args.length; index++) {
-		const schema = methodDefinition.args[index];
-		encoded.push(yield* Schema.encodeEffect(schema)(args[index]).pipe(Effect.mapError((cause) => new RpcArgumentEncodeError({
-			definition: definition.id,
-			method: methodName,
-			index,
+/** 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
 		}))));
-	}
-	return encoded;
-});
-const encodeSuccess = (definition, methodName, value) => {
-	const methodDefinition = definition.methods[methodName];
-	return Schema.encodeEffect(methodDefinition.success)(value).pipe(Effect.mapError((cause) => new RpcSuccessEncodeError({
-		definition: definition.id,
-		method: methodName,
-		cause
-	})));
-};
-const decodeSuccess = (definition, methodName, value) => {
-	const methodDefinition = definition.methods[methodName];
-	return Schema.decodeUnknownEffect(methodDefinition.success)(value).pipe(Effect.mapError((cause) => new RpcSuccessDecodeError({
-		definition: definition.id,
-		method: methodName,
-		cause
-	})));
-};
-const make$9 = (id, methods) => {
-	const definition = {
-		id,
-		methods
-	};
-	const reserved = Object.keys(definition.methods).find((methodName) => reservedMethodNames$4.has(methodName));
-	if (reserved !== void 0) throw new RpcReservedMethodNameError({
-		definition: id,
-		method: reserved
 	});
-	return 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);
+		}
+		return restored;
+	});
+	return {
+		serialize,
+		deserialize,
+		rehydrate,
+		schema
+	};
 };
-//#endregion
-//#region src/Rpc.ts
-var Rpc_exports = /* @__PURE__ */ __exportAll({
-	RpcStub: () => RpcStub,
-	RpcTarget: () => RpcTarget,
-	dispose: () => dispose,
-	isDisposable: () => isDisposable,
-	resolve: () => resolve,
-	scoped: () => scoped
-});
-const isDisposable = (value) => (typeof value === "object" || typeof value === "function") && value !== null && Symbol.dispose in value && typeof value[Symbol.dispose] === "function";
-const dispose = (value) => Effect.sync(() => {
-	if (isDisposable(value)) value[Symbol.dispose]();
-});
-const resolve = (value) => isPromiseLike(value) ? Effect.tryPromise({
-	try: () => value,
-	catch: (cause) => cause
-}) : Effect.sync(() => value);
-const scoped = (value) => Effect.acquireRelease(resolve(value), (resolved) => dispose(resolved));
-const isPromiseLike = (value) => (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
-//#endregion
-//#region src/internal/RpcInvocation.ts
-const isPropertyTarget = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
-const lookupRpcMethod = (target, method, makeError) => Effect.try({
-	try: () => {
-		if (!isPropertyTarget(target)) throw new TypeError(`RPC target is not object-like`);
-		const value = Reflect.get(target, method);
-		if (typeof value !== "function") throw new TypeError(`RPC method "${String(method)}" is not callable`);
-		return ((...args) => Reflect.apply(value, target, args));
-	},
-	catch: makeError
-});
-const invokeRpcMethod = (target, method, args, makeError) => Effect.gen(function* () {
-	const fn = yield* lookupRpcMethod(target, method, makeError);
-	return yield* Effect.try({
-		try: () => fn(...args),
-		catch: makeError
-	});
+/** 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/ServiceBinding.ts
-var ServiceBinding_exports = /* @__PURE__ */ __exportAll({
-	Service: () => Service$1,
-	ServiceBindingFetchError: () => ServiceBindingFetchError,
-	ServiceBindingRpcError: () => ServiceBindingRpcError,
-	isServiceBindingClient: () => isServiceBindingClient,
-	layer: () => layer$8,
-	makeClient: () => makeClient$5,
-	makeDirectMethods: () => makeDirectMethods$1
+//#region src/DurableObjectState.ts
+var DurableObjectState_exports = /* @__PURE__ */ __exportAll({
+	DurableObjectState: () => DurableObjectState,
+	fromDurableObjectState: () => fromDurableObjectState
 });
-const TypeId$2 = "effect-cf/ServiceBinding";
-const expectedServiceBinding = "Worker service binding with fetch()";
 /**
-* Failure raised when calling `fetch` on a service binding.
+* Context tag for accessing the current Durable Object state service.
 */
-var ServiceBindingFetchError = class extends Data.TaggedError("ServiceBindingFetchError") {};
+var DurableObjectState = class extends Context.Service()("effect-cf/DurableObjectState") {};
 /**
-* Failure raised when invoking an RPC method on a service binding.
+* Wraps a native Cloudflare `DurableObjectState` as a {@link DurableObjectStateService}.
 */
-var ServiceBindingRpcError = class extends Data.TaggedError("ServiceBindingRpcError") {};
-const isServiceBindingClient = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "fetch") === "function";
-const makeClient$5 = (definition) => {
-	return (service) => {
-		const fetch = (input, init) => Effect.tryPromise({
-			try: () => service.fetch(input, init),
-			catch: (cause) => new ServiceBindingFetchError({
-				binding: definition.binding,
-				cause
-			})
-		});
-		const rpc = (method, ...args) => Effect.gen(function* () {
-			const methodName = String(method);
-			return yield* invokeRpcMethod(service, method, definition.definition === void 0 ? args : yield* encodeArgs(definition.definition, methodName, args).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
-				binding: definition.binding,
-				method: methodName,
-				cause
-			}))), (cause) => new ServiceBindingRpcError({
-				binding: definition.binding,
-				method: methodName,
-				cause
-			}));
-		});
-		const decodeSuccess$2 = (methodName, value) => Effect.gen(function* () {
-			if (definition.definition === void 0) return value;
-			return yield* decodeSuccess(definition.definition, methodName, value).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
-				binding: definition.binding,
-				method: methodName,
-				cause
-			})));
-		});
-		const call = (method, ...args) => Effect.gen(function* () {
-			const methodName = String(method);
-			return yield* decodeSuccess$2(methodName, yield* resolve(yield* rpc(method, ...args)).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
-				binding: definition.binding,
-				method: methodName,
-				cause
-			}))));
-		});
-		const scopedCall = (method, ...args) => Effect.gen(function* () {
-			return yield* decodeSuccess$2(String(method), yield* scoped(yield* rpc(method, ...args)));
-		});
-		const directMethods = makeDirectMethods$1(definition.definition, call);
-		return Object.assign(directMethods, {
-			fetch,
-			rpc,
-			call,
-			scopedCall
-		});
-	};
+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;
 };
-const layer$8 = (tag, definition) => layer$10(tag, definition.binding, (value) => isServiceBindingClient(value), makeClient$5(definition), { expected: expectedServiceBinding });
+//#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
+});
 /**
-* Creates a typed Effect service for a Worker service binding.
+* Supported OpenTelemetry environment configuration for Cloudflare OTLP export.
 *
-* Returned value includes:
-* - a Context tag for dependency injection
-* - `fetch(...)` for raw HTTP forwarding
-* - `rpc(...)` for raw Cloudflare RPC results
-* - `call(...)` for resolved and decoded RPC results
-* - `scopedCall(...)` for scoped and decoded disposable RPC results
-* - direct RPC methods when `definition` is provided
+* 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:
 *
-* @example
-* ```ts
-* const Counter = WorkerDefinition.make("Counter", {
-*   increment: WorkerDefinition.method({
-*     args: [Schema.Number],
-*     success: Schema.Number,
-*   }),
-* });
+* - `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`
 *
-* const CounterLive = Counter.layer({ binding: "COUNTER" });
+* `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=...`.
 *
-* const program = Effect.gen(function* () {
-*   const counter = yield* Counter;
-*   const next = yield* counter.increment(1);
-*   return next;
-* });
-* ```
+* Consumers with non-standard binding names should map those names into
+* {@link CloudflareOtlpSettings} rather than changing this config globally.
 */
-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);
-	});
-	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.definition, call);
-	return Object.assign(tag, directMethods, {
-		[TypeId$2]: TypeId$2,
-		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$8,
-	method: () => method$3
+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)
 });
-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.
+* 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 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$9(id, methods);
-	return Object.assign(definition, { make: (layer, options) => make$7(layer, {
-		...options,
-		rpc: wrapHandlers$1(definition, options.rpc)
-	}) });
-};
-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);
-	const bindingDefinition = (binding) => ({
-		...binding,
-		definition
-	});
-	const layer = (binding) => layer$8(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;
-};
+* 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)
+});
 /**
-* Helper for implementing handlers with the exact method shape of a definition.
+* 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 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 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 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);
-		}));
-	})));
+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 {
-		raw: ctx,
-		waitUntil: (effect, options) => schedule(effect, options, options?.mode ?? "observe"),
-		waitUntilPropagating: (effect, options) => schedule(effect, options, "propagate"),
-		passThroughOnException: Effect.sync(() => ctx.passThroughOnException())
+		...commonHeaders,
+		...signalHeaders
 	};
 };
-//#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$7,
-	makeFetchHandler: () => makeFetchHandler,
-	method: () => method$2,
-	renderHttpResponse: () => renderHttpResponse
-});
-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 && ("fetch" in options || "queue" in options || "rpc" in options);
-function make$7(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)));
-		}
+const decodeHeaderComponent = (value) => {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
 	}
-	defineEntrypointRpcMethods("Worker", EffectWorker.prototype, options.rpc, reservedMethodNames$2, (self, effect) => self[RunSymbol$1](effect));
-	return assumeEntrypointClass(EffectWorker);
-}
-const makeFetchHandler = (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;
-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 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 tryStorageSync = (operation, evaluate) => Effect.try({
-	try: evaluate,
-	catch: (cause) => storageError(operation, cause)
+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 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 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 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 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 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 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"
 });
-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))
+/** Base OTLP telemetry layer forced to protobuf serialization. */
+const layerProtobuf = (options = {}) => layer$9({
+	...options,
+	serialization: "protobuf"
 });
 /**
-* Wraps native Cloudflare storage APIs as Effect-returning helpers.
+* 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 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)
+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/DurableObjectWebSocket.ts
-var DurableObjectWebSocket_exports = /* @__PURE__ */ __exportAll({
-	DurableWebSocketAttachmentError: () => DurableWebSocketAttachmentError,
-	DurableWebSocketCloseError: () => DurableWebSocketCloseError,
-	DurableWebSocketSendError: () => DurableWebSocketSendError,
-	acceptUpgrade: () => acceptUpgrade,
-	attachment: () => attachment,
-	fromWebSocket: () => fromWebSocket,
-	handlers: () => handlers
+//#region src/D1.ts
+var D1_exports = /* @__PURE__ */ __exportAll({
+	Service: () => Service$1,
+	make: () => make$10
 });
-/** 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 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";
 };
 /**
-* Accepts a websocket upgrade and registers the server socket on `DurableObjectState`.
+* 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
-* const response = yield* DurableObjectWebSocket.acceptUpgrade({
-*   tags: ["room:general"],
-* });
+* class TodoDatabase extends D1.Service<TodoDatabase>()("TodoDatabase", {
+*   binding: "TODO_DB",
+* }) {}
 *
-* return response.response;
+* const SqlLive = TodoDatabase.sqlLayer();
 * ```
 */
-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 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
 	});
-	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;
+};
+//#endregion
+//#region src/QueueBinding.ts
+var QueueBinding_exports = /* @__PURE__ */ __exportAll({
+	QueueOperationError: () => QueueOperationError,
+	isQueue: () => isQueue,
+	layer: () => layer$8,
+	makeClient: () => makeClient$6
+});
+const expectedQueueProducer = "Queue producer binding with send(); optional sendBatch()/metrics()";
+var QueueOperationError = class extends Data.TaggedError("QueueOperationError") {};
+const tryQueuePromise = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => new QueueOperationError({
+		binding,
+		operation,
+		cause,
+		message: `Cloudflare queue binding "${binding}" operation "${operation}" failed`
+	})
+});
+const isQueue = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	return typeof value.send === "function";
+};
+const makeClient$6 = (definition) => {
+	const encodeMessage = Schema.encodeEffect(definition.message);
+	return (queue) => ({
+		send: Effect.fnUntraced(function* (message, options) {
+			const encoded = yield* encodeMessage(message);
+			yield* tryQueuePromise(definition.binding, "send", () => queue.send(encoded, options));
+		}),
+		sendBatch: Effect.fnUntraced(function* (messages, options) {
+			const encodedMessages = [];
+			for (const message of messages) encodedMessages.push({
+				...message,
+				body: yield* encodeMessage(message.body)
+			});
+			const sendBatch = queue.sendBatch;
+			if (sendBatch !== void 0) {
+				yield* tryQueuePromise(definition.binding, "sendBatch", () => sendBatch.call(queue, encodedMessages, options));
+				return;
 			}
-			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;
+			yield* tryQueuePromise(definition.binding, "sendBatch", async () => {
+				for (const message of encodedMessages) await queue.send(message.body, {
+					contentType: message.contentType,
+					delaySeconds: message.delaySeconds ?? options?.delaySeconds
+				});
+			});
+		}),
+		metrics: () => {
+			const metrics = queue.metrics;
+			if (metrics === void 0) return Effect.fail(new QueueOperationError({
+				binding: definition.binding,
+				operation: "metrics",
+				cause: /* @__PURE__ */ new Error(`Queue binding "${definition.binding}" does not provide metrics()`),
+				message: `Cloudflare queue binding "${definition.binding}" does not provide metrics()`
+			}));
+			return tryQueuePromise(definition.binding, "metrics", () => metrics.call(queue));
+		},
+		unsafeRaw: Effect.succeed(queue)
 	});
-	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
-});
+const layer$8 = (tag, definition) => layer$10(tag, definition.binding, (value) => isQueue(value), makeClient$6(definition), { expected: expectedQueueProducer });
 //#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/QueueDefinition.ts
+var QueueDefinition_exports = /* @__PURE__ */ __exportAll({
+	Queue: () => Queue$1,
+	Tag: () => Tag$10,
+	implement: () => implement$7,
+	make: () => make$9
 });
-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;
+const makeDefinition$4 = (id, definition) => {
+	const queueDefinition = {
+		id,
+		message: definition.message
+	};
+	return Object.assign(queueDefinition, { make: (layer, options) => make$6(layer, {
+		...options,
+		queue: wrapHandler$1(queueDefinition, options.queue)
+	}) });
+};
+const make$9 = (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$8(tag, {
+		...binding,
+		message: definition.message
+	});
+	const send = Effect.fnUntraced(function* (message, options) {
+		yield* (yield* tag).send(message, options);
+	});
+	const sendBatch = Effect.fnUntraced(function* (messages, options) {
+		yield* (yield* tag).sendBatch(messages, options);
+	});
+	const metrics = Effect.fnUntraced(function* () {
+		return yield* (yield* tag).metrics();
+	});
+	const unsafeRaw = Effect.fnUntraced(function* () {
+		return yield* (yield* tag).unsafeRaw;
+	});
+	return Object.assign(tag, {
+		id: queueDefinition.id,
+		message: queueDefinition.message,
+		make: queueDefinition.make,
+		layer,
+		send,
+		sendBatch,
+		metrics,
+		unsafeRaw
+	});
+};
+const Queue$1 = Tag$10;
+const wrapHandler$1 = (definition, handler) => {
+	const decodeBody = Schema.decodeUnknownEffect(definition.message);
+	return (batch) => Effect.gen(function* () {
+		yield* handler(yield* decodeBatch(batch.raw, decodeBody));
+	});
 };
+const implement$7 = (_definition, handler) => handler;
 //#endregion
-//#region src/DurableObjectNamespace.ts
-var DurableObjectNamespace_exports = /* @__PURE__ */ __exportAll({
-	DurableObjectFetchError: () => DurableObjectFetchError,
-	DurableObjectRpcError: () => DurableObjectRpcError,
-	isDurableObjectNamespaceClient: () => isDurableObjectNamespaceClient,
-	layer: () => layer$7,
-	makeClient: () => makeClient$4,
-	makeDirectMethods: () => makeDirectMethods
+//#region src/Queue.ts
+var Queue_exports = /* @__PURE__ */ __exportAll({
+	QueueMessageDecodeError: () => QueueMessageDecodeError,
+	Tag: () => Tag$9,
+	decodeBatch: () => decodeBatch,
+	fromMessage: () => fromMessage,
+	fromMessageBatch: () => fromMessageBatch,
+	implement: () => implement$6
 });
-const expectedDurableObjectNamespace = "Durable Object namespace binding with getByName(), get(), idFromName(), idFromString(), newUniqueId(), and jurisdiction()";
-/**
-* Failure raised when invoking an RPC method on a Durable Object stub.
-*/
-var DurableObjectRpcError = class extends Data.TaggedError("DurableObjectRpcError") {};
+var QueueMessageDecodeError = class extends Data.TaggedError("QueueMessageDecodeError") {};
+const fromMessage = (message, body) => ({
+	raw: message,
+	id: message.id,
+	timestamp: message.timestamp,
+	body,
+	attempts: message.attempts,
+	ack: Effect.sync(() => message.ack()),
+	retry: (options) => Effect.sync(() => message.retry(options))
+});
+const fromMessageBatch = (batch, messages) => ({
+	raw: batch,
+	messages,
+	queue: batch.queue,
+	metadata: batch.metadata,
+	ackAll: Effect.sync(() => batch.ackAll()),
+	retryAll: (options) => Effect.sync(() => batch.retryAll(options))
+});
+const decodeBatch = (batch, decodeBody) => Effect.gen(function* () {
+	const messages = [];
+	for (let index = 0; index < batch.messages.length; index++) {
+		const message = batch.messages[index];
+		const body = yield* decodeBody(message.body).pipe(Effect.mapError((cause) => new QueueMessageDecodeError({
+			queue: batch.queue,
+			messageId: message.id,
+			index,
+			cause
+		})));
+		messages.push(fromMessage(message, body));
+	}
+	return fromMessageBatch(batch, messages);
+});
+const Tag$9 = Tag$10;
+const implement$6 = implement$7;
+//#endregion
+//#region src/RpcDefinition.ts
+var RpcDefinition_exports = /* @__PURE__ */ __exportAll({
+	ReservedMethodNameError: () => ReservedMethodNameError,
+	RpcArgumentCountError: () => RpcArgumentCountError,
+	RpcArgumentDecodeError: () => RpcArgumentDecodeError,
+	RpcArgumentEncodeError: () => RpcArgumentEncodeError,
+	RpcReservedMethodNameError: () => RpcReservedMethodNameError,
+	RpcSuccessDecodeError: () => RpcSuccessDecodeError,
+	RpcSuccessEncodeError: () => RpcSuccessEncodeError,
+	assertNoReservedMethodNames: () => assertNoReservedMethodNames,
+	assertNoReservedMethods: () => assertNoReservedMethods,
+	decodeArgs: () => decodeArgs,
+	decodeSuccess: () => decodeSuccess,
+	encodeArgs: () => encodeArgs,
+	encodeSuccess: () => encodeSuccess,
+	make: () => make$8,
+	method: () => method$4,
+	reservedMethodNames: () => reservedMethodNames$4
+});
+var RpcReservedMethodNameError = class extends Data.TaggedError("RpcReservedMethodNameError") {};
+var RpcArgumentCountError = class extends Data.TaggedError("RpcArgumentCountError") {};
+var RpcArgumentDecodeError = class extends Data.TaggedError("RpcArgumentDecodeError") {};
+var RpcArgumentEncodeError = class extends Data.TaggedError("RpcArgumentEncodeError") {};
+var RpcSuccessDecodeError = class extends Data.TaggedError("RpcSuccessDecodeError") {};
+var RpcSuccessEncodeError = class extends Data.TaggedError("RpcSuccessEncodeError") {};
+const reservedMethodNames$4 = new Set([
+	"constructor",
+	"fetch",
+	"connect",
+	"alarm",
+	"webSocketMessage",
+	"webSocketClose",
+	"webSocketError",
+	"then",
+	"dup",
+	"dispose",
+	"serialize",
+	"deserialize"
+]);
+var ReservedMethodNameError = class extends Error {
+	method;
+	target;
+	constructor(target, method) {
+		super(`${target} RPC method "${method}" is reserved by Cloudflare Workers RPC`);
+		this.name = "ReservedMethodNameError";
+		this.target = target;
+		this.method = method;
+	}
+};
+const assertNoReservedMethods = (target, methods, reserved) => {
+	for (const method of Object.keys(methods)) if (reserved.has(method)) throw new ReservedMethodNameError(target, method);
+};
+function method$4(definition) {
+	return {
+		args: definition.args ?? [],
+		success: definition.success
+	};
+}
+const assertNoReservedMethodNames = (definition) => Effect.forEach(Object.keys(definition.methods), (method) => reservedMethodNames$4.has(method) ? Effect.fail(new RpcReservedMethodNameError({
+	definition: definition.id,
+	method
+})) : Effect.void).pipe(Effect.asVoid);
+const decodeArgs = (definition, methodName, args) => Effect.gen(function* () {
+	const methodDefinition = definition.methods[methodName];
+	if (args.length !== methodDefinition.args.length) return yield* Effect.fail(new RpcArgumentCountError({
+		definition: definition.id,
+		method: methodName,
+		expected: methodDefinition.args.length,
+		actual: args.length
+	}));
+	const decoded = [];
+	for (let index = 0; index < methodDefinition.args.length; index++) {
+		const schema = methodDefinition.args[index];
+		decoded.push(yield* Schema.decodeUnknownEffect(schema)(args[index]).pipe(Effect.mapError((cause) => new RpcArgumentDecodeError({
+			definition: definition.id,
+			method: methodName,
+			index,
+			cause
+		}))));
+	}
+	return decoded;
+});
+const encodeArgs = (definition, methodName, args) => Effect.gen(function* () {
+	const methodDefinition = definition.methods[methodName];
+	if (args.length !== methodDefinition.args.length) return yield* Effect.fail(new RpcArgumentCountError({
+		definition: definition.id,
+		method: methodName,
+		expected: methodDefinition.args.length,
+		actual: args.length
+	}));
+	const encoded = [];
+	for (let index = 0; index < methodDefinition.args.length; index++) {
+		const schema = methodDefinition.args[index];
+		encoded.push(yield* Schema.encodeEffect(schema)(args[index]).pipe(Effect.mapError((cause) => new RpcArgumentEncodeError({
+			definition: definition.id,
+			method: methodName,
+			index,
+			cause
+		}))));
+	}
+	return encoded;
+});
+const encodeSuccess = (definition, methodName, value) => {
+	const methodDefinition = definition.methods[methodName];
+	return Schema.encodeEffect(methodDefinition.success)(value).pipe(Effect.mapError((cause) => new RpcSuccessEncodeError({
+		definition: definition.id,
+		method: methodName,
+		cause
+	})));
+};
+const decodeSuccess = (definition, methodName, value) => {
+	const methodDefinition = definition.methods[methodName];
+	return Schema.decodeUnknownEffect(methodDefinition.success)(value).pipe(Effect.mapError((cause) => new RpcSuccessDecodeError({
+		definition: definition.id,
+		method: methodName,
+		cause
+	})));
+};
+const make$8 = (id, methods) => {
+	const definition = {
+		id,
+		methods
+	};
+	const reserved = Object.keys(definition.methods).find((methodName) => reservedMethodNames$4.has(methodName));
+	if (reserved !== void 0) throw new RpcReservedMethodNameError({
+		definition: id,
+		method: reserved
+	});
+	return definition;
+};
+//#endregion
+//#region src/Rpc.ts
+var Rpc_exports = /* @__PURE__ */ __exportAll({
+	RpcStub: () => RpcStub,
+	RpcTarget: () => RpcTarget,
+	dispose: () => dispose,
+	isDisposable: () => isDisposable,
+	resolve: () => resolve,
+	scoped: () => scoped
+});
+const isDisposable = (value) => (typeof value === "object" || typeof value === "function") && value !== null && Symbol.dispose in value && typeof value[Symbol.dispose] === "function";
+const dispose = (value) => Effect.sync(() => {
+	if (isDisposable(value)) value[Symbol.dispose]();
+});
+const resolve = (value) => isPromiseLike(value) ? Effect.tryPromise({
+	try: () => value,
+	catch: (cause) => cause
+}) : Effect.sync(() => value);
+const scoped = (value) => Effect.acquireRelease(resolve(value), (resolved) => dispose(resolved));
+const isPromiseLike = (value) => (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
+//#endregion
+//#region src/internal/RpcInvocation.ts
+const isPropertyTarget = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
+const lookupRpcMethod = (target, method, makeError) => Effect.try({
+	try: () => {
+		if (!isPropertyTarget(target)) throw new TypeError(`RPC target is not object-like`);
+		const value = Reflect.get(target, method);
+		if (typeof value !== "function") throw new TypeError(`RPC method "${String(method)}" is not callable`);
+		return ((...args) => Reflect.apply(value, target, args));
+	},
+	catch: makeError
+});
+const invokeRpcMethod = (target, method, args, makeError) => Effect.gen(function* () {
+	const fn = yield* lookupRpcMethod(target, method, makeError);
+	return yield* Effect.try({
+		try: () => fn(...args),
+		catch: makeError
+	});
+});
+//#endregion
+//#region src/ServiceBinding.ts
+var ServiceBinding_exports = /* @__PURE__ */ __exportAll({
+	Service: () => Service,
+	ServiceBindingFetchError: () => ServiceBindingFetchError,
+	ServiceBindingRpcError: () => ServiceBindingRpcError,
+	isServiceBindingClient: () => isServiceBindingClient,
+	layer: () => layer$7,
+	makeClient: () => makeClient$5,
+	makeDirectMethods: () => makeDirectMethods$1
+});
+const TypeId$1 = "effect-cf/ServiceBinding";
+const expectedServiceBinding = "Worker service binding with fetch()";
 /**
-* Failure raised when forwarding a request to a Durable Object stub.
+* Failure raised when calling `fetch` on a service binding.
 */
-var DurableObjectFetchError = class extends Data.TaggedError("DurableObjectFetchError") {};
-const hasFunction$1 = (value, key) => typeof Reflect.get(value, key) === "function";
-const isDurableObjectNamespaceClient = (value) => typeof value === "object" && value !== null && hasFunction$1(value, "getByName") && hasFunction$1(value, "get") && hasFunction$1(value, "idFromName") && hasFunction$1(value, "idFromString") && hasFunction$1(value, "newUniqueId") && hasFunction$1(value, "jurisdiction");
-const makeClient$4 = (definition) => {
-	return (namespace) => {
-		const newUniqueId = (options) => Effect.sync(() => namespace.newUniqueId(options));
-		const idFromName = (name) => Effect.sync(() => namespace.idFromName(name));
-		const idFromString = (id) => Effect.sync(() => namespace.idFromString(id));
-		const get = (id, options) => Effect.sync(() => namespace.get(id, options));
-		const getByName = (name, options) => Effect.sync(() => namespace.getByName(name, options));
-		const jurisdiction = (value) => Effect.sync(() => namespace.jurisdiction(value));
-		const fetch = (stub, input, init) => Effect.tryPromise({
-			try: () => stub.fetch(input, init),
-			catch: (cause) => new DurableObjectFetchError({
+var ServiceBindingFetchError = class extends Data.TaggedError("ServiceBindingFetchError") {};
+/**
+* Failure raised when invoking an RPC method on a service binding.
+*/
+var ServiceBindingRpcError = class extends Data.TaggedError("ServiceBindingRpcError") {};
+const isServiceBindingClient = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "fetch") === "function";
+const makeClient$5 = (definition) => {
+	return (service) => {
+		const fetch = (input, init) => Effect.tryPromise({
+			try: () => service.fetch(input, init),
+			catch: (cause) => new ServiceBindingFetchError({
 				binding: definition.binding,
 				cause
 			})
 		});
-		const rpc = (stub, method, ...args) => Effect.gen(function* () {
+		const rpc = (method, ...args) => Effect.gen(function* () {
 			const methodName = String(method);
-			return yield* invokeRpcMethod(stub, method, definition.definition === void 0 ? args : yield* encodeArgs(definition.definition, methodName, args).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+			return yield* invokeRpcMethod(service, method, definition.definition === void 0 ? args : yield* encodeArgs(definition.definition, methodName, args).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
 				binding: definition.binding,
 				method: methodName,
 				cause
-			}))), (cause) => new DurableObjectRpcError({
+			}))), (cause) => new ServiceBindingRpcError({
 				binding: definition.binding,
 				method: methodName,
 				cause
 			}));
 		});
-		const decodeSuccess$1 = (methodName, value) => Effect.gen(function* () {
+		const decodeSuccess$2 = (methodName, value) => Effect.gen(function* () {
 			if (definition.definition === void 0) return value;
-			return yield* decodeSuccess(definition.definition, methodName, value).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+			return yield* decodeSuccess(definition.definition, methodName, value).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
 				binding: definition.binding,
 				method: methodName,
 				cause
 			})));
 		});
-		const call = (stub, method, ...args) => Effect.gen(function* () {
+		const call = (method, ...args) => Effect.gen(function* () {
 			const methodName = String(method);
-			return yield* decodeSuccess$1(methodName, yield* resolve(yield* rpc(stub, method, ...args)).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+			return yield* decodeSuccess$2(methodName, yield* resolve(yield* rpc(method, ...args)).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
 				binding: definition.binding,
 				method: methodName,
 				cause
 			}))));
 		});
-		const scopedCall = (stub, method, ...args) => Effect.gen(function* () {
-			return yield* decodeSuccess$1(String(method), yield* scoped(yield* rpc(stub, method, ...args)));
-		});
-		const directMethods = makeDirectMethods(definition.definition, {
-			call,
-			fetch,
-			get,
-			getByName
+		const scopedCall = (method, ...args) => Effect.gen(function* () {
+			return yield* decodeSuccess$2(String(method), yield* scoped(yield* rpc(method, ...args)));
 		});
+		const directMethods = makeDirectMethods$1(definition.definition, call);
 		return Object.assign(directMethods, {
-			newUniqueId,
-			idFromName,
-			idFromString,
-			get,
-			getByName,
-			jurisdiction,
 			fetch,
 			rpc,
 			call,
-			scopedCall,
-			unsafeRaw: Effect.succeed(namespace)
+			scopedCall
 		});
 	};
 };
-const layer$7 = (tag, definition) => layer$10(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$4(definition), { expected: expectedDurableObjectNamespace });
-const makeDirectMethods = (rpcDefinition, helpers) => {
+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.
+*
+* Returned value includes:
+* - a Context tag for dependency injection
+* - `fetch(...)` for raw HTTP forwarding
+* - `rpc(...)` for raw Cloudflare RPC results
+* - `call(...)` for resolved and decoded RPC results
+* - `scopedCall(...)` for scoped and decoded disposable RPC results
+* - direct RPC methods when `definition` is provided
+*
+* @example
+* ```ts
+* const Counter = WorkerDefinition.make("Counter", {
+*   increment: WorkerDefinition.method({
+*     args: [Schema.Number],
+*     success: Schema.Number,
+*   }),
+* });
+*
+* const CounterLive = Counter.layer({ binding: "COUNTER" });
+*
+* const program = Effect.gen(function* () {
+*   const counter = yield* Counter;
+*   const next = yield* counter.increment(1);
+*   return next;
+* });
+* ```
+*/
+const Service = () => (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);
+	});
+	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.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] = (stub, ...args) => helpers.call(stub, methodName, ...args);
-		const makeClient = (getStub) => {
-			const client = { fetch: (input, init) => Effect.gen(function* () {
-				const stub = yield* getStub();
-				return yield* helpers.fetch(stub, input, init);
-			}) };
-			for (const methodName of Object.keys(rpcDefinition.methods)) client[methodName] = (...args) => Effect.gen(function* () {
-				const stub = yield* getStub();
-				return yield* helpers.call(stub, methodName, ...args);
-			});
-			return client;
-		};
-		methods.byName = (name, options) => makeClient(() => helpers.getByName(name, options));
-		methods.byId = (id, options) => makeClient(() => helpers.get(id, options));
-	}
+	if (rpcDefinition !== void 0) for (const methodName of Object.keys(rpcDefinition.methods)) methods[methodName] = (...args) => call(methodName, ...args);
 	return methods;
 };
 //#endregion
-//#region src/DurableObjectDefinition.ts
-var DurableObjectDefinition_exports = /* @__PURE__ */ __exportAll({
-	DurableObject: () => DurableObject$1,
-	Tag: () => Tag$6,
-	implement: () => implement$3,
-	make: () => make$6,
-	method: () => method$1
+//#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$1 = new Set([
+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 Durable Object definition.
+* Defines a single RPC method schema in a worker definition.
 */
-const method$1 = method$4;
+const method$3 = method$4;
 /**
-* Creates a Durable Object RPC definition plus implementation/binding helpers.
+* Creates a typed worker RPC definition plus helpers for implementation and bindings.
 *
 * @example
 * ```ts
-* const ChatRoom = DurableObjectDefinition.make("ChatRoom", {
-*   postMessage: DurableObjectDefinition.method({
-*     args: [Schema.String],
-*     success: Schema.Void,
+* const CounterWorker = WorkerDefinition.make("CounterWorker", {
+*   increment: WorkerDefinition.method({
+*     args: [Schema.Number],
+*     success: Schema.Number,
 *   }),
 * });
 * ```
 */
-const makeDefinition$2 = (id, methods) => {
-	assertNoReservedMethods("Durable Object", methods, reservedMethodNames$1);
-	const definition = make$9(id, methods);
-	return Object.assign(definition, { make: (layer, options) => make$5(layer, {
+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(definition, options.rpc)
+		rpc: wrapHandlers$1(definition, options.rpc)
 	}) });
 };
-const make$6 = (id, methods) => Tag$6()(id, methods);
-const Tag$6 = () => (id, methods) => {
-	const definition = makeDefinition$2(id, methods);
+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 newUniqueId = Effect.fnUntraced(function* (options) {
-		return yield* (yield* tag).newUniqueId(options);
-	});
-	const idFromName = Effect.fnUntraced(function* (name) {
-		return yield* (yield* tag).idFromName(name);
-	});
-	const idFromString = Effect.fnUntraced(function* (value) {
-		return yield* (yield* tag).idFromString(value);
-	});
-	const get = Effect.fnUntraced(function* (objectId, options) {
-		return yield* (yield* tag).get(objectId, options);
-	});
-	const getByName = Effect.fnUntraced(function* (name, options) {
-		return yield* (yield* tag).getByName(name, options);
-	});
-	const jurisdiction = Effect.fnUntraced(function* (value) {
-		return yield* (yield* tag).jurisdiction(value);
-	});
-	const fetch = (stub, input, init) => Effect.gen(function* () {
-		return yield* (yield* tag).fetch(stub, input, init);
-	});
-	const rpc = (stub, method, ...args) => Effect.gen(function* () {
-		return yield* (yield* tag).rpc(stub, method, ...args);
-	});
-	const call = (stub, method, ...args) => Effect.gen(function* () {
-		return yield* (yield* tag).call(stub, method, ...args);
+	const fetch = (input, init) => Effect.gen(function* () {
+		return yield* (yield* tag).fetch(input, init);
 	});
-	const scopedCall = (stub, method, ...args) => Effect.gen(function* () {
-		return yield* (yield* tag).scopedCall(stub, method, ...args);
+	const rpc = (method, ...args) => Effect.gen(function* () {
+		return yield* (yield* tag).rpc(method, ...args);
 	});
-	const unsafeRaw = Effect.fnUntraced(function* () {
-		return yield* (yield* tag).unsafeRaw;
+	const call = (method, ...args) => Effect.gen(function* () {
+		return yield* (yield* tag).call(method, ...args);
 	});
-	const directMethods = makeDirectMethods(definition, {
-		call,
-		fetch,
-		get,
-		getByName
+	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,
-		newUniqueId,
-		idFromName,
-		idFromString,
-		get,
-		getByName,
-		jurisdiction,
 		fetch,
 		rpc,
 		call,
-		scopedCall,
-		unsafeRaw
+		scopedCall
 	});
 };
-const DurableObject$1 = Tag$6;
-const wrapHandlers = (definition, handlers) => {
+const Worker = Tag$8;
+const wrapHandlers$1 = (definition, handlers) => {
 	const wrapped = {};
 	for (const key of Object.keys(definition.methods)) {
 		const handler = handlers[key];
@@ -1201,444 +1177,418 @@ const wrapHandlers = (definition, handlers) => {
 /**
 * Helper for implementing handlers with the exact method shape of a definition.
 */
-const implement$3 = (_definition, handlers) => handlers;
+const implement$5 = (_definition, handlers) => handlers;
 //#endregion
-//#region src/DurableObject.ts
-var DurableObject_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$5,
-	implement: () => implement$2,
-	make: () => make$5,
-	method: () => method
-});
-const reservedMethodNames = new Set([
-	"constructor",
-	"dup",
-	"fetch",
-	"alarm",
-	"webSocketMessage",
-	"webSocketClose",
-	"webSocketError"
-]);
-const RunSymbol = Symbol.for("effect-cf/DurableObject/run");
-/**
-* Creates a Durable Object class backed by a single managed Effect runtime.
-*/
-const make$5 = (layer, options = {}) => {
-	class EffectDurableObject extends DurableObject {
-		runtime;
-		constructor(state, env) {
-			super(state, env);
-			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));
-		}
-		[RunSymbol](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 }));
-			return this[RunSymbol](Effect.provideService(fetchHandler, NativeRequest, request));
-		}
-		alarm(alarmInfo) {
-			const logicalAlarms = options.alarms?.pipe(Effect.asVoid);
-			const rawAlarm = options.alarm?.(alarmInfo);
-			if (logicalAlarms !== void 0 && rawAlarm !== void 0) return this[RunSymbol](Effect.gen(function* () {
-				yield* logicalAlarms;
-				yield* rawAlarm;
-			}));
-			if (logicalAlarms !== void 0) return this[RunSymbol](logicalAlarms);
-			if (rawAlarm !== void 0) return this[RunSymbol](rawAlarm);
-		}
-		webSocketMessage(socket, message) {
-			if (options.webSocketMessage !== void 0) return this[RunSymbol](options.webSocketMessage(fromWebSocket(socket), message));
+//#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)));
 		}
-		webSocketClose(socket, code, reason, wasClean) {
-			if (options.webSocketClose !== void 0) return this[RunSymbol](options.webSocketClose(fromWebSocket(socket), code, reason, wasClean));
+	});
+};
+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())
+	};
+};
+//#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
+});
+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);
 		}
-		webSocketError(socket, error) {
-			if (options.webSocketError !== void 0) return this[RunSymbol](options.webSocketError(fromWebSocket(socket), error));
+		[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("Durable Object", EffectDurableObject.prototype, options.rpc, reservedMethodNames, (self, effect) => self[RunSymbol](effect));
-	return assumeEntrypointClass(EffectDurableObject);
+	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$5 = Tag$6;
-const method = method$1;
-const implement$2 = implement$3;
+const Tag$7 = Tag$8;
+const method$2 = method$3;
+const implement$4 = implement$5;
 //#endregion
-//#region src/CloudflareOtlp.ts
-var CloudflareOtlp_exports = /* @__PURE__ */ __exportAll({
-	CloudflareOtlpSettings: () => CloudflareOtlpSettings,
-	durableObjectLayer: () => durableObjectLayer,
-	instrumentDurableObjectOptions: () => instrumentDurableObjectOptions,
-	instrumentWorkerOptions: () => instrumentWorkerOptions,
+//#region src/DurableObjectNamespace.ts
+var DurableObjectNamespace_exports = /* @__PURE__ */ __exportAll({
+	DurableObjectFetchError: () => DurableObjectFetchError,
+	DurableObjectRpcError: () => DurableObjectRpcError,
+	isDurableObjectNamespaceClient: () => isDurableObjectNamespaceClient,
 	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)
+	makeClient: () => makeClient$4,
+	makeDirectMethods: () => makeDirectMethods
 });
+const expectedDurableObjectNamespace = "Durable Object namespace binding with getByName(), get(), idFromName(), idFromString(), newUniqueId(), and jurisdiction()";
 /**
-* 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));
-* ```
+* Failure raised when invoking an RPC method on a Durable Object stub.
 */
-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)
-});
+var DurableObjectRpcError = class extends Data.TaggedError("DurableObjectRpcError") {};
 /**
-* 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.
+* Failure raised when forwarding a request to a Durable Object stub.
 */
-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
+var DurableObjectFetchError = class extends Data.TaggedError("DurableObjectFetchError") {};
+const hasFunction$1 = (value, key) => typeof Reflect.get(value, key) === "function";
+const isDurableObjectNamespaceClient = (value) => typeof value === "object" && value !== null && hasFunction$1(value, "getByName") && hasFunction$1(value, "get") && hasFunction$1(value, "idFromName") && hasFunction$1(value, "idFromString") && hasFunction$1(value, "newUniqueId") && hasFunction$1(value, "jurisdiction");
+const makeClient$4 = (definition) => {
+	return (namespace) => {
+		const newUniqueId = (options) => Effect.sync(() => namespace.newUniqueId(options));
+		const idFromName = (name) => Effect.sync(() => namespace.idFromName(name));
+		const idFromString = (id) => Effect.sync(() => namespace.idFromString(id));
+		const get = (id, options) => Effect.sync(() => namespace.get(id, options));
+		const getByName = (name, options) => Effect.sync(() => namespace.getByName(name, options));
+		const jurisdiction = (value) => Effect.sync(() => namespace.jurisdiction(value));
+		const fetch = (stub, input, init) => Effect.tryPromise({
+			try: () => stub.fetch(input, init),
+			catch: (cause) => new DurableObjectFetchError({
+				binding: definition.binding,
+				cause
+			})
+		});
+		const rpc = (stub, method, ...args) => Effect.gen(function* () {
+			const methodName = String(method);
+			return yield* invokeRpcMethod(stub, method, definition.definition === void 0 ? args : yield* encodeArgs(definition.definition, methodName, args).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			}))), (cause) => new DurableObjectRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			}));
+		});
+		const decodeSuccess$1 = (methodName, value) => Effect.gen(function* () {
+			if (definition.definition === void 0) return value;
+			return yield* decodeSuccess(definition.definition, methodName, value).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			})));
+		});
+		const call = (stub, method, ...args) => Effect.gen(function* () {
+			const methodName = String(method);
+			return yield* decodeSuccess$1(methodName, yield* resolve(yield* rpc(stub, method, ...args)).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			}))));
+		});
+		const scopedCall = (stub, method, ...args) => Effect.gen(function* () {
+			return yield* decodeSuccess$1(String(method), yield* scoped(yield* rpc(stub, method, ...args)));
+		});
+		const directMethods = makeDirectMethods(definition.definition, {
+			call,
+			fetch,
+			get,
+			getByName
+		});
+		return Object.assign(directMethods, {
+			newUniqueId,
+			idFromName,
+			idFromString,
+			get,
+			getByName,
+			jurisdiction,
+			fetch,
+			rpc,
+			call,
+			scopedCall,
+			unsafeRaw: Effect.succeed(namespace)
+		});
 	};
 };
-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)));
+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) {
+		for (const methodName of Object.keys(rpcDefinition.methods)) methods[methodName] = (stub, ...args) => helpers.call(stub, methodName, ...args);
+		const makeClient = (getStub) => {
+			const client = { fetch: (input, init) => Effect.gen(function* () {
+				const stub = yield* getStub();
+				return yield* helpers.fetch(stub, input, init);
+			}) };
+			for (const methodName of Object.keys(rpcDefinition.methods)) client[methodName] = (...args) => Effect.gen(function* () {
+				const stub = yield* getStub();
+				return yield* helpers.call(stub, methodName, ...args);
+			});
+			return client;
+		};
+		methods.byName = (name, options) => makeClient(() => helpers.getByName(name, options));
+		methods.byId = (id, options) => makeClient(() => helpers.get(id, options));
 	}
-	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"
+	return methods;
+};
+//#endregion
+//#region src/DurableObjectDefinition.ts
+var DurableObjectDefinition_exports = /* @__PURE__ */ __exportAll({
+	DurableObject: () => DurableObject$1,
+	Tag: () => Tag$6,
+	implement: () => implement$3,
+	make: () => make$5,
+	method: () => method$1
 });
+const reservedMethodNames$1 = new Set([
+	"constructor",
+	"dup",
+	"fetch",
+	"alarm",
+	"webSocketMessage",
+	"webSocketClose",
+	"webSocketError"
+]);
 /**
-* 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.
+* Defines a single RPC method schema in a Durable Object definition.
 */
-const workerLayer = (options = {}) => makeLayer(options, {
-	"cloudflare.resource_type": "worker",
-	"cloudflare.worker.name": options.workerName
-});
+const method$1 = method$4;
 /**
-* OTLP layer with Cloudflare Durable Object resource attributes.
+* Creates a Durable Object RPC definition plus implementation/binding helpers.
 *
-* 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.
+* @example
+* ```ts
+* const ChatRoom = DurableObjectDefinition.make("ChatRoom", {
+*   postMessage: DurableObjectDefinition.method({
+*     args: [Schema.String],
+*     success: Schema.Void,
+*   }),
+* });
+* ```
 */
-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));
-	} });
+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, {
+		...options,
+		rpc: wrapHandlers(definition, options.rpc)
+	}) });
 };
-/**
-* 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)
-	};
+const make$5 = (id, methods) => Tag$6()(id, methods);
+const Tag$6 = () => (id, methods) => {
+	const definition = makeDefinition$2(id, methods);
+	const tag = Context.Service()(id);
+	const bindingDefinition = (binding) => ({
+		...binding,
+		definition
+	});
+	const layer = (binding) => layer$6(tag, bindingDefinition(binding));
+	const newUniqueId = Effect.fnUntraced(function* (options) {
+		return yield* (yield* tag).newUniqueId(options);
+	});
+	const idFromName = Effect.fnUntraced(function* (name) {
+		return yield* (yield* tag).idFromName(name);
+	});
+	const idFromString = Effect.fnUntraced(function* (value) {
+		return yield* (yield* tag).idFromString(value);
+	});
+	const get = Effect.fnUntraced(function* (objectId, options) {
+		return yield* (yield* tag).get(objectId, options);
+	});
+	const getByName = Effect.fnUntraced(function* (name, options) {
+		return yield* (yield* tag).getByName(name, options);
+	});
+	const jurisdiction = Effect.fnUntraced(function* (value) {
+		return yield* (yield* tag).jurisdiction(value);
+	});
+	const fetch = (stub, input, init) => Effect.gen(function* () {
+		return yield* (yield* tag).fetch(stub, input, init);
+	});
+	const rpc = (stub, method, ...args) => Effect.gen(function* () {
+		return yield* (yield* tag).rpc(stub, method, ...args);
+	});
+	const call = (stub, method, ...args) => Effect.gen(function* () {
+		return yield* (yield* tag).call(stub, method, ...args);
+	});
+	const scopedCall = (stub, method, ...args) => Effect.gen(function* () {
+		return yield* (yield* tag).scopedCall(stub, method, ...args);
+	});
+	const unsafeRaw = Effect.fnUntraced(function* () {
+		return yield* (yield* tag).unsafeRaw;
+	});
+	const directMethods = makeDirectMethods(definition, {
+		call,
+		fetch,
+		get,
+		getByName
+	});
+	return Object.assign(tag, directMethods, {
+		id: definition.id,
+		methods: definition.methods,
+		make: definition.make,
+		layer,
+		newUniqueId,
+		idFromName,
+		idFromString,
+		get,
+		getByName,
+		jurisdiction,
+		fetch,
+		rpc,
+		call,
+		scopedCall,
+		unsafeRaw
+	});
+};
+const DurableObject$1 = Tag$6;
+const wrapHandlers = (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;
 };
 /**
-* 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.
+* Helper for implementing handlers with the exact method shape of a definition.
 */
-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)
-	};
-};
+const implement$3 = (_definition, handlers) => handlers;
 //#endregion
-//#region src/D1.ts
-var D1_exports = /* @__PURE__ */ __exportAll({
-	Service: () => Service,
-	make: () => make$4
+//#region src/DurableObject.ts
+var DurableObject_exports = /* @__PURE__ */ __exportAll({
+	Tag: () => Tag$5,
+	implement: () => implement$2,
+	make: () => make$4,
+	method: () => method
 });
-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);
+const reservedMethodNames = new Set([
+	"constructor",
+	"dup",
+	"fetch",
+	"alarm",
+	"webSocketMessage",
+	"webSocketClose",
+	"webSocketError"
+]);
+const RunSymbol = Symbol.for("effect-cf/DurableObject/run");
 /**
-* 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();
-* ```
+* Creates a Durable Object class backed by a single managed Effect runtime.
 */
-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
-	});
+const make$4 = (layer, options = {}) => {
+	class EffectDurableObject extends DurableObject {
+		runtime;
+		constructor(state, env) {
+			super(state, env);
+			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, { eventLayer: false }));
+		}
+		[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;
+			if (fetchHandler === void 0) return Promise.resolve(new Response("Not Found", { status: 404 }));
+			return this[RunSymbol](Effect.provideService(fetchHandler, NativeRequest, request));
+		}
+		alarm(alarmInfo) {
+			const logicalAlarms = options.alarms?.pipe(Effect.asVoid);
+			const rawAlarm = options.alarm?.(alarmInfo);
+			if (logicalAlarms !== void 0 && rawAlarm !== void 0) return this[RunSymbol](Effect.gen(function* () {
+				yield* logicalAlarms;
+				yield* rawAlarm;
+			}));
+			if (logicalAlarms !== void 0) return this[RunSymbol](logicalAlarms);
+			if (rawAlarm !== void 0) return this[RunSymbol](rawAlarm);
+		}
+		webSocketMessage(socket, message) {
+			if (options.webSocketMessage !== void 0) return this[RunSymbol](options.webSocketMessage(fromWebSocket(socket), message));
+		}
+		webSocketClose(socket, code, reason, wasClean) {
+			if (options.webSocketClose !== void 0) return this[RunSymbol](options.webSocketClose(fromWebSocket(socket), code, reason, wasClean));
+		}
+		webSocketError(socket, error) {
+			if (options.webSocketError !== void 0) return this[RunSymbol](options.webSocketError(fromWebSocket(socket), error));
+		}
+	}
+	defineEntrypointRpcMethods("Durable Object", EffectDurableObject.prototype, options.rpc, reservedMethodNames, (self, effect) => self[RunSymbol](effect));
+	return assumeEntrypointClass(EffectDurableObject);
 };
+const Tag$5 = Tag$6;
+const method = method$1;
+const implement$2 = implement$3;
 //#endregion
 //#region src/DurableObjectAlarm.ts
 var DurableObjectAlarm_exports = /* @__PURE__ */ __exportAll({