effect-cf 0.20.1 → 0.22.0

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { Cause, Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Layer, ManagedRuntime, Option, Queue, Result, Schema } from "effect";
+import { Cause, Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Function as Function$1, Layer, ManagedRuntime, Option, Predicate, Queue, Result, Schema } from "effect";
 import { FetchHttpClient, HttpClient, HttpClientRequest, HttpEffect, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
-import { OtlpLogger, OtlpMetrics, OtlpSerialization, OtlpTracer } from "effect/unstable/observability";
+import { OtlpExporter, OtlpLogger, OtlpMetrics, OtlpSerialization, OtlpTracer } from "effect/unstable/observability";
 import { D1Client } from "@effect/sql-d1";
 import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, WorkflowEntrypoint } from "cloudflare:workers";
 import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
@@ -9,6 +9,10 @@ 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/Environment.ts
+var Environment_exports = /* @__PURE__ */ __exportAll({
+	WorkerConfig: () => WorkerConfig,
+	WorkerEnvironment: () => WorkerEnvironment
+});
 /**
 * Context service for reading worker bindings from the current `env` object.
 */
@@ -20,7 +24,7 @@ let WorkerConfig;
 	_WorkerConfig.number = (name) => Config.number(name);
 	_WorkerConfig.integer = (name) => Config.int(name);
 	_WorkerConfig.boolean = (name) => Config.boolean(name);
-	const providerFromEnv = _WorkerConfig.providerFromEnv = (env) => ConfigProvider.fromUnknown(env);
+	const providerFromEnv = _WorkerConfig.providerFromEnv = (env, options) => ConfigProvider.fromUnknown(env, options);
 	const providerWith = _WorkerConfig.providerWith = (makeProvider) => Effect.map(WorkerEnvironment, makeProvider);
 	const provider = _WorkerConfig.provider = providerWith(providerFromEnv);
 	_WorkerConfig.layer = _WorkerConfig.providerLayer = ConfigProvider.layer(provider);
@@ -33,10 +37,10 @@ var Binding_exports = /* @__PURE__ */ __exportAll({
 	BindingValidationError: () => BindingValidationError,
 	Service: () => Service$2,
 	TypeId: () => TypeId$3,
-	layer: () => layer$20
+	layer: () => layer$19
 });
 /** Internal type id marker used by binding helper services. */
-const TypeId$3 = "effect-cf/Binding";
+const TypeId$3 = "~effect-cf/Binding";
 /** Error raised when a configured binding does not exist on `env`. */
 var BindingNotFoundError = class extends Data.TaggedError("BindingNotFoundError") {};
 /** Error raised when a binding exists but does not match the expected shape. */
@@ -118,34 +122,69 @@ const getBinding = (env, binding, isResource, options) => Effect.gen(function* (
 	}
 	return resource;
 });
-const layer$20 = (tag, binding, isResource, wrap, options) => Layer.effect(tag, Effect.gen(function* () {
+/**
+* The overloads on {@link layer} and {@link Service} guarantee that
+* `Service = Resource` whenever `wrap` is absent, making the fallback cast
+* safe.
+*/
+const makeBindingLayer = (tag, binding, isResource, wrap, options) => Layer.effect(tag, Effect.gen(function* () {
 	const env = yield* WorkerEnvironment;
 	const resource = yield* getBinding(env, binding, isResource, options);
 	return wrap === void 0 ? resource : wrap(resource);
 }));
-const Service$2 = () => (id, binding, isResource, wrap, options) => {
-	const tag = Context.Service()(id);
-	const serviceLayer = layer$20(tag, binding, isResource, wrap, options);
-	return Object.assign(tag, {
-		[TypeId$3]: TypeId$3,
-		binding,
-		layer: serviceLayer
-	});
+function layer$19(tag, binding, isResource, wrap, options) {
+	return makeBindingLayer(tag, binding, isResource, wrap, options);
+}
+const Service$2 = () => {
+	function makeService(id, binding, isResource, wrap, options) {
+		const tag = Context.Service()(`effect-cf/Binding/${id}`);
+		const serviceLayer = makeBindingLayer(tag, binding, isResource, wrap, options);
+		return Object.assign(tag, {
+			[TypeId$3]: TypeId$3,
+			id,
+			binding,
+			layer: serviceLayer
+		});
+	}
+	return makeService;
+};
+//#endregion
+//#region src/internal/ErrorMessage.ts
+/**
+* Renders the most useful human-readable description of an unknown `cause`
+* for use in tagged error `message` getters.
+*/
+const causeMessage = (cause) => {
+	if (typeof cause === "object" && cause !== null) {
+		const message = Reflect.get(cause, "message");
+		if (typeof message === "string" && message.length > 0) return message;
+	}
+	try {
+		return String(cause);
+	} catch {
+		return "unknown cause";
+	}
 };
+/** Renders a violation list as a single `path: message; ...` line. */
+const violationsMessage = (violations) => violations.map((violation) => `${violation.path}: ${violation.message}`).join("; ");
 //#endregion
 //#region src/WorkersAi.ts
 var WorkersAi_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$18,
+	Tag: () => Tag$16,
 	WorkersAiOperationError: () => WorkersAiOperationError,
 	embeddingResponse: () => embeddingResponse,
 	isWorkersAiBinding: () => isWorkersAiBinding,
-	layer: () => layer$19,
+	layer: () => layer$18,
 	make: () => make$18,
 	makeClient: () => makeClient$15
 });
 const expectedWorkersAiBinding = "Workers AI binding with run(), gateway(), and models()";
 /** Error raised when a Workers AI operation fails. */
-var WorkersAiOperationError = class extends Data.TaggedError("WorkersAiOperationError") {};
+var WorkersAiOperationError = class extends Data.TaggedError("WorkersAiOperationError") {
+	get message() {
+		return `Workers AI ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
 const workersAiError = (binding, operation, cause) => new WorkersAiOperationError({
 	binding,
 	operation,
@@ -166,22 +205,22 @@ const embeddingResponse = (value) => ({
 	shape: value.shape ?? []
 });
 const makeClient$15 = (definition) => (ai) => {
-	const run = ((model, input, options) => tryWorkersAiPromise(definition.binding, "run", () => ai.run(model, input, options)));
+	const run = Effect.fn("WorkersAi.run")((model, input, options) => tryWorkersAiPromise(definition.binding, "run", () => ai.run(model, input, options)));
 	return {
 		definition,
 		aiGatewayLogId: tryWorkersAiSync(definition.binding, "aiGatewayLogId", () => ai.aiGatewayLogId),
 		run,
-		runEmbedding: (model, input, options) => run(model, input, options).pipe(Effect.map((response) => embeddingResponse(response))),
-		models: (params) => tryWorkersAiPromise(definition.binding, "models", () => ai.models(params)),
+		runEmbedding: Effect.fn("WorkersAi.runEmbedding")((model, input, options) => run(model, input, options).pipe(Effect.map((response) => embeddingResponse(response)))),
+		models: Effect.fn("WorkersAi.models")((params) => tryWorkersAiPromise(definition.binding, "models", () => ai.models(params))),
 		gateway: (gatewayId) => tryWorkersAiSync(definition.binding, "gateway", () => ai.gateway(gatewayId)),
-		unsafeRaw: Effect.succeed(ai)
+		rawUnsafe: Effect.succeed(ai)
 	};
 };
-const layer$19 = (tag, definition) => layer$20(tag, definition.binding, (value) => isWorkersAiBinding(value), makeClient$15(definition), { expected: expectedWorkersAiBinding });
-const make$18 = (id) => Tag$18()(id);
-const Tag$18 = () => (id) => {
+const layer$18 = (tag, definition) => layer$19(tag, definition.binding, (value) => isWorkersAiBinding(value), makeClient$15(definition), { expected: expectedWorkersAiBinding });
+const make$18 = (id) => Tag$16()(id);
+const Tag$16 = () => (id) => {
 	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$19(tag, definition);
+	const makeLayer = (definition) => layer$18(tag, definition);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer
@@ -191,9 +230,9 @@ const Tag$18 = () => (id) => {
 //#region src/AiGateway.ts
 var AiGateway_exports = /* @__PURE__ */ __exportAll({
 	AiGatewayOperationError: () => AiGatewayOperationError,
-	Tag: () => Tag$17,
+	Tag: () => Tag$15,
 	isAiGatewayBinding: () => isAiGatewayBinding,
-	layer: () => layer$18,
+	layer: () => layer$17,
 	make: () => make$17,
 	makeClient: () => makeClient$14,
 	makeClientFromAi: () => makeClientFromAi,
@@ -201,7 +240,11 @@ var AiGateway_exports = /* @__PURE__ */ __exportAll({
 });
 const expectedAiGatewayBinding = "Workers AI binding with gateway()";
 /** Error raised when an AI Gateway operation fails. */
-var AiGatewayOperationError = class extends Data.TaggedError("AiGatewayOperationError") {};
+var AiGatewayOperationError = class extends Data.TaggedError("AiGatewayOperationError") {
+	get message() {
+		return `AI Gateway ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
 const aiGatewayError = (binding, operation, cause) => new AiGatewayOperationError({
 	binding,
 	operation,
@@ -211,6 +254,7 @@ const tryAiGatewayPromise = (binding, operation, evaluate) => Effect.tryPromise(
 	try: evaluate,
 	catch: (cause) => aiGatewayError(binding, operation, cause)
 });
+const mergeAbortSignals = (userSignal, signal) => userSignal === null || userSignal === void 0 ? signal : AbortSignal.any([userSignal, signal]);
 const tryAiGatewaySync = (binding, operation, evaluate) => Effect.try({
 	try: evaluate,
 	catch: (cause) => aiGatewayError(binding, operation, cause)
@@ -224,15 +268,18 @@ const gatewayUrl = (definition) => `https://gateway.ai.cloudflare.com/v1/${defin
 const isAiGatewayBinding = (value) => isWorkersAiBinding(value);
 const makeClient$14 = (definition, gateway) => ({
 	definition,
-	run: (data, options) => tryAiGatewayPromise(definition.binding, "run", () => gateway.run(Array.isArray(data) ? [...data] : data, options)),
-	getUrl: (provider) => tryAiGatewayPromise(definition.binding, "getUrl", () => gateway.getUrl(provider)),
-	fetch: (options) => Effect.gen(function* () {
+	run: Effect.fn("AiGateway.run")((data, options) => tryAiGatewayPromise(definition.binding, "run", () => gateway.run(Array.isArray(data) ? [...data] : data, options))),
+	getUrl: Effect.fn("AiGateway.getUrl")((provider) => tryAiGatewayPromise(definition.binding, "getUrl", () => gateway.getUrl(provider))),
+	fetch: Effect.fn("AiGateway.fetch")(function* (options) {
 		const baseUrl = yield* tryAiGatewayPromise(definition.binding, "getUrl", () => gateway.getUrl(options.provider));
-		return yield* tryAiGatewayPromise(definition.binding, "fetch", () => fetch(providerUrl(baseUrl, options.path).href, options.init));
+		return yield* tryAiGatewayPromise(definition.binding, "fetch", (signal) => fetch(providerUrl(baseUrl, options.path).href, {
+			...options.init,
+			signal: mergeAbortSignals(options.init?.signal, signal)
+		}));
 	}),
-	patchLog: (logId, data) => tryAiGatewayPromise(definition.binding, "patchLog", () => gateway.patchLog(logId, data)),
-	getLog: (logId) => tryAiGatewayPromise(definition.binding, "getLog", () => gateway.getLog(logId)),
-	unsafeRaw: Effect.succeed(gateway)
+	patchLog: Effect.fn("AiGateway.patchLog")((logId, data) => tryAiGatewayPromise(definition.binding, "patchLog", () => gateway.patchLog(logId, data))),
+	getLog: Effect.fn("AiGateway.getLog")((logId) => tryAiGatewayPromise(definition.binding, "getLog", () => gateway.getLog(logId))),
+	rawUnsafe: Effect.succeed(gateway)
 });
 const makeClientFromAi = (definition, ai) => {
 	const gateway = tryAiGatewaySync(definition.binding, "gateway", () => ai.gateway(definition.gatewayId));
@@ -244,7 +291,7 @@ const makeClientFromAi = (definition, ai) => {
 		fetch: (options) => withGateway((raw) => makeClient$14(definition, raw).fetch(options)),
 		patchLog: (logId, data) => withGateway((raw) => makeClient$14(definition, raw).patchLog(logId, data)),
 		getLog: (logId) => withGateway((raw) => makeClient$14(definition, raw).getLog(logId)),
-		unsafeRaw: gateway
+		rawUnsafe: gateway
 	};
 };
 const makeHttpClient = (definition, request = fetch) => {
@@ -261,33 +308,37 @@ const makeHttpClient = (definition, request = fetch) => {
 	};
 	return {
 		definition: clientDefinition,
-		run: (data, options) => tryAiGatewayPromise(binding, "run", () => request(gatewayUrl(definition), {
+		run: Effect.fn("AiGateway.run")((data, options) => tryAiGatewayPromise(binding, "run", (signal) => request(gatewayUrl(definition), {
 			method: "POST",
 			body: JSON.stringify(data),
 			headers: new Headers({
 				"content-type": "application/json",
 				...Object.fromEntries(new Headers(extraHeaders(options)).entries())
 			}),
-			signal: options?.signal
-		})),
+			signal: mergeAbortSignals(options?.signal, signal)
+		}))),
 		getUrl,
-		fetch: (options) => getUrl(options.provider).pipe(Effect.flatMap((baseUrl) => tryAiGatewayPromise(binding, "fetch", () => request(providerUrl(baseUrl, options.path).href, options.init)))),
-		patchLog: (logId, data) => tryAiGatewayPromise(binding, "patchLog", () => request(providerUrl(gatewayUrl(definition), `logs/${logId}`).href, {
+		fetch: Effect.fn("AiGateway.fetch")((options) => getUrl(options.provider).pipe(Effect.flatMap((baseUrl) => tryAiGatewayPromise(binding, "fetch", (signal) => request(providerUrl(baseUrl, options.path).href, {
+			...options.init,
+			signal: mergeAbortSignals(options.init?.signal, signal)
+		}))))),
+		patchLog: Effect.fn("AiGateway.patchLog")((logId, data) => tryAiGatewayPromise(binding, "patchLog", (signal) => request(providerUrl(gatewayUrl(definition), `logs/${logId}`).href, {
 			method: "PATCH",
 			body: JSON.stringify(data),
-			headers: { "content-type": "application/json" }
-		}).then(() => void 0)),
-		getLog: (logId) => tryAiGatewayPromise(binding, "getLog", async () => {
-			return await (await request(providerUrl(gatewayUrl(definition), `logs/${logId}`).href)).json();
-		}),
-		unsafeRaw: Effect.fail(aiGatewayError(binding, "unsafeRaw", /* @__PURE__ */ new TypeError("HTTP AI Gateway clients have no raw binding")))
+			headers: { "content-type": "application/json" },
+			signal
+		}).then(() => void 0))),
+		getLog: Effect.fn("AiGateway.getLog")((logId) => tryAiGatewayPromise(binding, "getLog", async (signal) => {
+			return await (await request(providerUrl(gatewayUrl(definition), `logs/${logId}`).href, { signal })).json();
+		})),
+		rawUnsafe: Effect.fail(aiGatewayError(binding, "rawUnsafe", /* @__PURE__ */ new TypeError("HTTP AI Gateway clients have no raw binding")))
 	};
 };
-const layer$18 = (tag, definition) => layer$20(tag, definition.binding, isAiGatewayBinding, (ai) => makeClientFromAi(definition, ai), { expected: expectedAiGatewayBinding });
-const make$17 = (id) => Tag$17()(id);
-const Tag$17 = () => (id) => {
+const layer$17 = (tag, definition) => layer$19(tag, definition.binding, isAiGatewayBinding, (ai) => makeClientFromAi(definition, ai), { expected: expectedAiGatewayBinding });
+const make$17 = (id) => Tag$15()(id);
+const Tag$15 = () => (id) => {
 	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$18(tag, definition);
+	const makeLayer = (definition) => layer$17(tag, definition);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer
@@ -302,16 +353,16 @@ var AnalyticsEngine_exports = /* @__PURE__ */ __exportAll({
 	AnalyticsEngineQueryError: () => AnalyticsEngineQueryError,
 	AnalyticsEngineWriteValidationError: () => AnalyticsEngineWriteValidationError,
 	QueryTag: () => QueryTag,
-	Tag: () => Tag$16,
+	Tag: () => Tag$14,
 	isAnalyticsEngineDataset: () => isAnalyticsEngineDataset,
-	layer: () => layer$17,
+	layer: () => layer$16,
+	layerFetch: () => layerFetch,
+	layerFetchConfig: () => layerFetchConfig,
 	make: () => make$16,
 	makeClient: () => makeClient$13,
 	makeQuery: () => makeQuery,
 	makeQueryClient: () => makeQueryClient,
 	queryConfig: () => queryConfig,
-	queryFetchLayer: () => queryFetchLayer,
-	queryFetchLayerConfig: () => queryFetchLayerConfig,
 	queryLayer: () => queryLayer,
 	queryLayerConfig: () => queryLayerConfig,
 	writeLimits: () => writeLimits
@@ -346,9 +397,17 @@ const AnalyticsEngineDataPointSchema = Schema.Struct({
 const decodeQueryResponse = Schema.decodeUnknownEffect(queryResponseSchema);
 const decodeDataPoint = Schema.decodeUnknownEffect(AnalyticsEngineDataPointSchema);
 /** Error raised when an Analytics Engine operation fails. */
-var AnalyticsEngineOperationError = class extends Data.TaggedError("AnalyticsEngineOperationError") {};
+var AnalyticsEngineOperationError = class extends Data.TaggedError("AnalyticsEngineOperationError") {
+	get message() {
+		return `Analytics Engine ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
 /** Error raised when an Analytics Engine write input violates Cloudflare limits. */
-var AnalyticsEngineWriteValidationError = class extends Data.TaggedError("AnalyticsEngineWriteValidationError") {};
+var AnalyticsEngineWriteValidationError = class extends Data.TaggedError("AnalyticsEngineWriteValidationError") {
+	get message() {
+		return `Analytics Engine ${this.operation} for binding "${this.binding}" failed validation: ${violationsMessage(this.violations)}`;
+	}
+};
 /** Error raised when an Analytics Engine SQL API query fails. */
 var AnalyticsEngineQueryError = class extends Data.TaggedError("AnalyticsEngineQueryError") {};
 const analyticsEngineError = (binding, operation, cause) => new AnalyticsEngineOperationError({
@@ -470,8 +529,8 @@ const executeQueryRequest = (definition, httpClient, sql, options) => Effect.gen
 	return response;
 });
 const makeQueryClientWith = (definition, httpClient) => {
-	const raw = (sql, options) => executeQueryRequest(definition, httpClient, sql, options);
-	const query = (sql, options) => Effect.gen(function* () {
+	const raw = Effect.fn("AnalyticsEngine.raw")((sql, options) => executeQueryRequest(definition, httpClient, sql, options));
+	const query = Effect.fn("AnalyticsEngine.query")(function* (sql, options) {
 		const json = yield* (yield* raw(sql, options)).json.pipe(Effect.catch((cause) => Effect.fail(analyticsEngineQueryError(definition, "json", "Failed to read Analytics Engine SQL API JSON response body", { cause }))));
 		return yield* decodeQueryResponse(json);
 	});
@@ -485,15 +544,15 @@ const makeQueryClientWith = (definition, httpClient) => {
 			data,
 			rows: result.rows
 		};
-	});
+	}).pipe(Effect.withSpan("AnalyticsEngine.queryResult"));
 	return {
 		definition,
 		raw,
 		query,
 		queryResult,
-		queryRows: (row, sql, options) => queryResult(row, sql, options).pipe(Effect.map((result) => result.data)),
-		queryOne: (row, sql, options) => queryResult(row, sql, options).pipe(Effect.map((result) => result.data[0] === void 0 ? Option.none() : Option.some(result.data[0]))),
-		queryText: (sql, options) => raw(sql, options).pipe(Effect.flatMap((response) => responseText(definition, response, "text")))
+		queryRows: (row, sql, options) => queryResult(row, sql, options).pipe(Effect.map((result) => result.data), Effect.withSpan("AnalyticsEngine.queryRows")),
+		queryOne: (row, sql, options) => queryResult(row, sql, options).pipe(Effect.map((result) => result.data[0] === void 0 ? Option.none() : Option.some(result.data[0])), Effect.withSpan("AnalyticsEngine.queryOne")),
+		queryText: Effect.fn("AnalyticsEngine.queryText")((sql, options) => raw(sql, options).pipe(Effect.flatMap((response) => responseText(definition, response, "text"))))
 	};
 };
 const makeQueryClient = (definition) => Effect.map(HttpClient.HttpClient, (httpClient) => makeQueryClientWith(definition, httpClient));
@@ -502,27 +561,25 @@ const isAnalyticsEngineDataset = (value) => {
 	return typeof Reflect.get(value, "writeDataPoint") === "function";
 };
 const makeClient$13 = (definition, defaults) => (dataset) => {
-	const writeDataPoint = (dataPoint, options) => {
+	const writeDataPoint = Effect.fn("AnalyticsEngine.writeDataPoint")((dataPoint, options) => {
 		const policy = resolveWritePolicy(defaults, options);
 		return validateOptionalDataPoint(definition.binding, "writeDataPoint", dataPoint).pipe(Effect.matchEffect({
 			onFailure: (error) => policy.onInvalid === "drop" ? Effect.succeed(void 0) : Effect.fail(error),
 			onSuccess: (point) => tryAnalyticsEngineSync(definition.binding, "writeDataPoint", () => dataset.writeDataPoint(point))
 		}));
-	};
-	const writeDataPoints = (dataPoints, options) => {
+	});
+	const writeDataPoints = Effect.fn("AnalyticsEngine.writeDataPoints")(function* (dataPoints, options) {
 		const policy = resolveWritePolicy(defaults, options);
-		return Effect.gen(function* () {
-			const validPoints = yield* validateDataPoints(definition.binding, "writeDataPoints", dataPoints, policy);
-			yield* writeChunks(definition.binding, "writeDataPoints", dataset, validPoints, policy.batchSize);
-		});
-	};
+		const validPoints = yield* validateDataPoints(definition.binding, "writeDataPoints", dataPoints, policy);
+		yield* writeChunks(definition.binding, "writeDataPoints", dataset, validPoints, policy.batchSize);
+	});
 	return {
 		definition,
 		writeDataPoint,
 		write: writeDataPoint,
 		writeDataPoints,
 		writeBatch: writeDataPoints,
-		unsafeRaw: Effect.succeed(dataset)
+		rawUnsafe: Effect.succeed(dataset)
 	};
 };
 const queryConfig = (options) => Config.all({
@@ -531,18 +588,18 @@ const queryConfig = (options) => Config.all({
 	apiBaseUrl: options?.apiBaseUrl ?? Config.string("CLOUDFLARE_API_BASE_URL").pipe(Config.withDefault(defaultQueryApiBaseUrl))
 });
 const queryLayer = (tag, definition) => Layer.effect(tag, makeQueryClient(definition));
-const queryFetchLayer = (tag, definition) => queryLayer(tag, definition).pipe(Layer.provide(FetchHttpClient.layer));
+const layerFetch = (tag, definition) => queryLayer(tag, definition).pipe(Layer.provide(FetchHttpClient.layer));
 const queryLayerConfig = (tag, config = queryConfig()) => Layer.effect(tag, Effect.gen(function* () {
 	const definition = yield* config;
 	return yield* makeQueryClient(definition);
 }));
-const queryFetchLayerConfig = (tag, config = queryConfig()) => queryLayerConfig(tag, config).pipe(Layer.provide(FetchHttpClient.layer));
-const layer$17 = (tag, definition) => layer$20(tag, definition.binding, isAnalyticsEngineDataset, makeClient$13(definition, definition.write), { expected: expectedAnalyticsEngineDataset });
-const make$16 = (id) => Tag$16()(id);
+const layerFetchConfig = (tag, config = queryConfig()) => queryLayerConfig(tag, config).pipe(Layer.provide(FetchHttpClient.layer));
+const layer$16 = (tag, definition) => layer$19(tag, definition.binding, isAnalyticsEngineDataset, makeClient$13(definition, definition.write), { expected: expectedAnalyticsEngineDataset });
+const make$16 = (id) => Tag$14()(id);
 const makeQuery = (id) => QueryTag()(id);
-const Tag$16 = () => (id) => {
+const Tag$14 = () => (id) => {
 	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$17(tag, definition);
+	const makeLayer = (definition) => layer$16(tag, definition);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer
@@ -551,30 +608,34 @@ const Tag$16 = () => (id) => {
 const QueryTag = () => (id) => {
 	const tag = Context.Service()(id);
 	const makeLayer = (definition) => queryLayer(tag, definition);
-	const makeFetchLayer = (definition) => queryFetchLayer(tag, definition);
+	const makeLayerFetch = (definition) => layerFetch(tag, definition);
 	const makeLayerConfig = (config) => queryLayerConfig(tag, config);
-	const makeFetchLayerConfig = (config) => queryFetchLayerConfig(tag, config);
+	const makeLayerFetchConfig = (config) => layerFetchConfig(tag, config);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer,
-		fetchLayer: makeFetchLayer,
+		layerFetch: makeLayerFetch,
 		layerConfig: makeLayerConfig,
-		fetchLayerConfig: makeFetchLayerConfig
+		layerFetchConfig: makeLayerFetchConfig
 	});
 };
 //#endregion
 //#region src/BrowserRendering.ts
 var BrowserRendering_exports = /* @__PURE__ */ __exportAll({
 	BrowserRenderingOperationError: () => BrowserRenderingOperationError,
-	Tag: () => Tag$15,
+	Tag: () => Tag$13,
 	isBrowserRenderingBinding: () => isBrowserRenderingBinding,
-	layer: () => layer$16,
+	layer: () => layer$15,
 	make: () => make$15,
 	makeClient: () => makeClient$12
 });
 const expectedBrowserRenderingBinding = "Browser Rendering binding resource";
 /** Error raised when a Browser Rendering operation fails. */
-var BrowserRenderingOperationError = class extends Data.TaggedError("BrowserRenderingOperationError") {};
+var BrowserRenderingOperationError = class extends Data.TaggedError("BrowserRenderingOperationError") {
+	get message() {
+		return `Browser Rendering ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
 const browserRenderingError = (binding, operation, cause) => new BrowserRenderingOperationError({
 	binding,
 	operation,
@@ -609,15 +670,15 @@ const wrapBrowser = (binding, browser) => ({
 const isBrowserRenderingBinding = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
 const makeClient$12 = (definition) => (binding) => ({
 	definition,
-	launchWith: (launch, options) => tryBrowserRenderingPromise(definition.binding, "launch", () => launch(binding, options)).pipe(Effect.map((browser) => wrapBrowser(definition.binding, browser))),
-	connectWith: (connect, options) => tryBrowserRenderingPromise(definition.binding, "connect", () => connect(binding, options)).pipe(Effect.map((browser) => wrapBrowser(definition.binding, browser))),
-	unsafeRaw: Effect.succeed(binding)
+	launchWith: (launch, options) => tryBrowserRenderingPromise(definition.binding, "launch", () => launch(binding, options)).pipe(Effect.map((browser) => wrapBrowser(definition.binding, browser)), Effect.withSpan("BrowserRendering.launchWith")),
+	connectWith: (connect, options) => tryBrowserRenderingPromise(definition.binding, "connect", () => connect(binding, options)).pipe(Effect.map((browser) => wrapBrowser(definition.binding, browser)), Effect.withSpan("BrowserRendering.connectWith")),
+	rawUnsafe: Effect.succeed(binding)
 });
-const layer$16 = (tag, definition) => layer$20(tag, definition.binding, isBrowserRenderingBinding, makeClient$12(definition), { expected: expectedBrowserRenderingBinding });
-const make$15 = (id) => Tag$15()(id);
-const Tag$15 = () => (id) => {
+const layer$15 = (tag, definition) => layer$19(tag, definition.binding, isBrowserRenderingBinding, makeClient$12(definition), { expected: expectedBrowserRenderingBinding });
+const make$15 = (id) => Tag$13()(id);
+const Tag$13 = () => (id) => {
 	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$16(tag, definition);
+	const makeLayer = (definition) => layer$15(tag, definition);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer
@@ -628,13 +689,17 @@ const Tag$15 = () => (id) => {
 var Cache_exports = /* @__PURE__ */ __exportAll({
 	CacheOperationError: () => CacheOperationError,
 	CacheStorage: () => CacheStorage,
-	layer: () => layer$15,
+	layer: () => layer$14,
 	layerFrom: () => layerFrom,
 	makeCacheClient: () => makeCacheClient,
 	makeClient: () => makeClient$11
 });
 /** Error raised when a Cloudflare Cache API operation fails. */
-var CacheOperationError = class extends Data.TaggedError("CacheOperationError") {};
+var CacheOperationError = class extends Data.TaggedError("CacheOperationError") {
+	get message() {
+		return `Cache ${this.operation} failed for cache "${this.cache}": ${causeMessage(this.cause)}`;
+	}
+};
 /** Service for Cloudflare's global Cache API. */
 var CacheStorage = class extends Context.Service()("effect-cf/CacheStorage") {};
 const cacheError = (cache, operation, cause) => new CacheOperationError({
@@ -646,24 +711,28 @@ const tryCachePromise = (cache, operation, evaluate) => Effect.tryPromise({
 	try: evaluate,
 	catch: (cause) => cacheError(cache, operation, cause)
 });
+const spanOptions$2 = (cache, operation) => ({ attributes: {
+	cache,
+	operation
+} });
 /** Wraps a native Cloudflare `Cache` instance. */
 const makeCacheClient = (cache, name = "default") => ({
 	name,
-	match: (request, options) => tryCachePromise(name, "match", () => cache.match(request, options)).pipe(Effect.map(Option.fromUndefinedOr)),
-	put: (request, response) => tryCachePromise(name, "put", () => cache.put(request, response)),
-	delete: (request, options) => tryCachePromise(name, "delete", () => cache.delete(request, options)),
-	unsafeRaw: Effect.succeed(cache)
+	match: Effect.fn("Cache.match", spanOptions$2(name, "match"))((request, options) => tryCachePromise(name, "match", () => cache.match(request, options)).pipe(Effect.map(Option.fromUndefinedOr))),
+	put: Effect.fn("Cache.put", spanOptions$2(name, "put"))((request, response) => tryCachePromise(name, "put", () => cache.put(request, response))),
+	delete: Effect.fn("Cache.delete", spanOptions$2(name, "delete"))((request, options) => tryCachePromise(name, "delete", () => cache.delete(request, options))),
+	rawUnsafe: Effect.succeed(cache)
 });
 /** Wraps a native Cloudflare `CacheStorage` instance. */
 const makeClient$11 = (storage) => ({
 	default: makeCacheClient(storage.default),
-	open: (name) => tryCachePromise(name, "open", () => storage.open(name)).pipe(Effect.map((cache) => makeCacheClient(cache, name))),
-	unsafeRaw: Effect.succeed(storage)
+	open: (name) => tryCachePromise(name, "open", () => storage.open(name)).pipe(Effect.map((cache) => makeCacheClient(cache, name)), Effect.withSpan("Cache.open", spanOptions$2(name, "open"))),
+	rawUnsafe: Effect.succeed(storage)
 });
 /** Provides Cache API services from an explicit native `CacheStorage` instance. */
 const layerFrom = (storage) => Layer.succeed(CacheStorage, makeClient$11(storage));
 /** Provides Cache API services from Cloudflare's global `caches` object. */
-const layer$15 = Layer.sync(CacheStorage, () => makeClient$11(caches));
+const layer$14 = Layer.sync(CacheStorage, () => makeClient$11(caches));
 //#endregion
 //#region src/DurableObjectStorage.ts
 var DurableObjectStorage_exports = /* @__PURE__ */ __exportAll({
@@ -671,7 +740,11 @@ var DurableObjectStorage_exports = /* @__PURE__ */ __exportAll({
 	fromDurableObjectStorage: () => fromDurableObjectStorage
 });
 /** Error type used when a storage operation throws or rejects. */
-var StorageOperationError = class extends Data.TaggedError("StorageOperationError") {};
+var StorageOperationError = class extends Data.TaggedError("StorageOperationError") {
+	get message() {
+		return `Durable Object storage ${this.operation} failed: ${causeMessage(this.cause)}`;
+	}
+};
 const storageError = (operation, cause) => new StorageOperationError({
 	operation,
 	cause
@@ -798,11 +871,23 @@ var DurableObjectWebSocket_exports = /* @__PURE__ */ __exportAll({
 	handlers: () => handlers
 });
 /** Error raised when sending on a Durable Object websocket fails. */
-var DurableWebSocketSendError = class extends Data.TaggedError("DurableWebSocketSendError") {};
+var DurableWebSocketSendError = class extends Data.TaggedError("DurableWebSocketSendError") {
+	get message() {
+		return `Durable Object websocket send failed: ${causeMessage(this.cause)}`;
+	}
+};
 /** Error raised when closing a Durable Object websocket fails. */
-var DurableWebSocketCloseError = class extends Data.TaggedError("DurableWebSocketCloseError") {};
+var DurableWebSocketCloseError = class extends Data.TaggedError("DurableWebSocketCloseError") {
+	get message() {
+		return `Durable Object websocket close failed: ${causeMessage(this.cause)}`;
+	}
+};
 /** Error raised when serializing or deserializing a websocket attachment fails. */
-var DurableWebSocketAttachmentError = class extends Data.TaggedError("DurableWebSocketAttachmentError") {};
+var DurableWebSocketAttachmentError = class extends Data.TaggedError("DurableWebSocketAttachmentError") {
+	get message() {
+		return `Durable Object websocket attachment ${this.operation} failed: ${causeMessage(this.cause)}`;
+	}
+};
 const wrappers = /* @__PURE__ */ new WeakMap();
 /** Wraps a native Cloudflare websocket in the Effect-native Durable Object API. */
 const fromWebSocket = (raw) => {
@@ -848,12 +933,12 @@ const fromWebSocket = (raw) => {
 * return response.response;
 * ```
 */
-const acceptUpgrade = (options = {}) => Effect.gen(function* () {
+const acceptUpgrade = Effect.fn("DurableObjectWebSocket.acceptUpgrade")(function* (options = {}) {
 	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);
+	if (options.attachment !== void 0) yield* server.serializeAttachment(options.attachment);
 	yield* state.acceptWebSocket(server, options.tags === void 0 ? void 0 : [...options.tags]);
 	return {
 		client,
@@ -883,25 +968,16 @@ const attachment = (schema) => {
 		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)) {
+			const decoded = yield* Effect.result(deserialize(socket));
+			if (Result.isSuccess(decoded) && Option.isSome(decoded.success)) {
 				restored.push({
 					socket,
-					attachment: decoded.value.value
+					attachment: decoded.success.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);
+			if (Result.isFailure(decoded) && onInvalid === "fail") return yield* Effect.fail(decoded.failure);
+			if (Result.isFailure(decoded) && onInvalid === "ignore-and-close") yield* socket.close(1008, "invalid websocket attachment").pipe(Effect.ignore);
 		}
 		return restored;
 	});
@@ -936,8 +1012,8 @@ const fromDurableObjectState = (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)))))),
+	blockConcurrencyWhile: (effect) => Effect.context().pipe(Effect.flatMap((context) => Effect.promise(() => state.blockConcurrencyWhile(() => runPromiseExitPreservingTypedFailures(context, effect)))), Effect.flatten),
+	blockConcurrencyWhileOrReset: (effect) => Effect.context().pipe(Effect.flatMap((context) => Effect.promise(() => state.blockConcurrencyWhile(() => Effect.runPromiseWith(context)(effect))))),
 	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)),
@@ -948,19 +1024,33 @@ const fromDurableObjectState = (state) => ({
 	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);
+const runPromiseExitPreservingTypedFailures = async (context, effect) => {
+	const exit = await Effect.runPromiseExitWith(context)(effect);
 	if (Exit.isFailure(exit) && (Cause.hasDies(exit.cause) || Cause.hasInterrupts(exit.cause))) throw Cause.squash(exit.cause);
 	return exit;
 };
 //#endregion
 //#region src/CloudflareOtlp.ts
+/**
+* OTLP telemetry layers for Cloudflare Workers and Durable Objects.
+*
+* Every layer exposes {@link OtlpExporter.Flusher}, which drains buffered
+* telemetry on demand. Cloudflare isolates can freeze before the periodic
+* export interval fires, so flush explicitly before returning a response, or
+* hand the flush to `ctx.waitUntil`:
+*
+* ```ts
+* const flusher = yield* OtlpExporter.Flusher;
+*
+* yield* flusher.flush;
+* ```
+*/
 var CloudflareOtlp_exports = /* @__PURE__ */ __exportAll({
-	durableObjectLayer: () => durableObjectLayer,
-	layer: () => layer$14,
+	layer: () => layer$13,
+	layerDurableObject: () => layerDurableObject,
 	layerJson: () => layerJson,
 	layerProtobuf: () => layerProtobuf,
-	workerLayer: () => workerLayer
+	layerWorker: () => layerWorker
 });
 const allSignals = [
 	"logs",
@@ -1009,7 +1099,7 @@ const makeLayer = (options = {}, runtimeAttributes = {}) => {
 		resource,
 		headers: options.headers
 	}));
-	if (layers.length === 0) return Layer.empty;
+	if (layers.length === 0) return OtlpExporter.layerFlusher;
 	return mergeSignalLayers(layers).pipe(Layer.provide(cloudflareConfigProviderLayer), Layer.provide(serializationLayer(options.serialization)), Layer.provide(FetchHttpClient.layer));
 };
 /**
@@ -1019,15 +1109,18 @@ const makeLayer = (options = {}, runtimeAttributes = {}) => {
 * layers. In Cloudflare Workers and Durable Objects, the current `env` object is
 * installed as the primary `ConfigProvider`; outside Cloudflare, the ambient
 * Effect `ConfigProvider` remains the fallback.
+*
+* The layer provides {@link OtlpExporter.Flusher} for draining buffered
+* telemetry before the isolate freezes.
 */
-const layer$14 = (options = {}) => makeLayer(options);
+const layer$13 = (options = {}) => makeLayer(options);
 /** Base OTLP telemetry layer forced to JSON serialization. */
-const layerJson = (options = {}) => layer$14({
+const layerJson = (options = {}) => layer$13({
 	...options,
 	serialization: "json"
 });
 /** Base OTLP telemetry layer forced to protobuf serialization. */
-const layerProtobuf = (options = {}) => layer$14({
+const layerProtobuf = (options = {}) => layer$13({
 	...options,
 	serialization: "protobuf"
 });
@@ -1037,7 +1130,7 @@ const layerProtobuf = (options = {}) => layer$14({
 * Provide this layer at runtime scope for long-lived metrics aggregation, or at
 * handler scope when traces/logs should flush as the Cloudflare event finishes.
 */
-const workerLayer = (options = {}) => makeLayer(options, {
+const layerWorker = (options = {}) => makeLayer(options, {
 	"cloudflare.resource_type": "worker",
 	"cloudflare.worker.name": options.workerName
 });
@@ -1048,7 +1141,7 @@ const workerLayer = (options = {}) => makeLayer(options, {
 * 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, {
+const layerDurableObject = (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
@@ -1059,9 +1152,9 @@ var ContainerNamespace_exports = /* @__PURE__ */ __exportAll({
 	ContainerNamespace: () => ContainerNamespace,
 	ContainerOperationError: () => ContainerOperationError,
 	ContainerState: () => ContainerState,
-	Tag: () => Tag$14,
+	Tag: () => Tag$12,
 	isContainerNamespaceResource: () => isContainerNamespaceResource,
-	layer: () => layer$13,
+	layer: () => layer$12,
 	make: () => make$14,
 	makeClient: () => makeClient$10
 });
@@ -1081,7 +1174,11 @@ const ContainerState = Schema.Union([Schema.Struct({
 	exitCode: Schema.optionalKey(Schema.Int)
 })]);
 /** Failure raised when invoking a named Container operation. */
-var ContainerOperationError = class extends Data.TaggedError("ContainerOperationError") {};
+var ContainerOperationError = class extends Data.TaggedError("ContainerOperationError") {
+	get message() {
+		return `Container ${this.operation} failed for binding "${this.binding}" instance "${this.instance}": ${causeMessage(this.cause)}`;
+	}
+};
 const tryContainerPromise = (definition, instance, operation, evaluate) => Effect.tryPromise({
 	try: evaluate,
 	catch: (cause) => new ContainerOperationError({
@@ -1091,20 +1188,35 @@ const tryContainerPromise = (definition, instance, operation, evaluate) => Effec
 		cause
 	})
 });
-const makeInstanceClient = (definition, instance, stub) => ({
-	unsafeRaw: Effect.succeed(stub),
-	state: tryContainerPromise(definition, instance, "state", () => stub.getState()).pipe(Effect.flatMap(Schema.decodeUnknownEffect(ContainerState)), Effect.mapError((cause) => cause instanceof ContainerOperationError ? cause : new ContainerOperationError({
+const makeInstanceClient = (definition, instance, stub) => {
+	const spanOptions = (operation) => ({ attributes: {
 		binding: definition.binding,
 		instance,
-		operation: "state",
-		cause
-	}))),
-	fetch: (input, init) => tryContainerPromise(definition, instance, "fetch", () => stub.fetch(input, init)),
-	start: (options, waitOptions) => tryContainerPromise(definition, instance, "start", () => stub.start(options, waitOptions)),
-	startAndWaitForPorts: (options) => tryContainerPromise(definition, instance, "startAndWaitForPorts", () => stub.startAndWaitForPorts(options)),
-	stop: (signal) => tryContainerPromise(definition, instance, "stop", () => stub.stop(signal)),
-	destroy: tryContainerPromise(definition, instance, "destroy", () => stub.destroy())
-});
+		operation
+	} });
+	return {
+		rawUnsafe: Effect.succeed(stub),
+		state: tryContainerPromise(definition, instance, "state", () => stub.getState()).pipe(Effect.flatMap(Schema.decodeUnknownEffect(ContainerState)), Effect.mapError((cause) => cause instanceof ContainerOperationError ? cause : new ContainerOperationError({
+			binding: definition.binding,
+			instance,
+			operation: "state",
+			cause
+		})), Effect.withSpan("ContainerNamespace.state", spanOptions("state"))),
+		fetch: Effect.fn("ContainerNamespace.fetch", spanOptions("fetch"))(function* (input, init) {
+			return yield* tryContainerPromise(definition, instance, "fetch", () => stub.fetch(input, init));
+		}),
+		start: Effect.fn("ContainerNamespace.start", spanOptions("start"))(function* (options, waitOptions) {
+			return yield* tryContainerPromise(definition, instance, "start", () => stub.start(options, waitOptions));
+		}),
+		startAndWaitForPorts: Effect.fn("ContainerNamespace.startAndWaitForPorts", spanOptions("startAndWaitForPorts"))(function* (options) {
+			return yield* tryContainerPromise(definition, instance, "startAndWaitForPorts", () => stub.startAndWaitForPorts(options));
+		}),
+		stop: Effect.fn("ContainerNamespace.stop", spanOptions("stop"))(function* (signal) {
+			return yield* tryContainerPromise(definition, instance, "stop", () => stub.stop(signal));
+		}),
+		destroy: tryContainerPromise(definition, instance, "destroy", () => stub.destroy()).pipe(Effect.withSpan("ContainerNamespace.destroy", spanOptions("destroy")))
+	};
+};
 const isContainerNamespaceResource = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "getByName") === "function";
 const makeClient$10 = (definition) => (namespace) => {
 	const getByName = (name, options) => Effect.try({
@@ -1119,7 +1231,7 @@ const makeClient$10 = (definition) => (namespace) => {
 	const byName = (name, options) => {
 		const instance = getByName(name, options);
 		return {
-			unsafeRaw: Effect.flatMap(instance, (client) => client.unsafeRaw),
+			rawUnsafe: Effect.flatMap(instance, (client) => client.rawUnsafe),
 			state: Effect.flatMap(instance, (client) => client.state),
 			fetch: (input, init) => Effect.flatMap(instance, (client) => client.fetch(input, init)),
 			start: (startOptions, waitOptions) => Effect.flatMap(instance, (client) => client.start(startOptions, waitOptions)),
@@ -1132,16 +1244,16 @@ const makeClient$10 = (definition) => (namespace) => {
 		definition,
 		getByName,
 		byName,
-		unsafeRaw: Effect.succeed(namespace)
+		rawUnsafe: Effect.succeed(namespace)
 	};
 };
-const layer$13 = (tag, definition) => layer$20(tag, definition.binding, isContainerNamespaceResource, makeClient$10(definition), { expected: expectedContainerNamespace });
-const make$14 = (id) => Tag$14()(id);
+const layer$12 = (tag, definition) => layer$19(tag, definition.binding, isContainerNamespaceResource, makeClient$10(definition), { expected: expectedContainerNamespace });
+const make$14 = (id) => Tag$12()(id);
 /** Creates a typed Effect service for a Cloudflare Container namespace. */
-const Tag$14 = () => (id) => {
-	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$13(tag, definition);
-	const getByName = (name, options) => Effect.gen(function* () {
+const Tag$12 = () => (id) => {
+	const tag = Context.Service()(`effect-cf/Container/${id}`);
+	const makeLayer = (definition) => layer$12(tag, definition);
+	const getByName = Effect.fnUntraced(function* (name, options) {
 		return yield* (yield* tag).getByName(name, options);
 	});
 	const byName = (name, options) => ({
@@ -1151,27 +1263,25 @@ const Tag$14 = () => (id) => {
 		startAndWaitForPorts: (startOptions) => Effect.flatMap(getByName(name, options), (instance) => instance.startAndWaitForPorts(startOptions)),
 		stop: (signal) => Effect.flatMap(getByName(name, options), (instance) => instance.stop(signal)),
 		destroy: Effect.flatMap(getByName(name, options), (instance) => instance.destroy),
-		unsafeRaw: Effect.flatMap(getByName(name, options), (instance) => instance.unsafeRaw)
-	});
-	const unsafeRaw = Effect.fn(function* () {
-		return yield* (yield* tag).unsafeRaw;
+		rawUnsafe: Effect.flatMap(getByName(name, options), (instance) => instance.rawUnsafe)
 	});
+	const rawUnsafe = Effect.flatMap(tag, (namespace) => namespace.rawUnsafe);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer,
 		getByName,
 		byName,
-		unsafeRaw
+		rawUnsafe
 	});
 };
-const ContainerNamespace = Tag$14;
+const ContainerNamespace = Tag$12;
 //#endregion
 //#region src/D1.ts
 var D1_exports = /* @__PURE__ */ __exportAll({
 	Service: () => Service$1,
 	make: () => make$13
 });
-const TypeId$2 = "effect-cf/D1";
+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;
@@ -1217,7 +1327,7 @@ const Service$1 = () => (id, definition) => {
 var QueueBinding_exports = /* @__PURE__ */ __exportAll({
 	QueueOperationError: () => QueueOperationError,
 	isQueue: () => isQueue,
-	layer: () => layer$12,
+	layer: () => layer$11,
 	makeClient: () => makeClient$9
 });
 const expectedQueueProducer = "Queue producer binding with send(); optional sendBatch()/metrics()";
@@ -1238,27 +1348,30 @@ const isQueue = (value) => {
 const makeClient$9 = (definition) => {
 	const encodeMessage = Schema.encodeEffect(definition.message);
 	return (queue) => ({
-		send: Effect.fnUntraced(function* (message, options) {
+		send: Effect.fn("QueueBinding.send", { attributes: {
+			binding: definition.binding,
+			operation: "send"
+		} })(function* (message, options) {
 			const encoded = yield* encodeMessage(message);
 			yield* tryQueuePromise(definition.binding, "send", () => queue.send(encoded, options));
 		}),
-		sendBatch: Effect.fnUntraced(function* (messages, options) {
+		sendBatch: Effect.fn("QueueBinding.sendBatch", { attributes: {
+			binding: definition.binding,
+			operation: "sendBatch"
+		} })(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
-				});
+			if (sendBatch === void 0) return yield* new QueueOperationError({
+				binding: definition.binding,
+				operation: "sendBatch",
+				cause: /* @__PURE__ */ new Error(`Queue binding "${definition.binding}" does not provide sendBatch()`),
+				message: `Cloudflare queue binding "${definition.binding}" does not provide sendBatch()`
 			});
+			yield* tryQueuePromise(definition.binding, "sendBatch", () => sendBatch.call(queue, encodedMessages, options));
 		}),
 		metrics: () => {
 			const metrics = queue.metrics;
@@ -1270,16 +1383,16 @@ const makeClient$9 = (definition) => {
 			}));
 			return tryQueuePromise(definition.binding, "metrics", () => metrics.call(queue));
 		},
-		unsafeRaw: Effect.succeed(queue)
+		rawUnsafe: Effect.succeed(queue)
 	});
 };
-const layer$12 = (tag, definition) => layer$20(tag, definition.binding, (value) => isQueue(value), makeClient$9(definition), { expected: expectedQueueProducer });
+const layer$11 = (tag, definition) => layer$19(tag, definition.binding, (value) => isQueue(value), makeClient$9(definition), { expected: expectedQueueProducer });
 //#endregion
 //#region src/QueueDefinition.ts
 var QueueDefinition_exports = /* @__PURE__ */ __exportAll({
 	Queue: () => Queue$1,
-	Tag: () => Tag$13,
-	implement: () => implement$7,
+	Tag: () => Tag$11,
+	implement: () => implement$5,
 	make: () => make$12
 });
 const makeDefinition$4 = (id, definition) => {
@@ -1292,11 +1405,11 @@ const makeDefinition$4 = (id, definition) => {
 		queue: wrapHandler$1(queueDefinition, options.queue)
 	}) });
 };
-const make$12 = (id, definition) => Tag$13()(id, definition);
-const Tag$13 = () => (id, definition) => {
+const make$12 = (id, definition) => Tag$11()(id, definition);
+const Tag$11 = () => (id, definition) => {
 	const queueDefinition = makeDefinition$4(id, definition);
-	const tag = Context.Service()(id);
-	const layer = (binding) => layer$12(tag, {
+	const tag = Context.Service()(`effect-cf/Queue/${id}`);
+	const layer = (binding) => layer$11(tag, {
 		...binding,
 		message: definition.message
 	});
@@ -1309,9 +1422,7 @@ const Tag$13 = () => (id, definition) => {
 	const metrics = Effect.fnUntraced(function* () {
 		return yield* (yield* tag).metrics();
 	});
-	const unsafeRaw = Effect.fnUntraced(function* () {
-		return yield* (yield* tag).unsafeRaw;
-	});
+	const rawUnsafe = Effect.flatMap(tag, (queue) => queue.rawUnsafe);
 	return Object.assign(tag, {
 		id: queueDefinition.id,
 		message: queueDefinition.message,
@@ -1320,28 +1431,32 @@ const Tag$13 = () => (id, definition) => {
 		send,
 		sendBatch,
 		metrics,
-		unsafeRaw
+		rawUnsafe
 	});
 };
-const Queue$1 = Tag$13;
+const Queue$1 = Tag$11;
 const wrapHandler$1 = (definition, handler) => {
 	const decodeBody = Schema.decodeUnknownEffect(definition.message);
-	return (batch) => Effect.gen(function* () {
+	return Effect.fnUntraced(function* (batch) {
 		yield* handler(yield* decodeBatch(batch.raw, decodeBody));
 	});
 };
-const implement$7 = (_definition, handler) => handler;
+const implement$5 = (_definition, handler) => handler;
 //#endregion
 //#region src/Queue.ts
 var Queue_exports = /* @__PURE__ */ __exportAll({
 	QueueMessageDecodeError: () => QueueMessageDecodeError,
-	Tag: () => Tag$12,
+	Tag: () => Tag$10,
 	decodeBatch: () => decodeBatch,
 	fromMessage: () => fromMessage,
 	fromMessageBatch: () => fromMessageBatch,
-	implement: () => implement$6
+	implement: () => implement$4
 });
-var QueueMessageDecodeError = class extends Data.TaggedError("QueueMessageDecodeError") {};
+var QueueMessageDecodeError = class extends Data.TaggedError("QueueMessageDecodeError") {
+	get message() {
+		return `Queue "${this.queue}" failed to decode message "${this.messageId}" at index ${this.index}: ${causeMessage(this.cause)}`;
+	}
+};
 const fromMessage = (message, body) => ({
 	raw: message,
 	id: message.id,
@@ -1373,34 +1488,102 @@ const decodeBatch = (batch, decodeBody) => Effect.gen(function* () {
 	}
 	return fromMessageBatch(batch, messages);
 });
-const Tag$12 = Tag$13;
-const implement$6 = implement$7;
+const Tag$10 = Tag$11;
+const implement$4 = implement$5;
 //#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,
+	decodeWireError: () => decodeWireError,
 	encodeArgs: () => encodeArgs,
 	encodeSuccess: () => encodeSuccess,
+	encodeWireError: () => encodeWireError,
+	isWireError: () => isWireError,
 	make: () => make$11,
-	method: () => method$4,
+	method: () => method$2,
 	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") {};
+var RpcReservedMethodNameError = class extends Data.TaggedError("RpcReservedMethodNameError") {
+	get message() {
+		return `${this.definition} RPC method "${this.method}" is reserved by Cloudflare Workers RPC`;
+	}
+};
+var RpcArgumentCountError = class extends Schema.TaggedError()("RpcArgumentCountError", {
+	definition: Schema.String,
+	method: Schema.String,
+	expected: Schema.Number,
+	actual: Schema.Number
+}) {
+	get message() {
+		return `${this.definition} RPC method "${this.method}" expected ${this.expected} arguments but received ${this.actual}`;
+	}
+};
+var RpcArgumentDecodeError = class extends Schema.TaggedError()("RpcArgumentDecodeError", {
+	definition: Schema.String,
+	method: Schema.String,
+	cause: Schema.Defect()
+}) {
+	get message() {
+		return `${this.definition} RPC method "${this.method}" argument decode failed: ${causeMessage(this.cause)}`;
+	}
+};
+var RpcArgumentEncodeError = class extends Data.TaggedError("RpcArgumentEncodeError") {
+	get message() {
+		return `${this.definition} RPC method "${this.method}" argument encode failed: ${causeMessage(this.cause)}`;
+	}
+};
+var RpcSuccessDecodeError = class extends Data.TaggedError("RpcSuccessDecodeError") {
+	get message() {
+		return `${this.definition} RPC method "${this.method}" success decode failed: ${causeMessage(this.cause)}`;
+	}
+};
+var RpcSuccessEncodeError = class extends Schema.TaggedError()("RpcSuccessEncodeError", {
+	definition: Schema.String,
+	method: Schema.String,
+	cause: Schema.Defect()
+}) {
+	get message() {
+		return `${this.definition} RPC method "${this.method}" success encode failed: ${causeMessage(this.cause)}`;
+	}
+};
+const WireErrorSchema = Schema.Union([
+	RpcArgumentCountError,
+	RpcArgumentDecodeError,
+	RpcSuccessEncodeError
+]);
+const wireErrorKey = "effect-cf/RpcDefinition/wireError";
+const isWireError = (error) => error instanceof RpcArgumentCountError || error instanceof RpcArgumentDecodeError || error instanceof RpcSuccessEncodeError;
+/**
+* Encodes package RPC errors into a plain `Error` envelope so their tags
+* survive Cloudflare RPC serialization, which drops custom error properties.
+*/
+const encodeWireError = (error) => {
+	if (!isWireError(error)) return error;
+	try {
+		return new Error(JSON.stringify({ [wireErrorKey]: Schema.encodeSync(WireErrorSchema)(error) }));
+	} catch {
+		return error;
+	}
+};
+/** Restores package RPC errors from the {@link encodeWireError} envelope. */
+const decodeWireError = (cause) => {
+	if (!(cause instanceof Error)) return cause;
+	try {
+		const parsed = JSON.parse(cause.message);
+		if (!Predicate.hasProperty(parsed, wireErrorKey)) return cause;
+		return Schema.decodeUnknownSync(WireErrorSchema)(parsed[wireErrorKey]);
+	} catch {
+		return cause;
+	}
+};
 const reservedMethodNames$4 = /* @__PURE__ */ new Set([
 	"constructor",
 	"fetch",
@@ -1415,72 +1598,56 @@ const reservedMethodNames$4 = /* @__PURE__ */ new Set([
 	"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;
-	}
-};
+/**
+* Workers RPC structured-clones every value that crosses an isolate boundary
+* and rejects class instances. Declaration schemas such as `Schema.Result`
+* keep their container instance in their `Encoded` form, so the declared
+* schemas are lowered to their canonical JSON codec before touching the wire.
+*/
+const wireCodec = (schema) => Schema.toCodecJson(schema);
 const assertNoReservedMethods = (target, methods, reserved) => {
-	for (const method of Object.keys(methods)) if (reserved.has(method)) throw new ReservedMethodNameError(target, method);
+	for (const method of Object.keys(methods)) if (reserved.has(method)) throw new RpcReservedMethodNameError({
+		definition: target,
+		method
+	});
 };
-function method$4(definition) {
+function method$2(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 decodeArgs = Effect.fnUntraced(function* (definition, methodName, args) {
 	const methodDefinition = definition.methods[methodName];
-	if (args.length !== methodDefinition.args.length) return yield* Effect.fail(new RpcArgumentCountError({
+	if (args.length !== methodDefinition.args.length) return yield* 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;
+	});
+	return yield* Schema.decodeUnknownEffect(wireCodec(Schema.Tuple(methodDefinition.args)))(args).pipe(Effect.mapError((cause) => new RpcArgumentDecodeError({
+		definition: definition.id,
+		method: methodName,
+		cause
+	})));
 });
-const encodeArgs = (definition, methodName, args) => Effect.gen(function* () {
+const encodeArgs = Effect.fnUntraced(function* (definition, methodName, args) {
 	const methodDefinition = definition.methods[methodName];
-	if (args.length !== methodDefinition.args.length) return yield* Effect.fail(new RpcArgumentCountError({
+	if (args.length !== methodDefinition.args.length) return yield* 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;
+	});
+	return yield* Schema.encodeUnknownEffect(wireCodec(Schema.Tuple(methodDefinition.args)))(args).pipe(Effect.mapError((cause) => new RpcArgumentEncodeError({
+		definition: definition.id,
+		method: methodName,
+		cause
+	})));
 });
 const encodeSuccess = (definition, methodName, value) => {
 	const methodDefinition = definition.methods[methodName];
-	return Schema.encodeEffect(methodDefinition.success)(value).pipe(Effect.mapError((cause) => new RpcSuccessEncodeError({
+	return Schema.encodeUnknownEffect(wireCodec(methodDefinition.success))(value).pipe(Effect.mapError((cause) => new RpcSuccessEncodeError({
 		definition: definition.id,
 		method: methodName,
 		cause
@@ -1488,23 +1655,92 @@ const encodeSuccess = (definition, methodName, value) => {
 };
 const decodeSuccess = (definition, methodName, value) => {
 	const methodDefinition = definition.methods[methodName];
-	return Schema.decodeUnknownEffect(methodDefinition.success)(value).pipe(Effect.mapError((cause) => new RpcSuccessDecodeError({
+	return Schema.decodeUnknownEffect(wireCodec(methodDefinition.success))(value).pipe(Effect.mapError((cause) => new RpcSuccessDecodeError({
 		definition: definition.id,
 		method: methodName,
 		cause
 	})));
 };
 const make$11 = (id, methods) => {
-	const definition = {
+	assertNoReservedMethods(id, methods, reservedMethodNames$4);
+	return {
 		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
+};
+//#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)).pipe(Effect.mapError(encodeWireError)));
+		}
 	});
-	return definition;
+};
+const assumeEntrypointClass = (entrypoint) => entrypoint;
+//#endregion
+//#region src/internal/Runtime.ts
+/**
+* Assembles the shared `ManagedRuntime` used by the Cloudflare entrypoint
+* classes (Worker, Durable Object, Workflow).
+*
+* The entrypoint-specific services are merged with the env-backed
+* `ConfigProvider` and `WorkerEnvironment`, then provided to the user-supplied
+* layer so the resulting runtime satisfies both the user services and the
+* platform services.
+*/
+const makeEntrypointRuntime = (layer, env, services) => {
+	const entrypointServices = Layer.mergeAll(services, ConfigProvider.layer(WorkerConfig.providerFromEnv(env)), Layer.succeed(WorkerEnvironment, env));
+	return ManagedRuntime.make(provideEntrypointServices(layer, entrypointServices));
+};
+/**
+* Runs a Cloudflare event effect on an entrypoint runtime.
+*
+* When an event layer is given it is built inside the event's Effect scope
+* (finalized when the event effect completes). The casts widen away the
+* `REvent` requirement satisfied by the event layer; TypeScript cannot reduce
+* `Exclude<...>` over the generic union.
+*/
+const runEventPromise = (runtime, effect, eventLayer) => {
+	const withEventLayer = eventLayer === void 0 ? effect : effect.pipe(Effect.provide(eventLayer, { local: true }));
+	return runtime.runPromise(Effect.scoped(withEventLayer));
+};
+//#endregion
+//#region src/internal/WorkerContext.ts
+const causeError = (cause) => {
+	const squashed = Cause.squash(cause);
+	return squashed instanceof Error ? squashed : new Error(Cause.pretty(cause), { cause: squashed });
+};
+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))));
+/**
+* Builds the `WorkerContext` service from a native `ExecutionContext`.
+*
+* Background effects capture the calling fiber's context via `Effect.context`
+* before being handed to `ctx.waitUntil`, so the default module-level
+* `Effect.runPromiseExit` runner is sufficient; entrypoints may still pass a
+* runtime-bound runner.
+*/
+const fromExecutionContext = (ctx, runPromiseExit = (effect) => Effect.runPromiseExit(effect)) => {
+	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/Rpc.ts
@@ -1522,7 +1758,7 @@ const dispose = (value) => Effect.sync(() => {
 });
 const resolve = (value) => isPromiseLike(value) ? Effect.tryPromise({
 	try: () => value,
-	catch: (cause) => cause
+	catch: (cause) => decodeWireError(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";
@@ -1538,7 +1774,7 @@ const lookupRpcMethod = (target, method, makeError) => Effect.try({
 	},
 	catch: makeError
 });
-const invokeRpcMethod = (target, method, args, makeError) => Effect.gen(function* () {
+const invokeRpcMethod = Effect.fnUntraced(function* (target, method, args, makeError) {
 	const fn = yield* lookupRpcMethod(target, method, makeError);
 	return yield* Effect.try({
 		try: () => fn(...args),
@@ -1552,7 +1788,7 @@ var ServiceBinding_exports = /* @__PURE__ */ __exportAll({
 	ServiceBindingFetchError: () => ServiceBindingFetchError,
 	ServiceBindingRpcError: () => ServiceBindingRpcError,
 	isServiceBindingClient: () => isServiceBindingClient,
-	layer: () => layer$11,
+	layer: () => layer$10,
 	makeClient: () => makeClient$8,
 	makeDirectMethods: () => makeDirectMethods$1
 });
@@ -1561,22 +1797,32 @@ const expectedServiceBinding = "Worker service binding with fetch()";
 /**
 * Failure raised when calling `fetch` on a service binding.
 */
-var ServiceBindingFetchError = class extends Data.TaggedError("ServiceBindingFetchError") {};
+var ServiceBindingFetchError = class extends Data.TaggedError("ServiceBindingFetchError") {
+	get message() {
+		return `Service binding "${this.binding}" fetch failed: ${causeMessage(this.cause)}`;
+	}
+};
 /**
 * Failure raised when invoking an RPC method on a service binding.
 */
-var ServiceBindingRpcError = class extends Data.TaggedError("ServiceBindingRpcError") {};
+var ServiceBindingRpcError = class extends Data.TaggedError("ServiceBindingRpcError") {
+	get message() {
+		return `Service binding "${this.binding}" RPC method "${this.method}" failed: ${causeMessage(this.cause)}`;
+	}
+};
 const isServiceBindingClient = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "fetch") === "function";
 const makeClient$8 = (definition) => {
 	return (service) => {
-		const fetch = (input, init) => Effect.tryPromise({
-			try: () => service.fetch(input, init),
-			catch: (cause) => new ServiceBindingFetchError({
-				binding: definition.binding,
-				cause
-			})
+		const fetch = Effect.fn("ServiceBinding.fetch")(function* (input, init) {
+			return yield* Effect.tryPromise({
+				try: () => service.fetch(input, init),
+				catch: (cause) => new ServiceBindingFetchError({
+					binding: definition.binding,
+					cause
+				})
+			});
 		});
-		const rpc = (method, ...args) => Effect.gen(function* () {
+		const rpc = Effect.fn("ServiceBinding.rpc")(function* (method, ...args) {
 			const methodName = String(method);
 			const encodedArgs = definition.definition === void 0 ? args : yield* encodeArgs(definition.definition, methodName, args).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
 				binding: definition.binding,
@@ -1589,7 +1835,7 @@ const makeClient$8 = (definition) => {
 				cause
 			}));
 		});
-		const decodeSuccess$2 = (methodName, value) => Effect.gen(function* () {
+		const decodeSuccess$2 = Effect.fnUntraced(function* (methodName, value) {
 			if (definition.definition === void 0) return value;
 			return yield* decodeSuccess(definition.definition, methodName, value).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
 				binding: definition.binding,
@@ -1597,7 +1843,7 @@ const makeClient$8 = (definition) => {
 				cause
 			})));
 		});
-		const call = (method, ...args) => Effect.gen(function* () {
+		const call = Effect.fn("ServiceBinding.call")(function* (method, ...args) {
 			const methodName = String(method);
 			const value = yield* resolve(yield* rpc(method, ...args)).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
 				binding: definition.binding,
@@ -1606,7 +1852,7 @@ const makeClient$8 = (definition) => {
 			})));
 			return yield* decodeSuccess$2(methodName, value);
 		});
-		const scopedCall = (method, ...args) => Effect.gen(function* () {
+		const scopedCall = Effect.fn("ServiceBinding.scopedCall")(function* (method, ...args) {
 			const methodName = String(method);
 			const result = yield* rpc(method, ...args);
 			const value = yield* scoped(result);
@@ -1621,7 +1867,7 @@ const makeClient$8 = (definition) => {
 		});
 	};
 };
-const layer$11 = (tag, definition) => layer$20(tag, definition.binding, (value) => isServiceBindingClient(value), makeClient$8(definition), { expected: expectedServiceBinding });
+const layer$10 = (tag, definition) => layer$19(tag, definition.binding, (value) => isServiceBindingClient(value), makeClient$8(definition), { expected: expectedServiceBinding });
 /**
 * Creates a typed Effect service for a Worker service binding.
 *
@@ -1653,16 +1899,16 @@ const layer$11 = (tag, definition) => layer$20(tag, definition.binding, (value)
 */
 const Service = () => (id, definition) => {
 	const tag = Service$2()(id, definition.binding, (value) => isServiceBindingClient(value), makeClient$8(definition));
-	const fetch = (input, init) => Effect.gen(function* () {
+	const fetch = Effect.fnUntraced(function* (input, init) {
 		return yield* (yield* tag).fetch(input, init);
 	});
-	const rpc = (method, ...args) => Effect.gen(function* () {
+	const rpc = Effect.fnUntraced(function* (method, ...args) {
 		return yield* (yield* tag).rpc(method, ...args);
 	});
-	const call = (method, ...args) => Effect.gen(function* () {
+	const call = Effect.fnUntraced(function* (method, ...args) {
 		return yield* (yield* tag).call(method, ...args);
 	});
-	const scopedCall = (method, ...args) => Effect.gen(function* () {
+	const scopedCall = Effect.fnUntraced(function* (method, ...args) {
 		return yield* (yield* tag).scopedCall(method, ...args);
 	});
 	const directMethods = makeDirectMethods$1(definition.definition, call);
@@ -1683,11 +1929,11 @@ const makeDirectMethods$1 = (rpcDefinition, call) => {
 //#endregion
 //#region src/WorkerDefinition.ts
 var WorkerDefinition_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$11,
+	Tag: () => Tag$9,
 	Worker: () => Worker,
-	implement: () => implement$5,
+	implement: () => implement$3,
 	make: () => make$10,
-	method: () => method$3
+	method: () => method$1
 });
 const reservedMethodNames$3 = /* @__PURE__ */ new Set([
 	"constructor",
@@ -1708,7 +1954,7 @@ const reservedMethodNames$3 = /* @__PURE__ */ new Set([
 /**
 * Defines a single RPC method schema in a worker definition.
 */
-const method$3 = method$4;
+const method$1 = method$2;
 /**
 * Creates a typed worker RPC definition plus helpers for implementation and bindings.
 *
@@ -1730,15 +1976,15 @@ const makeDefinition$3 = (id, methods) => {
 		rpc: wrapHandlers$1(definition, options.rpc)
 	}) });
 };
-const make$10 = (id, methods) => Tag$11()(id, methods);
-const Tag$11 = () => (id, methods) => {
+const make$10 = (id, methods) => Tag$9()(id, methods);
+const Tag$9 = () => (id, methods) => {
 	const definition = makeDefinition$3(id, methods);
 	const tag = Context.Service()(id);
 	const bindingDefinition = (binding) => ({
 		...binding,
 		definition
 	});
-	const layer = (binding) => layer$11(tag, bindingDefinition(binding));
+	const layer = (binding) => layer$10(tag, bindingDefinition(binding));
 	const fetch = (input, init) => Effect.gen(function* () {
 		return yield* (yield* tag).fetch(input, init);
 	});
@@ -1763,7 +2009,7 @@ const Tag$11 = () => (id, methods) => {
 		scopedCall
 	});
 };
-const Worker = Tag$11;
+const Worker = Tag$9;
 const wrapHandlers$1 = (definition, handlers) => {
 	const wrapped = {};
 	for (const key of Object.keys(definition.methods)) {
@@ -1779,82 +2025,44 @@ const wrapHandlers$1 = (definition, handlers) => {
 /**
 * Helper for implementing handlers with the exact method shape of a definition.
 */
-const implement$5 = (_definition, handlers) => handlers;
-//#endregion
-//#region src/internal/Clock.ts
-const maxTimerMillis = 2 ** 31 - 1;
-const nanosPerMilli = BigInt(1e6);
-const clock = {
-	currentTimeMillisUnsafe: () => Date.now(),
-	currentTimeMillis: Effect.sync(() => clock.currentTimeMillisUnsafe()),
-	currentTimeNanosUnsafe: () => BigInt(Date.now()) * nanosPerMilli,
-	currentTimeNanos: Effect.sync(() => clock.currentTimeNanosUnsafe()),
-	monotonicTimeNanosUnsafe: () => typeof performance === "undefined" ? BigInt(Date.now()) * nanosPerMilli : BigInt(Math.round(performance.now() * 1e6)),
-	monotonicTimeNanos: Effect.sync(() => clock.monotonicTimeNanosUnsafe()),
-	sleep: (duration) => {
-		const millis = Duration.toMillis(duration);
-		if (millis <= 0) return Effect.yieldNow;
-		return Effect.callback((resume) => {
-			if (millis > maxTimerMillis) return;
-			const handle = setTimeout(() => resume(Effect.void), millis);
-			return Effect.sync(() => clearTimeout(handle));
-		});
-	}
-};
-const layer$10 = Layer.effect(Clock.Clock, Effect.succeed(clock));
-//#endregion
-//#region src/internal/Entrypoint.ts
-const provideEntrypointServices = (layer, services) => layer.pipe(Layer.provideMerge(services));
-const defineEntrypointRpcMethods = (target, prototype, rpc, reservedMethodNames, run) => {
-	const methods = rpc ?? {};
-	assertNoReservedMethods(target, methods, reservedMethodNames);
-	for (const [key, method] of Object.entries(methods)) Object.defineProperty(prototype, key, {
-		enumerable: true,
-		value(...args) {
-			return run(this, Effect.suspend(() => method(...args)));
-		}
-	});
-};
-const assumeEntrypointClass = (entrypoint) => entrypoint;
-//#endregion
-//#region src/internal/WorkerContext.ts
-const causeError = (cause) => new Error(Cause.pretty(cause));
-const failureHandler = (cause, options) => (options?.onFailure?.(cause) ?? Effect.logError("WorkerContext.waitUntil failed", Cause.pretty(cause))).pipe(Effect.catchCause((handlerCause) => Effect.logError("WorkerContext.waitUntil failure handler failed", Cause.pretty(cause), Cause.pretty(handlerCause))));
-const fromExecutionContext = (ctx, runPromiseExit) => {
-	const schedule = (effect, options, mode) => Effect.context().pipe(Effect.flatMap((context) => Effect.sync(() => {
-		const runHandler = (cause) => runPromiseExit(Effect.scoped(Effect.provideContext(failureHandler(cause, options), context))).then((exit) => {
-			if (Exit.isFailure(exit)) console.error("WorkerContext.waitUntil failure handler failed", Cause.pretty(exit.cause));
-		});
-		ctx.waitUntil(runPromiseExit(Effect.scoped(Effect.provideContext(effect, context))).then(async (exit) => {
-			if (Exit.isSuccess(exit)) return;
-			await runHandler(exit.cause);
-			if (mode === "propagate") throw causeError(exit.cause);
-		}));
-	})));
-	return {
-		raw: ctx,
-		waitUntil: (effect, options) => schedule(effect, options, options?.mode ?? "observe"),
-		waitUntilPropagating: (effect, options) => schedule(effect, options, "propagate"),
-		passThroughOnException: Effect.sync(() => ctx.passThroughOnException())
-	};
-};
+const implement$3 = (_definition, handlers) => handlers;
 //#endregion
 //#region src/Worker.ts
 var Worker_exports = /* @__PURE__ */ __exportAll({
 	ExecutionContext: () => ExecutionContext,
 	NativeRequest: () => NativeRequest,
-	Tag: () => Tag$10,
+	Tag: () => Tag$9,
 	WorkerContext: () => WorkerContext,
-	implement: () => implement$4,
+	implement: () => implement$3,
 	isWebSocketUpgrade: () => isWebSocketUpgrade,
 	make: () => make$9,
 	makeFetchHandler: () => makeFetchHandler,
-	method: () => method$2,
-	renderHttpResponse: () => renderHttpResponse
+	method: () => method$1
 });
+/**
+* Access to Cloudflare's native `ExecutionContext`.
+*/
 var ExecutionContext = class extends Context.Service()("effect-cf/ExecutionContext") {};
+/**
+* Service used inside handlers to schedule background work via `waitUntil`.
+*
+* @example
+* ```ts
+* const handler = Effect.gen(function* () {
+*   const ctx = yield* Worker.WorkerContext;
+*   yield* ctx.waitUntil(Effect.log("flush analytics"));
+*   return new Response("ok");
+* });
+* ```
+*/
 var WorkerContext = class extends Context.Service()("effect-cf/WorkerContext") {};
+/**
+* Access to the incoming `Request` currently handled by a worker or Durable Object fetch.
+*/
 var NativeRequest = class extends Context.Service()("effect-cf/NativeRequest") {};
+/**
+* Returns `true` when the request is a websocket upgrade request.
+*/
 const isWebSocketUpgrade = (request) => request.headers.get("Upgrade")?.toLowerCase() === "websocket";
 const reservedMethodNames$2 = /* @__PURE__ */ new Set([
 	"constructor",
@@ -1873,7 +2081,7 @@ const reservedMethodNames$2 = /* @__PURE__ */ new Set([
 	"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 FetchSymbol = Symbol.for("effect-cf/Worker/fetch");
 const renderFetchSuccess = (effect) => Effect.suspend(() => {
 	let nativeResponse;
 	let webResponse;
@@ -1895,28 +2103,39 @@ const renderFetchSuccess = (effect) => Effect.suspend(() => {
 		onSuccess: captured
 	});
 });
-const isWorkerOptions = (options) => typeof options === "object" && options !== null && ("eventLayer" in options || "fetch" in options || "queue" in options || "rpc" in options);
+const isWorkerOptions = (options) => !Effect.isEffect(options);
+/**
+* Drains buffered OTLP telemetry once the fetch handler has produced its
+* response.
+*
+* The flush is handed to `ctx.waitUntil` so it never delays the response
+* (including streaming bodies still being consumed). It is a no-op when the
+* context does not contain an `OtlpExporter.Flusher`.
+*/
+const scheduleTelemetryFlush = Effect.flatMap(Effect.serviceOption(OtlpExporter.Flusher), Option.match({
+	onNone: () => Effect.void,
+	onSome: (flusher) => Effect.flatMap(WorkerContext, (workerContext) => workerContext.waitUntil(flusher.flush))
+}));
 function make$9(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 services = Layer.mergeAll(layer$10, Layer.succeed(ExecutionContext, ctx), ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env))), Layer.succeed(WorkerContext, fromExecutionContext(ctx, (effect) => runWaitUntilEffect(effect))), Layer.succeed(WorkerEnvironment, env));
-			const runtimeLayer = provideEntrypointServices(layer, services);
-			this.runtime = ManagedRuntime.make(runtimeLayer);
-			runWaitUntilEffect = (effect) => this.runtime.runPromiseExit(effect);
+			this.runtime = makeEntrypointRuntime(layer, env, Layer.mergeAll(Layer.succeed(ExecutionContext, ctx), Layer.succeed(WorkerContext, fromExecutionContext(ctx))));
 		}
 		[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));
+			return runEventPromise(this.runtime, effect, runOptions.eventLayer === false ? void 0 : options.eventLayer);
 		}
 		fetch(request) {
+			return this[FetchSymbol](request);
+		}
+		[FetchSymbol](request, requestContext) {
 			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)));
+			const ctx = requestContext ?? this.ctx;
+			const requestServices = Layer.mergeAll(Layer.succeed(NativeRequest, request), Layer.succeed(HttpServerRequest.HttpServerRequest, HttpServerRequest.fromWeb(request)), Layer.succeed(ExecutionContext, ctx), Layer.succeed(WorkerContext, fromExecutionContext(ctx)));
+			return this[RunSymbol$1](renderFetchSuccess(fetchHandler).pipe(Effect.tap(() => scheduleTelemetryFlush), Effect.provide(requestServices)));
 		}
 		queue(batch) {
 			const queueHandler = options.queue;
@@ -1928,13 +2147,29 @@ function make$9(layer, optionsOrFetch) {
 	defineEntrypointRpcMethods("Worker", EffectWorker.prototype, options.rpc, reservedMethodNames$2, (self, effect) => self[RunSymbol$1](effect));
 	return assumeEntrypointClass(EffectWorker);
 }
+/**
+* Creates an `ExportedHandler`-compatible `{ fetch }` object backed by
+* {@link make}.
+*
+* The Effect runtime is cached per `env` identity, so the user layer builds
+* once per isolate instead of once per request. `ExecutionContext`-backed
+* services (`Worker.ExecutionContext`, `Worker.WorkerContext`) are still
+* provided fresh for every request. Layer finalizers do not run when the
+* isolate is evicted; Cloudflare provides no shutdown hook. Use `eventLayer`
+* for resources that must be finalized per event.
+*/
 const makeFetchHandler = (layer, options) => {
 	const WorkerClass = make$9(layer, options);
-	return { fetch: (request, env, ctx) => Promise.resolve(new WorkerClass(ctx, env).fetch(request)) };
+	const instances = /* @__PURE__ */ new WeakMap();
+	return { fetch: (request, env, ctx) => {
+		let instance = instances.get(env);
+		if (instance === void 0) {
+			instance = new WorkerClass(ctx, env);
+			instances.set(env, instance);
+		}
+		return instance[FetchSymbol](request, ctx);
+	} };
 };
-const Tag$10 = Tag$11;
-const method$2 = method$3;
-const implement$4 = implement$5;
 //#endregion
 //#region src/DurableObjectNamespace.ts
 var DurableObjectNamespace_exports = /* @__PURE__ */ __exportAll({
@@ -1949,11 +2184,19 @@ const expectedDurableObjectNamespace = "Durable Object namespace binding with ge
 /**
 * Failure raised when invoking an RPC method on a Durable Object stub.
 */
-var DurableObjectRpcError = class extends Data.TaggedError("DurableObjectRpcError") {};
+var DurableObjectRpcError = class extends Data.TaggedError("DurableObjectRpcError") {
+	get message() {
+		return `Durable Object RPC method "${this.method}" failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
 /**
 * Failure raised when forwarding a request to a Durable Object stub.
 */
-var DurableObjectFetchError = class extends Data.TaggedError("DurableObjectFetchError") {};
+var DurableObjectFetchError = class extends Data.TaggedError("DurableObjectFetchError") {
+	get message() {
+		return `Durable Object fetch failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
 const hasFunction$2 = (value, key) => typeof Reflect.get(value, key) === "function";
 const isDurableObjectNamespaceClient = (value) => typeof value === "object" && value !== null && hasFunction$2(value, "getByName") && hasFunction$2(value, "get") && hasFunction$2(value, "idFromName") && hasFunction$2(value, "idFromString") && hasFunction$2(value, "newUniqueId") && hasFunction$2(value, "jurisdiction");
 const makeClient$7 = (definition) => {
@@ -1971,7 +2214,7 @@ const makeClient$7 = (definition) => {
 				cause
 			})
 		});
-		const rpc = (stub, method, ...args) => Effect.gen(function* () {
+		const rpc = Effect.fn("DurableObjectNamespace.rpc")(function* (stub, method, ...args) {
 			const methodName = String(method);
 			const encodedArgs = definition.definition === void 0 ? args : yield* encodeArgs(definition.definition, methodName, args).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
 				binding: definition.binding,
@@ -1984,7 +2227,7 @@ const makeClient$7 = (definition) => {
 				cause
 			}));
 		});
-		const decodeSuccess$1 = (methodName, value) => Effect.gen(function* () {
+		const decodeSuccess$1 = Effect.fn("DurableObjectNamespace.decodeSuccess")(function* (methodName, value) {
 			if (definition.definition === void 0) return value;
 			return yield* decodeSuccess(definition.definition, methodName, value).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
 				binding: definition.binding,
@@ -1992,7 +2235,7 @@ const makeClient$7 = (definition) => {
 				cause
 			})));
 		});
-		const call = (stub, method, ...args) => Effect.gen(function* () {
+		const call = Effect.fn("DurableObjectNamespace.call")(function* (stub, method, ...args) {
 			const methodName = String(method);
 			const value = yield* resolve(yield* rpc(stub, method, ...args)).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
 				binding: definition.binding,
@@ -2001,7 +2244,7 @@ const makeClient$7 = (definition) => {
 			})));
 			return yield* decodeSuccess$1(methodName, value);
 		});
-		const scopedCall = (stub, method, ...args) => Effect.gen(function* () {
+		const scopedCall = Effect.fn("DurableObjectNamespace.scopedCall")(function* (stub, method, ...args) {
 			const methodName = String(method);
 			const result = yield* rpc(stub, method, ...args);
 			const value = yield* scoped(result);
@@ -2024,11 +2267,11 @@ const makeClient$7 = (definition) => {
 			rpc,
 			call,
 			scopedCall,
-			unsafeRaw: Effect.succeed(namespace)
+			rawUnsafe: Effect.succeed(namespace)
 		});
 	};
 };
-const layer$9 = (tag, definition) => layer$20(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$7(definition), { expected: expectedDurableObjectNamespace });
+const layer$9 = (tag, definition) => layer$19(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$7(definition), { expected: expectedDurableObjectNamespace });
 const makeDirectMethods = (rpcDefinition, helpers) => {
 	const methods = {};
 	if (rpcDefinition !== void 0) {
@@ -2053,10 +2296,10 @@ const makeDirectMethods = (rpcDefinition, helpers) => {
 //#region src/DurableObjectDefinition.ts
 var DurableObjectDefinition_exports = /* @__PURE__ */ __exportAll({
 	DurableObject: () => DurableObject$1,
-	Tag: () => Tag$9,
-	implement: () => implement$3,
+	Tag: () => Tag$8,
+	implement: () => implement$2,
 	make: () => make$8,
-	method: () => method$1
+	method: () => method
 });
 const reservedMethodNames$1 = /* @__PURE__ */ new Set([
 	"constructor",
@@ -2070,7 +2313,7 @@ const reservedMethodNames$1 = /* @__PURE__ */ new Set([
 /**
 * Defines a single RPC method schema in a Durable Object definition.
 */
-const method$1 = method$4;
+const method = method$2;
 /**
 * Creates a Durable Object RPC definition plus implementation/binding helpers.
 *
@@ -2092,47 +2335,48 @@ const makeDefinition$2 = (id, methods) => {
 		rpc: wrapHandlers(definition, options.rpc)
 	}) });
 };
-const make$8 = (id, methods) => Tag$9()(id, methods);
-const Tag$9 = () => (id, methods) => {
+const make$8 = (id, methods) => Tag$8()(id, methods);
+const Tag$8 = () => (id, methods) => {
 	const definition = makeDefinition$2(id, methods);
-	const tag = Context.Service()(id);
+	const serviceKey = `effect-cf/DurableObject/${id}`;
+	const tag = Context.Service()(serviceKey);
 	const bindingDefinition = (binding) => ({
 		...binding,
 		definition
 	});
 	const layer = (binding) => layer$9(tag, bindingDefinition(binding));
-	const newUniqueId = Effect.fnUntraced(function* (options) {
+	const newUniqueId = Effect.fn("DurableObject.newUniqueId")(function* (options) {
 		return yield* (yield* tag).newUniqueId(options);
 	});
-	const idFromName = Effect.fnUntraced(function* (name) {
+	const idFromName = Effect.fn("DurableObject.idFromName")(function* (name) {
 		return yield* (yield* tag).idFromName(name);
 	});
-	const idFromString = Effect.fnUntraced(function* (value) {
+	const idFromString = Effect.fn("DurableObject.idFromString")(function* (value) {
 		return yield* (yield* tag).idFromString(value);
 	});
-	const get = Effect.fnUntraced(function* (objectId, options) {
+	const get = Effect.fn("DurableObject.get")(function* (objectId, options) {
 		return yield* (yield* tag).get(objectId, options);
 	});
-	const getByName = Effect.fnUntraced(function* (name, options) {
+	const getByName = Effect.fn("DurableObject.getByName")(function* (name, options) {
 		return yield* (yield* tag).getByName(name, options);
 	});
-	const jurisdiction = Effect.fnUntraced(function* (value) {
+	const jurisdiction = Effect.fn("DurableObject.jurisdiction")(function* (value) {
 		return yield* (yield* tag).jurisdiction(value);
 	});
-	const fetch = (stub, input, init) => Effect.gen(function* () {
+	const fetch = Effect.fn("DurableObject.fetch")(function* (stub, input, init) {
 		return yield* (yield* tag).fetch(stub, input, init);
 	});
-	const rpc = (stub, method, ...args) => Effect.gen(function* () {
+	const rpc = Effect.fn("DurableObject.rpc")(function* (stub, method, ...args) {
 		return yield* (yield* tag).rpc(stub, method, ...args);
 	});
-	const call = (stub, method, ...args) => Effect.gen(function* () {
+	const call = Effect.fn("DurableObject.call")(function* (stub, method, ...args) {
 		return yield* (yield* tag).call(stub, method, ...args);
 	});
-	const scopedCall = (stub, method, ...args) => Effect.gen(function* () {
+	const scopedCall = Effect.fn("DurableObject.scopedCall")(function* (stub, method, ...args) {
 		return yield* (yield* tag).scopedCall(stub, method, ...args);
 	});
-	const unsafeRaw = Effect.fnUntraced(function* () {
-		return yield* (yield* tag).unsafeRaw;
+	const rawUnsafe = Effect.fnUntraced(function* () {
+		return yield* (yield* tag).rawUnsafe;
 	});
 	const directMethods = makeDirectMethods(definition, {
 		call,
@@ -2155,10 +2399,10 @@ const Tag$9 = () => (id, methods) => {
 		rpc,
 		call,
 		scopedCall,
-		unsafeRaw
+		rawUnsafe
 	});
 };
-const DurableObject$1 = Tag$9;
+const DurableObject$1 = Tag$8;
 const wrapHandlers = (definition, handlers) => {
 	const wrapped = {};
 	for (const key of Object.keys(definition.methods)) {
@@ -2174,7 +2418,7 @@ const wrapHandlers = (definition, handlers) => {
 /**
 * Helper for implementing handlers with the exact method shape of a definition.
 */
-const implement$3 = (_definition, handlers) => handlers;
+const implement$2 = (_definition, handlers) => handlers;
 //#endregion
 //#region src/DurableObject.ts
 var DurableObject_exports = /* @__PURE__ */ __exportAll({
@@ -2201,15 +2445,12 @@ const make$7 = (layer, options = {}) => {
 		runtime;
 		constructor(state, env) {
 			super(state, env);
-			const services = Layer.mergeAll(layer$10, ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env))), Layer.succeed(DurableObjectState, fromDurableObjectState(state)), Layer.succeed(WorkerEnvironment, env));
-			const runtimeLayer = provideEntrypointServices(layer, services);
-			this.runtime = ManagedRuntime.make(runtimeLayer);
+			this.runtime = makeEntrypointRuntime(layer, env, Layer.succeed(DurableObjectState, fromDurableObjectState(state)));
 			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));
+			return runEventPromise(this.runtime, effect, runOptions.eventLayer === false ? void 0 : options.eventLayer);
 		}
 		fetch(request) {
 			const fetchHandler = options.fetch;
@@ -2239,9 +2480,6 @@ const make$7 = (layer, options = {}) => {
 	defineEntrypointRpcMethods("Durable Object", EffectDurableObject.prototype, options.rpc, reservedMethodNames, (self, effect) => self[RunSymbol](effect));
 	return assumeEntrypointClass(EffectDurableObject);
 };
-const Tag$8 = Tag$9;
-const method = method$1;
-const implement$2 = implement$3;
 //#endregion
 //#region src/DurableObjectAlarm.ts
 var DurableObjectAlarm_exports = /* @__PURE__ */ __exportAll({
@@ -2271,11 +2509,31 @@ CREATE INDEX IF NOT EXISTS idx_effect_cf_scheduled_alarms_run_at_storage_id
 const DEFAULT_PROCESS_DUE_ALARMS_LIMIT = 100;
 const DEFAULT_PROCESS_DUE_ALARMS_FAILURE_RESCHEDULE_AFTER = "30 seconds";
 const getScheduledEventId = (input) => `effect-cf-alarm:${encodeURIComponent(input.tag)}:${encodeURIComponent(input.id)}`;
-var InvalidAlarmRefError = class extends Data.TaggedError("InvalidAlarmRefError") {};
-var InvalidAlarmPayloadError = class extends Data.TaggedError("InvalidAlarmPayloadError") {};
-var InvalidRepeatEveryError = class extends Data.TaggedError("InvalidRepeatEveryError") {};
-var InvalidProcessDueAlarmsOptionsError = class extends Data.TaggedError("InvalidProcessDueAlarmsOptionsError") {};
-var StoredAlarmDecodeError = class extends Data.TaggedError("StoredAlarmDecodeError") {};
+var InvalidAlarmRefError = class extends Data.TaggedError("InvalidAlarmRefError") {
+	get message() {
+		return `Invalid Durable Object alarm ref: ${causeMessage(this.cause)}`;
+	}
+};
+var InvalidAlarmPayloadError = class extends Data.TaggedError("InvalidAlarmPayloadError") {
+	get message() {
+		return `Invalid Durable Object alarm payload: ${causeMessage(this.cause)}`;
+	}
+};
+var InvalidRepeatEveryError = class extends Data.TaggedError("InvalidRepeatEveryError") {
+	get message() {
+		return `Invalid Durable Object alarm repeatEvery: ${causeMessage(this.cause)}`;
+	}
+};
+var InvalidProcessDueAlarmsOptionsError = class extends Data.TaggedError("InvalidProcessDueAlarmsOptionsError") {
+	get message() {
+		return `Invalid processDueAlarms options: ${causeMessage(this.cause)}`;
+	}
+};
+var StoredAlarmDecodeError = class extends Data.TaggedError("StoredAlarmDecodeError") {
+	get message() {
+		return `Failed to decode stored alarm "${this.storageId}": ${causeMessage(this.cause)}`;
+	}
+};
 /**
 * Events handled by `processDueAlarms`.
 *
@@ -2319,7 +2577,7 @@ const toRepeatEveryMillis = (input) => {
 	if (input === void 0) return Effect.succeed(null);
 	return Effect.try({
 		try: () => {
-			const millis = Duration.toMillis(Duration.fromInputUnsafe(input));
+			const millis = Duration.toMillis(input);
 			if (!Number.isFinite(millis) || millis <= 0) throw new Error("Alarm repeatEvery must be a positive finite duration");
 			return Math.ceil(millis);
 		},
@@ -2335,7 +2593,7 @@ const toAlarmDue = (row) => Effect.gen(function* () {
 		_tag: "AlarmDue",
 		id: row.alarm_id,
 		payload: yield* decodeStoredPayload(row),
-		scheduledAt: DateTime.toUtc(DateTime.makeUnsafe(row.run_at)),
+		scheduledAt: DateTime.makeUnsafe(row.run_at),
 		tag: row.tag
 	});
 });
@@ -2346,7 +2604,7 @@ const getProcessLimit = (options) => {
 };
 const toFailureRescheduleMillis = (input) => Effect.try({
 	try: () => {
-		const millis = Duration.toMillis(Duration.fromInputUnsafe(input));
+		const millis = Duration.toMillis(input);
 		if (!Number.isFinite(millis) || millis <= 0) throw new Error("Alarm failure rescheduleAfter must be a positive finite duration");
 		return Math.ceil(millis);
 	},
@@ -2644,7 +2902,7 @@ const layer$8 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 				connectionsById.get(clientId)?.socket.raw.close();
 			}),
 			clientIds: Effect.sync(() => clientIds),
-			initialMessage: Effect.succeed(Option.none()),
+			initialMessage: Effect.succeedNone,
 			supportsAck: true,
 			supportsTransferables: false,
 			supportsSpanPropagation: true
@@ -2659,7 +2917,7 @@ const layer$8 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 			const connection = register(socket);
 			const decoded = yield* Effect.try({
 				try: () => connection.parser.decode(normalizeMessage(message)),
-				catch: RpcMessage.ResponseDefectEncoded
+				catch: (cause) => cause
 			});
 			const run = writeRequest;
 			if (run === void 0) {
@@ -2667,9 +2925,9 @@ const layer$8 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 				return;
 			}
 			for (const current of decoded) yield* run(connection.id, current);
-		}).pipe(Effect.catch((error) => {
+		}).pipe(Effect.catch((cause) => {
 			const connection = register(socket);
-			return send(connection, error);
+			return Predicate.isTagged(cause, "MaxBufferSizeExceeded") ? Effect.ignore(connection.socket.close(1009, String(cause))) : send(connection, RpcMessage.ResponseDefectEncoded(cause));
 		})),
 		close: unregister,
 		error: (socket, error) => Effect.gen(function* () {
@@ -2710,7 +2968,7 @@ const layer$7 = (options) => Layer.unwrap(Effect.gen(function* () {
 	const state = yield* DurableObjectState;
 	return SqliteClient.layer({
 		...options,
-		db: state.raw.storage.sql
+		storage: state.raw.storage
 	});
 }));
 //#endregion
@@ -2743,7 +3001,14 @@ const sendLimits = {
 	/** Allowlisted custom headers, excluding `X-` prefixed headers. */
 	maxAllowlistHeaders: 20
 };
-/** Error codes reported by Cloudflare Email Sending. */
+/**
+* Error codes reported by Cloudflare Email Sending.
+*
+* Surfaced on {@link EmailOperationError} `code` on a best-effort basis: the
+* runtime attaches them as a non-standard `code` property on thrown errors,
+* which may be missing depending on the runtime or dev-time proxying
+* (miniflare remote bindings serialize errors and can strip it).
+*/
 const emailErrorCodes = [
 	"E_VALIDATION_ERROR",
 	"E_FIELD_MISSING",
@@ -2767,9 +3032,24 @@ const emailErrorCodes = [
 	"E_HEADERS_TOO_MANY"
 ];
 /** Error raised when a Cloudflare Send Email operation fails. */
-var EmailOperationError = class extends Data.TaggedError("EmailOperationError") {};
+var EmailOperationError = class extends Data.TaggedError("EmailOperationError") {
+	get message() {
+		const code = this.code === void 0 ? "" : ` (${this.code})`;
+		return `Email ${this.operation} failed for binding "${this.binding}"${code}: ${causeMessage(this.cause)}`;
+	}
+};
 /** Error raised when a message violates documented Cloudflare Email Sending limits. */
-var EmailValidationError = class extends Data.TaggedError("EmailValidationError") {};
+var EmailValidationError = class extends Data.TaggedError("EmailValidationError") {
+	get message() {
+		return `Email ${this.operation} for binding "${this.binding}" failed validation: ${violationsMessage(this.violations)}`;
+	}
+};
+/**
+* Best-effort extraction of the Cloudflare error `code` from a thrown error.
+* Returns `undefined` when the property is absent — e.g. when a dev-time
+* proxy such as a miniflare remote binding (`"remote": true`) serializes the
+* error and strips non-standard properties.
+*/
 const emailErrorCode = (cause) => {
 	if (typeof cause !== "object" || cause === null) return;
 	const code = Reflect.get(cause, "code");
@@ -2939,18 +3219,16 @@ const isEmailBinding = (value) => {
 const makeClient$6 = (definition, options) => (email) => {
 	const runtime = email;
 	const validate = options?.validate ?? true;
-	const send = ((message) => {
-		const dispatch = () => tryEmailPromise(definition.binding, "send", () => runtime.send(message));
-		if (!validate || !isEmailMessageBuilder(message)) return dispatch();
-		return validateSendInput(definition.binding, "send", message).pipe(Effect.flatMap(dispatch));
-	});
 	return {
 		definition,
-		send,
-		unsafeRaw: Effect.succeed(email)
+		send: Effect.fn("Email.send")(function* (message) {
+			if (validate && isEmailMessageBuilder(message)) yield* validateSendInput(definition.binding, "send", message);
+			return yield* tryEmailPromise(definition.binding, "send", () => runtime.send(message));
+		}),
+		rawUnsafe: Effect.succeed(email)
 	};
 };
-const layer$6 = (tag, definition) => layer$20(tag, definition.binding, isEmailBinding, makeClient$6(definition, definition.send), { expected: expectedSendEmailBinding });
+const layer$6 = (tag, definition) => layer$19(tag, definition.binding, isEmailBinding, makeClient$6(definition, definition.send), { expected: expectedSendEmailBinding });
 const make$6 = (id) => Tag$7()(id);
 const Tag$7 = () => (id) => {
 	const tag = Context.Service()(id);
@@ -2977,9 +3255,9 @@ const isHyperdrive = (value) => {
 const makeClient$5 = (definition) => (hyperdrive) => ({
 	definition,
 	connectionString: hyperdrive.connectionString,
-	unsafeRaw: Effect.succeed(hyperdrive)
+	rawUnsafe: Effect.succeed(hyperdrive)
 });
-const layer$5 = (tag, definition) => layer$20(tag, definition.binding, isHyperdrive, makeClient$5(definition), { expected: expectedHyperdrive });
+const layer$5 = (tag, definition) => layer$19(tag, definition.binding, isHyperdrive, makeClient$5(definition), { expected: expectedHyperdrive });
 const make$5 = (id) => Tag$6()(id);
 const Tag$6 = () => (id) => {
 	const tag = Context.Service()(id);
@@ -2993,6 +3271,7 @@ const Tag$6 = () => (id) => {
 //#region src/Images.ts
 var Images_exports = /* @__PURE__ */ __exportAll({
 	ImagesOperationError: () => ImagesOperationError,
+	Step: () => Step,
 	Tag: () => Tag$5,
 	draw: () => draw,
 	empty: () => empty,
@@ -3002,30 +3281,23 @@ var Images_exports = /* @__PURE__ */ __exportAll({
 	makeClient: () => makeClient$4,
 	transform: () => transform
 });
-const TypeId = "effect-cf/Images/Steps";
+const TypeId = "~effect-cf/Images/Steps";
 const expectedImagesBinding = "Images binding with info() and input()";
 /** Error raised when a Cloudflare Images operation fails. */
-var ImagesOperationError = class extends Data.TaggedError("ImagesOperationError") {};
+var ImagesOperationError = class extends Data.TaggedError("ImagesOperationError") {
+	get message() {
+		return `Images ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
+const Step = Data.taggedEnum();
 const makeSteps = (steps) => ({
 	[TypeId]: TypeId,
 	steps
 });
 /** Empty Images transformation pipeline. */
 const empty = makeSteps([]);
-function transform(stepsOrTransform, transformValue) {
-	if (transformValue === void 0) return (steps) => transform(steps, stepsOrTransform);
-	return makeSteps([...stepsOrTransform.steps, {
-		_tag: "Transform",
-		transform: transformValue
-	}]);
-}
-function draw(stepsOrDraw, drawValue) {
-	if (drawValue === void 0) return (steps) => draw(steps, stepsOrDraw);
-	return makeSteps([...stepsOrDraw.steps, {
-		_tag: "Draw",
-		...drawValue
-	}]);
-}
+const transform = Function$1.dual(2, (steps, transformValue) => makeSteps([...steps.steps, Step.Transform({ transform: transformValue })]));
+const draw = Function$1.dual(2, (steps, drawValue) => makeSteps([...steps.steps, Step.Draw(drawValue)]));
 const imagesError = (binding, operation, cause) => new ImagesOperationError({
 	binding,
 	operation,
@@ -3039,7 +3311,7 @@ const tryImagesSync = (binding, operation, evaluate) => Effect.try({
 	try: evaluate,
 	catch: (cause) => imagesError(binding, operation, cause)
 });
-const maybe$1 = (value) => value === null ? Option.none() : Option.some(value);
+const maybe = (value) => value === null ? Option.none() : Option.some(value);
 const hasFunction$1 = (value, key) => typeof Reflect.get(value, key) === "function";
 const isHostedImagesBinding = (value) => typeof value === "object" && value !== null && hasFunction$1(value, "image") && hasFunction$1(value, "upload") && hasFunction$1(value, "list");
 const isImagesBinding = (value) => typeof value === "object" && value !== null && hasFunction$1(value, "info") && hasFunction$1(value, "input");
@@ -3051,42 +3323,38 @@ const wrapResult = (binding, result) => ({
 });
 const wrapHandle = (binding, handle) => ({
 	raw: handle,
-	details: tryImagesPromise(binding, "details", () => handle.details()).pipe(Effect.map(maybe$1)),
-	bytes: tryImagesPromise(binding, "bytes", () => handle.bytes()).pipe(Effect.map(maybe$1)),
-	update: (options) => tryImagesPromise(binding, "update", () => handle.update(options)),
-	delete: tryImagesPromise(binding, "delete", () => handle.delete())
+	details: tryImagesPromise(binding, "details", () => handle.details()).pipe(Effect.map(maybe), Effect.withSpan("Images.details")),
+	bytes: tryImagesPromise(binding, "bytes", () => handle.bytes()).pipe(Effect.map(maybe), Effect.withSpan("Images.bytes")),
+	update: Effect.fn("Images.update")((options) => tryImagesPromise(binding, "update", () => handle.update(options))),
+	delete: tryImagesPromise(binding, "delete", () => handle.delete()).pipe(Effect.withSpan("Images.delete"))
 });
 const wrapHosted = (binding, hosted) => ({
 	image: (imageId) => wrapHandle(binding, hosted.image(imageId)),
-	upload: (image, options) => tryImagesPromise(binding, "upload", () => hosted.upload(image, options)),
-	list: (options) => tryImagesPromise(binding, "list", () => hosted.list(options)),
-	unsafeRaw: Effect.succeed(hosted)
+	upload: Effect.fn("Images.upload")((image, options) => tryImagesPromise(binding, "upload", () => hosted.upload(image, options))),
+	list: Effect.fn("Images.list")((options) => tryImagesPromise(binding, "list", () => hosted.list(options))),
+	rawUnsafe: Effect.succeed(hosted)
 });
 const makeClient$4 = (definition) => (images) => {
 	const input = (image, options) => tryImagesSync(definition.binding, "input", () => images.input(image, options));
-	const process = (steps, options) => Effect.gen(function* () {
+	const process = Effect.fn("Images.process")(function* (steps, options) {
 		let transformer = yield* input(options.stream, options.inputOptions);
-		for (const step of steps.steps) switch (step._tag) {
-			case "Draw":
-				transformer = yield* tryImagesSync(definition.binding, "draw", () => transformer.draw(step.image, step.options));
-				break;
-			case "Transform":
-				transformer = yield* tryImagesSync(definition.binding, "transform", () => transformer.transform(step.transform));
-				break;
-		}
+		for (const step of steps.steps) transformer = yield* Step.$match(step, {
+			Draw: (drawStep) => tryImagesSync(definition.binding, "draw", () => transformer.draw(drawStep.image, drawStep.options)),
+			Transform: (transformStep) => tryImagesSync(definition.binding, "transform", () => transformer.transform(transformStep.transform))
+		});
 		const result = yield* tryImagesPromise(definition.binding, "output", () => transformer.output(options.outputOptions));
 		return wrapResult(definition.binding, result);
 	});
 	return {
 		definition,
-		info: (image, options) => tryImagesPromise(definition.binding, "info", () => images.info(image, options)),
+		info: Effect.fn("Images.info")((image, options) => tryImagesPromise(definition.binding, "info", () => images.info(image, options))),
 		input,
 		process,
 		hosted: isHostedImagesBinding(images.hosted) ? Option.some(wrapHosted(definition.binding, images.hosted)) : Option.none(),
-		unsafeRaw: Effect.succeed(images)
+		rawUnsafe: Effect.succeed(images)
 	};
 };
-const layer$4 = (tag, definition) => layer$20(tag, definition.binding, isImagesBinding, makeClient$4(definition), { expected: expectedImagesBinding });
+const layer$4 = (tag, definition) => layer$19(tag, definition.binding, isImagesBinding, makeClient$4(definition), { expected: expectedImagesBinding });
 const make$4 = (id) => Tag$5()(id);
 const Tag$5 = () => (id) => {
 	const tag = Context.Service()(id);
@@ -3107,9 +3375,11 @@ var Kv_exports = /* @__PURE__ */ __exportAll({
 });
 const expectedKvNamespace = "KV namespace binding with get(), put(), delete(), getWithMetadata(), and list()";
 /** Error raised when a KV operation fails. */
-var KvOperationError = class extends Data.TaggedError("KvOperationError") {};
-const maybeString = (value) => value === null || value === void 0 ? Option.none() : Option.some(value);
-const maybeNumber = (value) => value === void 0 ? Option.none() : Option.some(value);
+var KvOperationError = class extends Data.TaggedError("KvOperationError") {
+	get message() {
+		return `Kv ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
 const kvError = (binding, operation, cause) => new KvOperationError({
 	binding,
 	operation,
@@ -3127,22 +3397,32 @@ const isKvNamespace = (value) => {
 const makeClient$3 = (definition) => {
 	const encodeKey = Schema.encodeEffect(definition.key);
 	const decodeKey = Schema.decodeUnknownEffect(definition.key);
-	const encodeValue = Schema.encodeEffect(Schema.fromJsonString(Schema.toCodecJson(definition.value)));
-	const decodeValue = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.toCodecJson(definition.value)));
+	const jsonValue = Schema.fromJsonString(Schema.toCodecJson(definition.value));
+	const encodeValue = Schema.encodeEffect(jsonValue);
+	const decodeValue = Schema.decodeUnknownEffect(jsonValue);
 	return (kv) => ({
 		definition,
-		put: Effect.fnUntraced(function* (key, value, options) {
+		put: Effect.fn("Kv.put", { attributes: {
+			binding: definition.binding,
+			operation: "put"
+		} })(function* (key, value, options) {
 			const keyEncoded = yield* encodeKey(key);
 			const valueEncoded = yield* encodeValue(value);
 			yield* tryKvPromise(definition.binding, "put", () => kv.put(keyEncoded, valueEncoded, options));
 		}),
-		get: Effect.fnUntraced(function* (key) {
+		get: Effect.fn("Kv.get", { attributes: {
+			binding: definition.binding,
+			operation: "get"
+		} })(function* (key) {
 			const keyEncoded = yield* encodeKey(key);
 			const valueEncoded = yield* tryKvPromise(definition.binding, "get", () => kv.get(keyEncoded));
 			if (valueEncoded === null) return Option.none();
 			return yield* decodeValue(valueEncoded).pipe(Effect.map(Option.some));
 		}),
-		getWithMetadata: Effect.fnUntraced(function* (key, metadataSchema) {
+		getWithMetadata: Effect.fn("Kv.getWithMetadata", { attributes: {
+			binding: definition.binding,
+			operation: "getWithMetadata"
+		} })(function* (key, metadataSchema) {
 			const keyEncoded = yield* encodeKey(key);
 			const result = yield* tryKvPromise(definition.binding, "getWithMetadata", () => kv.getWithMetadata(keyEncoded));
 			if (result.value === null) return Option.none();
@@ -3151,10 +3431,13 @@ const makeClient$3 = (definition) => {
 			return Option.some({
 				value,
 				metadata,
-				cacheStatus: maybeString(result.cacheStatus)
+				cacheStatus: Option.fromNullishOr(result.cacheStatus)
 			});
 		}),
-		list: Effect.fnUntraced(function* (options) {
+		list: Effect.fn("Kv.list", { attributes: {
+			binding: definition.binding,
+			operation: "list"
+		} })(function* (options) {
 			const { metadataSchema, ...kvOptions } = options ?? {};
 			const result = yield* tryKvPromise(definition.binding, "list", () => kv.list(kvOptions));
 			const keys = [];
@@ -3163,25 +3446,28 @@ const makeClient$3 = (definition) => {
 				const decodedMetadata = key.metadata === void 0 ? Option.none() : metadataSchema === void 0 ? Option.some(key.metadata) : Option.some(yield* Schema.decodeUnknownEffect(metadataSchema)(key.metadata));
 				keys.push({
 					name: decodedName,
-					expiration: maybeNumber(key.expiration),
+					expiration: Option.fromUndefinedOr(key.expiration),
 					metadata: decodedMetadata
 				});
 			}
 			return {
 				keys,
 				listComplete: result.list_complete,
-				cursor: maybeString("cursor" in result ? result.cursor : void 0),
-				cacheStatus: maybeString(result.cacheStatus)
+				cursor: Option.fromNullishOr("cursor" in result ? result.cursor : void 0),
+				cacheStatus: Option.fromNullishOr(result.cacheStatus)
 			};
 		}),
-		remove: Effect.fnUntraced(function* (key) {
+		delete: Effect.fn("Kv.delete", { attributes: {
+			binding: definition.binding,
+			operation: "delete"
+		} })(function* (key) {
 			const keyEncoded = yield* encodeKey(key);
 			yield* tryKvPromise(definition.binding, "delete", () => kv.delete(keyEncoded));
 		}),
-		unsafeRaw: Effect.succeed(kv)
+		rawUnsafe: Effect.succeed(kv)
 	});
 };
-const layer$3 = (tag, definition) => layer$20(tag, definition.binding, isKvNamespace, makeClient$3(definition), { expected: expectedKvNamespace });
+const layer$3 = (tag, definition) => layer$19(tag, definition.binding, isKvNamespace, makeClient$3(definition), { expected: expectedKvNamespace });
 const makeDefinition$1 = (id, definition) => {
 	const kvDefinition = {
 		id,
@@ -3217,7 +3503,11 @@ var R2_exports = /* @__PURE__ */ __exportAll({
 });
 const expectedR2Bucket = "R2 bucket binding with head(), get(), put(), createMultipartUpload(), resumeMultipartUpload(), delete(), and list()";
 /** Error raised when an R2 operation fails. */
-var R2OperationError = class extends Data.TaggedError("R2OperationError") {};
+var R2OperationError = class extends Data.TaggedError("R2OperationError") {
+	get message() {
+		return `R2 ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
 const r2Error = (binding, operation, cause) => new R2OperationError({
 	binding,
 	operation,
@@ -3231,7 +3521,10 @@ const tryR2Sync = (binding, operation, evaluate) => Effect.try({
 	try: evaluate,
 	catch: (cause) => r2Error(binding, operation, cause)
 });
-const maybe = (value) => value === null ? Option.none() : Option.some(value);
+const spanOptions$1 = (binding, operation) => ({ attributes: {
+	binding,
+	operation
+} });
 const isR2ObjectBody = (value) => "body" in value && typeof value.arrayBuffer === "function" && typeof value.bytes === "function" && typeof value.text === "function" && typeof value.json === "function" && typeof value.blob === "function";
 const wrapObjectBody = (binding, object) => ({
 	key: object.key,
@@ -3252,11 +3545,11 @@ const wrapObjectBody = (binding, object) => ({
 	get bodyUsed() {
 		return object.bodyUsed;
 	},
-	arrayBuffer: tryR2Promise(binding, "arrayBuffer", () => object.arrayBuffer()),
-	bytes: tryR2Promise(binding, "bytes", () => object.bytes()),
-	text: tryR2Promise(binding, "text", () => object.text()),
-	json: () => tryR2Promise(binding, "json", () => object.json()),
-	blob: tryR2Promise(binding, "blob", () => object.blob())
+	arrayBuffer: tryR2Promise(binding, "arrayBuffer", () => object.arrayBuffer()).pipe(Effect.withSpan("R2.arrayBuffer", spanOptions$1(binding, "arrayBuffer"))),
+	bytes: tryR2Promise(binding, "bytes", () => object.bytes()).pipe(Effect.withSpan("R2.bytes", spanOptions$1(binding, "bytes"))),
+	text: tryR2Promise(binding, "text", () => object.text()).pipe(Effect.withSpan("R2.text", spanOptions$1(binding, "text"))),
+	json: () => tryR2Promise(binding, "json", () => object.json()).pipe(Effect.withSpan("R2.json", spanOptions$1(binding, "json"))),
+	blob: tryR2Promise(binding, "blob", () => object.blob()).pipe(Effect.withSpan("R2.blob", spanOptions$1(binding, "blob")))
 });
 const wrapGetResult = (binding, object) => {
 	if (object === null || !isR2ObjectBody(object)) return object;
@@ -3272,33 +3565,33 @@ const makeClient$2 = (definition) => {
 		raw: upload,
 		key: upload.key,
 		uploadId: upload.uploadId,
-		uploadPart: (partNumber, value, options) => tryR2Promise(definition.binding, "uploadPart", () => upload.uploadPart(partNumber, value, options)),
-		abort: tryR2Promise(definition.binding, "abortMultipartUpload", () => upload.abort()),
-		complete: (uploadedParts) => tryR2Promise(definition.binding, "completeMultipartUpload", () => upload.complete([...uploadedParts]))
+		uploadPart: Effect.fn("R2.uploadPart", spanOptions$1(definition.binding, "uploadPart"))((partNumber, value, options) => tryR2Promise(definition.binding, "uploadPart", () => upload.uploadPart(partNumber, value, options))),
+		abort: tryR2Promise(definition.binding, "abortMultipartUpload", () => upload.abort()).pipe(Effect.withSpan("R2.abortMultipartUpload", spanOptions$1(definition.binding, "abortMultipartUpload"))),
+		complete: Effect.fn("R2.completeMultipartUpload", spanOptions$1(definition.binding, "completeMultipartUpload"))((uploadedParts) => tryR2Promise(definition.binding, "completeMultipartUpload", () => upload.complete([...uploadedParts])))
 	});
 	return (bucket) => {
-		const get = ((key, options) => tryR2Promise(definition.binding, "get", () => bucket.get(key, options)).pipe(Effect.map((object) => maybe(wrapGetResult(definition.binding, object)))));
+		const get = Effect.fn("R2.get", spanOptions$1(definition.binding, "get"))((key, options) => tryR2Promise(definition.binding, "get", () => bucket.get(key, options)).pipe(Effect.map((object) => Option.fromNullOr(wrapGetResult(definition.binding, object)))));
 		return {
 			definition,
-			head: (key) => tryR2Promise(definition.binding, "head", () => bucket.head(key)).pipe(Effect.map(maybe)),
+			head: Effect.fn("R2.head", spanOptions$1(definition.binding, "head"))((key) => tryR2Promise(definition.binding, "head", () => bucket.head(key)).pipe(Effect.map(Option.fromNullOr))),
 			get,
-			put: ((key, value, options) => tryR2Promise(definition.binding, "put", () => bucket.put(key, value, options)).pipe(Effect.map((object) => {
+			put: Effect.fn("R2.put", spanOptions$1(definition.binding, "put"))((key, value, options) => tryR2Promise(definition.binding, "put", () => bucket.put(key, value, options)).pipe(Effect.map((object) => {
 				if (object === null) return Option.none();
 				if (options !== void 0 && "onlyIf" in options) return Option.some(object);
 				return object;
 			}))),
-			createMultipartUpload: (key, options) => tryR2Promise(definition.binding, "createMultipartUpload", () => bucket.createMultipartUpload(key, options)).pipe(Effect.map(wrapUpload)),
-			resumeMultipartUpload: (key, uploadId) => tryR2Sync(definition.binding, "resumeMultipartUpload", () => wrapUpload(bucket.resumeMultipartUpload(key, uploadId))),
-			delete: (keys) => {
+			createMultipartUpload: Effect.fn("R2.createMultipartUpload", spanOptions$1(definition.binding, "createMultipartUpload"))((key, options) => tryR2Promise(definition.binding, "createMultipartUpload", () => bucket.createMultipartUpload(key, options)).pipe(Effect.map(wrapUpload))),
+			resumeMultipartUpload: Effect.fn("R2.resumeMultipartUpload", spanOptions$1(definition.binding, "resumeMultipartUpload"))((key, uploadId) => tryR2Sync(definition.binding, "resumeMultipartUpload", () => wrapUpload(bucket.resumeMultipartUpload(key, uploadId)))),
+			delete: Effect.fn("R2.delete", spanOptions$1(definition.binding, "delete"))((keys) => {
 				const nativeKeys = typeof keys === "string" ? keys : [...keys];
 				return tryR2Promise(definition.binding, "delete", () => bucket.delete(nativeKeys));
-			},
-			list: (options) => tryR2Promise(definition.binding, "list", () => bucket.list(options)),
-			unsafeRaw: Effect.succeed(bucket)
+			}),
+			list: Effect.fn("R2.list", spanOptions$1(definition.binding, "list"))((options) => tryR2Promise(definition.binding, "list", () => bucket.list(options))),
+			rawUnsafe: Effect.succeed(bucket)
 		};
 	};
 };
-const layer$2 = (tag, definition) => layer$20(tag, definition.binding, isR2Bucket, makeClient$2(definition), { expected: expectedR2Bucket });
+const layer$2 = (tag, definition) => layer$19(tag, definition.binding, isR2Bucket, makeClient$2(definition), { expected: expectedR2Bucket });
 const make$3 = (id) => Tag$3()(id);
 const Tag$3 = () => (id) => {
 	const tag = Context.Service()(id);
@@ -3309,17 +3602,83 @@ const Tag$3 = () => (id) => {
 	});
 };
 //#endregion
+//#region src/Vectorize.ts
+var Vectorize_exports = /* @__PURE__ */ __exportAll({
+	Tag: () => Tag$2,
+	VectorizeOperationError: () => VectorizeOperationError,
+	isVectorizeBinding: () => isVectorizeBinding,
+	layer: () => layer$1,
+	make: () => make$2,
+	makeClient: () => makeClient$1
+});
+const expectedVectorizeBinding = "Vectorize index binding with describe(), query(), insert(), upsert(), deleteByIds(), and getByIds()";
+/** Error raised when a Vectorize operation fails. */
+var VectorizeOperationError = class extends Data.TaggedError("VectorizeOperationError") {
+	get message() {
+		return `Vectorize ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
+const vectorizeError = (binding, operation, cause) => new VectorizeOperationError({
+	binding,
+	operation,
+	cause
+});
+const tryVectorizePromise = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => vectorizeError(binding, operation, cause)
+});
+const spanOptions = (binding, operation) => ({ attributes: {
+	binding,
+	operation
+} });
+const hasFunction = (value, key) => typeof Reflect.get(value, key) === "function";
+const isVectorizeBinding = (value) => typeof value === "object" && value !== null && hasFunction(value, "describe") && hasFunction(value, "query") && hasFunction(value, "insert") && hasFunction(value, "upsert") && hasFunction(value, "deleteByIds") && hasFunction(value, "getByIds");
+const makeClient$1 = (definition) => (index) => {
+	const runtime = index;
+	const deleteByIds = Effect.fn("Vectorize.deleteByIds", spanOptions(definition.binding, "deleteByIds"))((ids) => tryVectorizePromise(definition.binding, "deleteByIds", () => runtime.deleteByIds([...ids])));
+	return {
+		definition,
+		describe: tryVectorizePromise(definition.binding, "describe", () => runtime.describe()).pipe(Effect.withSpan("Vectorize.describe", spanOptions(definition.binding, "describe"))),
+		query: Effect.fn("Vectorize.query", spanOptions(definition.binding, "query"))((vector, options) => tryVectorizePromise(definition.binding, "query", () => runtime.query(vector, options))),
+		queryById: Effect.fn("Vectorize.queryById", spanOptions(definition.binding, "queryById"))((vectorId, options) => runtime.queryById !== void 0 ? tryVectorizePromise(definition.binding, "queryById", () => runtime.queryById(vectorId, options)) : Effect.fail(vectorizeError(definition.binding, "queryById", /* @__PURE__ */ new TypeError("Vectorize binding does not expose queryById()")))),
+		insert: Effect.fn("Vectorize.insert", spanOptions(definition.binding, "insert"))((vectors) => tryVectorizePromise(definition.binding, "insert", () => runtime.insert([...vectors]))),
+		upsert: Effect.fn("Vectorize.upsert", spanOptions(definition.binding, "upsert"))((vectors) => tryVectorizePromise(definition.binding, "upsert", () => runtime.upsert([...vectors]))),
+		deleteByIds,
+		delete: deleteByIds,
+		getByIds: Effect.fn("Vectorize.getByIds", spanOptions(definition.binding, "getByIds"))((ids) => tryVectorizePromise(definition.binding, "getByIds", () => runtime.getByIds([...ids]))),
+		rawUnsafe: Effect.succeed(index)
+	};
+};
+const layer$1 = (tag, definition) => layer$19(tag, definition.binding, isVectorizeBinding, makeClient$1(definition), { expected: expectedVectorizeBinding });
+const make$2 = (id) => Tag$2()(id);
+const Tag$2 = () => (id) => {
+	const tag = Context.Service()(id);
+	const makeLayer = (definition) => layer$1(tag, definition);
+	return Object.assign(tag, {
+		id,
+		layer: makeLayer
+	});
+};
+//#endregion
 //#region src/WorkflowBinding.ts
 var WorkflowBinding_exports = /* @__PURE__ */ __exportAll({
 	WorkflowOperationError: () => WorkflowOperationError,
 	WorkflowResultDecodeError: () => WorkflowResultDecodeError,
 	isWorkflow: () => isWorkflow,
-	layer: () => layer$1,
-	makeClient: () => makeClient$1
+	layer: () => layer,
+	makeClient: () => makeClient
 });
 const expectedWorkflow = "Workflow binding with create(), createBatch(), and get()";
-var WorkflowOperationError = class extends Data.TaggedError("WorkflowOperationError") {};
-var WorkflowResultDecodeError = class extends Data.TaggedError("WorkflowResultDecodeError") {};
+var WorkflowOperationError = class extends Data.TaggedError("WorkflowOperationError") {
+	get message() {
+		return `Workflow ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
+var WorkflowResultDecodeError = class extends Data.TaggedError("WorkflowResultDecodeError") {
+	get message() {
+		return `Workflow result decode failed for binding "${this.binding}" instance "${this.instanceId}": ${causeMessage(this.cause)}`;
+	}
+};
 const workflowError = (binding, operation, cause) => new WorkflowOperationError({
 	binding,
 	operation,
@@ -3334,7 +3693,7 @@ const isWorkflow = (value) => {
 	const resource = value;
 	return typeof resource.create === "function" && typeof resource.createBatch === "function" && typeof resource.get === "function";
 };
-const makeClient$1 = (definition) => {
+const makeClient = (definition) => {
 	const encodePayload = Schema.encodeEffect(definition.payload);
 	const decodeResult = Schema.decodeUnknownEffect(definition.result);
 	const wrapInstance = (raw) => {
@@ -3362,7 +3721,10 @@ const makeClient$1 = (definition) => {
 		};
 	};
 	return (workflow) => ({
-		create: Effect.fnUntraced(function* (payload, options) {
+		create: Effect.fn("WorkflowBinding.create", { attributes: {
+			binding: definition.binding,
+			operation: "create"
+		} })(function* (payload, options) {
 			const encoded = yield* encodePayload(payload);
 			const raw = yield* tryWorkflowPromise(definition.binding, "create", () => workflow.create({
 				...options,
@@ -3370,7 +3732,10 @@ const makeClient$1 = (definition) => {
 			}));
 			return wrapInstance(raw);
 		}),
-		createBatch: Effect.fnUntraced(function* (batch) {
+		createBatch: Effect.fn("WorkflowBinding.createBatch", { attributes: {
+			binding: definition.binding,
+			operation: "createBatch"
+		} })(function* (batch) {
 			const encodedBatch = [];
 			for (const item of batch) {
 				const { payload, ...options } = item;
@@ -3382,17 +3747,17 @@ const makeClient$1 = (definition) => {
 			return (yield* tryWorkflowPromise(definition.binding, "createBatch", () => workflow.createBatch(encodedBatch))).map(wrapInstance);
 		}),
 		get: (instanceId) => tryWorkflowPromise(definition.binding, "get", () => workflow.get(instanceId)).pipe(Effect.map(wrapInstance)),
-		unsafeRaw: Effect.succeed(workflow)
+		rawUnsafe: Effect.succeed(workflow)
 	});
 };
-const layer$1 = (tag, definition) => layer$20(tag, definition.binding, (value) => isWorkflow(value), makeClient$1(definition), { expected: expectedWorkflow });
+const layer = (tag, definition) => layer$19(tag, definition.binding, (value) => isWorkflow(value), makeClient(definition), { expected: expectedWorkflow });
 //#endregion
 //#region src/WorkflowDefinition.ts
 var WorkflowDefinition_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$2,
+	Tag: () => Tag$1,
 	Workflow: () => Workflow,
 	implement: () => implement$1,
-	make: () => make$2
+	make: () => make$1
 });
 const makeDefinition = (id, definition) => {
 	const workflowDefinition = {
@@ -3400,13 +3765,13 @@ const makeDefinition = (id, definition) => {
 		payload: definition.payload,
 		result: definition.result
 	};
-	return Object.assign(workflowDefinition, { make: (layer, options) => make$1(layer, { run: wrapHandler(workflowDefinition, options.run) }) });
+	return Object.assign(workflowDefinition, { make: (layer, options) => make(layer, { run: wrapHandler(workflowDefinition, options.run) }) });
 };
-const make$2 = (id, definition) => Tag$2()(id, definition);
-const Tag$2 = () => (id, definition) => {
+const make$1 = (id, definition) => Tag$1()(id, definition);
+const Tag$1 = () => (id, definition) => {
 	const workflowDefinition = makeDefinition(id, definition);
-	const tag = Context.Service()(id);
-	const layer = (binding) => layer$1(tag, {
+	const tag = Context.Service()(`effect-cf/Workflow/${id}`);
+	const layer$20 = (binding) => layer(tag, {
 		...binding,
 		payload: definition.payload,
 		result: definition.result
@@ -3420,26 +3785,24 @@ const Tag$2 = () => (id, definition) => {
 	const get = Effect.fnUntraced(function* (instanceId) {
 		return yield* (yield* tag).get(instanceId);
 	});
-	const unsafeRaw = Effect.fnUntraced(function* () {
-		return yield* (yield* tag).unsafeRaw;
-	});
+	const rawUnsafe = Effect.flatMap(tag, (workflow) => workflow.rawUnsafe);
 	return Object.assign(tag, {
 		id: workflowDefinition.id,
 		payload: workflowDefinition.payload,
 		result: workflowDefinition.result,
 		make: workflowDefinition.make,
-		layer,
+		layer: layer$20,
 		create,
 		createBatch,
 		get,
-		unsafeRaw
+		rawUnsafe
 	});
 };
-const Workflow = Tag$2;
+const Workflow = Tag$1;
 const wrapHandler = (definition, handler) => {
 	const decodePayload = Schema.decodeUnknownEffect(definition.payload);
 	const encodeResult = Schema.encodeEffect(definition.result);
-	return (payload) => Effect.gen(function* () {
+	return Effect.fnUntraced(function* (payload) {
 		const decodedPayload = yield* decodePayload(payload);
 		const decodedEvent = {
 			...yield* WorkflowEvent$1,
@@ -3452,19 +3815,31 @@ const wrapHandler = (definition, handler) => {
 const implement$1 = (_definition, handler) => handler;
 //#endregion
 //#region src/Workflow.ts
+/**
+* Effect wrapper for Cloudflare Workflows entrypoints and bindings; distinct
+* from Effect's runtime-agnostic `effect/unstable/workflow` cluster module.
+*/
 var Workflow_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$1,
+	Tag: () => Tag,
 	WorkflowEvent: () => WorkflowEvent$1,
 	WorkflowStep: () => WorkflowStep$1,
 	WorkflowStepContext: () => WorkflowStepContext$1,
+	WorkflowStepError: () => WorkflowStepError,
 	implement: () => implement,
-	make: () => make$1,
+	make: () => make,
 	sleep: () => sleep,
 	sleepUntil: () => sleepUntil,
 	step: () => step,
 	waitForEvent: () => waitForEvent
 });
 var WorkflowEvent$1 = class extends Context.Service()("effect-cf/WorkflowEvent") {};
+/** Failure raised when a Cloudflare Workflow step operation rejects. */
+var WorkflowStepError = class extends Data.TaggedError("WorkflowStepError") {
+	get message() {
+		const step = this.step === void 0 ? "" : ` in step "${this.step}"`;
+		return `Workflow ${this.operation} failed${step}: ${causeMessage(this.cause)}`;
+	}
+};
 var WorkflowStep$1 = class extends Context.Service()("effect-cf/WorkflowStep") {};
 var WorkflowStepContext$1 = class extends Context.Service()("effect-cf/WorkflowStepContext") {};
 const fromWorkflowEvent = (event) => ({
@@ -3482,35 +3857,47 @@ const fromWorkflowStep = (step, runPromise) => ({
 			const rawStep = step;
 			return config === void 0 ? rawStep.do(name, run) : rawStep.do(name, config, run);
 		},
-		catch: (cause) => cause
+		catch: (cause) => new WorkflowStepError({
+			step: name,
+			operation: "do",
+			cause
+		})
 	}))),
 	sleep: (name, duration) => Effect.tryPromise({
 		try: () => step.sleep(name, duration),
-		catch: (cause) => cause
+		catch: (cause) => new WorkflowStepError({
+			step: name,
+			operation: "sleep",
+			cause
+		})
 	}),
 	sleepUntil: (name, timestamp) => Effect.tryPromise({
 		try: () => step.sleepUntil(name, timestamp),
-		catch: (cause) => cause
+		catch: (cause) => new WorkflowStepError({
+			step: name,
+			operation: "sleepUntil",
+			cause
+		})
 	}),
 	waitForEvent: (name, options) => Effect.tryPromise({
 		try: () => step.waitForEvent(name, options),
-		catch: (cause) => cause
+		catch: (cause) => new WorkflowStepError({
+			step: name,
+			operation: "waitForEvent",
+			cause
+		})
 	})
 });
-const make$1 = (layer, options) => {
+const make = (layer, options) => {
 	class EffectWorkflow extends WorkflowEntrypoint {
 		runtime;
 		constructor(ctx, env) {
 			super(ctx, env);
-			let runWaitUntilEffect = () => Promise.reject(/* @__PURE__ */ new Error("WorkerContext runtime is not initialized"));
-			const services = 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));
-			const runtimeLayer = provideEntrypointServices(layer, services);
-			this.runtime = ManagedRuntime.make(runtimeLayer);
-			runWaitUntilEffect = (effect) => this.runtime.runPromiseExit(effect);
+			this.runtime = makeEntrypointRuntime(layer, env, Layer.mergeAll(Layer.succeed(ExecutionContext, ctx), Layer.succeed(WorkerContext, fromExecutionContext(ctx))));
 		}
 		run(event, step) {
 			const workflowServices = Layer.mergeAll(Layer.succeed(WorkflowEvent$1, fromWorkflowEvent(event)), Layer.succeed(WorkflowStep$1, fromWorkflowStep(step, (effect) => this.runtime.runPromise(effect))));
-			return this.runtime.runPromise(Effect.scoped(options.run(event.payload).pipe(Effect.provide(workflowServices))));
+			return runEventPromise(this.runtime, options.run(event.payload), workflowServices);
 		}
 	}
 	return assumeEntrypointClass(EffectWorkflow);
@@ -3519,57 +3906,7 @@ const step = (name, effect, config) => Effect.flatMap(WorkflowStep$1, (workflowS
 const sleep = (name, duration) => Effect.flatMap(WorkflowStep$1, (workflowStep) => workflowStep.sleep(name, duration));
 const sleepUntil = (name, timestamp) => Effect.flatMap(WorkflowStep$1, (workflowStep) => workflowStep.sleepUntil(name, timestamp));
 const waitForEvent = (name, options) => Effect.flatMap(WorkflowStep$1, (workflowStep) => workflowStep.waitForEvent(name, options));
-const Tag$1 = Tag$2;
+const Tag = Tag$1;
 const implement = implement$1;
 //#endregion
-//#region src/Vectorize.ts
-var Vectorize_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag,
-	VectorizeOperationError: () => VectorizeOperationError,
-	isVectorizeBinding: () => isVectorizeBinding,
-	layer: () => layer,
-	make: () => make,
-	makeClient: () => makeClient
-});
-const expectedVectorizeBinding = "Vectorize index binding with describe(), query(), insert(), upsert(), deleteByIds(), and getByIds()";
-/** Error raised when a Vectorize operation fails. */
-var VectorizeOperationError = class extends Data.TaggedError("VectorizeOperationError") {};
-const vectorizeError = (binding, operation, cause) => new VectorizeOperationError({
-	binding,
-	operation,
-	cause
-});
-const tryVectorizePromise = (binding, operation, evaluate) => Effect.tryPromise({
-	try: evaluate,
-	catch: (cause) => vectorizeError(binding, operation, cause)
-});
-const hasFunction = (value, key) => typeof Reflect.get(value, key) === "function";
-const isVectorizeBinding = (value) => typeof value === "object" && value !== null && hasFunction(value, "describe") && hasFunction(value, "query") && hasFunction(value, "insert") && hasFunction(value, "upsert") && hasFunction(value, "deleteByIds") && hasFunction(value, "getByIds");
-const makeClient = (definition) => (index) => {
-	const runtime = index;
-	const deleteByIds = (ids) => tryVectorizePromise(definition.binding, "deleteByIds", () => runtime.deleteByIds([...ids]));
-	return {
-		definition,
-		describe: tryVectorizePromise(definition.binding, "describe", () => runtime.describe()),
-		query: (vector, options) => tryVectorizePromise(definition.binding, "query", () => runtime.query(vector, options)),
-		queryById: (vectorId, options) => runtime.queryById !== void 0 ? tryVectorizePromise(definition.binding, "queryById", () => runtime.queryById(vectorId, options)) : Effect.fail(vectorizeError(definition.binding, "queryById", /* @__PURE__ */ new TypeError("Vectorize binding does not expose queryById()"))),
-		insert: (vectors) => tryVectorizePromise(definition.binding, "insert", () => runtime.insert([...vectors])),
-		upsert: (vectors) => tryVectorizePromise(definition.binding, "upsert", () => runtime.upsert([...vectors])),
-		deleteByIds,
-		delete: deleteByIds,
-		getByIds: (ids) => tryVectorizePromise(definition.binding, "getByIds", () => runtime.getByIds([...ids])),
-		unsafeRaw: Effect.succeed(index)
-	};
-};
-const layer = (tag, definition) => layer$20(tag, definition.binding, isVectorizeBinding, makeClient(definition), { expected: expectedVectorizeBinding });
-const make = (id) => Tag()(id);
-const Tag = () => (id) => {
-	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer(tag, definition);
-	return Object.assign(tag, {
-		id,
-		layer: makeLayer
-	});
-};
-//#endregion
-export { AiGateway_exports as AiGateway, AnalyticsEngine_exports as AnalyticsEngine, Binding_exports as Binding, BrowserRendering_exports as BrowserRendering, Cache_exports as Cache, CloudflareOtlp_exports as CloudflareOtlp, ContainerNamespace_exports as ContainerNamespace, D1_exports as D1, DurableObject_exports as DurableObject, DurableObjectAlarm_exports as DurableObjectAlarm, DurableObjectDefinition_exports as DurableObjectDefinition, DurableObjectNamespace_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_exports as DurableObjectSqlite, DurableObjectState_exports as DurableObjectState, DurableObjectStorage_exports as DurableObjectStorage, DurableObjectWebSocket_exports as DurableObjectWebSocket, Email_exports as Email, Hyperdrive_exports as Hyperdrive, Images_exports as Images, Kv_exports as Kv, Queue_exports as Queue, QueueBinding_exports as QueueBinding, QueueDefinition_exports as QueueDefinition, R2_exports as R2, Rpc_exports as Rpc, RpcDefinition_exports as RpcDefinition, ServiceBinding_exports as ServiceBinding, Vectorize_exports as Vectorize, Worker_exports as Worker, WorkerConfig, WorkerDefinition_exports as WorkerDefinition, WorkerEnvironment, WorkersAi_exports as WorkersAi, Workflow_exports as Workflow, WorkflowBinding_exports as WorkflowBinding, WorkflowDefinition_exports as WorkflowDefinition };
+export { AiGateway_exports as AiGateway, AnalyticsEngine_exports as AnalyticsEngine, Binding_exports as Binding, BrowserRendering_exports as BrowserRendering, Cache_exports as Cache, CloudflareOtlp_exports as CloudflareOtlp, ContainerNamespace_exports as ContainerNamespace, D1_exports as D1, DurableObject_exports as DurableObject, DurableObjectAlarm_exports as DurableObjectAlarm, DurableObjectDefinition_exports as DurableObjectDefinition, DurableObjectNamespace_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_exports as DurableObjectSqlite, DurableObjectState_exports as DurableObjectState, DurableObjectStorage_exports as DurableObjectStorage, DurableObjectWebSocket_exports as DurableObjectWebSocket, Email_exports as Email, Environment_exports as Environment, Hyperdrive_exports as Hyperdrive, Images_exports as Images, Kv_exports as Kv, Queue_exports as Queue, QueueBinding_exports as QueueBinding, QueueDefinition_exports as QueueDefinition, R2_exports as R2, Rpc_exports as Rpc, RpcDefinition_exports as RpcDefinition, ServiceBinding_exports as ServiceBinding, Vectorize_exports as Vectorize, Worker_exports as Worker, WorkerConfig, WorkerDefinition_exports as WorkerDefinition, WorkerEnvironment, WorkersAi_exports as WorkersAi, Workflow_exports as Workflow, WorkflowBinding_exports as WorkflowBinding, WorkflowDefinition_exports as WorkflowDefinition };