effect-cf 0.33.0 → 0.35.0

package/dist/index.mjs

@@ -1,10 +1,10 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { a as WorkerEnvironment, i as WorkerConfig, n as violationsMessage, r as Environment_exports, t as causeMessage } from "./ErrorMessage-BM0K-Nik.mjs";
-import { n as Service$2, r as layer$19, t as Binding_exports } from "./Binding-pfilNJmP.mjs";
-import { n as Artifacts_exports } from "./Artifacts-CSIk1Oml.mjs";
-import { a as DurableObjectWebSocket_exports, c as DurableObjectStorage_exports, i as fromExecutionContext, n as DurableObjectState_exports, o as DurableWebSocketAttachmentError, r as fromDurableObjectState, s as fromWebSocket, t as DurableObjectState } from "./DurableObjectState-CVLLse69.mjs";
-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 { a as WorkerEnvironment, i as WorkerConfig, n as violationsMessage, r as Environment_exports, t as causeMessage } from "./ErrorMessage-Byx2OgNd.mjs";
+import { n as Service$2, r as layer$19, t as Binding_exports } from "./Binding-C82jRhdr.mjs";
+import { n as Artifacts_exports } from "./Artifacts-CBxWGeZB.mjs";
+import { a as DurableObjectWebSocket_exports, c as DurableObjectStorage_exports, i as fromExecutionContext, n as DurableObjectState_exports, o as DurableWebSocketAttachmentError, r as fromDurableObjectState, s as fromWebSocket, t as DurableObjectState } from "./DurableObjectState-DcqElJ4e.mjs";
+import { Cause, Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, FiberSet, Function as Function$1, Layer, ManagedRuntime, Option, Predicate, Queue, References, Result, Schema, Tracer } from "effect";
+import { FetchHttpClient, HttpClient, HttpClientRequest, HttpEffect, HttpMiddleware, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 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";
@@ -24,7 +24,6 @@ var WorkersAi_exports = /* @__PURE__ */ __exportAll({
 	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") {
 	get message() {
 		return `Workers AI ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
@@ -51,7 +50,7 @@ const embeddingResponse = (value) => ({
 	data: value.data ?? [],
 	[embeddingDimensionsKey]: value[embeddingDimensionsKey] ?? []
 });
-const decodeEmbeddingResponse = Schema.decodeUnknownOption(Schema.Struct({
+const decodeEmbeddingResponse = Schema.decodeUnknownEffect(Schema.Struct({
 	data: Schema.optional(Schema.Array(Schema.Array(Schema.Number))),
 	[embeddingDimensionsKey]: Schema.optional(Schema.Array(Schema.Number))
 }));
@@ -63,11 +62,14 @@ const makeClient$15 = (definition) => (ai) => {
 		definition,
 		aiGatewayLogId: tryWorkersAiSync(definition.binding, "aiGatewayLogId", () => ai.aiGatewayLogId),
 		run,
-		runEmbedding: Effect.fn("WorkersAi.runEmbedding")((model, input, options) => {
-			return run(model, input, options).pipe(Effect.map((response) => Option.match(decodeEmbeddingResponse(response), {
-				onNone: () => embeddingResponse({}),
-				onSome: embeddingResponse
+		runEmbedding: Effect.fn("WorkersAi.runEmbedding")(function* (model, input, options) {
+			const response = yield* run(model, input, options);
+			const decoded = yield* decodeEmbeddingResponse(response).pipe(Effect.mapError((cause) => new WorkersAiOperationError({
+				binding: definition.binding,
+				operation: "runEmbedding",
+				cause
 			})));
+			return embeddingResponse(decoded);
 		}),
 		models: Effect.fn("WorkersAi.models")((params) => tryWorkersAiPromise(definition.binding, "models", () => ai.models(params))),
 		gateway: (gatewayId) => tryWorkersAiSync(definition.binding, "gateway", () => ai.gateway(gatewayId)),
@@ -97,7 +99,6 @@ var AiGateway_exports = /* @__PURE__ */ __exportAll({
 	makeHttpClient: () => makeHttpClient
 });
 const expectedAiGatewayBinding = "Workers AI binding with gateway()";
-/** Error raised when an AI Gateway operation fails. */
 var AiGatewayOperationError = class extends Data.TaggedError("AiGatewayOperationError") {
 	get message() {
 		return `AI Gateway ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
@@ -306,19 +307,16 @@ 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") {
 	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") {
 	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({
 	binding,
@@ -418,7 +416,11 @@ const queryRequest = (definition, sql, options) => {
 };
 const responseText = (definition, response, operation) => response.text.pipe(Effect.catch((cause) => Effect.fail(analyticsEngineQueryError(definition, operation, "Failed to read Analytics Engine SQL API response body", { cause }))));
 const executeQueryRequest = (definition, httpClient, sql, options) => Effect.gen(function* () {
-	const response = yield* httpClient.execute(queryRequest(definition, sql, options)).pipe(Effect.mapError((cause) => analyticsEngineQueryError(definition, "query", "Analytics Engine SQL API request failed", { cause })));
+	const request = yield* Effect.try({
+		try: () => queryRequest(definition, sql, options),
+		catch: (cause) => analyticsEngineQueryError(definition, "query", "Invalid Analytics Engine SQL API URL", { cause })
+	});
+	const response = yield* httpClient.execute(request).pipe(Effect.mapError((cause) => analyticsEngineQueryError(definition, "query", "Analytics Engine SQL API request failed", { cause })));
 	if (response.status < 200 || response.status >= 300) {
 		const body = yield* responseText(definition, response, "queryErrorBody");
 		return yield* Effect.fail(analyticsEngineQueryError(definition, "query", `Analytics Engine SQL API returned HTTP ${response.status}`, {
@@ -523,7 +525,6 @@ var BrowserRendering_exports = /* @__PURE__ */ __exportAll({
 	makeClient: () => makeClient$12
 });
 const expectedBrowserRenderingBinding = "Browser Rendering binding resource";
-/** Error raised when a Browser Rendering operation fails. */
 var BrowserRenderingOperationError = class extends Data.TaggedError("BrowserRenderingOperationError") {
 	get message() {
 		return `Browser Rendering ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
@@ -596,13 +597,11 @@ var Cache_exports = /* @__PURE__ */ __exportAll({
 	makeCacheClient: () => makeCacheClient,
 	makeClient: () => makeClient$11
 });
-/** Error raised when a Cloudflare Cache API operation fails. */
 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({
 	cache,
@@ -617,7 +616,6 @@ const spanOptions$2 = (cache, operation) => ({ attributes: {
 	cache,
 	operation
 } });
-/** Wraps a native Cloudflare `Cache` instance. */
 const makeCacheClient = (cache, name = "default") => ({
 	name,
 	match: Effect.fn("Cache.match", spanOptions$2(name, "match"))((request, options) => tryCachePromise(name, "match", () => cache.match(request, options)).pipe(Effect.map(Option.fromUndefinedOr))),
@@ -625,43 +623,20 @@ const makeCacheClient = (cache, name = "default") => ({
 	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)), 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$14 = Layer.sync(CacheStorage, () => makeClient$11(caches));
 //#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. Effect-backed Worker fetch handlers, Worker or
-* Durable Object native RPC handlers, and Durable Object alarm handlers
-* schedule this flusher automatically. These automatic flushes are capped at
-* two seconds and silently discard timeouts and failures so telemetry cannot
-* extend or fail the user event, or recursively log through an unhealthy
-* exporter.
-*
-* Other entrypoint lifecycles, including queue handlers, do not flush
-* automatically. Applications can flush explicitly or hand the flush to their
-* `waitUntil` mechanism, and own the timeout and failure policy at that call
-* site:
-*
-* ```ts
-* const flusher = yield* OtlpExporter.Flusher;
-*
-* yield* flusher.flush.pipe(
-*   Effect.timeoutOption("2 seconds"),
-*   Effect.ignoreCause,
-* );
-* ```
+* Worker fetch/queue/RPC and Durable Object alarm/RPC handlers schedule a
+* best-effort flusher. It settles within two seconds; other lifecycles must
+* flush explicitly. Scheduled flush failures cannot fail user events. Exporter
+* layer finalizers run separately and follow their configured shutdown timeout.
 */
 var CloudflareOtlp_exports = /* @__PURE__ */ __exportAll({
 	layer: () => layer$13,
@@ -692,7 +667,6 @@ const makeResource = (options, runtimeAttributes) => ({
 	}
 });
 const serializationLayer = (serialization) => serialization === "json" ? OtlpSerialization.layerJson : OtlpSerialization.layerProtobuf;
-/** Merges a non-empty signal layer list; callers handle the empty case. */
 const mergeSignalLayers = (layers) => {
 	let merged = layers[0];
 	for (let index = 1; index < layers.length; index++) merged = Layer.mergeAll(merged, layers[index]);
@@ -747,6 +721,8 @@ const layerProtobuf = (options = {}) => layer$13({
 *
 * 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.
+* A handler-scoped exporter can delay scope closure while its own finalizer
+* flushes; the two-second background flush limit does not bound layer shutdown.
 */
 const layerWorker = (options = {}) => makeLayer(options, {
 	"cloudflare.resource_type": "worker",
@@ -791,7 +767,6 @@ const ContainerState = Schema.Union([Schema.Struct({
 	status: Schema.Literal("stopped_with_code"),
 	exitCode: Schema.optionalKey(Schema.Int)
 })]);
-/** Failure raised when invoking a named Container operation. */
 var ContainerOperationError = class extends Data.TaggedError("ContainerOperationError") {
 	get message() {
 		return `Container ${this.operation} failed for binding "${this.binding}" instance "${this.instance}": ${causeMessage(this.cause)}`;
@@ -889,7 +864,6 @@ const makeClient$10 = (definition) => (namespace) => {
 };
 const layer$12 = (tag, definition) => layer$19(tag, definition.binding, (value) => isContainerNamespaceResource(value), makeClient$10(definition), { expected: expectedContainerNamespace });
 const make$14 = (id) => Tag$12()(id);
-/** Creates a typed Effect service for a Cloudflare Container namespace. */
 const Tag$12 = () => (id) => {
 	const tag = Context.Service()(`effect-cf/Container/${id}`);
 	const makeLayer = (definition) => layer$12(tag, definition);
@@ -931,25 +905,7 @@ var D1_exports = /* @__PURE__ */ __exportAll({
 const TypeId$2 = "~effect-cf/D1";
 const expectedD1Database = "D1 database binding with prepare(), batch(), and exec()";
 const isD1Database = (value) => Predicate.hasProperty(value, "prepare") && Predicate.isFunction(value.prepare) && Predicate.hasProperty(value, "batch") && Predicate.isFunction(value.batch) && Predicate.hasProperty(value, "exec") && Predicate.isFunction(value.exec);
-/**
-* Creates a typed D1 service tag plus Effect helpers.
-*/
 const make$13 = (id, definition) => Service$1()(id, definition);
-/**
-* Builds a D1 service around a Cloudflare D1 database binding.
-*
-* The returned service exposes the raw `D1Database` binding and `sqlLayer(...)`
-* for providing `effect/unstable/sql` via `@effect/sql-d1`.
-*
-* @example
-* ```ts
-* class TodoDatabase extends D1.Service<TodoDatabase>()("TodoDatabase", {
-*   binding: "TODO_DB",
-* }) {}
-*
-* const SqlLive = TodoDatabase.sqlLayer();
-* ```
-*/
 const Service$1 = () => (id, definition) => {
 	const tag = Service$2()(id, definition.binding, isD1Database, void 0, { expected: expectedD1Database });
 	const sqlLayer = (options) => Layer.unwrap(Effect.gen(function* () {
@@ -1213,7 +1169,6 @@ const encodeWireError = (error) => {
 		return error;
 	}
 };
-/** Restores package RPC errors from the {@link encodeWireError} envelope. */
 const decodeWireError = (cause) => {
 	if (!(cause instanceof Error)) return cause;
 	try {
@@ -1309,19 +1264,123 @@ const make$11 = (id, methods) => {
 	};
 };
 //#endregion
+//#region src/RpcTracing.ts
+var RpcTracing_exports = /* @__PURE__ */ __exportAll({
+	RpcTraceContext: () => RpcTraceContext,
+	withRpcClientSpan: () => withRpcClientSpan,
+	withRpcServerSpan: () => withRpcServerSpan,
+	withRpcTraceContext: () => withRpcTraceContext
+});
+/**
+* Live native RPC metadata. Opted-in receivers reserve a valid trailing value
+* with this tag for transport context; do not use it as a final domain argument.
+* Never store this in durable messages or envelopes.
+*/
+const RpcTraceContext = Schema.Struct({
+	_tag: Schema.Literal("effect-cf/RpcTraceContext/v1"),
+	traceId: Schema.String.check(Schema.isPattern(/^(?!0{32}$)[0-9a-f]{32}$/)),
+	spanId: Schema.String.check(Schema.isPattern(/^(?!0{16}$)[0-9a-f]{16}$/)),
+	sampled: Schema.Boolean
+});
+const isRpcTraceContext$1 = Schema.is(RpcTraceContext);
+/**
+* Appends the current live parent only for a receiver that has opted in.
+* Call this inside the CLIENT span, immediately before the native invocation.
+* With no valid propagating parent, the original argument array is returned.
+*/
+const withRpcTraceContext = Effect.fnUntraced(function* (args) {
+	if (yield* Tracer.DisablePropagation) return args;
+	const parent = yield* Effect.serviceOption(Tracer.ParentSpan);
+	if (Option.isNone(parent) || Context.get(parent.value.annotations, Tracer.DisablePropagation)) return args;
+	const context = {
+		_tag: "effect-cf/RpcTraceContext/v1",
+		traceId: parent.value.traceId,
+		spanId: parent.value.spanId,
+		sampled: parent.value.sampled
+	};
+	return isRpcTraceContext$1(context) ? [...args, context] : args;
+});
+const attributes = (service, method) => ({
+	"sentry.op": "rpc",
+	"rpc.system.name": "cloudflare",
+	"rpc.method": `${service}/${method}`,
+	"server.address": service
+});
+const withRpcSpan = (effect, service, method, options) => Effect.useSpan(`${service}/${method}`, {
+	...options,
+	attributes: attributes(service, method)
+}, (span) => effect.pipe(Effect.withParentSpan(span), Effect.onExit((exit) => {
+	if (Exit.isSuccess(exit) || Cause.hasInterruptsOnly(exit.cause) || span.status._tag === "Ended") return Effect.void;
+	return Effect.gen(function* () {
+		const endTime = (yield* References.TracerTimingEnabled) ? yield* Clock.currentTimeNanos : 0n;
+		span.attribute("error.type", "_OTHER");
+		span.end(endTime, Exit.fail("RPC failed"));
+	});
+})));
+/** Wrap the whole call, including native result resolution and success decoding. */
+const withRpcClientSpan = (effect, binding, method) => withRpcSpan(effect, binding, method, { kind: "client" });
+/**
+* Optional application instrumentation for the entire receiver effect.
+* Use in a RunSymbol override to include argument decode, handler and encode.
+* Records stable service/method attributes and failure status, not argument or
+* error payloads. The original typed failure still propagates to the caller.
+*/
+const withRpcServerSpan = (effect, invocation) => withRpcSpan(effect, invocation.service, invocation.method, {
+	kind: "server",
+	parent: invocation.parent === void 0 ? void 0 : Tracer.externalSpan(invocation.parent)
+});
+//#endregion
+//#region src/internal/RpcInvocation.ts
+/** Scoped to the incoming event effect, never the instance runtime or storage. */
+var CurrentInvocation = class extends Context.Service()("effect-cf/internal/RpcInvocation") {};
+const recordDecodedArgs = (args) => Effect.map(Effect.serviceOption(CurrentInvocation), (invocation) => {
+	if (Option.isSome(invocation)) invocation.value.decodedArgs = args;
+});
+const invokeWithReceiver = (value, receiver, args) => {
+	return Function.prototype.apply.call(value, receiver, args);
+};
+const lookupRpcMethod = (target, method, makeError) => Effect.try({
+	try: () => {
+		if (!Predicate.isObjectKeyword(target)) throw new TypeError(`RPC target is not object-like`);
+		const receiver = target;
+		const value = receiver[method];
+		if (!Predicate.isFunction(value)) throw new TypeError(`RPC method "${String(method)}" is not callable`);
+		const callable = value;
+		return (...args) => invokeWithReceiver(callable, receiver, args);
+	},
+	catch: makeError
+});
+const invokeRpcMethod = Effect.fnUntraced(function* (target, method, args, makeError) {
+	const fn = yield* lookupRpcMethod(target, method, makeError);
+	return yield* Effect.try({
+		try: () => fn(...args),
+		catch: makeError
+	});
+});
+//#endregion
 //#region src/internal/Entrypoint.ts
-const invokeEntrypointRpcMethod = (self, method, args, run, onExit) => {
-	const handler = Effect.suspend(() => method(...args)).pipe(Effect.mapError(encodeWireError));
-	return run(self, onExit === void 0 ? handler : handler.pipe(Effect.onExit(() => onExit(self))));
+const isRpcTraceContext = Schema.is(RpcTraceContext);
+const invokeEntrypointRpcMethod = (self, method, args, run, onExit, service, key, rpcTracing) => {
+	const last = args.at(-1);
+	const parent = rpcTracing !== void 0 && isRpcTraceContext(last) ? last : void 0;
+	const handlerArgs = parent === void 0 ? args : args.slice(0, -1);
+	const invocation = {
+		service: rpcTracing?.service ?? service,
+		method: key,
+		args: handlerArgs,
+		parent
+	};
+	const handler = Effect.suspend(() => method(...handlerArgs)).pipe(Effect.provideService(CurrentInvocation, invocation), Effect.mapError(encodeWireError));
+	return run(self, onExit === void 0 ? handler : handler.pipe(Effect.onExit(() => onExit(self))), invocation);
 };
 const provideEntrypointServices = (layer, services) => layer.pipe(Layer.provideMerge(services));
-const defineEntrypointRpcMethods = (target, prototype, rpc, reservedMethodNames, run, onExit) => {
+const defineEntrypointRpcMethods = (target, prototype, rpc, reservedMethodNames, run, onExit, rpcTracing) => {
 	const methods = rpc ?? {};
 	assertNoReservedMethods(target, methods, reservedMethodNames);
 	for (const [key, method] of Object.entries(methods)) Object.defineProperty(prototype, key, {
 		enumerable: true,
 		value(...args) {
-			return invokeEntrypointRpcMethod(this, method, args, run, onExit);
+			return invokeEntrypointRpcMethod(this, method, args, run, onExit, target, key, rpcTracing);
 		}
 	});
 };
@@ -1344,9 +1403,13 @@ const makeEntrypointRuntime = (layer, env, services) => {
 	return ManagedRuntime.make(provideEntrypointServices(layer, entrypointServices));
 };
 function runEventPromise(...args) {
-	const [runtime, effect, eventLayer] = args;
-	if (eventLayer === void 0) return runtime.runPromise(Effect.scoped(effect));
-	return runtime.runPromise(Effect.scoped(effect.pipe(Effect.provide(eventLayer, { local: true }))));
+	const [runtime, effect, eventLayer, parent] = args;
+	if (eventLayer === void 0) {
+		const event = Effect.scoped(effect);
+		return runtime.runPromise(parent === void 0 ? event : Effect.withParentSpan(event, parent));
+	}
+	const event = Effect.scoped(effect.pipe(Effect.provide(eventLayer, { local: true })));
+	return runtime.runPromise(parent === void 0 ? event : Effect.withParentSpan(event, parent));
 }
 //#endregion
 //#region src/internal/Telemetry.ts
@@ -1386,29 +1449,6 @@ const resolve = (value) => Predicate.isPromiseLike(value) ? Effect.tryPromise({
 });
 const scoped = (value) => Effect.acquireRelease(resolve(value), (resolved) => dispose(resolved));
 //#endregion
-//#region src/internal/RpcInvocation.ts
-const invokeWithReceiver = (value, receiver, args) => {
-	return Function.prototype.apply.call(value, receiver, args);
-};
-const lookupRpcMethod = (target, method, makeError) => Effect.try({
-	try: () => {
-		if (!Predicate.isObjectKeyword(target)) throw new TypeError(`RPC target is not object-like`);
-		const receiver = target;
-		const value = receiver[method];
-		if (!Predicate.isFunction(value)) throw new TypeError(`RPC method "${String(method)}" is not callable`);
-		const callable = value;
-		return (...args) => invokeWithReceiver(callable, receiver, args);
-	},
-	catch: makeError
-});
-const invokeRpcMethod = Effect.fnUntraced(function* (target, method, args, makeError) {
-	const fn = yield* lookupRpcMethod(target, method, makeError);
-	return yield* Effect.try({
-		try: () => fn(...args),
-		catch: makeError
-	});
-});
-//#endregion
 //#region src/ServiceBinding.ts
 var ServiceBinding_exports = /* @__PURE__ */ __exportAll({
 	Service: () => Service,
@@ -1444,21 +1484,28 @@ const makeClient$8 = (definition) => {
 	return (service) => {
 		const fetch = Effect.fn("ServiceBinding.fetch")(function* (input, init) {
 			return yield* Effect.tryPromise({
-				try: () => service.fetch(input, init),
+				try: (signal) => {
+					const callerSignal = init?.signal !== void 0 ? init.signal : input instanceof Request ? input.signal : void 0;
+					return service.fetch(input, {
+						...init,
+						signal: callerSignal === null || callerSignal === void 0 ? signal : AbortSignal.any([callerSignal, signal])
+					});
+				},
 				catch: (cause) => new ServiceBindingFetchError({
 					binding: definition.binding,
 					cause
 				})
 			});
 		});
-		const rpc = Effect.fn("ServiceBinding.rpc")(function* (method, ...args) {
+		const rpc = Effect.fnUntraced(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,
 				method: methodName,
 				cause
 			})));
-			return yield* invokeRpcMethod(service, method, encodedArgs, (cause) => new ServiceBindingRpcError({
+			const nativeArgs = definition.rpcTracing ? yield* withRpcTraceContext(encodedArgs) : encodedArgs;
+			return yield* invokeRpcMethod(service, method, nativeArgs, (cause) => new ServiceBindingRpcError({
 				binding: definition.binding,
 				method: methodName,
 				cause
@@ -1472,7 +1519,7 @@ const makeClient$8 = (definition) => {
 				cause
 			})));
 		});
-		const call = Effect.fn("ServiceBinding.call")(function* (method, ...args) {
+		const call = Effect.fnUntraced(function* (method, ...args) {
 			const methodName = String(method);
 			const value = yield* resolve(yield* rpc(method, ...args)).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
 				binding: definition.binding,
@@ -1480,13 +1527,17 @@ const makeClient$8 = (definition) => {
 				cause
 			})));
 			return yield* decodeSuccess$2(methodName, value);
-		});
-		const scopedCall = Effect.fn("ServiceBinding.scopedCall")(function* (method, ...args) {
+		}, (effect, ...args) => withRpcClientSpan(effect, definition.binding, String(args[0])));
+		const scopedCall = Effect.fnUntraced(function* (method, ...args) {
 			const methodName = String(method);
 			const result = yield* rpc(method, ...args);
-			const value = yield* scoped(result);
+			const value = yield* scoped(result).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			})));
 			return yield* decodeSuccess$2(methodName, value);
-		});
+		}, (effect, ...args) => withRpcClientSpan(effect, definition.binding, String(args[0])));
 		const directMethods = makeDirectMethods$1(definition.definition, call);
 		return Object.assign(directMethods, {
 			fetch,
@@ -1497,35 +1548,6 @@ const makeClient$8 = (definition) => {
 	};
 };
 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.
-*
-* Returned value includes:
-* - a Context tag for dependency injection
-* - `fetch(...)` for raw HTTP forwarding
-* - `rpc(...)` for raw Cloudflare RPC results
-* - `call(...)` for resolved and decoded RPC results
-* - `scopedCall(...)` for scoped and decoded disposable RPC results
-* - direct RPC methods when `definition` is provided
-*
-* @example
-* ```ts
-* const Counter = WorkerDefinition.make("Counter", {
-*   increment: WorkerDefinition.method({
-*     args: [Schema.Number],
-*     success: Schema.Number,
-*   }),
-* });
-*
-* const CounterLive = Counter.layer({ binding: "COUNTER" });
-*
-* const program = Effect.gen(function* () {
-*   const counter = yield* Counter;
-*   const next = yield* counter.increment(1);
-*   return next;
-* });
-* ```
-*/
 const Service = () => (id, definition) => {
 	const tag = Service$2()(id, definition.binding, (value) => isServiceBindingClient(value), makeClient$8(definition));
 	const fetch = Effect.fnUntraced(function* (input, init) {
@@ -1590,19 +1612,6 @@ const assumeTagClass = (value) => {
 * Defines a single RPC method schema in a worker definition.
 */
 const method$1 = method$2;
-/**
-* Creates a typed worker RPC definition plus helpers for implementation and bindings.
-*
-* @example
-* ```ts
-* const CounterWorker = WorkerDefinition.make("CounterWorker", {
-*   increment: WorkerDefinition.method({
-*     args: [Schema.Number],
-*     success: Schema.Number,
-*   }),
-* });
-* ```
-*/
 const makeDefinition$3 = (id, methods) => {
 	assertNoReservedMethods("Worker", methods, reservedMethodNames$3);
 	const definition = make$11(id, methods);
@@ -1655,6 +1664,7 @@ const wrapHandlers$1 = (definition, handlers) => {
 		const handler = handlers[key];
 		wrapped[key] = (...args) => Effect.gen(function* () {
 			const decodedArgs = yield* decodeArgs(definition, key, args);
+			yield* recordDecodedArgs(decodedArgs);
 			const value = yield* handler(...decodedArgs);
 			return yield* encodeSuccess(definition, key, value);
 		});
@@ -1670,6 +1680,7 @@ const implement$3 = (_definition, handlers) => handlers;
 var Worker_exports = /* @__PURE__ */ __exportAll({
 	ExecutionContext: () => ExecutionContext,
 	NativeRequest: () => NativeRequest,
+	RunSymbol: () => RunSymbol$1,
 	Tag: () => Tag$9,
 	WorkerContext: () => WorkerContext,
 	implement: () => implement$3,
@@ -1678,64 +1689,47 @@ var Worker_exports = /* @__PURE__ */ __exportAll({
 	makeFetchHandler: () => makeFetchHandler,
 	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",
-	"dup",
-	"fetch",
-	"connect",
+	...reservedMethodNames$4,
 	"queue",
 	"scheduled",
 	"tail",
 	"tailStream",
 	"test",
-	"trace",
-	"alarm",
-	"webSocketMessage",
-	"webSocketClose",
-	"webSocketError"
+	"trace"
 ]);
+/** Override to instrument the whole event, then call super[RunSymbol]. */
 const RunSymbol$1 = Symbol.for("effect-cf/Worker/run");
 const FetchSymbol = Symbol.for("effect-cf/Worker/fetch");
-const renderFetchSuccess = (effect) => Effect.suspend(() => {
+const renderFetchSuccess = (effect, eventLayer) => Effect.suspend(() => {
 	let nativeResponse;
 	let webResponse;
-	const handled = HttpEffect.toHandled(Effect.flatMap(effect, (response) => {
+	const httpApp = Effect.flatMap(effect, (response) => {
 		if (response instanceof Response) {
 			nativeResponse = response;
 			return Effect.succeed(HttpServerResponse.empty());
 		}
 		return Effect.succeed(response);
-	}), (request, response) => nativeResponse !== void 0 ? Effect.void : Effect.map(Effect.context(), (context) => {
+	});
+	const handleResponse = (request, response) => nativeResponse !== void 0 ? Effect.void : Effect.map(Effect.context(), (context) => {
 		webResponse = HttpServerResponse.toWeb(HttpEffect.scopeTransferToStream(response), {
 			withoutBody: request.method === "HEAD",
 			context
 		});
+	});
+	const telemetryMiddleware = HttpMiddleware.make((self) => Effect.gen(function* () {
+		yield* Effect.addFinalizer(() => scheduleTelemetryFlush$1);
+		return yield* self;
 	}));
+	const handled = eventLayer === void 0 ? HttpEffect.toHandled(httpApp, handleResponse, telemetryMiddleware) : Effect.flatMap(References.TracerEnabled, (tracerEnabled) => HttpEffect.toHandled(httpApp, handleResponse, HttpMiddleware.make((self) => Effect.provideService(Effect.gen(function* () {
+		const context = yield* Layer.build(Layer.fresh(eventLayer));
+		yield* Effect.addFinalizer(() => Effect.provideContext(scheduleTelemetryFlush$1, context));
+		return yield* HttpMiddleware.tracer(self).pipe(Effect.onExit(() => Effect.yieldNow), Effect.provideContext(context));
+	}), References.TracerEnabled, tracerEnabled))).pipe(Effect.withTracerEnabled(false)));
 	const captured = () => nativeResponse ?? webResponse ?? new Response(null, { status: 500 });
 	return Effect.matchCause(handled, {
 		onFailure: captured,
@@ -1744,13 +1738,13 @@ const renderFetchSuccess = (effect) => Effect.suspend(() => {
 });
 const isWorkerOptions = (options) => !Effect.isEffect(options);
 /**
-* Drains buffered OTLP telemetry once the fetch handler has produced its
-* response.
+* Drains buffered OTLP telemetry when the fetch Effect scope closes. Effect
+* response streams transfer that scope to the body and schedule the flush when
+* the body finishes or is canceled.
 *
-* 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`. The handed-off effect is
-* best-effort and silently settles within two seconds.
+* The flush is handed to `ctx.waitUntil` instead of being awaited by the
+* handler. It is a no-op when the context does not contain an
+* `OtlpExporter.Flusher`, and silently settles within two seconds.
 */
 const scheduleTelemetryFlush$1 = scheduleTelemetryFlush$2((flush) => Effect.flatMap(WorkerContext, (workerContext) => workerContext.waitUntil(flush)));
 function make$9(layer, optionsOrFetch) {
@@ -1761,10 +1755,12 @@ function make$9(layer, optionsOrFetch) {
 			super(ctx, env);
 			this.runtime = makeEntrypointRuntime(layer, env, Layer.mergeAll(Layer.succeed(ExecutionContext, ctx), Layer.succeed(WorkerContext, fromExecutionContext(ctx))));
 		}
-		[RunSymbol$1](effect) {
-			const eventLayer = options.eventLayer;
-			if (eventLayer === void 0) return runEventPromise(this.runtime, effect);
-			return runEventPromise(this.runtime, effect, eventLayer);
+		[RunSymbol$1](effect, runOptions = {}) {
+			const eventLayer = runOptions.event === "fetch" ? void 0 : options.eventLayer;
+			const parent = runOptions.rpc?.parent;
+			const parentSpan = parent === void 0 ? void 0 : Tracer.externalSpan(parent);
+			if (eventLayer === void 0) return runEventPromise(this.runtime, effect, void 0, parentSpan);
+			return runEventPromise(this.runtime, effect, eventLayer, parentSpan);
 		}
 		fetch(request) {
 			return this[FetchSymbol](request);
@@ -1774,16 +1770,19 @@ function make$9(layer, optionsOrFetch) {
 			if (fetchHandler === void 0) return Promise.resolve(new Response("Not Found", { status: 404 }));
 			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$1), Effect.provide(requestServices)));
+			return this[RunSymbol$1](renderFetchSuccess(fetchHandler, options.eventLayer).pipe(Effect.provide(requestServices)), { event: "fetch" });
 		}
 		queue(batch) {
 			const queueHandler = options.queue;
 			if (queueHandler === void 0) return Promise.resolve();
 			const messages = batch.messages.map((message) => fromMessage(message, message.body));
-			return this[RunSymbol$1](queueHandler(fromMessageBatch(batch, messages)));
+			return this[RunSymbol$1](queueHandler(fromMessageBatch(batch, messages)).pipe(Effect.onExit(() => scheduleTelemetryFlush$1)), { event: "queue" });
 		}
 	}
-	defineEntrypointRpcMethods("Worker", EffectWorker.prototype, options.rpc, reservedMethodNames$2, (self, effect) => self[RunSymbol$1](effect), () => scheduleTelemetryFlush$1);
+	defineEntrypointRpcMethods("Worker", EffectWorker.prototype, options.rpc, reservedMethodNames$2, (self, effect, rpc) => self[RunSymbol$1](effect, {
+		event: "rpc",
+		rpc
+	}), () => scheduleTelemetryFlush$1, options.rpcTracing);
 	return assumeEntrypointClass(EffectWorker);
 }
 function makeFetchHandler(layer, options) {
@@ -1836,26 +1835,33 @@ const makeClient$7 = (definition) => {
 		const getByName = (name, options) => Effect.sync(() => namespace.getByName(name, options));
 		const jurisdiction = (value) => Effect.sync(() => namespace.jurisdiction(value));
 		const fetch = (stub, input, init) => Effect.tryPromise({
-			try: () => stub.fetch(input, init),
+			try: (signal) => {
+				const callerSignal = init?.signal !== void 0 ? init.signal : input instanceof Request ? input.signal : void 0;
+				return stub.fetch(input, {
+					...init,
+					signal: callerSignal === null || callerSignal === void 0 ? signal : AbortSignal.any([callerSignal, signal])
+				});
+			},
 			catch: (cause) => new DurableObjectFetchError({
 				binding: definition.binding,
 				cause
 			})
 		});
-		const rpc = Effect.fn("DurableObjectNamespace.rpc")(function* (stub, method, ...args) {
+		const rpc = Effect.fnUntraced(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,
 				method: methodName,
 				cause
 			})));
-			return yield* invokeRpcMethod(stub, method, encodedArgs, (cause) => new DurableObjectRpcError({
+			const nativeArgs = definition.rpcTracing ? yield* withRpcTraceContext(encodedArgs) : encodedArgs;
+			return yield* invokeRpcMethod(stub, method, nativeArgs, (cause) => new DurableObjectRpcError({
 				binding: definition.binding,
 				method: methodName,
 				cause
 			}));
 		});
-		const decodeSuccess$1 = Effect.fn("DurableObjectNamespace.decodeSuccess")(function* (methodName, value) {
+		const decodeSuccess$1 = Effect.fnUntraced(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,
@@ -1863,7 +1869,7 @@ const makeClient$7 = (definition) => {
 				cause
 			})));
 		});
-		const call = Effect.fn("DurableObjectNamespace.call")(function* (stub, method, ...args) {
+		const call = Effect.fnUntraced(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,
@@ -1871,13 +1877,17 @@ const makeClient$7 = (definition) => {
 				cause
 			})));
 			return yield* decodeSuccess$1(methodName, value);
-		});
-		const scopedCall = Effect.fn("DurableObjectNamespace.scopedCall")(function* (stub, method, ...args) {
+		}, (effect, ...args) => withRpcClientSpan(effect, definition.binding, String(args[1])));
+		const scopedCall = Effect.fnUntraced(function* (stub, method, ...args) {
 			const methodName = String(method);
 			const result = yield* rpc(stub, method, ...args);
-			const value = yield* scoped(result);
+			const value = yield* scoped(result).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			})));
 			return yield* decodeSuccess$1(methodName, value);
-		});
+		}, (effect, ...args) => withRpcClientSpan(effect, definition.binding, String(args[1])));
 		const directMethods = makeDirectMethods(definition.definition, {
 			call,
 			fetch,
@@ -1941,19 +1951,6 @@ const reservedMethodNames$1 = /* @__PURE__ */ new Set([
 function method(definition) {
 	return method$2(definition);
 }
-/**
-* Creates a Durable Object RPC definition plus implementation/binding helpers.
-*
-* @example
-* ```ts
-* const ChatRoom = DurableObjectDefinition.make("ChatRoom", {
-*   postMessage: DurableObjectDefinition.method({
-*     args: [Schema.String],
-*     success: Schema.Void,
-*   }),
-* });
-* ```
-*/
 const makeDefinition$2 = (id, methods) => {
 	assertNoReservedMethods("Durable Object", methods, reservedMethodNames$1);
 	const definition = make$11(id, methods);
@@ -1993,15 +1990,15 @@ const Tag$8 = () => (id, methods) => {
 	const fetch = Effect.fn("DurableObject.fetch")(function* (stub, input, init) {
 		return yield* (yield* tag).fetch(stub, input, init);
 	});
-	const rpc = Effect.fn("DurableObject.rpc")(function* (stub, methodName, ...args) {
+	const rpc = Effect.fnUntraced(function* (stub, methodName, ...args) {
 		const invokeRpc = (yield* tag).rpc;
 		return yield* invokeRpc(stub, methodName, ...args);
 	});
-	const call = Effect.fn("DurableObject.call")(function* (stub, methodName, ...args) {
+	const call = Effect.fnUntraced(function* (stub, methodName, ...args) {
 		const invokeCall = (yield* tag).call;
 		return yield* invokeCall(stub, methodName, ...args);
 	});
-	const scopedCall = Effect.fn("DurableObject.scopedCall")(function* (stub, methodName, ...args) {
+	const scopedCall = Effect.fnUntraced(function* (stub, methodName, ...args) {
 		const invokeScopedCall = (yield* tag).scopedCall;
 		return yield* invokeScopedCall(stub, methodName, ...args);
 	});
@@ -2039,6 +2036,7 @@ const wrapHandlers = (definition, handlers) => {
 		const handler = handlers[key];
 		wrapped[key] = (...args) => Effect.gen(function* () {
 			const decodedArgs = yield* decodeArgs(definition, key, args);
+			yield* recordDecodedArgs(decodedArgs);
 			const value = yield* handler(...decodedArgs);
 			return yield* encodeSuccess(definition, key, value);
 		});
@@ -2052,24 +2050,21 @@ const implement$2 = (_definition, handlers) => handlers;
 //#endregion
 //#region src/DurableObject.ts
 var DurableObject_exports = /* @__PURE__ */ __exportAll({
+	RunSymbol: () => RunSymbol,
 	Tag: () => Tag$8,
 	implement: () => implement$2,
 	make: () => make$7,
 	method: () => method
 });
-const reservedMethodNames = /* @__PURE__ */ new Set([
-	"constructor",
-	"dup",
-	"fetch",
-	"alarm",
-	"webSocketMessage",
-	"webSocketClose",
-	"webSocketError"
-]);
+const reservedMethodNames = reservedMethodNames$4;
+/** Override to instrument the whole event, then call super[RunSymbol]. */
 const RunSymbol = Symbol.for("effect-cf/DurableObject/run");
 const scheduleTelemetryFlush = scheduleTelemetryFlush$2((flush) => Effect.flatMap(DurableObjectState, (state) => state.waitUntil(flush)));
 /**
-* Creates a Durable Object class backed by a single managed Effect runtime.
+* Builds a Durable Object whose base `layer` lives for the in-memory instance.
+* Cloudflare does not expose an eviction or shutdown hook, so finalizers in
+* that layer are not guaranteed to run. Put resources that require timely
+* release in `eventLayer`, whose scope closes after each handled event.
 */
 const make$7 = (layer, options = {}) => {
 	class EffectDurableObject extends DurableObject {
@@ -2082,13 +2077,15 @@ const make$7 = (layer, options = {}) => {
 		}
 		[RunSymbol](effect, runOptions = {}) {
 			const eventLayer = runOptions.eventLayer === false ? void 0 : options.eventLayer;
-			if (eventLayer === void 0) return runEventPromise(this.runtime, effect);
-			return runEventPromise(this.runtime, effect, eventLayer);
+			const parent = runOptions.rpc?.parent;
+			const parentSpan = parent === void 0 ? void 0 : Tracer.externalSpan(parent);
+			if (eventLayer === void 0) return runEventPromise(this.runtime, effect, void 0, parentSpan);
+			return runEventPromise(this.runtime, effect, eventLayer, parentSpan);
 		}
 		fetch(request) {
 			const fetchHandler = options.fetch;
 			if (fetchHandler === void 0) return Promise.resolve(new Response("Not Found", { status: 404 }));
-			return this[RunSymbol](Effect.provideService(fetchHandler, NativeRequest, request));
+			return this[RunSymbol](Effect.provideService(fetchHandler, NativeRequest, request), { event: "fetch" });
 		}
 		alarm(alarmInfo) {
 			const logicalAlarms = options.alarms?.pipe(Effect.asVoid);
@@ -2097,19 +2094,22 @@ const make$7 = (layer, options = {}) => {
 				yield* logicalAlarms;
 				yield* rawAlarm;
 			}) : logicalAlarms ?? rawAlarm;
-			if (alarmEffect !== void 0) return this[RunSymbol](alarmEffect.pipe(Effect.onExit(() => scheduleTelemetryFlush)));
+			if (alarmEffect !== void 0) return this[RunSymbol](alarmEffect.pipe(Effect.onExit(() => scheduleTelemetryFlush)), { event: "alarm" });
 		}
 		webSocketMessage(socket, message) {
-			if (options.webSocketMessage !== void 0) return this[RunSymbol](options.webSocketMessage(fromWebSocket(socket), message));
+			if (options.webSocketMessage !== void 0) return this[RunSymbol](options.webSocketMessage(fromWebSocket(socket), message), { event: "webSocketMessage" });
 		}
 		webSocketClose(socket, code, reason, wasClean) {
-			if (options.webSocketClose !== void 0) return this[RunSymbol](options.webSocketClose(fromWebSocket(socket), code, reason, wasClean));
+			if (options.webSocketClose !== void 0) return this[RunSymbol](options.webSocketClose(fromWebSocket(socket), code, reason, wasClean), { event: "webSocketClose" });
 		}
 		webSocketError(socket, cause) {
-			if (options.webSocketError !== void 0) return this[RunSymbol](options.webSocketError(fromWebSocket(socket), cause));
+			if (options.webSocketError !== void 0) return this[RunSymbol](options.webSocketError(fromWebSocket(socket), cause), { event: "webSocketError" });
 		}
 	}
-	defineEntrypointRpcMethods("Durable Object", EffectDurableObject.prototype, options.rpc, reservedMethodNames, (self, effect) => self[RunSymbol](effect), () => scheduleTelemetryFlush);
+	defineEntrypointRpcMethods("Durable Object", EffectDurableObject.prototype, options.rpc, reservedMethodNames, (self, effect, rpc) => self[RunSymbol](effect, {
+		event: "rpc",
+		rpc
+	}), () => scheduleTelemetryFlush, options.rpcTracing);
 	return assumeEntrypointClass(EffectDurableObject);
 };
 //#endregion
@@ -2165,30 +2165,10 @@ var StoredAlarmDecodeError = class extends Data.TaggedError("StoredAlarmDecodeEr
 		return `Failed to decode stored alarm "${this.storageId}": ${causeMessage(this.cause)}`;
 	}
 };
-/**
-* Events handled by `processDueAlarms`.
-*
-* `AlarmDue` represents one durable alarm whose scheduled time is now due. The
-* `tag` is the consumer-owned routing key, while `id` is the stable alarm id
-* within that tag.
-*
-* `scheduledAt` is the logical due-after timestamp from durable storage. It is
-* not expected to match the current Durable Object alarm invocation time,
-* especially during retries. Retries re-scan durable rows with `run_at <= now`
-* and identify logical events by `{ tag, id }`.
-*
-* @example Handling events by tag
-* ```ts
-* yield* durableObjectAlarm.processDueAlarms((event) =>
-*   event.tag === "heartbeat"
-*     ? heartbeatManager.handleAlarmEvent(event).pipe(Effect.asVoid)
-*     : Effect.void
-* );
-* ```
-*/
 const DurableObjectAlarmEvent = Schema.TaggedUnion({ AlarmDue: {
 	id: Schema.NonEmptyString,
 	payload: Schema.Json,
+	/** Persisted due time, which can differ from the invocation time during retries. */
 	scheduledAt: Schema.DateTimeUtc,
 	tag: Schema.NonEmptyString
 } });
@@ -2278,50 +2258,6 @@ const define = (definitions) => ({ handlers: (handlers, options) => processDue((
 		return action ?? optionAction;
 	})
 }) });
-/**
-* SQLite-backed Durable Object alarm scheduler.
-*
-* `DurableObjectAlarm` stores alarms in the current Durable Object's SQLite storage
-* and keeps the platform alarm set to the earliest pending scheduled alarm. The
-* platform alarm timestamp is only a wake-up hint; logical event identity comes
-* from persisted `{ tag, id }` rows.
-*
-* Retry safety depends on acknowledgement ordering. `processDueAlarms` runs the
-* caller's handler first and only then conditionally deletes or advances the
-* same selected row. By default, handler failures are isolated: the failed row
-* is retried after a delay, later due rows continue, and the platform alarm is
-* reconciled once at the end. Use `mode: "ordered"` for strict workflows where
-* one failed logical alarm should block later due alarms.
-*
-* Provide `DurableObjectAlarm.layer` anywhere `DurableObjectState` is available.
-*
-* @example Providing the service
-* ```ts
-* const program = Effect.gen(function* () {
-*   const durableObjectAlarm = yield* DurableObjectAlarm;
-*   const now = yield* DateTime.now;
-*
-*   yield* durableObjectAlarm.scheduleAlarm({
-*     tag: "heartbeat",
-*     id: "heartbeat-check",
-*     runAt: DateTime.add(now, { seconds: 5 }),
-*     repeatEvery: Duration.seconds(5),
-*     payload: null,
-*   });
-* }).pipe(Effect.provide(DurableObjectAlarm.layer));
-* ```
-*
-* @example Processing due alarms
-* ```ts
-* const handledEvents = yield* durableObjectAlarm.processDueAlarms((event) =>
-*   Effect.gen(function* () {
-*     if (event.tag === "heartbeat") {
-*       yield* heartbeatManager.handleAlarmEvent(event);
-*     }
-*   })
-* );
-* ```
-*/
 var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("effect-cf/DurableObjectAlarm") {
 	static layer = Layer.effect(DurableObjectAlarm, Effect.gen(function* () {
 		const state = yield* DurableObjectState;
@@ -2486,9 +2422,6 @@ const ResumableAttachmentMetadataSchema = Schema.Struct({
 	subscriptions: Schema.Array(PersistedSubscriptionSchema)
 });
 const decodeResumableAttachment = Schema.decodeUnknownOption(ResumableAttachmentMetadataSchema);
-/**
-* Context tag for the Durable Object RPC websocket service.
-*/
 var DurableObjectRpcWebSocket = class extends Context.Service()("effect-cf/DurableObjectRpcWebSocket") {};
 /**
 * Builds a hibernation-aware transport that bridges Durable Object websocket
@@ -2509,7 +2442,6 @@ const layer$8 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 	const disconnects = yield* Queue.make();
 	const connectionsBySocket = /* @__PURE__ */ new Map();
 	const connectionsById = /* @__PURE__ */ new Map();
-	const clientIds = /* @__PURE__ */ new Set();
 	const resetSockets = /* @__PURE__ */ new WeakSet();
 	const declarationsById = /* @__PURE__ */ new Map();
 	const declarationsByTag = /* @__PURE__ */ new Map();
@@ -2525,14 +2457,6 @@ const layer$8 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 		declarationsByTag.set(declaration.rpcTag, declaration);
 	}
 	const reserveClientId = (socket) => {
-		const attachment = readAttachment(socket.raw, attachmentKey);
-		if (attachment._tag === "Invalid") throw new Error("Invalid Durable Object RPC websocket attachment metadata");
-		if (attachment._tag === "Valid") {
-			const metadata = attachment.metadata;
-			nextClientId = Math.max(nextClientId, metadata.clientId + 1);
-			writeAttachment(socket.raw, attachmentKey, metadata);
-			return metadata;
-		}
 		const id = nextClientId++;
 		const created = {
 			version: legacyAttachmentVersion,
@@ -2585,7 +2509,6 @@ const layer$8 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 		for (const subscription of restoredSubscriptions) if (!addSubscription(connection, subscription)) throw new Error("Duplicate restored resumable RPC stream subscription identity");
 		connectionsBySocket.set(socket.raw, connection);
 		connectionsById.set(connection.id, connection);
-		clientIds.add(connection.id);
 		nextClientId = Math.max(nextClientId, connection.id + 1);
 		return connection;
 	};
@@ -2622,7 +2545,6 @@ const layer$8 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 		if (connection === void 0) return;
 		connectionsBySocket.delete(socket.raw);
 		connectionsById.delete(connection.id);
-		clientIds.delete(connection.id);
 		activeNonResumableRequestCount -= connection.nonResumableRequestIds.size;
 		connection.requestIds.clear();
 		connection.nonResumableRequestIds.clear();
@@ -2841,7 +2763,7 @@ const layer$8 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 			end: (clientId) => Effect.sync(() => {
 				connectionsById.get(clientId)?.socket.raw.close();
 			}),
-			clientIds: Effect.sync(() => clientIds),
+			clientIds: Effect.sync(() => new Set(connectionsById.keys())),
 			initialMessage: Effect.succeedNone,
 			supportsAck: true,
 			supportsTransferables: false,
@@ -2975,13 +2897,9 @@ const writeAttachment = (socket, key, metadata) => {
 	const current = socket.deserializeAttachment();
 	if (current !== null && current !== void 0 && !Predicate.isObject(current)) throw new Error("DurableObjectRpcWebSocket requires object-shaped websocket attachments so adapter metadata can preserve application fields");
 	const attachment = Predicate.isObject(current) ? current : {};
-	const currentMetadata = Predicate.hasProperty(attachment, key) && Predicate.isObject(attachment[key]) ? attachment[key] : {};
 	socket.serializeAttachment({
 		...attachment,
-		[key]: {
-			...currentMetadata,
-			...metadata
-		}
+		[key]: metadata
 	});
 };
 const makeHeartbeatController = (state, serialization, policy) => Effect.gen(function* () {
@@ -3004,17 +2922,6 @@ const makeHeartbeatController = (state, serialization, policy) => Effect.gen(fun
 //#endregion
 //#region src/DurableObjectSqlite.ts
 var DurableObjectSqlite_exports = /* @__PURE__ */ __exportAll({ layer: () => layer$7 });
-/**
-* Provides `effect/unstable/sql` from the current Durable Object SQLite storage.
-*
-* @example
-* ```ts
-* const RoomLayer = Layer.mergeAll(
-*   DurableObjectSqlite.layer(),
-*   OtherRoomServices,
-* );
-* ```
-*/
 const layer$7 = (options) => Layer.unwrap(Effect.gen(function* () {
 	const state = yield* DurableObjectState;
 	return SqliteClient.layer({
@@ -3038,17 +2945,13 @@ var Email_exports = /* @__PURE__ */ __exportAll({
 });
 const expectedSendEmailBinding = "Send Email binding with send()";
 const textEncoder = new TextEncoder();
-/** Documented Cloudflare Email Sending limits. */
 const sendLimits = {
-	/** Combined `to`, `cc`, and `bcc` addresses per message. */
 	maxRecipients: 50,
 	maxAttachments: 32,
-	/** Total message size, including attachments. Not enforced client side. */
 	maxMessageBytes: 5 * 1024 * 1024,
 	maxHeaderNameBytes: 100,
 	maxHeaderValueBytes: 2048,
 	maxHeadersBytes: 16 * 1024,
-	/** Allowlisted custom headers, excluding `X-` prefixed headers. */
 	maxAllowlistHeaders: 20
 };
 /**
@@ -3081,14 +2984,12 @@ const emailErrorCodes = [
 	"E_HEADERS_TOO_LARGE",
 	"E_HEADERS_TOO_MANY"
 ];
-/** Error raised when a Cloudflare Send Email operation fails. */
 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") {
 	get message() {
 		return `Email ${this.operation} for binding "${this.binding}" failed validation: ${violationsMessage(this.violations)}`;
@@ -3309,7 +3210,6 @@ var Images_exports = /* @__PURE__ */ __exportAll({
 });
 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") {
 	get message() {
 		return `Images ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
@@ -3320,7 +3220,6 @@ const makeSteps = (steps) => ({
 	[TypeId]: TypeId,
 	steps
 });
-/** Empty Images transformation pipeline. */
 const empty = makeSteps([]);
 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)]));
@@ -3407,7 +3306,6 @@ var Kv_exports = /* @__PURE__ */ __exportAll({
 	makeClient: () => makeClient$3
 });
 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") {
 	get message() {
 		return `Kv ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
@@ -3531,7 +3429,6 @@ var R2_exports = /* @__PURE__ */ __exportAll({
 	makeClient: () => makeClient$2
 });
 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") {
 	get message() {
 		return `R2 ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
@@ -3639,7 +3536,6 @@ var Vectorize_exports = /* @__PURE__ */ __exportAll({
 	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)}`;
@@ -3715,11 +3611,8 @@ var WebTransport_exports = /* @__PURE__ */ __exportAll({
 * `Record<string, unknown>` side of `request.cf`.
 */
 var InboundTransport = class extends Schema.Class("InboundTransport")({
-	/** The HTTP protocol the client used, e.g. `"HTTP/2"` or `"HTTP/3"`. */
 	httpProtocol: Schema.String,
-	/** Client round-trip time; only present for QUIC (HTTP/3) connections. */
 	clientQuicRtt: Schema.optional(Schema.Number),
-	/** Client round-trip time; only present for TCP (HTTP/1.x, HTTP/2) connections. */
 	clientTcpRtt: Schema.optional(Schema.Number)
 }) {};
 const decodeInboundTransport = Schema.decodeUnknownResult(InboundTransport);
@@ -3731,16 +3624,7 @@ const decodeInboundTransport = Schema.decodeUnknownResult(InboundTransport);
 * the expected shape.
 */
 const inboundTransport = (request) => Result.getSuccess(decodeInboundTransport(request.cf));
-/**
-* Returns `true` when the client reached Cloudflare's edge over QUIC
-* (HTTP/3). Prefers the documented QUIC signal (`clientQuicRtt` is only
-* present for QUIC connections) and falls back to the `httpProtocol` string.
-*
-* Note this describes the browser→edge hop only: the edge always terminates
-* QUIC, and the Worker still handles an ordinary `fetch` Request.
-*/
 const isHttp3 = (transport) => transport.clientQuicRtt !== void 0 || transport.httpProtocol === "HTTP/3";
-/** Feature-detects the WebTransport capabilities of the current runtime. */
 const capabilities = Effect.sync(() => {
 	const runtime = globalThis;
 	return {
@@ -3748,7 +3632,6 @@ const capabilities = Effect.sync(() => {
 		outboundSessions: Predicate.hasProperty(runtime, "WebTransport") && Predicate.isFunction(runtime["WebTransport"])
 	};
 });
-/** Raised when a WebTransport capability is unavailable in this runtime. */
 var WebTransportUnsupportedError = class extends Data.TaggedError("WebTransportUnsupportedError") {
 	get message() {
 		return this.capability === "inbound-sessions" ? "Cloudflare Workers cannot accept inbound WebTransport sessions: the edge terminates QUIC and no runtime session API exists (cloudflare/workerd#6451). Use Durable Object WebSockets for bidirectional push." : "This Workers runtime provides no WebTransport client: workerd has no QUIC stack and cloudflare:sockets is TCP-only.";
@@ -3918,10 +3801,6 @@ 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,
 	WorkflowEvent: () => WorkflowEvent$1,
@@ -3937,7 +3816,6 @@ var Workflow_exports = /* @__PURE__ */ __exportAll({
 	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}"`;
@@ -3973,20 +3851,29 @@ const exposeCloudflareNonRetryableError = (effect) => Effect.catchCause(effect,
 	const error = Cause.findErrorOption(cause);
 	return Option.isSome(error) && error.value instanceof WorkflowStepNonRetryableError ? Effect.die(toCloudflareNonRetryableError(error.value)) : Effect.failCause(cause);
 });
-const fromWorkflowStep = (step, runPromise) => ({
+const fromWorkflowStep = (step) => ({
 	raw: step,
-	do: (name, effect, config) => Effect.context().pipe(Effect.flatMap((context) => Effect.tryPromise({
-		try: () => {
-			const run = (stepContext) => runPromise(exposeCloudflareNonRetryableError(Effect.scoped(Effect.provideService(Effect.provideContext(effect, context), WorkflowStepContext$1, stepContext))));
-			const rawStep = step;
-			return config === void 0 ? rawStep.do(name, run) : rawStep.do(name, config, run);
-		},
-		catch: (cause) => new WorkflowStepError({
-			step: name,
-			operation: "do",
-			cause
-		})
-	}))),
+	do: (name, effect, config) => Effect.gen(function* () {
+		const context = yield* Effect.context();
+		return yield* Effect.scoped(Effect.gen(function* () {
+			const runPromise = yield* FiberSet.makeRuntimePromise();
+			return yield* Effect.tryPromise({
+				try: () => {
+					const run = (stepContext) => {
+						const stepEffect = Effect.scoped(Effect.provideService(effect, WorkflowStepContext$1, stepContext));
+						return runPromise(exposeCloudflareNonRetryableError(Effect.provideContext(stepEffect, context)));
+					};
+					const rawStep = step;
+					return config === void 0 ? rawStep.do(name, run) : rawStep.do(name, config, run);
+				},
+				catch: (cause) => new WorkflowStepError({
+					step: name,
+					operation: "do",
+					cause
+				})
+			});
+		}));
+	}),
 	sleep: (name, duration) => Effect.tryPromise({
 		try: () => step.sleep(name, duration),
 		catch: (cause) => new WorkflowStepError({
@@ -4022,7 +3909,7 @@ const make = (layer, options) => {
 			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))));
+			const workflowServices = Layer.mergeAll(Layer.succeed(WorkflowEvent$1, fromWorkflowEvent(event)), Layer.succeed(WorkflowStep$1, fromWorkflowStep(step)));
 			return runEventPromise(this.runtime, options.run(event.payload), workflowServices);
 		}
 	}
@@ -4035,4 +3922,4 @@ const waitForEvent = (name, options) => Effect.flatMap(WorkflowStep$1, (workflow
 const Tag = Tag$1;
 const implement = implement$1;
 //#endregion
-export { AiGateway_exports as AiGateway, AnalyticsEngine_exports as AnalyticsEngine, Artifacts_exports as Artifacts, 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, WebTransport_exports as WebTransport, 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, Artifacts_exports as Artifacts, 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, RpcTracing_exports as RpcTracing, ServiceBinding_exports as ServiceBinding, Vectorize_exports as Vectorize, WebTransport_exports as WebTransport, 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 };