effect-cf 0.35.0 → 0.37.0

package/dist/index.mjs

@@ -1,13 +1,15 @@
 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-Byx2OgNd.mjs";
-import { n as Service$2, r as layer$19, t as Binding_exports } from "./Binding-C82jRhdr.mjs";
+import { n as Service$1, r as layer$17, 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 { t as fromExecutionContext } from "./WorkerContext-Yobnfw-K.mjs";
+import { a as DurableWebSocketAttachmentError, c as StorageOperationError, i as DurableObjectWebSocket_exports, n as DurableObjectState_exports, o as fromWebSocket, r as fromDurableObjectState, s as DurableObjectStorage_exports, t as DurableObjectState } from "./DurableObjectState-DLL0YgBd.mjs";
+import { A as QueueDefinition_exports, C as decodeSuccess, D as method$1, E as make$15, O as reservedMethodNames$2, S as decodeArgs, T as encodeSuccess, _ as RpcTracing_exports, a as WorkerDefinition_exports, b as RpcDefinition_exports, c as resolve, d as makeEntrypointRuntime, f as runEventPromise, g as recordDecodedArgs, h as invokeRpcMethod, i as Worker_exports, j as QueueBinding_exports, k as Queue_exports, l as scoped, m as defineEntrypointRpcMethods, n as NativeRequest, o as ServiceBinding_exports, p as assumeEntrypointClass, r as WorkerContext, s as Rpc_exports, t as ExecutionContext, u as scheduleTelemetryFlush$1, v as withRpcClientSpan, w as encodeArgs, x as assertNoReservedMethods, y as withRpcTraceContext } from "./Worker-XsGJsCJX.mjs";
+import { Cause, Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, FiberSet, Function as Function$1, Layer, Option, Predicate, Queue, Result, Schema, Tracer } from "effect";
+import { FetchHttpClient, HttpClient, HttpClientRequest } 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";
+import { DurableObject, WorkflowEntrypoint } from "cloudflare:workers";
 import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
 import * as RpcServer from "effect/unstable/rpc/RpcServer";
@@ -15,13 +17,13 @@ import { SqliteClient } from "@effect/sql-sqlite-do";
 import { NonRetryableError } from "cloudflare:workflows";
 //#region src/WorkersAi.ts
 var WorkersAi_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$16,
+	Tag: () => Tag$13,
 	WorkersAiOperationError: () => WorkersAiOperationError,
 	embeddingResponse: () => embeddingResponse,
 	isWorkersAiBinding: () => isWorkersAiBinding,
-	layer: () => layer$18,
-	make: () => make$18,
-	makeClient: () => makeClient$15
+	layer: () => layer$16,
+	make: () => make$14,
+	makeClient: () => makeClient$13
 });
 const expectedWorkersAiBinding = "Workers AI binding with run(), gateway(), and models()";
 var WorkersAiOperationError = class extends Data.TaggedError("WorkersAiOperationError") {
@@ -54,7 +56,7 @@ const decodeEmbeddingResponse = Schema.decodeUnknownEffect(Schema.Struct({
 	data: Schema.optional(Schema.Array(Schema.Array(Schema.Number))),
 	[embeddingDimensionsKey]: Schema.optional(Schema.Array(Schema.Number))
 }));
-const makeClient$15 = (definition) => (ai) => {
+const makeClient$13 = (definition) => (ai) => {
 	const run = Effect.fn("WorkersAi.run")((model, input, options) => tryWorkersAiPromise(definition.binding, "run", () => {
 		return ai.run(model, input, options);
 	}));
@@ -76,11 +78,11 @@ const makeClient$15 = (definition) => (ai) => {
 		rawUnsafe: Effect.succeed(ai)
 	};
 };
-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 layer$16 = (tag, definition) => layer$17(tag, definition.binding, (value) => isWorkersAiBinding(value), makeClient$13(definition), { expected: expectedWorkersAiBinding });
+const make$14 = (id) => Tag$13()(id);
+const Tag$13 = () => (id) => {
 	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$18(tag, definition);
+	const makeLayer = (definition) => layer$16(tag, definition);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer
@@ -90,11 +92,11 @@ const Tag$16 = () => (id) => {
 //#region src/AiGateway.ts
 var AiGateway_exports = /* @__PURE__ */ __exportAll({
 	AiGatewayOperationError: () => AiGatewayOperationError,
-	Tag: () => Tag$15,
+	Tag: () => Tag$12,
 	isAiGatewayBinding: () => isAiGatewayBinding,
-	layer: () => layer$17,
-	make: () => make$17,
-	makeClient: () => makeClient$14,
+	layer: () => layer$15,
+	make: () => make$13,
+	makeClient: () => makeClient$12,
 	makeClientFromAi: () => makeClientFromAi,
 	makeHttpClient: () => makeHttpClient
 });
@@ -171,7 +173,7 @@ const ensureSuccessfulResponse = (response) => {
 	if (!response.ok) throw new Error(`AI Gateway HTTP request failed with status ${response.status}`);
 };
 const isAiGatewayBinding = (value) => isWorkersAiBinding(value);
-const makeClient$14 = (definition, gateway) => ({
+const makeClient$12 = (definition, gateway) => ({
 	definition,
 	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))),
@@ -191,11 +193,11 @@ const makeClientFromAi = (definition, ai) => {
 	const withGateway = (operation) => gateway.pipe(Effect.flatMap(operation));
 	return {
 		definition,
-		run: (data, options) => withGateway((raw) => makeClient$14(definition, raw).run(data, options)),
-		getUrl: (provider) => withGateway((raw) => makeClient$14(definition, raw).getUrl(provider)),
-		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)),
+		run: (data, options) => withGateway((raw) => makeClient$12(definition, raw).run(data, options)),
+		getUrl: (provider) => withGateway((raw) => makeClient$12(definition, raw).getUrl(provider)),
+		fetch: (options) => withGateway((raw) => makeClient$12(definition, raw).fetch(options)),
+		patchLog: (logId, data) => withGateway((raw) => makeClient$12(definition, raw).patchLog(logId, data)),
+		getLog: (logId) => withGateway((raw) => makeClient$12(definition, raw).getLog(logId)),
 		rawUnsafe: gateway
 	};
 };
@@ -245,11 +247,11 @@ const makeHttpClient = (definition, request = fetch) => {
 		rawUnsafe: Effect.fail(aiGatewayError(binding, "rawUnsafe", /* @__PURE__ */ new TypeError("HTTP AI Gateway clients have no raw binding")))
 	};
 };
-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 layer$15 = (tag, definition) => layer$17(tag, definition.binding, isAiGatewayBinding, (ai) => makeClientFromAi(definition, ai), { expected: expectedAiGatewayBinding });
+const make$13 = (id) => Tag$12()(id);
+const Tag$12 = () => (id) => {
 	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$17(tag, definition);
+	const makeLayer = (definition) => layer$15(tag, definition);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer
@@ -264,13 +266,13 @@ var AnalyticsEngine_exports = /* @__PURE__ */ __exportAll({
 	AnalyticsEngineQueryError: () => AnalyticsEngineQueryError,
 	AnalyticsEngineWriteValidationError: () => AnalyticsEngineWriteValidationError,
 	QueryTag: () => QueryTag,
-	Tag: () => Tag$14,
+	Tag: () => Tag$11,
 	isAnalyticsEngineDataset: () => isAnalyticsEngineDataset,
-	layer: () => layer$16,
+	layer: () => layer$14,
 	layerFetch: () => layerFetch,
 	layerFetchConfig: () => layerFetchConfig,
-	make: () => make$16,
-	makeClient: () => makeClient$13,
+	make: () => make$12,
+	makeClient: () => makeClient$11,
 	makeQuery: () => makeQuery,
 	makeQueryClient: () => makeQueryClient,
 	queryConfig: () => queryConfig,
@@ -459,7 +461,7 @@ const makeQueryClientWith = (definition, httpClient) => {
 };
 const makeQueryClient = (definition) => Effect.map(HttpClient.HttpClient, (httpClient) => makeQueryClientWith(definition, httpClient));
 const isAnalyticsEngineDataset = (value) => Predicate.hasProperty(value, "writeDataPoint") && Predicate.isFunction(value.writeDataPoint);
-const makeClient$13 = (definition, defaults) => (dataset) => {
+const makeClient$11 = (definition, defaults) => (dataset) => {
 	return {
 		definition,
 		writeDataPoint: Effect.fn("AnalyticsEngine.writeDataPoint")((dataPoint, options) => {
@@ -489,12 +491,12 @@ const queryLayerConfig = (tag, config = queryConfig()) => Layer.effect(tag, Effe
 	return yield* makeQueryClient(definition);
 }));
 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 layer$14 = (tag, definition) => layer$17(tag, definition.binding, isAnalyticsEngineDataset, makeClient$11(definition, definition.write), { expected: expectedAnalyticsEngineDataset });
+const make$12 = (id) => Tag$11()(id);
 const makeQuery = (id) => QueryTag()(id);
-const Tag$14 = () => (id) => {
+const Tag$11 = () => (id) => {
 	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$16(tag, definition);
+	const makeLayer = (definition) => layer$14(tag, definition);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer
@@ -518,11 +520,11 @@ const QueryTag = () => (id) => {
 //#region src/BrowserRendering.ts
 var BrowserRendering_exports = /* @__PURE__ */ __exportAll({
 	BrowserRenderingOperationError: () => BrowserRenderingOperationError,
-	Tag: () => Tag$13,
+	Tag: () => Tag$10,
 	isBrowserRenderingBinding: () => isBrowserRenderingBinding,
-	layer: () => layer$15,
-	make: () => make$15,
-	makeClient: () => makeClient$12
+	layer: () => layer$13,
+	make: () => make$11,
+	makeClient: () => makeClient$10
 });
 const expectedBrowserRenderingBinding = "Browser Rendering binding resource";
 var BrowserRenderingOperationError = class extends Data.TaggedError("BrowserRenderingOperationError") {
@@ -571,17 +573,17 @@ const wrapBrowser = (binding, browser) => ({
 	disconnect: browser.disconnect === void 0 ? Effect.void : tryBrowserRenderingSync(binding, "disconnect", () => browser.disconnect())
 });
 const isBrowserRenderingBinding = (value) => Predicate.isObjectOrArray(value) || Predicate.isFunction(value);
-const makeClient$12 = (definition) => (binding) => ({
+const makeClient$10 = (definition) => (binding) => ({
 	definition,
 	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$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 layer$13 = (tag, definition) => layer$17(tag, definition.binding, isBrowserRenderingBinding, makeClient$10(definition), { expected: expectedBrowserRenderingBinding });
+const make$11 = (id) => Tag$10()(id);
+const Tag$10 = () => (id) => {
 	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$15(tag, definition);
+	const makeLayer = (definition) => layer$13(tag, definition);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer
@@ -592,10 +594,10 @@ const Tag$13 = () => (id) => {
 var Cache_exports = /* @__PURE__ */ __exportAll({
 	CacheOperationError: () => CacheOperationError,
 	CacheStorage: () => CacheStorage,
-	layer: () => layer$14,
+	layer: () => layer$12,
 	layerFrom: () => layerFrom,
 	makeCacheClient: () => makeCacheClient,
-	makeClient: () => makeClient$11
+	makeClient: () => makeClient$9
 });
 var CacheOperationError = class extends Data.TaggedError("CacheOperationError") {
 	get message() {
@@ -623,13 +625,13 @@ 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)
 });
-const makeClient$11 = (storage) => ({
+const makeClient$9 = (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)
 });
-const layerFrom = (storage) => Layer.succeed(CacheStorage, makeClient$11(storage));
-const layer$14 = Layer.sync(CacheStorage, () => makeClient$11(caches));
+const layerFrom = (storage) => Layer.succeed(CacheStorage, makeClient$9(storage));
+const layer$12 = Layer.sync(CacheStorage, () => makeClient$9(caches));
 //#endregion
 //#region src/CloudflareOtlp.ts
 /**
@@ -639,7 +641,7 @@ const layer$14 = Layer.sync(CacheStorage, () => makeClient$11(caches));
 * layer finalizers run separately and follow their configured shutdown timeout.
 */
 var CloudflareOtlp_exports = /* @__PURE__ */ __exportAll({
-	layer: () => layer$13,
+	layer: () => layer$11,
 	layerDurableObject: () => layerDurableObject,
 	layerJson: () => layerJson,
 	layerProtobuf: () => layerProtobuf,
@@ -705,14 +707,14 @@ const makeLayer = (options = {}, runtimeAttributes = {}) => {
 * The layer provides {@link OtlpExporter.Flusher} for draining buffered
 * telemetry before the isolate freezes.
 */
-const layer$13 = (options = {}) => makeLayer(options);
+const layer$11 = (options = {}) => makeLayer(options);
 /** Base OTLP telemetry layer forced to JSON serialization. */
-const layerJson = (options = {}) => layer$13({
+const layerJson = (options = {}) => layer$11({
 	...options,
 	serialization: "json"
 });
 /** Base OTLP telemetry layer forced to protobuf serialization. */
-const layerProtobuf = (options = {}) => layer$13({
+const layerProtobuf = (options = {}) => layer$11({
 	...options,
 	serialization: "protobuf"
 });
@@ -746,11 +748,11 @@ var ContainerNamespace_exports = /* @__PURE__ */ __exportAll({
 	ContainerNamespace: () => ContainerNamespace,
 	ContainerOperationError: () => ContainerOperationError,
 	ContainerState: () => ContainerState,
-	Tag: () => Tag$12,
+	Tag: () => Tag$9,
 	isContainerNamespaceResource: () => isContainerNamespaceResource,
-	layer: () => layer$12,
-	make: () => make$14,
-	makeClient: () => makeClient$10
+	layer: () => layer$10,
+	make: () => make$10,
+	makeClient: () => makeClient$8
 });
 const expectedContainerNamespace = "Container namespace binding with getByName()";
 /** Serializable state reported by a Cloudflare Container instance. */
@@ -826,7 +828,7 @@ const makeInstanceClient = (definition, instance, stub) => {
 	};
 };
 const isContainerNamespaceResource = (value) => Predicate.hasProperty(value, "getByName") && Predicate.isFunction(value.getByName);
-const makeClient$10 = (definition) => (namespace) => {
+const makeClient$8 = (definition) => (namespace) => {
 	const getByName = (name, options) => Effect.try({
 		try: () => makeInstanceClient(definition, name, namespace.getByName(name, options)),
 		catch: (cause) => new ContainerOperationError({
@@ -862,11 +864,11 @@ const makeClient$10 = (definition) => (namespace) => {
 		rawUnsafe: Effect.succeed(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);
-const Tag$12 = () => (id) => {
+const layer$10 = (tag, definition) => layer$17(tag, definition.binding, (value) => isContainerNamespaceResource(value), makeClient$8(definition), { expected: expectedContainerNamespace });
+const make$10 = (id) => Tag$9()(id);
+const Tag$9 = () => (id) => {
 	const tag = Context.Service()(`effect-cf/Container/${id}`);
-	const makeLayer = (definition) => layer$12(tag, definition);
+	const makeLayer = (definition) => layer$10(tag, definition);
 	const getByName = Effect.fnUntraced(function* (name, options) {
 		return yield* (yield* tag).getByName(name, options);
 	});
@@ -895,19 +897,19 @@ const Tag$12 = () => (id) => {
 		rawUnsafe
 	});
 };
-const ContainerNamespace = Tag$12;
+const ContainerNamespace = Tag$9;
 //#endregion
 //#region src/D1.ts
 var D1_exports = /* @__PURE__ */ __exportAll({
-	Service: () => Service$1,
-	make: () => make$13
+	Service: () => Service,
+	make: () => make$9
 });
-const TypeId$2 = "~effect-cf/D1";
+const TypeId$1 = "~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);
-const make$13 = (id, definition) => Service$1()(id, definition);
-const Service$1 = () => (id, definition) => {
-	const tag = Service$2()(id, definition.binding, isD1Database, void 0, { expected: expectedD1Database });
+const make$9 = (id, definition) => Service()(id, definition);
+const Service = () => (id, definition) => {
+	const tag = Service$1()(id, definition.binding, isD1Database, void 0, { expected: expectedD1Database });
 	const sqlLayer = (options) => Layer.unwrap(Effect.gen(function* () {
 		const db = yield* tag;
 		return D1Client.layer({
@@ -916,887 +918,11 @@ const Service$1 = () => (id, definition) => {
 		});
 	})).pipe(Layer.provide(tag.layer));
 	return Object.assign(tag, {
-		[TypeId$2]: TypeId$2,
-		definition,
-		sqlLayer
-	});
-};
-//#endregion
-//#region src/QueueBinding.ts
-var QueueBinding_exports = /* @__PURE__ */ __exportAll({
-	QueueOperationError: () => QueueOperationError,
-	isQueue: () => isQueue,
-	layer: () => layer$11,
-	makeClient: () => makeClient$9
-});
-const expectedQueueProducer = "Queue producer binding with send(); optional sendBatch()/metrics()";
-var QueueOperationError = class extends Data.TaggedError("QueueOperationError") {};
-const tryQueuePromise = (binding, operation, evaluate) => Effect.tryPromise({
-	try: evaluate,
-	catch: (cause) => new QueueOperationError({
-		binding,
-		operation,
-		cause,
-		message: `Cloudflare queue binding "${binding}" operation "${operation}" failed`
-	})
-});
-const isQueue = (value) => Predicate.hasProperty(value, "send") && Predicate.isFunction(value.send);
-const makeClient$9 = (definition) => {
-	const encodeMessage = Schema.encodeEffect(definition.message);
-	return (queue) => ({
-		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.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) 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;
-			if (metrics === void 0) return Effect.fail(new QueueOperationError({
-				binding: definition.binding,
-				operation: "metrics",
-				cause: /* @__PURE__ */ new Error(`Queue binding "${definition.binding}" does not provide metrics()`),
-				message: `Cloudflare queue binding "${definition.binding}" does not provide metrics()`
-			}));
-			return tryQueuePromise(definition.binding, "metrics", () => metrics.call(queue));
-		},
-		rawUnsafe: Effect.succeed(queue)
-	});
-};
-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$11,
-	implement: () => implement$5,
-	make: () => make$12
-});
-const makeDefinition$4 = (id, definition) => {
-	const queueDefinition = {
-		id,
-		message: definition.message
-	};
-	return Object.assign(queueDefinition, { make: (layer, options) => make$9(layer, {
-		...options,
-		queue: wrapHandler$1(queueDefinition, options.queue)
-	}) });
-};
-const make$12 = (id, definition) => Tag$11()(id, definition);
-const Tag$11 = () => (id, definition) => {
-	const queueDefinition = makeDefinition$4(id, definition);
-	const tag = Context.Service()(`effect-cf/Queue/${id}`);
-	const layer = (binding) => layer$11(tag, {
-		...binding,
-		message: definition.message
-	});
-	const send = Effect.fnUntraced(function* (message, options) {
-		yield* (yield* tag).send(message, options);
-	});
-	const sendBatch = Effect.fnUntraced(function* (messages, options) {
-		yield* (yield* tag).sendBatch(messages, options);
-	});
-	const metrics = Effect.fnUntraced(function* () {
-		return yield* (yield* tag).metrics();
-	});
-	const rawUnsafe = Effect.flatMap(tag, (queue) => queue.rawUnsafe);
-	return Object.assign(tag, {
-		id: queueDefinition.id,
-		message: queueDefinition.message,
-		make: queueDefinition.make,
-		layer,
-		send,
-		sendBatch,
-		metrics,
-		rawUnsafe
-	});
-};
-const Queue$1 = Tag$11;
-const wrapHandler$1 = (definition, handler) => {
-	const decodeBody = Schema.decodeUnknownEffect(definition.message);
-	return Effect.fnUntraced(function* (batch) {
-		yield* handler(yield* decodeBatch(batch.raw, decodeBody));
-	});
-};
-const implement$5 = (_definition, handler) => handler;
-//#endregion
-//#region src/Queue.ts
-var Queue_exports = /* @__PURE__ */ __exportAll({
-	QueueMessageDecodeError: () => QueueMessageDecodeError,
-	Tag: () => Tag$10,
-	decodeBatch: () => decodeBatch,
-	fromMessage: () => fromMessage,
-	fromMessageBatch: () => fromMessageBatch,
-	implement: () => implement$4
-});
-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,
-	timestamp: message.timestamp,
-	body,
-	attempts: message.attempts,
-	ack: Effect.sync(() => message.ack()),
-	retry: (options) => Effect.sync(() => message.retry(options))
-});
-const fromMessageBatch = (batch, messages) => ({
-	raw: batch,
-	messages,
-	queue: batch.queue,
-	metadata: batch.metadata,
-	ackAll: Effect.sync(() => batch.ackAll()),
-	retryAll: (options) => Effect.sync(() => batch.retryAll(options))
-});
-const decodeBatch = (batch, decodeBody) => Effect.gen(function* () {
-	const messages = [];
-	for (let index = 0; index < batch.messages.length; index++) {
-		const message = batch.messages[index];
-		const body = yield* decodeBody(message.body).pipe(Effect.mapError((cause) => new QueueMessageDecodeError({
-			queue: batch.queue,
-			messageId: message.id,
-			index,
-			cause
-		})));
-		messages.push(fromMessage(message, body));
-	}
-	return fromMessageBatch(batch, messages);
-});
-const Tag$10 = Tag$11;
-const implement$4 = implement$5;
-//#endregion
-//#region src/RpcDefinition.ts
-var RpcDefinition_exports = /* @__PURE__ */ __exportAll({
-	RpcArgumentCountError: () => RpcArgumentCountError,
-	RpcArgumentDecodeError: () => RpcArgumentDecodeError,
-	RpcArgumentEncodeError: () => RpcArgumentEncodeError,
-	RpcReservedMethodNameError: () => RpcReservedMethodNameError,
-	RpcSuccessDecodeError: () => RpcSuccessDecodeError,
-	RpcSuccessEncodeError: () => RpcSuccessEncodeError,
-	assertNoReservedMethods: () => assertNoReservedMethods,
-	decodeArgs: () => decodeArgs,
-	decodeSuccess: () => decodeSuccess,
-	decodeWireError: () => decodeWireError,
-	encodeArgs: () => encodeArgs,
-	encodeSuccess: () => encodeSuccess,
-	encodeWireError: () => encodeWireError,
-	isWireError: () => isWireError,
-	make: () => make$11,
-	method: () => method$2,
-	reservedMethodNames: () => reservedMethodNames$4
-});
-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;
-	}
-};
-const decodeWireError = (cause) => {
-	if (!(cause instanceof Error)) return cause;
-	try {
-		const parsed = Schema.decodeUnknownSync(Schema.Unknown)(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",
-	"connect",
-	"alarm",
-	"webSocketMessage",
-	"webSocketClose",
-	"webSocketError",
-	"then",
-	"dup",
-	"dispose",
-	"serialize",
-	"deserialize"
-]);
-/**
-* 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 RpcReservedMethodNameError({
-		definition: target,
-		method
-	});
-};
-function method$2(definition) {
-	return {
-		args: definition.args ?? [],
-		success: definition.success
-	};
-}
-const decodeArgs = Effect.fnUntraced(function* (definition, methodName, args) {
-	const methodDefinition = definition.methods[methodName];
-	if (args.length !== methodDefinition.args.length) return yield* new RpcArgumentCountError({
-		definition: definition.id,
-		method: methodName,
-		expected: methodDefinition.args.length,
-		actual: args.length
-	});
-	return yield* Schema.decodeUnknownEffect(wireCodec(Schema.Tuple(methodDefinition.args)))(args).pipe(Effect.mapError((cause) => new RpcArgumentDecodeError({
-		definition: definition.id,
-		method: methodName,
-		cause
-	})));
-});
-const encodeArgs = Effect.fnUntraced(function* (definition, methodName, args) {
-	const methodDefinition = definition.methods[methodName];
-	if (args.length !== methodDefinition.args.length) return yield* new RpcArgumentCountError({
-		definition: definition.id,
-		method: methodName,
-		expected: methodDefinition.args.length,
-		actual: args.length
-	});
-	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.encodeUnknownEffect(wireCodec(methodDefinition.success))(value).pipe(Effect.mapError((cause) => new RpcSuccessEncodeError({
-		definition: definition.id,
-		method: methodName,
-		cause
-	})));
-};
-const decodeSuccess = (definition, methodName, value) => {
-	const methodDefinition = definition.methods[methodName];
-	return Schema.decodeUnknownEffect(wireCodec(methodDefinition.success))(value).pipe(Effect.mapError((cause) => new RpcSuccessDecodeError({
-		definition: definition.id,
-		method: methodName,
-		cause
-	})));
-};
-const make$11 = (id, methods) => {
-	assertNoReservedMethods(id, methods, reservedMethodNames$4);
-	return {
-		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 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, 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, target, key, rpcTracing);
-		}
-	});
-};
-const assumeEntrypointClass = (entrypoint) => {
-	return 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));
-};
-function runEventPromise(...args) {
-	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
-/** Maximum event lifetime spent on an internally scheduled telemetry flush. */
-const scheduledFlushTimeout = "2 seconds";
-/**
-* Schedules a configured OTLP flusher through the current Cloudflare event.
-*
-* The handed-off effect is best-effort: it settles within two seconds and
-* silently absorbs every failure cause so telemetry cannot extend or fail the
-* user event, or recursively log through an unhealthy exporter.
-*/
-const scheduleTelemetryFlush$2 = (waitUntil) => Effect.gen(function* () {
-	const flusher = yield* Effect.serviceOption(OtlpExporter.Flusher);
-	if (Option.isNone(flusher)) return;
-	yield* waitUntil(flusher.value.flush.pipe(Effect.timeoutOption(scheduledFlushTimeout), Effect.ignoreCause, Effect.asVoid));
-}).pipe(Effect.ignoreCause);
-//#endregion
-//#region src/Rpc.ts
-var Rpc_exports = /* @__PURE__ */ __exportAll({
-	RpcStub: () => RpcStub,
-	RpcTarget: () => RpcTarget,
-	dispose: () => dispose,
-	isDisposable: () => isDisposable,
-	resolve: () => resolve,
-	scoped: () => scoped
-});
-const isDisposable = (value) => Predicate.hasProperty(value, Symbol.dispose) && Predicate.isFunction(value[Symbol.dispose]);
-const dispose = (value) => Effect.sync(() => {
-	if (isDisposable(value)) value[Symbol.dispose]();
-});
-const resolve = (value) => Predicate.isPromiseLike(value) ? Effect.tryPromise({
-	try: () => Promise.resolve(value),
-	catch: (cause) => decodeWireError(cause)
-}) : Effect.sync(() => {
-	return value;
-});
-const scoped = (value) => Effect.acquireRelease(resolve(value), (resolved) => dispose(resolved));
-//#endregion
-//#region src/ServiceBinding.ts
-var ServiceBinding_exports = /* @__PURE__ */ __exportAll({
-	Service: () => Service,
-	ServiceBindingFetchError: () => ServiceBindingFetchError,
-	ServiceBindingRpcError: () => ServiceBindingRpcError,
-	isServiceBindingClient: () => isServiceBindingClient,
-	layer: () => layer$10,
-	makeClient: () => makeClient$8,
-	makeDirectMethods: () => makeDirectMethods$1
-});
-const TypeId$1 = "effect-cf/ServiceBinding";
-const expectedServiceBinding = "Worker service binding with fetch()";
-/**
-* Failure raised when calling `fetch` on a service binding.
-*/
-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") {
-	get message() {
-		return `Service binding "${this.binding}" RPC method "${this.method}" failed: ${causeMessage(this.cause)}`;
-	}
-};
-const ServiceBindingSchema = Schema.declare((value) => Predicate.hasProperty(value, "fetch") && Predicate.isFunction(value.fetch));
-const decodeServiceBinding = Schema.decodeUnknownOption(ServiceBindingSchema);
-const isServiceBindingClient = (value) => Option.isSome(decodeServiceBinding(value));
-const makeClient$8 = (definition) => {
-	return (service) => {
-		const fetch = Effect.fn("ServiceBinding.fetch")(function* (input, init) {
-			return yield* Effect.tryPromise({
-				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.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
-			})));
-			const nativeArgs = definition.rpcTracing ? yield* withRpcTraceContext(encodedArgs) : encodedArgs;
-			return yield* invokeRpcMethod(service, method, nativeArgs, (cause) => new ServiceBindingRpcError({
-				binding: definition.binding,
-				method: methodName,
-				cause
-			}));
-		});
-		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,
-				method: methodName,
-				cause
-			})));
-		});
-		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,
-				method: methodName,
-				cause
-			})));
-			return yield* decodeSuccess$2(methodName, value);
-		}, (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).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,
-			rpc,
-			call,
-			scopedCall
-		});
-	};
-};
-const layer$10 = (tag, definition) => layer$19(tag, definition.binding, (value) => isServiceBindingClient(value), makeClient$8(definition), { expected: expectedServiceBinding });
-const Service = () => (id, definition) => {
-	const tag = Service$2()(id, definition.binding, (value) => isServiceBindingClient(value), makeClient$8(definition));
-	const fetch = Effect.fnUntraced(function* (input, init) {
-		return yield* (yield* tag).fetch(input, init);
-	});
-	const rpc = Effect.fnUntraced(function* (method, ...args) {
-		return yield* (yield* tag).rpc(method, ...args);
-	});
-	const call = Effect.fnUntraced(function* (method, ...args) {
-		return yield* (yield* tag).call(method, ...args);
-	});
-	const scopedCall = Effect.fnUntraced(function* (method, ...args) {
-		return yield* (yield* tag).scopedCall(method, ...args);
-	});
-	const directMethods = makeDirectMethods$1(definition.definition, call);
-	return Object.assign(tag, directMethods, {
 		[TypeId$1]: TypeId$1,
 		definition,
-		fetch,
-		rpc,
-		call,
-		scopedCall
-	});
-};
-const makeDirectMethods$1 = (rpcDefinition, call) => {
-	const methods = {};
-	if (rpcDefinition !== void 0) {
-		const invoke = call;
-		for (const methodName of Object.keys(rpcDefinition.methods)) methods[methodName] = (...args) => invoke(methodName, ...args);
-	}
-	return methods;
-};
-//#endregion
-//#region src/WorkerDefinition.ts
-var WorkerDefinition_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$9,
-	Worker: () => Worker,
-	implement: () => implement$3,
-	make: () => make$10,
-	method: () => method$1
-});
-const reservedMethodNames$3 = /* @__PURE__ */ new Set([
-	"constructor",
-	"dup",
-	"fetch",
-	"connect",
-	"queue",
-	"scheduled",
-	"tail",
-	"tailStream",
-	"test",
-	"trace",
-	"alarm",
-	"webSocketMessage",
-	"webSocketClose",
-	"webSocketError"
-]);
-const assumeTagClass = (value) => {
-	return value;
-};
-/**
-* Defines a single RPC method schema in a worker definition.
-*/
-const method$1 = method$2;
-const makeDefinition$3 = (id, methods) => {
-	assertNoReservedMethods("Worker", methods, reservedMethodNames$3);
-	const definition = make$11(id, methods);
-	return Object.assign(definition, { make: (layer, options) => {
-		const workerOptions = {
-			...options,
-			rpc: wrapHandlers$1(definition, options.rpc)
-		};
-		if (workerOptions.eventLayer === void 0) return make$9(layer, workerOptions);
-		return make$9(layer, workerOptions);
-	} });
-};
-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$10(tag, bindingDefinition(binding));
-	const fetch = (input, init) => Effect.gen(function* () {
-		return yield* (yield* tag).fetch(input, init);
-	});
-	const rpc = (method, ...args) => Effect.gen(function* () {
-		return yield* (yield* tag).rpc(method, ...args);
-	});
-	const call = (method, ...args) => Effect.gen(function* () {
-		return yield* (yield* tag).call(method, ...args);
-	});
-	const scopedCall = (method, ...args) => Effect.gen(function* () {
-		return yield* (yield* tag).scopedCall(method, ...args);
+		sqlLayer
 	});
-	const directMethods = makeDirectMethods$1(definition, call);
-	return assumeTagClass(Object.assign(tag, directMethods, {
-		id: definition.id,
-		methods: definition.methods,
-		make: definition.make,
-		layer,
-		fetch,
-		rpc,
-		call,
-		scopedCall
-	}));
-};
-const Worker = Tag$9;
-const wrapHandlers$1 = (definition, handlers) => {
-	const wrapped = Object.create(null);
-	for (const key of Object.keys(definition.methods)) {
-		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);
-		});
-	}
-	return wrapped;
 };
-/**
-* Helper for implementing handlers with the exact method shape of a definition.
-*/
-const implement$3 = (_definition, handlers) => handlers;
-//#endregion
-//#region src/Worker.ts
-var Worker_exports = /* @__PURE__ */ __exportAll({
-	ExecutionContext: () => ExecutionContext,
-	NativeRequest: () => NativeRequest,
-	RunSymbol: () => RunSymbol$1,
-	Tag: () => Tag$9,
-	WorkerContext: () => WorkerContext,
-	implement: () => implement$3,
-	isWebSocketUpgrade: () => isWebSocketUpgrade,
-	make: () => make$9,
-	makeFetchHandler: () => makeFetchHandler,
-	method: () => method$1
-});
-var ExecutionContext = class extends Context.Service()("effect-cf/ExecutionContext") {};
-var WorkerContext = class extends Context.Service()("effect-cf/WorkerContext") {};
-var NativeRequest = class extends Context.Service()("effect-cf/NativeRequest") {};
-const isWebSocketUpgrade = (request) => request.headers.get("Upgrade")?.toLowerCase() === "websocket";
-const reservedMethodNames$2 = /* @__PURE__ */ new Set([
-	...reservedMethodNames$4,
-	"queue",
-	"scheduled",
-	"tail",
-	"tailStream",
-	"test",
-	"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, eventLayer) => Effect.suspend(() => {
-	let nativeResponse;
-	let webResponse;
-	const httpApp = Effect.flatMap(effect, (response) => {
-		if (response instanceof Response) {
-			nativeResponse = response;
-			return Effect.succeed(HttpServerResponse.empty());
-		}
-		return Effect.succeed(response);
-	});
-	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,
-		onSuccess: captured
-	});
-});
-const isWorkerOptions = (options) => !Effect.isEffect(options);
-/**
-* 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` 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) {
-	const options = isWorkerOptions(optionsOrFetch) ? optionsOrFetch : { fetch: optionsOrFetch };
-	class EffectWorker extends WorkerEntrypoint {
-		runtime;
-		constructor(ctx, env) {
-			super(ctx, env);
-			this.runtime = makeEntrypointRuntime(layer, env, Layer.mergeAll(Layer.succeed(ExecutionContext, ctx), Layer.succeed(WorkerContext, fromExecutionContext(ctx))));
-		}
-		[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);
-		}
-		[FetchSymbol](request, requestContext) {
-			const fetchHandler = options.fetch;
-			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, 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)).pipe(Effect.onExit(() => scheduleTelemetryFlush$1)), { event: "queue" });
-		}
-	}
-	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) {
-	const WorkerClass = options.eventLayer === void 0 ? make$9(layer, options) : make$9(layer, options);
-	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);
-	} };
-}
 //#endregion
 //#region src/DurableObjectNamespace.ts
 var DurableObjectNamespace_exports = /* @__PURE__ */ __exportAll({
@@ -1854,8 +980,7 @@ const makeClient$7 = (definition) => {
 				method: methodName,
 				cause
 			})));
-			const nativeArgs = definition.rpcTracing ? yield* withRpcTraceContext(encodedArgs) : encodedArgs;
-			return yield* invokeRpcMethod(stub, method, nativeArgs, (cause) => new DurableObjectRpcError({
+			return yield* invokeRpcMethod(stub, method, definition.rpcTracing ? yield* withRpcTraceContext(encodedArgs) : encodedArgs, (cause) => new DurableObjectRpcError({
 				binding: definition.binding,
 				method: methodName,
 				cause
@@ -1880,8 +1005,7 @@ const makeClient$7 = (definition) => {
 		}, (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).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+			const value = yield* scoped(yield* rpc(stub, method, ...args)).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
 				binding: definition.binding,
 				method: methodName,
 				cause
@@ -1909,7 +1033,7 @@ const makeClient$7 = (definition) => {
 		});
 	};
 };
-const layer$9 = (tag, definition) => layer$19(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$7(definition), { expected: expectedDurableObjectNamespace });
+const layer$9 = (tag, definition) => layer$17(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$7(definition), { expected: expectedDurableObjectNamespace });
 const makeDirectMethods = (rpcDefinition, helpers) => {
 	const methods = {};
 	if (rpcDefinition !== void 0) {
@@ -1949,11 +1073,11 @@ const reservedMethodNames$1 = /* @__PURE__ */ new Set([
 	"webSocketError"
 ]);
 function method(definition) {
-	return method$2(definition);
+	return method$1(definition);
 }
 const makeDefinition$2 = (id, methods) => {
 	assertNoReservedMethods("Durable Object", methods, reservedMethodNames$1);
-	const definition = make$11(id, methods);
+	const definition = make$15(id, methods);
 	return Object.assign(definition, { make: (layer, options) => make$7(layer, {
 		...options,
 		rpc: wrapHandlers(definition, options.rpc)
@@ -2056,10 +1180,10 @@ var DurableObject_exports = /* @__PURE__ */ __exportAll({
 	make: () => make$7,
 	method: () => method
 });
-const reservedMethodNames = reservedMethodNames$4;
+const reservedMethodNames = reservedMethodNames$2;
 /** 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)));
+const scheduleTelemetryFlush = scheduleTelemetryFlush$1((flush) => Effect.flatMap(DurableObjectState, (state) => state.waitUntil(flush)));
 /**
 * 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
@@ -2306,25 +1430,35 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 		});
 		const cancelAlarm = Effect.fn("DurableObjectAlarm.cancelAlarm")(function* (input) {
 			const ref = yield* decodeAlarmRef(input);
-			yield* state.storage.transaction(() => Effect.gen(function* () {
-				yield* ensureTable(state);
-				yield* state.storage.sql.exec(`DELETE FROM effect_cf_scheduled_alarms WHERE storage_id = ?`, getScheduledEventId(ref)).pipe(Effect.asVoid);
-				yield* reconcileAlarm();
-			}));
+			yield* state.storage.sql.exec(`DELETE FROM effect_cf_scheduled_alarms WHERE storage_id = ?`, getScheduledEventId(ref));
 		});
 		const scheduleAlarm = Effect.fn("DurableObjectAlarm.scheduleAlarm")(function* (input) {
 			const ref = yield* decodeAlarmRef(input);
 			const repeatEveryMillis = yield* toRepeatEveryMillis(input.repeatEvery);
 			const payload = yield* encodeStoredPayload(input.payload);
 			const runAt = DateTime.toEpochMillis(input.runAt);
-			yield* state.storage.transaction(() => Effect.gen(function* () {
-				yield* ensureTable(state);
-				yield* state.storage.sql.exec(`INSERT OR REPLACE INTO effect_cf_scheduled_alarms
+			yield* state.storage.sql.exec(`INSERT OR REPLACE INTO effect_cf_scheduled_alarms
                    (storage_id, alarm_id, tag, run_at, repeat_every_ms, payload)
-                 VALUES (?, ?, ?, ?, ?, ?)`, getScheduledEventId(ref), ref.id, ref.tag, runAt, repeatEveryMillis, payload).pipe(Effect.asVoid);
-				yield* reconcileAlarm();
-			}));
+                 VALUES (?, ?, ?, ?, ?, ?)`, getScheduledEventId(ref), ref.id, ref.tag, runAt, repeatEveryMillis, payload);
 		});
+		const transaction = (closure) => state.storage.transaction(() => Effect.withFiber((owner) => {
+			let active = true;
+			const requireActive = (effect) => Effect.withFiber((fiber) => active && fiber === owner ? effect : Effect.fail(new StorageOperationError({
+				operation: "alarm.transaction",
+				cause: /* @__PURE__ */ new Error("Alarm mutations require their active transaction callback")
+			})));
+			return Effect.gen(function* () {
+				yield* ensureTable(state);
+				const result = yield* Effect.suspend(() => closure({
+					cancelAlarm: (input) => requireActive(cancelAlarm(input)),
+					scheduleAlarm: (input) => requireActive(scheduleAlarm(input))
+				})).pipe(Effect.ensuring(Effect.sync(() => {
+					active = false;
+				})));
+				yield* reconcileAlarm();
+				return result;
+			});
+		}));
 		const processDueAlarms = Effect.fn("DurableObjectAlarm.processDueAlarms")(function* (handle, options) {
 			yield* ensureTable(state);
 			const mode = options?.mode ?? "isolated";
@@ -2383,9 +1517,10 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 			};
 		});
 		return DurableObjectAlarm.of({
-			cancelAlarm,
+			cancelAlarm: (input) => transaction((alarms) => alarms.cancelAlarm(input)),
 			processDueAlarms,
-			scheduleAlarm
+			scheduleAlarm: (input) => transaction((alarms) => alarms.scheduleAlarm(input)),
+			transaction
 		});
 	}).pipe(Effect.withSpan("DurableObjectAlarm.layer")));
 };
@@ -3158,7 +2293,7 @@ const makeClient$6 = (definition, options) => (email) => {
 		rawUnsafe: Effect.succeed(email)
 	};
 };
-const layer$6 = (tag, definition) => layer$19(tag, definition.binding, isEmailBinding, makeClient$6(definition, definition.send), { expected: expectedSendEmailBinding });
+const layer$6 = (tag, definition) => layer$17(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);
@@ -3184,7 +2319,7 @@ const makeClient$5 = (definition) => (hyperdrive) => ({
 	connectionString: hyperdrive.connectionString,
 	rawUnsafe: Effect.succeed(hyperdrive)
 });
-const layer$5 = (tag, definition) => layer$19(tag, definition.binding, isHyperdrive, makeClient$5(definition), { expected: expectedHyperdrive });
+const layer$5 = (tag, definition) => layer$17(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);
@@ -3286,7 +2421,7 @@ const makeClient$4 = (definition) => (images) => {
 		rawUnsafe: Effect.succeed(images)
 	};
 };
-const layer$4 = (tag, definition) => layer$19(tag, definition.binding, isImagesBinding, makeClient$4(definition), { expected: expectedImagesBinding });
+const layer$4 = (tag, definition) => layer$17(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);
@@ -3394,7 +2529,7 @@ const makeClient$3 = (definition) => {
 		rawUnsafe: Effect.succeed(kv)
 	});
 };
-const layer$3 = (tag, definition) => layer$19(tag, definition.binding, isKvNamespace, makeClient$3(definition), { expected: expectedKvNamespace });
+const layer$3 = (tag, definition) => layer$17(tag, definition.binding, isKvNamespace, makeClient$3(definition), { expected: expectedKvNamespace });
 const makeDefinition$1 = (id, definition) => {
 	const kvDefinition = {
 		id,
@@ -3515,7 +2650,7 @@ const makeClient$2 = (definition) => {
 		};
 	};
 };
-const layer$2 = (tag, definition) => layer$19(tag, definition.binding, isR2Bucket, makeClient$2(definition), { expected: expectedR2Bucket });
+const layer$2 = (tag, definition) => layer$17(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);
@@ -3581,7 +2716,7 @@ const makeClient$1 = (definition) => (index) => {
 		rawUnsafe: Effect.succeed(index)
 	};
 };
-const layer$1 = (tag, definition) => layer$19(tag, definition.binding, isVectorizeBinding, makeClient$1(definition), { expected: expectedVectorizeBinding });
+const layer$1 = (tag, definition) => layer$17(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);
@@ -3736,7 +2871,7 @@ const makeClient = (definition) => {
 		rawUnsafe: Effect.succeed(workflow)
 	});
 };
-const layer = (tag, definition) => layer$19(tag, definition.binding, (value) => isWorkflow(value), makeClient(definition), { expected: expectedWorkflow });
+const layer = (tag, definition) => layer$17(tag, definition.binding, (value) => isWorkflow(value), makeClient(definition), { expected: expectedWorkflow });
 //#endregion
 //#region src/WorkflowDefinition.ts
 var WorkflowDefinition_exports = /* @__PURE__ */ __exportAll({
@@ -3757,7 +2892,7 @@ const make$1 = (id, definition) => Tag$1()(id, definition);
 const Tag$1 = () => (id, definition) => {
 	const workflowDefinition = makeDefinition(id, definition);
 	const tag = Context.Service()(`effect-cf/Workflow/${id}`);
-	const layer$20 = (binding) => layer(tag, {
+	const layer$18 = (binding) => layer(tag, {
 		...binding,
 		payload: definition.payload,
 		result: definition.result
@@ -3777,7 +2912,7 @@ const Tag$1 = () => (id, definition) => {
 		payload: workflowDefinition.payload,
 		result: workflowDefinition.result,
 		make: workflowDefinition.make,
-		layer: layer$20,
+		layer: layer$18,
 		create,
 		createBatch,
 		get,