effect-cf 0.18.0 → 0.20.1

package/dist/index.mjs

@@ -1,7 +1,6 @@
-import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
-import { a as WorkerConfig, i as layer$19, n as Binding_exports, o as WorkerEnvironment, r as Service$2, t as Hyperdrive_exports } from "./Hyperdrive-89hg_Fck.mjs";
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { Cause, Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Layer, ManagedRuntime, Option, Queue, Result, Schema } from "effect";
-import { FetchHttpClient, HttpClient, HttpClientRequest, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { FetchHttpClient, HttpClient, HttpClientRequest, HttpEffect, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import { OtlpLogger, OtlpMetrics, OtlpSerialization, OtlpTracer } from "effect/unstable/observability";
 import { D1Client } from "@effect/sql-d1";
 import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, WorkflowEntrypoint } from "cloudflare:workers";
@@ -9,15 +8,140 @@ import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
 import * as RpcServer from "effect/unstable/rpc/RpcServer";
 import { SqliteClient } from "@effect/sql-sqlite-do";
+//#region src/Environment.ts
+/**
+* Context service for reading worker bindings from the current `env` object.
+*/
+var WorkerEnvironment = class extends Context.Service()("effect-cf/WorkerEnvironment") {};
+let WorkerConfig;
+(function(_WorkerConfig) {
+	_WorkerConfig.string = (name) => Config.string(name);
+	_WorkerConfig.redacted = (name) => Config.redacted(name);
+	_WorkerConfig.number = (name) => Config.number(name);
+	_WorkerConfig.integer = (name) => Config.int(name);
+	_WorkerConfig.boolean = (name) => Config.boolean(name);
+	const providerFromEnv = _WorkerConfig.providerFromEnv = (env) => ConfigProvider.fromUnknown(env);
+	const providerWith = _WorkerConfig.providerWith = (makeProvider) => Effect.map(WorkerEnvironment, makeProvider);
+	const provider = _WorkerConfig.provider = providerWith(providerFromEnv);
+	_WorkerConfig.layer = _WorkerConfig.providerLayer = ConfigProvider.layer(provider);
+	_WorkerConfig.layerWith = (makeProvider) => ConfigProvider.layer(providerWith(makeProvider));
+})(WorkerConfig || (WorkerConfig = {}));
+//#endregion
+//#region src/Binding.ts
+var Binding_exports = /* @__PURE__ */ __exportAll({
+	BindingNotFoundError: () => BindingNotFoundError,
+	BindingValidationError: () => BindingValidationError,
+	Service: () => Service$2,
+	TypeId: () => TypeId$3,
+	layer: () => layer$20
+});
+/** Internal type id marker used by binding helper services. */
+const TypeId$3 = "effect-cf/Binding";
+/** Error raised when a configured binding does not exist on `env`. */
+var BindingNotFoundError = class extends Data.TaggedError("BindingNotFoundError") {};
+/** Error raised when a binding exists but does not match the expected shape. */
+var BindingValidationError = class extends Data.TaggedError("BindingValidationError") {};
+const defaultExpected = "Cloudflare binding resource";
+const isPropertyTarget$1 = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
+const getObjectName = (value) => {
+	const tag = (() => {
+		try {
+			return Object.prototype.toString.call(value).slice(8, -1);
+		} catch {
+			return typeof value;
+		}
+	})();
+	const constructorName = (() => {
+		try {
+			return "constructor" in value && typeof value.constructor === "function" && typeof value.constructor.name === "string" ? value.constructor.name : void 0;
+		} catch {
+			return;
+		}
+	})();
+	if (tag !== "Object") return tag;
+	if (constructorName !== void 0 && constructorName !== "" && constructorName !== "Object") return constructorName;
+	return tag;
+};
+const propertyNames = (value) => {
+	const names = /* @__PURE__ */ new Set();
+	for (const target of [value, Object.getPrototypeOf(value)]) {
+		if (target === null || target === Object.prototype || target === Function.prototype) continue;
+		try {
+			for (const name of Object.getOwnPropertyNames(target)) names.add(name);
+		} catch {
+			continue;
+		}
+	}
+	return [...names].filter((name) => name !== "constructor").sort();
+};
+const isMethod = (value, name) => {
+	try {
+		return typeof Reflect.get(value, name) === "function";
+	} catch {
+		return false;
+	}
+};
+const describeActual = (value) => {
+	if (value === null) return "null";
+	if (typeof value !== "object" && typeof value !== "function") return typeof value;
+	const names = propertyNames(value);
+	const methods = names.filter((name) => isMethod(value, name));
+	const properties = names.filter((name) => !methods.includes(name));
+	const details = [methods.length > 0 ? `methods ${methods.join(", ")}` : void 0, properties.length > 0 ? `properties ${properties.join(", ")}` : void 0].filter((detail) => detail !== void 0);
+	if (details.length === 0) return getObjectName(value);
+	return `${getObjectName(value)} with ${details.join("; ")}`;
+};
+const getBinding = (env, binding, isResource, options) => Effect.gen(function* () {
+	if (!isPropertyTarget$1(env)) {
+		const actual = describeActual(env);
+		return yield* Effect.fail(new BindingValidationError({
+			binding,
+			expected: "WorkerEnvironment object",
+			actual,
+			message: `Cloudflare binding "${binding}" failed validation. Expected WorkerEnvironment object; got ${actual}`
+		}));
+	}
+	const resource = Reflect.get(env, binding);
+	if (resource === void 0) return yield* Effect.fail(new BindingNotFoundError({
+		binding,
+		message: `Cloudflare binding "${binding}" was not found in WorkerEnvironment`
+	}));
+	if (!isResource(resource)) {
+		const expected = options?.expected ?? defaultExpected;
+		const actual = describeActual(resource);
+		return yield* Effect.fail(new BindingValidationError({
+			binding,
+			expected,
+			actual,
+			message: `Cloudflare binding "${binding}" failed validation. Expected ${expected}; got ${actual}`
+		}));
+	}
+	return resource;
+});
+const layer$20 = (tag, binding, isResource, wrap, options) => Layer.effect(tag, Effect.gen(function* () {
+	const env = yield* WorkerEnvironment;
+	const resource = yield* getBinding(env, binding, isResource, options);
+	return wrap === void 0 ? resource : wrap(resource);
+}));
+const Service$2 = () => (id, binding, isResource, wrap, options) => {
+	const tag = Context.Service()(id);
+	const serviceLayer = layer$20(tag, binding, isResource, wrap, options);
+	return Object.assign(tag, {
+		[TypeId$3]: TypeId$3,
+		binding,
+		layer: serviceLayer
+	});
+};
+//#endregion
 //#region src/WorkersAi.ts
 var WorkersAi_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$17,
+	Tag: () => Tag$18,
 	WorkersAiOperationError: () => WorkersAiOperationError,
 	embeddingResponse: () => embeddingResponse,
 	isWorkersAiBinding: () => isWorkersAiBinding,
-	layer: () => layer$18,
-	make: () => make$17,
-	makeClient: () => makeClient$14
+	layer: () => layer$19,
+	make: () => make$18,
+	makeClient: () => makeClient$15
 });
 const expectedWorkersAiBinding = "Workers AI binding with run(), gateway(), and models()";
 /** Error raised when a Workers AI operation fails. */
@@ -41,7 +165,7 @@ const embeddingResponse = (value) => ({
 	data: value.data ?? [],
 	shape: value.shape ?? []
 });
-const makeClient$14 = (definition) => (ai) => {
+const makeClient$15 = (definition) => (ai) => {
 	const run = ((model, input, options) => tryWorkersAiPromise(definition.binding, "run", () => ai.run(model, input, options)));
 	return {
 		definition,
@@ -53,11 +177,11 @@ const makeClient$14 = (definition) => (ai) => {
 		unsafeRaw: Effect.succeed(ai)
 	};
 };
-const layer$18 = (tag, definition) => layer$19(tag, definition.binding, (value) => isWorkersAiBinding(value), makeClient$14(definition), { expected: expectedWorkersAiBinding });
-const make$17 = (id) => Tag$17()(id);
-const Tag$17 = () => (id) => {
+const layer$19 = (tag, definition) => layer$20(tag, definition.binding, (value) => isWorkersAiBinding(value), makeClient$15(definition), { expected: expectedWorkersAiBinding });
+const make$18 = (id) => Tag$18()(id);
+const Tag$18 = () => (id) => {
 	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$18(tag, definition);
+	const makeLayer = (definition) => layer$19(tag, definition);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer
@@ -67,11 +191,11 @@ const Tag$17 = () => (id) => {
 //#region src/AiGateway.ts
 var AiGateway_exports = /* @__PURE__ */ __exportAll({
 	AiGatewayOperationError: () => AiGatewayOperationError,
-	Tag: () => Tag$16,
+	Tag: () => Tag$17,
 	isAiGatewayBinding: () => isAiGatewayBinding,
-	layer: () => layer$17,
-	make: () => make$16,
-	makeClient: () => makeClient$13,
+	layer: () => layer$18,
+	make: () => make$17,
+	makeClient: () => makeClient$14,
 	makeClientFromAi: () => makeClientFromAi,
 	makeHttpClient: () => makeHttpClient
 });
@@ -98,7 +222,7 @@ const providerUrl = (baseUrl, path = "") => {
 };
 const gatewayUrl = (definition) => `https://gateway.ai.cloudflare.com/v1/${definition.accountId}/${definition.gatewayId}/`;
 const isAiGatewayBinding = (value) => isWorkersAiBinding(value);
-const makeClient$13 = (definition, gateway) => ({
+const makeClient$14 = (definition, gateway) => ({
 	definition,
 	run: (data, options) => tryAiGatewayPromise(definition.binding, "run", () => gateway.run(Array.isArray(data) ? [...data] : data, options)),
 	getUrl: (provider) => tryAiGatewayPromise(definition.binding, "getUrl", () => gateway.getUrl(provider)),
@@ -115,11 +239,11 @@ const makeClientFromAi = (definition, ai) => {
 	const withGateway = (operation) => gateway.pipe(Effect.flatMap(operation));
 	return {
 		definition,
-		run: (data, options) => withGateway((raw) => makeClient$13(definition, raw).run(data, options)),
-		getUrl: (provider) => withGateway((raw) => makeClient$13(definition, raw).getUrl(provider)),
-		fetch: (options) => withGateway((raw) => makeClient$13(definition, raw).fetch(options)),
-		patchLog: (logId, data) => withGateway((raw) => makeClient$13(definition, raw).patchLog(logId, data)),
-		getLog: (logId) => withGateway((raw) => makeClient$13(definition, raw).getLog(logId)),
+		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)),
 		unsafeRaw: gateway
 	};
 };
@@ -159,11 +283,11 @@ const makeHttpClient = (definition, request = fetch) => {
 		unsafeRaw: Effect.fail(aiGatewayError(binding, "unsafeRaw", /* @__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$16 = (id) => Tag$16()(id);
-const Tag$16 = () => (id) => {
+const layer$18 = (tag, definition) => layer$20(tag, definition.binding, isAiGatewayBinding, (ai) => makeClientFromAi(definition, ai), { expected: expectedAiGatewayBinding });
+const make$17 = (id) => Tag$17()(id);
+const Tag$17 = () => (id) => {
 	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$17(tag, definition);
+	const makeLayer = (definition) => layer$18(tag, definition);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer
@@ -178,11 +302,11 @@ var AnalyticsEngine_exports = /* @__PURE__ */ __exportAll({
 	AnalyticsEngineQueryError: () => AnalyticsEngineQueryError,
 	AnalyticsEngineWriteValidationError: () => AnalyticsEngineWriteValidationError,
 	QueryTag: () => QueryTag,
-	Tag: () => Tag$15,
+	Tag: () => Tag$16,
 	isAnalyticsEngineDataset: () => isAnalyticsEngineDataset,
-	layer: () => layer$16,
-	make: () => make$15,
-	makeClient: () => makeClient$12,
+	layer: () => layer$17,
+	make: () => make$16,
+	makeClient: () => makeClient$13,
 	makeQuery: () => makeQuery,
 	makeQueryClient: () => makeQueryClient,
 	queryConfig: () => queryConfig,
@@ -194,7 +318,7 @@ var AnalyticsEngine_exports = /* @__PURE__ */ __exportAll({
 });
 const expectedAnalyticsEngineDataset = "Analytics Engine dataset binding with writeDataPoint()";
 const defaultQueryApiBaseUrl = "https://api.cloudflare.com/client/v4";
-const textEncoder = new TextEncoder();
+const textEncoder$1 = new TextEncoder();
 const writeLimits = {
 	maxBlobs: 20,
 	maxDoubles: 20,
@@ -260,9 +384,9 @@ const resolveWritePolicy = (defaults, options) => ({
 });
 const fieldPath = (prefix, field) => prefix === "" ? field : `${prefix}.${field}`;
 const indexedPath = (prefix, field, index) => `${fieldPath(prefix, field)}[${index}]`;
-const byteLength = (value) => {
+const byteLength$1 = (value) => {
 	if (value === null) return 0;
-	return typeof value === "string" ? textEncoder.encode(value).byteLength : value.byteLength;
+	return typeof value === "string" ? textEncoder$1.encode(value).byteLength : value.byteLength;
 };
 const lengthViolation = (path, label, actual, limit) => ({
 	path,
@@ -276,11 +400,11 @@ const validateDataPointLimits = (dataPoint, pathPrefix = "") => {
 	if (dataPoint.doubles !== void 0 && dataPoint.doubles.length > writeLimits.maxDoubles) violations.push(lengthViolation(fieldPath(pathPrefix, "doubles"), "doubles", dataPoint.doubles.length, writeLimits.maxDoubles));
 	if (dataPoint.indexes !== void 0 && dataPoint.indexes.length > writeLimits.maxIndexes) violations.push(lengthViolation(fieldPath(pathPrefix, "indexes"), "indexes", dataPoint.indexes.length, writeLimits.maxIndexes));
 	if (dataPoint.blobs !== void 0) {
-		const blobBytes = dataPoint.blobs.reduce((total, value) => total + byteLength(value), 0);
+		const blobBytes = dataPoint.blobs.reduce((total, value) => total + byteLength$1(value), 0);
 		if (blobBytes > writeLimits.maxBlobBytes) violations.push(lengthViolation(fieldPath(pathPrefix, "blobs"), "blob bytes", blobBytes, writeLimits.maxBlobBytes));
 	}
 	if (dataPoint.indexes !== void 0) for (let index = 0; index < dataPoint.indexes.length; index++) {
-		const indexBytes = byteLength(dataPoint.indexes[index] ?? null);
+		const indexBytes = byteLength$1(dataPoint.indexes[index] ?? null);
 		if (indexBytes > writeLimits.maxIndexBytes) violations.push(lengthViolation(indexedPath(pathPrefix, "indexes", index), "index bytes", indexBytes, writeLimits.maxIndexBytes));
 	}
 	return violations;
@@ -295,7 +419,8 @@ const toAnalyticsEngineDataPoint = (dataPoint) => ({
 	...dataPoint.blobs === void 0 ? {} : { blobs: [...dataPoint.blobs] }
 });
 const validateDataPoint = (binding, operation, dataPoint, pathPrefix = "") => Effect.gen(function* () {
-	const validated = toAnalyticsEngineDataPoint(yield* decodeDataPoint(dataPoint).pipe(Effect.mapError((cause) => analyticsEngineWriteValidationError(binding, operation, [schemaViolation(pathPrefix, cause)], cause))));
+	const decoded = yield* decodeDataPoint(dataPoint).pipe(Effect.mapError((cause) => analyticsEngineWriteValidationError(binding, operation, [schemaViolation(pathPrefix, cause)], cause)));
+	const validated = toAnalyticsEngineDataPoint(decoded);
 	const violations = validateDataPointLimits(validated, pathPrefix);
 	if (violations.length > 0) return yield* Effect.fail(analyticsEngineWriteValidationError(binding, operation, violations));
 	return validated;
@@ -347,7 +472,8 @@ const executeQueryRequest = (definition, httpClient, sql, options) => Effect.gen
 const makeQueryClientWith = (definition, httpClient) => {
 	const raw = (sql, options) => executeQueryRequest(definition, httpClient, sql, options);
 	const query = (sql, options) => Effect.gen(function* () {
-		return yield* decodeQueryResponse(yield* (yield* raw(sql, options)).json.pipe(Effect.catch((cause) => Effect.fail(analyticsEngineQueryError(definition, "json", "Failed to read Analytics Engine SQL API JSON response body", { cause })))));
+		const json = yield* (yield* raw(sql, options)).json.pipe(Effect.catch((cause) => Effect.fail(analyticsEngineQueryError(definition, "json", "Failed to read Analytics Engine SQL API JSON response body", { cause }))));
+		return yield* decodeQueryResponse(json);
 	});
 	const queryResult = (row, sql, options) => Effect.gen(function* () {
 		const result = yield* query(sql, options);
@@ -375,7 +501,7 @@ const isAnalyticsEngineDataset = (value) => {
 	if (typeof value !== "object" || value === null) return false;
 	return typeof Reflect.get(value, "writeDataPoint") === "function";
 };
-const makeClient$12 = (definition, defaults) => (dataset) => {
+const makeClient$13 = (definition, defaults) => (dataset) => {
 	const writeDataPoint = (dataPoint, options) => {
 		const policy = resolveWritePolicy(defaults, options);
 		return validateOptionalDataPoint(definition.binding, "writeDataPoint", dataPoint).pipe(Effect.matchEffect({
@@ -407,15 +533,16 @@ const queryConfig = (options) => Config.all({
 const queryLayer = (tag, definition) => Layer.effect(tag, makeQueryClient(definition));
 const queryFetchLayer = (tag, definition) => queryLayer(tag, definition).pipe(Layer.provide(FetchHttpClient.layer));
 const queryLayerConfig = (tag, config = queryConfig()) => Layer.effect(tag, Effect.gen(function* () {
-	return yield* makeQueryClient(yield* config);
+	const definition = yield* config;
+	return yield* makeQueryClient(definition);
 }));
 const queryFetchLayerConfig = (tag, config = queryConfig()) => queryLayerConfig(tag, config).pipe(Layer.provide(FetchHttpClient.layer));
-const layer$16 = (tag, definition) => layer$19(tag, definition.binding, isAnalyticsEngineDataset, makeClient$12(definition, definition.write), { expected: expectedAnalyticsEngineDataset });
-const make$15 = (id) => Tag$15()(id);
+const layer$17 = (tag, definition) => layer$20(tag, definition.binding, isAnalyticsEngineDataset, makeClient$13(definition, definition.write), { expected: expectedAnalyticsEngineDataset });
+const make$16 = (id) => Tag$16()(id);
 const makeQuery = (id) => QueryTag()(id);
-const Tag$15 = () => (id) => {
+const Tag$16 = () => (id) => {
 	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$16(tag, definition);
+	const makeLayer = (definition) => layer$17(tag, definition);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer
@@ -439,11 +566,11 @@ const QueryTag = () => (id) => {
 //#region src/BrowserRendering.ts
 var BrowserRendering_exports = /* @__PURE__ */ __exportAll({
 	BrowserRenderingOperationError: () => BrowserRenderingOperationError,
-	Tag: () => Tag$14,
+	Tag: () => Tag$15,
 	isBrowserRenderingBinding: () => isBrowserRenderingBinding,
-	layer: () => layer$15,
-	make: () => make$14,
-	makeClient: () => makeClient$11
+	layer: () => layer$16,
+	make: () => make$15,
+	makeClient: () => makeClient$12
 });
 const expectedBrowserRenderingBinding = "Browser Rendering binding resource";
 /** Error raised when a Browser Rendering operation fails. */
@@ -480,17 +607,17 @@ const wrapBrowser = (binding, browser) => ({
 	disconnect: browser.disconnect === void 0 ? Effect.void : tryBrowserRenderingSync(binding, "disconnect", () => browser.disconnect())
 });
 const isBrowserRenderingBinding = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
-const makeClient$11 = (definition) => (binding) => ({
+const makeClient$12 = (definition) => (binding) => ({
 	definition,
 	launchWith: (launch, options) => tryBrowserRenderingPromise(definition.binding, "launch", () => launch(binding, options)).pipe(Effect.map((browser) => wrapBrowser(definition.binding, browser))),
 	connectWith: (connect, options) => tryBrowserRenderingPromise(definition.binding, "connect", () => connect(binding, options)).pipe(Effect.map((browser) => wrapBrowser(definition.binding, browser))),
 	unsafeRaw: Effect.succeed(binding)
 });
-const layer$15 = (tag, definition) => layer$19(tag, definition.binding, isBrowserRenderingBinding, makeClient$11(definition), { expected: expectedBrowserRenderingBinding });
-const make$14 = (id) => Tag$14()(id);
-const Tag$14 = () => (id) => {
+const layer$16 = (tag, definition) => layer$20(tag, definition.binding, isBrowserRenderingBinding, makeClient$12(definition), { expected: expectedBrowserRenderingBinding });
+const make$15 = (id) => Tag$15()(id);
+const Tag$15 = () => (id) => {
 	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$15(tag, definition);
+	const makeLayer = (definition) => layer$16(tag, definition);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer
@@ -501,10 +628,10 @@ const Tag$14 = () => (id) => {
 var Cache_exports = /* @__PURE__ */ __exportAll({
 	CacheOperationError: () => CacheOperationError,
 	CacheStorage: () => CacheStorage,
-	layer: () => layer$14,
+	layer: () => layer$15,
 	layerFrom: () => layerFrom,
 	makeCacheClient: () => makeCacheClient,
-	makeClient: () => makeClient$10
+	makeClient: () => makeClient$11
 });
 /** Error raised when a Cloudflare Cache API operation fails. */
 var CacheOperationError = class extends Data.TaggedError("CacheOperationError") {};
@@ -528,15 +655,15 @@ const makeCacheClient = (cache, name = "default") => ({
 	unsafeRaw: Effect.succeed(cache)
 });
 /** Wraps a native Cloudflare `CacheStorage` instance. */
-const makeClient$10 = (storage) => ({
+const makeClient$11 = (storage) => ({
 	default: makeCacheClient(storage.default),
 	open: (name) => tryCachePromise(name, "open", () => storage.open(name)).pipe(Effect.map((cache) => makeCacheClient(cache, name))),
 	unsafeRaw: Effect.succeed(storage)
 });
 /** Provides Cache API services from an explicit native `CacheStorage` instance. */
-const layerFrom = (storage) => Layer.succeed(CacheStorage, makeClient$10(storage));
+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$10(caches));
+const layer$15 = Layer.sync(CacheStorage, () => makeClient$11(caches));
 //#endregion
 //#region src/DurableObjectStorage.ts
 var DurableObjectStorage_exports = /* @__PURE__ */ __exportAll({
@@ -745,7 +872,7 @@ const attachment = (schema) => {
 	})), Effect.flatMap((encoded) => socket.serializeAttachment(encoded)));
 	const deserialize = (socket) => Effect.gen(function* () {
 		const value = yield* socket.deserializeAttachment;
-		if (value == null) return Option.none();
+		if (value === null || value === void 0) return Option.none();
 		return Option.some(yield* Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError((cause) => new DurableWebSocketAttachmentError({
 			operation: "deserialize",
 			cause
@@ -830,7 +957,7 @@ const runPromiseExitPreservingTypedFailures = async (effect) => {
 //#region src/CloudflareOtlp.ts
 var CloudflareOtlp_exports = /* @__PURE__ */ __exportAll({
 	durableObjectLayer: () => durableObjectLayer,
-	layer: () => layer$13,
+	layer: () => layer$14,
 	layerJson: () => layerJson,
 	layerProtobuf: () => layerProtobuf,
 	workerLayer: () => workerLayer
@@ -857,8 +984,8 @@ 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) => {
-	if (layers.length === 0) return Layer.empty;
 	let merged = layers[0];
 	for (let index = 1; index < layers.length; index++) merged = Layer.mergeAll(merged, layers[index]);
 	return merged;
@@ -882,6 +1009,7 @@ const makeLayer = (options = {}, runtimeAttributes = {}) => {
 		resource,
 		headers: options.headers
 	}));
+	if (layers.length === 0) return Layer.empty;
 	return mergeSignalLayers(layers).pipe(Layer.provide(cloudflareConfigProviderLayer), Layer.provide(serializationLayer(options.serialization)), Layer.provide(FetchHttpClient.layer));
 };
 /**
@@ -892,14 +1020,14 @@ const makeLayer = (options = {}, runtimeAttributes = {}) => {
 * installed as the primary `ConfigProvider`; outside Cloudflare, the ambient
 * Effect `ConfigProvider` remains the fallback.
 */
-const layer$13 = (options = {}) => makeLayer(options);
+const layer$14 = (options = {}) => makeLayer(options);
 /** Base OTLP telemetry layer forced to JSON serialization. */
-const layerJson = (options = {}) => layer$13({
+const layerJson = (options = {}) => layer$14({
 	...options,
 	serialization: "json"
 });
 /** Base OTLP telemetry layer forced to protobuf serialization. */
-const layerProtobuf = (options = {}) => layer$13({
+const layerProtobuf = (options = {}) => layer$14({
 	...options,
 	serialization: "protobuf"
 });
@@ -931,11 +1059,11 @@ var ContainerNamespace_exports = /* @__PURE__ */ __exportAll({
 	ContainerNamespace: () => ContainerNamespace,
 	ContainerOperationError: () => ContainerOperationError,
 	ContainerState: () => ContainerState,
-	Tag: () => Tag$13,
+	Tag: () => Tag$14,
 	isContainerNamespaceResource: () => isContainerNamespaceResource,
-	layer: () => layer$12,
-	make: () => make$13,
-	makeClient: () => makeClient$9
+	layer: () => layer$13,
+	make: () => make$14,
+	makeClient: () => makeClient$10
 });
 const expectedContainerNamespace = "Container namespace binding with getByName()";
 /** Serializable state reported by a Cloudflare Container instance. */
@@ -978,7 +1106,7 @@ const makeInstanceClient = (definition, instance, stub) => ({
 	destroy: tryContainerPromise(definition, instance, "destroy", () => stub.destroy())
 });
 const isContainerNamespaceResource = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "getByName") === "function";
-const makeClient$9 = (definition) => (namespace) => {
+const makeClient$10 = (definition) => (namespace) => {
 	const getByName = (name, options) => Effect.try({
 		try: () => makeInstanceClient(definition, name, namespace.getByName(name, options)),
 		catch: (cause) => new ContainerOperationError({
@@ -1007,12 +1135,12 @@ const makeClient$9 = (definition) => (namespace) => {
 		unsafeRaw: Effect.succeed(namespace)
 	};
 };
-const layer$12 = (tag, definition) => layer$19(tag, definition.binding, isContainerNamespaceResource, makeClient$9(definition), { expected: expectedContainerNamespace });
-const make$13 = (id) => Tag$13()(id);
+const layer$13 = (tag, definition) => layer$20(tag, definition.binding, isContainerNamespaceResource, makeClient$10(definition), { expected: expectedContainerNamespace });
+const make$14 = (id) => Tag$14()(id);
 /** Creates a typed Effect service for a Cloudflare Container namespace. */
-const Tag$13 = () => (id) => {
+const Tag$14 = () => (id) => {
 	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$12(tag, definition);
+	const makeLayer = (definition) => layer$13(tag, definition);
 	const getByName = (name, options) => Effect.gen(function* () {
 		return yield* (yield* tag).getByName(name, options);
 	});
@@ -1036,12 +1164,12 @@ const Tag$13 = () => (id) => {
 		unsafeRaw
 	});
 };
-const ContainerNamespace = Tag$13;
+const ContainerNamespace = Tag$14;
 //#endregion
 //#region src/D1.ts
 var D1_exports = /* @__PURE__ */ __exportAll({
 	Service: () => Service$1,
-	make: () => make$12
+	make: () => make$13
 });
 const TypeId$2 = "effect-cf/D1";
 const expectedD1Database = "D1 database binding with prepare(), batch(), and exec()";
@@ -1053,7 +1181,7 @@ const isD1Database = (value) => {
 /**
 * Creates a typed D1 service tag plus Effect helpers.
 */
-const make$12 = (id, definition) => Service$1()(id, definition);
+const make$13 = (id, definition) => Service$1()(id, definition);
 /**
 * Builds a D1 service around a Cloudflare D1 database binding.
 *
@@ -1089,8 +1217,8 @@ const Service$1 = () => (id, definition) => {
 var QueueBinding_exports = /* @__PURE__ */ __exportAll({
 	QueueOperationError: () => QueueOperationError,
 	isQueue: () => isQueue,
-	layer: () => layer$11,
-	makeClient: () => makeClient$8
+	layer: () => layer$12,
+	makeClient: () => makeClient$9
 });
 const expectedQueueProducer = "Queue producer binding with send(); optional sendBatch()/metrics()";
 var QueueOperationError = class extends Data.TaggedError("QueueOperationError") {};
@@ -1107,7 +1235,7 @@ const isQueue = (value) => {
 	if (typeof value !== "object" || value === null) return false;
 	return typeof value.send === "function";
 };
-const makeClient$8 = (definition) => {
+const makeClient$9 = (definition) => {
 	const encodeMessage = Schema.encodeEffect(definition.message);
 	return (queue) => ({
 		send: Effect.fnUntraced(function* (message, options) {
@@ -1145,30 +1273,30 @@ const makeClient$8 = (definition) => {
 		unsafeRaw: Effect.succeed(queue)
 	});
 };
-const layer$11 = (tag, definition) => layer$19(tag, definition.binding, (value) => isQueue(value), makeClient$8(definition), { expected: expectedQueueProducer });
+const layer$12 = (tag, definition) => layer$20(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$12,
+	Tag: () => Tag$13,
 	implement: () => implement$7,
-	make: () => make$11
+	make: () => make$12
 });
 const makeDefinition$4 = (id, definition) => {
 	const queueDefinition = {
 		id,
 		message: definition.message
 	};
-	return Object.assign(queueDefinition, { make: (layer, options) => make$8(layer, {
+	return Object.assign(queueDefinition, { make: (layer, options) => make$9(layer, {
 		...options,
 		queue: wrapHandler$1(queueDefinition, options.queue)
 	}) });
 };
-const make$11 = (id, definition) => Tag$12()(id, definition);
-const Tag$12 = () => (id, definition) => {
+const make$12 = (id, definition) => Tag$13()(id, definition);
+const Tag$13 = () => (id, definition) => {
 	const queueDefinition = makeDefinition$4(id, definition);
 	const tag = Context.Service()(id);
-	const layer = (binding) => layer$11(tag, {
+	const layer = (binding) => layer$12(tag, {
 		...binding,
 		message: definition.message
 	});
@@ -1195,7 +1323,7 @@ const Tag$12 = () => (id, definition) => {
 		unsafeRaw
 	});
 };
-const Queue$1 = Tag$12;
+const Queue$1 = Tag$13;
 const wrapHandler$1 = (definition, handler) => {
 	const decodeBody = Schema.decodeUnknownEffect(definition.message);
 	return (batch) => Effect.gen(function* () {
@@ -1207,7 +1335,7 @@ const implement$7 = (_definition, handler) => handler;
 //#region src/Queue.ts
 var Queue_exports = /* @__PURE__ */ __exportAll({
 	QueueMessageDecodeError: () => QueueMessageDecodeError,
-	Tag: () => Tag$11,
+	Tag: () => Tag$12,
 	decodeBatch: () => decodeBatch,
 	fromMessage: () => fromMessage,
 	fromMessageBatch: () => fromMessageBatch,
@@ -1245,7 +1373,7 @@ const decodeBatch = (batch, decodeBody) => Effect.gen(function* () {
 	}
 	return fromMessageBatch(batch, messages);
 });
-const Tag$11 = Tag$12;
+const Tag$12 = Tag$13;
 const implement$6 = implement$7;
 //#endregion
 //#region src/RpcDefinition.ts
@@ -1263,7 +1391,7 @@ var RpcDefinition_exports = /* @__PURE__ */ __exportAll({
 	decodeSuccess: () => decodeSuccess,
 	encodeArgs: () => encodeArgs,
 	encodeSuccess: () => encodeSuccess,
-	make: () => make$10,
+	make: () => make$11,
 	method: () => method$4,
 	reservedMethodNames: () => reservedMethodNames$4
 });
@@ -1273,7 +1401,7 @@ var RpcArgumentDecodeError = class extends Data.TaggedError("RpcArgumentDecodeEr
 var RpcArgumentEncodeError = class extends Data.TaggedError("RpcArgumentEncodeError") {};
 var RpcSuccessDecodeError = class extends Data.TaggedError("RpcSuccessDecodeError") {};
 var RpcSuccessEncodeError = class extends Data.TaggedError("RpcSuccessEncodeError") {};
-const reservedMethodNames$4 = new Set([
+const reservedMethodNames$4 = /* @__PURE__ */ new Set([
 	"constructor",
 	"fetch",
 	"connect",
@@ -1366,7 +1494,7 @@ const decodeSuccess = (definition, methodName, value) => {
 		cause
 	})));
 };
-const make$10 = (id, methods) => {
+const make$11 = (id, methods) => {
 	const definition = {
 		id,
 		methods
@@ -1424,8 +1552,8 @@ var ServiceBinding_exports = /* @__PURE__ */ __exportAll({
 	ServiceBindingFetchError: () => ServiceBindingFetchError,
 	ServiceBindingRpcError: () => ServiceBindingRpcError,
 	isServiceBindingClient: () => isServiceBindingClient,
-	layer: () => layer$10,
-	makeClient: () => makeClient$7,
+	layer: () => layer$11,
+	makeClient: () => makeClient$8,
 	makeDirectMethods: () => makeDirectMethods$1
 });
 const TypeId$1 = "effect-cf/ServiceBinding";
@@ -1439,7 +1567,7 @@ var ServiceBindingFetchError = class extends Data.TaggedError("ServiceBindingFet
 */
 var ServiceBindingRpcError = class extends Data.TaggedError("ServiceBindingRpcError") {};
 const isServiceBindingClient = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "fetch") === "function";
-const makeClient$7 = (definition) => {
+const makeClient$8 = (definition) => {
 	return (service) => {
 		const fetch = (input, init) => Effect.tryPromise({
 			try: () => service.fetch(input, init),
@@ -1450,11 +1578,12 @@ const makeClient$7 = (definition) => {
 		});
 		const rpc = (method, ...args) => Effect.gen(function* () {
 			const methodName = String(method);
-			return yield* invokeRpcMethod(service, method, definition.definition === void 0 ? args : yield* encodeArgs(definition.definition, methodName, args).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
+			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
-			}))), (cause) => new ServiceBindingRpcError({
+			})));
+			return yield* invokeRpcMethod(service, method, encodedArgs, (cause) => new ServiceBindingRpcError({
 				binding: definition.binding,
 				method: methodName,
 				cause
@@ -1470,14 +1599,18 @@ const makeClient$7 = (definition) => {
 		});
 		const call = (method, ...args) => Effect.gen(function* () {
 			const methodName = String(method);
-			return yield* decodeSuccess$2(methodName, yield* resolve(yield* rpc(method, ...args)).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
+			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);
 		});
 		const scopedCall = (method, ...args) => Effect.gen(function* () {
-			return yield* decodeSuccess$2(String(method), yield* scoped(yield* rpc(method, ...args)));
+			const methodName = String(method);
+			const result = yield* rpc(method, ...args);
+			const value = yield* scoped(result);
+			return yield* decodeSuccess$2(methodName, value);
 		});
 		const directMethods = makeDirectMethods$1(definition.definition, call);
 		return Object.assign(directMethods, {
@@ -1488,7 +1621,7 @@ const makeClient$7 = (definition) => {
 		});
 	};
 };
-const layer$10 = (tag, definition) => layer$19(tag, definition.binding, (value) => isServiceBindingClient(value), makeClient$7(definition), { expected: expectedServiceBinding });
+const layer$11 = (tag, definition) => layer$20(tag, definition.binding, (value) => isServiceBindingClient(value), makeClient$8(definition), { expected: expectedServiceBinding });
 /**
 * Creates a typed Effect service for a Worker service binding.
 *
@@ -1519,7 +1652,7 @@ const layer$10 = (tag, definition) => layer$19(tag, definition.binding, (value)
 * ```
 */
 const Service = () => (id, definition) => {
-	const tag = Service$2()(id, definition.binding, (value) => isServiceBindingClient(value), makeClient$7(definition));
+	const tag = Service$2()(id, definition.binding, (value) => isServiceBindingClient(value), makeClient$8(definition));
 	const fetch = (input, init) => Effect.gen(function* () {
 		return yield* (yield* tag).fetch(input, init);
 	});
@@ -1550,13 +1683,13 @@ const makeDirectMethods$1 = (rpcDefinition, call) => {
 //#endregion
 //#region src/WorkerDefinition.ts
 var WorkerDefinition_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$10,
+	Tag: () => Tag$11,
 	Worker: () => Worker,
 	implement: () => implement$5,
-	make: () => make$9,
+	make: () => make$10,
 	method: () => method$3
 });
-const reservedMethodNames$3 = new Set([
+const reservedMethodNames$3 = /* @__PURE__ */ new Set([
 	"constructor",
 	"dup",
 	"fetch",
@@ -1591,21 +1724,21 @@ const method$3 = method$4;
 */
 const makeDefinition$3 = (id, methods) => {
 	assertNoReservedMethods("Worker", methods, reservedMethodNames$3);
-	const definition = make$10(id, methods);
-	return Object.assign(definition, { make: (layer, options) => make$8(layer, {
+	const definition = make$11(id, methods);
+	return Object.assign(definition, { make: (layer, options) => make$9(layer, {
 		...options,
 		rpc: wrapHandlers$1(definition, options.rpc)
 	}) });
 };
-const make$9 = (id, methods) => Tag$10()(id, methods);
-const Tag$10 = () => (id, methods) => {
+const make$10 = (id, methods) => Tag$11()(id, methods);
+const Tag$11 = () => (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 layer = (binding) => layer$11(tag, bindingDefinition(binding));
 	const fetch = (input, init) => Effect.gen(function* () {
 		return yield* (yield* tag).fetch(input, init);
 	});
@@ -1630,13 +1763,15 @@ const Tag$10 = () => (id, methods) => {
 		scopedCall
 	});
 };
-const Worker = Tag$10;
+const Worker = Tag$11;
 const wrapHandlers$1 = (definition, handlers) => {
 	const wrapped = {};
 	for (const key of Object.keys(definition.methods)) {
 		const handler = handlers[key];
 		wrapped[key] = (...args) => Effect.gen(function* () {
-			return yield* encodeSuccess(definition, key, yield* handler(...yield* decodeArgs(definition, key, args)));
+			const decodedArgs = yield* decodeArgs(definition, key, args);
+			const value = yield* handler(...decodedArgs);
+			return yield* encodeSuccess(definition, key, value);
 		});
 	}
 	return wrapped;
@@ -1654,6 +1789,8 @@ const clock = {
 	currentTimeMillis: Effect.sync(() => clock.currentTimeMillisUnsafe()),
 	currentTimeNanosUnsafe: () => BigInt(Date.now()) * nanosPerMilli,
 	currentTimeNanos: Effect.sync(() => clock.currentTimeNanosUnsafe()),
+	monotonicTimeNanosUnsafe: () => typeof performance === "undefined" ? BigInt(Date.now()) * nanosPerMilli : BigInt(Math.round(performance.now() * 1e6)),
+	monotonicTimeNanos: Effect.sync(() => clock.monotonicTimeNanosUnsafe()),
 	sleep: (duration) => {
 		const millis = Duration.toMillis(duration);
 		if (millis <= 0) return Effect.yieldNow;
@@ -1664,7 +1801,7 @@ const clock = {
 		});
 	}
 };
-const layer$9 = Layer.effect(Clock.Clock, Effect.succeed(clock));
+const layer$10 = Layer.effect(Clock.Clock, Effect.succeed(clock));
 //#endregion
 //#region src/internal/Entrypoint.ts
 const provideEntrypointServices = (layer, services) => layer.pipe(Layer.provideMerge(services));
@@ -1706,11 +1843,11 @@ const fromExecutionContext = (ctx, runPromiseExit) => {
 var Worker_exports = /* @__PURE__ */ __exportAll({
 	ExecutionContext: () => ExecutionContext,
 	NativeRequest: () => NativeRequest,
-	Tag: () => Tag$9,
+	Tag: () => Tag$10,
 	WorkerContext: () => WorkerContext,
 	implement: () => implement$4,
 	isWebSocketUpgrade: () => isWebSocketUpgrade,
-	make: () => make$8,
+	make: () => make$9,
 	makeFetchHandler: () => makeFetchHandler,
 	method: () => method$2,
 	renderHttpResponse: () => renderHttpResponse
@@ -1719,7 +1856,7 @@ var ExecutionContext = class extends Context.Service()("effect-cf/ExecutionConte
 var WorkerContext = class extends Context.Service()("effect-cf/WorkerContext") {};
 var NativeRequest = class extends Context.Service()("effect-cf/NativeRequest") {};
 const isWebSocketUpgrade = (request) => request.headers.get("Upgrade")?.toLowerCase() === "websocket";
-const reservedMethodNames$2 = new Set([
+const reservedMethodNames$2 = /* @__PURE__ */ new Set([
 	"constructor",
 	"dup",
 	"fetch",
@@ -1737,16 +1874,37 @@ const reservedMethodNames$2 = new Set([
 ]);
 const RunSymbol$1 = Symbol.for("effect-cf/Worker/run");
 const renderHttpResponse = (effect) => Effect.flatMap(effect, (response) => Effect.map(Effect.context(), (context) => HttpServerResponse.toWeb(response, { context })));
-const renderFetchSuccess = (effect) => Effect.flatMap(effect, (response) => response instanceof Response ? Effect.succeed(response) : Effect.map(Effect.context(), (context) => HttpServerResponse.toWeb(response, { context })));
+const renderFetchSuccess = (effect) => Effect.suspend(() => {
+	let nativeResponse;
+	let webResponse;
+	const handled = HttpEffect.toHandled(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) => {
+		webResponse = HttpServerResponse.toWeb(HttpEffect.scopeTransferToStream(response), {
+			withoutBody: request.method === "HEAD",
+			context
+		});
+	}));
+	const captured = () => nativeResponse ?? webResponse ?? new Response(null, { status: 500 });
+	return Effect.matchCause(handled, {
+		onFailure: captured,
+		onSuccess: captured
+	});
+});
 const isWorkerOptions = (options) => typeof options === "object" && options !== null && ("eventLayer" in options || "fetch" in options || "queue" in options || "rpc" in options);
-function make$8(layer, optionsOrFetch) {
+function make$9(layer, optionsOrFetch) {
 	const options = isWorkerOptions(optionsOrFetch) ? optionsOrFetch : { fetch: optionsOrFetch };
 	class EffectWorker extends WorkerEntrypoint {
 		runtime;
 		constructor(ctx, env) {
 			super(ctx, env);
 			let runWaitUntilEffect = () => Promise.reject(/* @__PURE__ */ new Error("WorkerContext runtime is not initialized"));
-			const runtimeLayer = provideEntrypointServices(layer, Layer.mergeAll(layer$9, Layer.succeed(ExecutionContext, ctx), ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env))), Layer.succeed(WorkerContext, fromExecutionContext(ctx, (effect) => runWaitUntilEffect(effect))), Layer.succeed(WorkerEnvironment, env)));
+			const services = Layer.mergeAll(layer$10, Layer.succeed(ExecutionContext, ctx), ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env))), Layer.succeed(WorkerContext, fromExecutionContext(ctx, (effect) => runWaitUntilEffect(effect))), Layer.succeed(WorkerEnvironment, env));
+			const runtimeLayer = provideEntrypointServices(layer, services);
 			this.runtime = ManagedRuntime.make(runtimeLayer);
 			runWaitUntilEffect = (effect) => this.runtime.runPromiseExit(effect);
 		}
@@ -1771,10 +1929,10 @@ function make$8(layer, optionsOrFetch) {
 	return assumeEntrypointClass(EffectWorker);
 }
 const makeFetchHandler = (layer, options) => {
-	const WorkerClass = make$8(layer, options);
+	const WorkerClass = make$9(layer, options);
 	return { fetch: (request, env, ctx) => Promise.resolve(new WorkerClass(ctx, env).fetch(request)) };
 };
-const Tag$9 = Tag$10;
+const Tag$10 = Tag$11;
 const method$2 = method$3;
 const implement$4 = implement$5;
 //#endregion
@@ -1783,8 +1941,8 @@ var DurableObjectNamespace_exports = /* @__PURE__ */ __exportAll({
 	DurableObjectFetchError: () => DurableObjectFetchError,
 	DurableObjectRpcError: () => DurableObjectRpcError,
 	isDurableObjectNamespaceClient: () => isDurableObjectNamespaceClient,
-	layer: () => layer$8,
-	makeClient: () => makeClient$6,
+	layer: () => layer$9,
+	makeClient: () => makeClient$7,
 	makeDirectMethods: () => makeDirectMethods
 });
 const expectedDurableObjectNamespace = "Durable Object namespace binding with getByName(), get(), idFromName(), idFromString(), newUniqueId(), and jurisdiction()";
@@ -1798,7 +1956,7 @@ var DurableObjectRpcError = class extends Data.TaggedError("DurableObjectRpcErro
 var DurableObjectFetchError = class extends Data.TaggedError("DurableObjectFetchError") {};
 const hasFunction$2 = (value, key) => typeof Reflect.get(value, key) === "function";
 const isDurableObjectNamespaceClient = (value) => typeof value === "object" && value !== null && hasFunction$2(value, "getByName") && hasFunction$2(value, "get") && hasFunction$2(value, "idFromName") && hasFunction$2(value, "idFromString") && hasFunction$2(value, "newUniqueId") && hasFunction$2(value, "jurisdiction");
-const makeClient$6 = (definition) => {
+const makeClient$7 = (definition) => {
 	return (namespace) => {
 		const newUniqueId = (options) => Effect.sync(() => namespace.newUniqueId(options));
 		const idFromName = (name) => Effect.sync(() => namespace.idFromName(name));
@@ -1815,11 +1973,12 @@ const makeClient$6 = (definition) => {
 		});
 		const rpc = (stub, method, ...args) => Effect.gen(function* () {
 			const methodName = String(method);
-			return yield* invokeRpcMethod(stub, method, definition.definition === void 0 ? args : yield* encodeArgs(definition.definition, methodName, args).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+			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
-			}))), (cause) => new DurableObjectRpcError({
+			})));
+			return yield* invokeRpcMethod(stub, method, encodedArgs, (cause) => new DurableObjectRpcError({
 				binding: definition.binding,
 				method: methodName,
 				cause
@@ -1835,14 +1994,18 @@ const makeClient$6 = (definition) => {
 		});
 		const call = (stub, method, ...args) => Effect.gen(function* () {
 			const methodName = String(method);
-			return yield* decodeSuccess$1(methodName, yield* resolve(yield* rpc(stub, method, ...args)).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+			const value = yield* resolve(yield* rpc(stub, method, ...args)).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
 				binding: definition.binding,
 				method: methodName,
 				cause
-			}))));
+			})));
+			return yield* decodeSuccess$1(methodName, value);
 		});
 		const scopedCall = (stub, method, ...args) => Effect.gen(function* () {
-			return yield* decodeSuccess$1(String(method), yield* scoped(yield* rpc(stub, method, ...args)));
+			const methodName = String(method);
+			const result = yield* rpc(stub, method, ...args);
+			const value = yield* scoped(result);
+			return yield* decodeSuccess$1(methodName, value);
 		});
 		const directMethods = makeDirectMethods(definition.definition, {
 			call,
@@ -1865,7 +2028,7 @@ const makeClient$6 = (definition) => {
 		});
 	};
 };
-const layer$8 = (tag, definition) => layer$19(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$6(definition), { expected: expectedDurableObjectNamespace });
+const layer$9 = (tag, definition) => layer$20(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$7(definition), { expected: expectedDurableObjectNamespace });
 const makeDirectMethods = (rpcDefinition, helpers) => {
 	const methods = {};
 	if (rpcDefinition !== void 0) {
@@ -1890,12 +2053,12 @@ const makeDirectMethods = (rpcDefinition, helpers) => {
 //#region src/DurableObjectDefinition.ts
 var DurableObjectDefinition_exports = /* @__PURE__ */ __exportAll({
 	DurableObject: () => DurableObject$1,
-	Tag: () => Tag$8,
+	Tag: () => Tag$9,
 	implement: () => implement$3,
-	make: () => make$7,
+	make: () => make$8,
 	method: () => method$1
 });
-const reservedMethodNames$1 = new Set([
+const reservedMethodNames$1 = /* @__PURE__ */ new Set([
 	"constructor",
 	"dup",
 	"fetch",
@@ -1923,21 +2086,21 @@ const method$1 = method$4;
 */
 const makeDefinition$2 = (id, methods) => {
 	assertNoReservedMethods("Durable Object", methods, reservedMethodNames$1);
-	const definition = make$10(id, methods);
-	return Object.assign(definition, { make: (layer, options) => make$6(layer, {
+	const definition = make$11(id, methods);
+	return Object.assign(definition, { make: (layer, options) => make$7(layer, {
 		...options,
 		rpc: wrapHandlers(definition, options.rpc)
 	}) });
 };
-const make$7 = (id, methods) => Tag$8()(id, methods);
-const Tag$8 = () => (id, methods) => {
+const make$8 = (id, methods) => Tag$9()(id, methods);
+const Tag$9 = () => (id, methods) => {
 	const definition = makeDefinition$2(id, methods);
 	const tag = Context.Service()(id);
 	const bindingDefinition = (binding) => ({
 		...binding,
 		definition
 	});
-	const layer = (binding) => layer$8(tag, bindingDefinition(binding));
+	const layer = (binding) => layer$9(tag, bindingDefinition(binding));
 	const newUniqueId = Effect.fnUntraced(function* (options) {
 		return yield* (yield* tag).newUniqueId(options);
 	});
@@ -1995,13 +2158,15 @@ const Tag$8 = () => (id, methods) => {
 		unsafeRaw
 	});
 };
-const DurableObject$1 = Tag$8;
+const DurableObject$1 = Tag$9;
 const wrapHandlers = (definition, handlers) => {
 	const wrapped = {};
 	for (const key of Object.keys(definition.methods)) {
 		const handler = handlers[key];
 		wrapped[key] = (...args) => Effect.gen(function* () {
-			return yield* encodeSuccess(definition, key, yield* handler(...yield* decodeArgs(definition, key, args)));
+			const decodedArgs = yield* decodeArgs(definition, key, args);
+			const value = yield* handler(...decodedArgs);
+			return yield* encodeSuccess(definition, key, value);
 		});
 	}
 	return wrapped;
@@ -2013,12 +2178,12 @@ const implement$3 = (_definition, handlers) => handlers;
 //#endregion
 //#region src/DurableObject.ts
 var DurableObject_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$7,
+	Tag: () => Tag$8,
 	implement: () => implement$2,
-	make: () => make$6,
+	make: () => make$7,
 	method: () => method
 });
-const reservedMethodNames = new Set([
+const reservedMethodNames = /* @__PURE__ */ new Set([
 	"constructor",
 	"dup",
 	"fetch",
@@ -2031,12 +2196,13 @@ const RunSymbol = Symbol.for("effect-cf/DurableObject/run");
 /**
 * Creates a Durable Object class backed by a single managed Effect runtime.
 */
-const make$6 = (layer, options = {}) => {
+const make$7 = (layer, options = {}) => {
 	class EffectDurableObject extends DurableObject {
 		runtime;
 		constructor(state, env) {
 			super(state, env);
-			const runtimeLayer = provideEntrypointServices(layer, Layer.mergeAll(layer$9, ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env))), Layer.succeed(DurableObjectState, fromDurableObjectState(state)), Layer.succeed(WorkerEnvironment, env)));
+			const services = Layer.mergeAll(layer$10, ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env))), Layer.succeed(DurableObjectState, fromDurableObjectState(state)), Layer.succeed(WorkerEnvironment, env));
+			const runtimeLayer = provideEntrypointServices(layer, services);
 			this.runtime = ManagedRuntime.make(runtimeLayer);
 			const initialize = options.initialize;
 			if (initialize !== void 0) state.waitUntil(this[RunSymbol](initialize, { eventLayer: false }));
@@ -2073,7 +2239,7 @@ const make$6 = (layer, options = {}) => {
 	defineEntrypointRpcMethods("Durable Object", EffectDurableObject.prototype, options.rpc, reservedMethodNames, (self, effect) => self[RunSymbol](effect));
 	return assumeEntrypointClass(EffectDurableObject);
 };
-const Tag$7 = Tag$8;
+const Tag$8 = Tag$9;
 const method = method$1;
 const implement$2 = implement$3;
 //#endregion
@@ -2360,7 +2526,8 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 				const actionMode = failureAction === void 0 ? mode : getFailureActionMode(failureAction);
 				if (actionMode === "retry" || actionMode === "isolated") {
 					const actionRetryDelay = failureAction === void 0 ? void 0 : getFailureActionRetryDelay(failureAction);
-					yield* rescheduleFailedAlarm(row, actionRetryDelay === void 0 ? yield* getFailureRetryDelay(options) : yield* toFailureRescheduleMillis(actionRetryDelay));
+					const retryDelay = actionRetryDelay === void 0 ? yield* getFailureRetryDelay(options) : yield* toFailureRescheduleMillis(actionRetryDelay);
+					yield* rescheduleFailedAlarm(row, retryDelay);
 					return "continue";
 				}
 				if (actionMode === "skip-and-advance-repeat") {
@@ -2402,7 +2569,7 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 //#region src/DurableObjectRpcWebSocket.ts
 var DurableObjectRpcWebSocket_exports = /* @__PURE__ */ __exportAll({
 	DurableObjectRpcWebSocket: () => DurableObjectRpcWebSocket,
-	layer: () => layer$7
+	layer: () => layer$8
 });
 const defaultAttachmentKey = "effectCloudflareRpcClientId";
 const defaultTag = "effect-cf-rpc";
@@ -2413,7 +2580,7 @@ var DurableObjectRpcWebSocket = class extends Context.Service()("effect-cf/Durab
 /**
 * Builds a layer that bridges Durable Object websocket events to `RpcServer.Protocol`.
 */
-const layer$7 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
+const layer$8 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 	const tag = options.tag ?? defaultTag;
 	const attachmentKey = options.attachmentKey ?? defaultAttachmentKey;
 	const durableObjectState = yield* DurableObjectState;
@@ -2501,7 +2668,8 @@ const layer$7 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 			}
 			for (const current of decoded) yield* run(connection.id, current);
 		}).pipe(Effect.catch((error) => {
-			return send(register(socket), error);
+			const connection = register(socket);
+			return send(connection, error);
 		})),
 		close: unregister,
 		error: (socket, error) => Effect.gen(function* () {
@@ -2526,7 +2694,7 @@ const writeAttachment = (socket, key, clientId) => {
 };
 //#endregion
 //#region src/DurableObjectSqlite.ts
-var DurableObjectSqlite_exports = /* @__PURE__ */ __exportAll({ layer: () => layer$6 });
+var DurableObjectSqlite_exports = /* @__PURE__ */ __exportAll({ layer: () => layer$7 });
 /**
 * Provides `effect/unstable/sql` from the current Durable Object SQLite storage.
 *
@@ -2538,7 +2706,7 @@ var DurableObjectSqlite_exports = /* @__PURE__ */ __exportAll({ layer: () => lay
 * );
 * ```
 */
-const layer$6 = (options) => Layer.unwrap(Effect.gen(function* () {
+const layer$7 = (options) => Layer.unwrap(Effect.gen(function* () {
 	const state = yield* DurableObjectState;
 	return SqliteClient.layer({
 		...options,
@@ -2549,38 +2717,269 @@ const layer$6 = (options) => Layer.unwrap(Effect.gen(function* () {
 //#region src/Email.ts
 var Email_exports = /* @__PURE__ */ __exportAll({
 	EmailOperationError: () => EmailOperationError,
-	Tag: () => Tag$6,
+	EmailValidationError: () => EmailValidationError,
+	Tag: () => Tag$7,
+	emailErrorCodes: () => emailErrorCodes,
 	isEmailBinding: () => isEmailBinding,
-	layer: () => layer$5,
-	make: () => make$5,
-	makeClient: () => makeClient$5
+	isEmailMessageBuilder: () => isEmailMessageBuilder,
+	layer: () => layer$6,
+	make: () => make$6,
+	makeClient: () => makeClient$6,
+	sendLimits: () => sendLimits,
+	validateMessage: () => validateMessage
 });
 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
+};
+/** Error codes reported by Cloudflare Email Sending. */
+const emailErrorCodes = [
+	"E_VALIDATION_ERROR",
+	"E_FIELD_MISSING",
+	"E_TOO_MANY_RECIPIENTS",
+	"E_TOO_MANY_ATTACHMENTS",
+	"E_SENDER_NOT_VERIFIED",
+	"E_RECIPIENT_NOT_ALLOWED",
+	"E_RECIPIENT_SUPPRESSED",
+	"E_SENDER_DOMAIN_NOT_AVAILABLE",
+	"E_CONTENT_TOO_LARGE",
+	"E_DELIVERY_FAILED",
+	"E_RATE_LIMIT_EXCEEDED",
+	"E_DAILY_LIMIT_EXCEEDED",
+	"E_INTERNAL_SERVER_ERROR",
+	"E_HEADER_NOT_ALLOWED",
+	"E_HEADER_USE_API_FIELD",
+	"E_HEADER_VALUE_INVALID",
+	"E_HEADER_VALUE_TOO_LONG",
+	"E_HEADER_NAME_INVALID",
+	"E_HEADERS_TOO_LARGE",
+	"E_HEADERS_TOO_MANY"
+];
 /** Error raised when a Cloudflare Send Email operation fails. */
 var EmailOperationError = class extends Data.TaggedError("EmailOperationError") {};
+/** Error raised when a message violates documented Cloudflare Email Sending limits. */
+var EmailValidationError = class extends Data.TaggedError("EmailValidationError") {};
+const emailErrorCode = (cause) => {
+	if (typeof cause !== "object" || cause === null) return;
+	const code = Reflect.get(cause, "code");
+	return typeof code === "string" ? code : void 0;
+};
 const emailError = (binding, operation, cause) => new EmailOperationError({
 	binding,
 	operation,
-	cause
+	cause,
+	code: emailErrorCode(cause)
+});
+const emailValidationError = (binding, operation, violations) => new EmailValidationError({
+	binding,
+	operation,
+	violations
 });
 const tryEmailPromise = (binding, operation, evaluate) => Effect.tryPromise({
 	try: evaluate,
 	catch: (cause) => emailError(binding, operation, cause)
 });
+const builderFields = [
+	"subject",
+	"html",
+	"text",
+	"cc",
+	"bcc",
+	"replyTo",
+	"attachments",
+	"headers"
+];
+/**
+* Distinguishes structured Email Sending messages from raw MIME `EmailMessage`
+* values, which only carry envelope `from` and `to` addresses.
+*/
+const isEmailMessageBuilder = (message) => {
+	if (typeof message !== "object" || message === null) return false;
+	return builderFields.some((field) => Reflect.get(message, field) !== void 0);
+};
+const byteLength = (value) => textEncoder.encode(value).byteLength;
+const limitViolation = (path, label, actual, limit) => ({
+	path,
+	message: `${label} exceeds Cloudflare Email Sending limit`,
+	actual,
+	limit
+});
+const addressList = (value) => {
+	if (value === void 0) return [];
+	return Array.isArray(value) ? value : [value];
+};
+const addressViolations = (path, value) => {
+	if (typeof value === "string") return value.includes("@") ? [] : [{
+		path,
+		message: "Email address must contain an @ symbol"
+	}];
+	if (typeof value !== "object" || value === null) return [{
+		path,
+		message: "Email address must be a string or { name, email } object"
+	}];
+	const email = Reflect.get(value, "email");
+	if (typeof email !== "string" || !email.includes("@")) return [{
+		path: `${path}.email`,
+		message: "Email address must contain an @ symbol"
+	}];
+	return [];
+};
+const recipientViolations = (field, value) => addressList(value).flatMap((address, index) => addressViolations(`${field}[${index}]`, address));
+const attachmentViolations = (attachments) => {
+	const violations = [];
+	if (attachments.length > sendLimits.maxAttachments) violations.push(limitViolation("attachments", "attachments", attachments.length, sendLimits.maxAttachments));
+	for (let index = 0; index < attachments.length; index++) {
+		const attachment = attachments[index];
+		const path = `attachments[${index}]`;
+		if (typeof attachment !== "object" || attachment === null) {
+			violations.push({
+				path,
+				message: "Attachment must be an object"
+			});
+			continue;
+		}
+		if (typeof attachment.filename !== "string" || attachment.filename === "") violations.push({
+			path: `${path}.filename`,
+			message: "Attachment filename is required"
+		});
+		if (typeof attachment.type !== "string" || attachment.type === "") violations.push({
+			path: `${path}.type`,
+			message: "Attachment MIME type is required"
+		});
+		if (attachment.content === void 0 || attachment.content === null) violations.push({
+			path: `${path}.content`,
+			message: "Attachment content is required"
+		});
+		if (attachment.disposition === "inline" && typeof attachment.contentId !== "string") violations.push({
+			path: `${path}.contentId`,
+			message: "Inline attachments require a contentId"
+		});
+	}
+	return violations;
+};
+const headerViolations = (headers) => {
+	const violations = [];
+	const entries = Object.entries(headers);
+	let totalBytes = 0;
+	let allowlistHeaders = 0;
+	for (const [name, value] of entries) {
+		const path = `headers["${name}"]`;
+		const nameBytes = byteLength(name);
+		if (nameBytes > sendLimits.maxHeaderNameBytes) violations.push(limitViolation(path, "header name bytes", nameBytes, sendLimits.maxHeaderNameBytes));
+		if (typeof value !== "string") {
+			violations.push({
+				path,
+				message: "Header value must be a string"
+			});
+			continue;
+		}
+		const valueBytes = byteLength(value);
+		if (valueBytes > sendLimits.maxHeaderValueBytes) violations.push(limitViolation(path, "header value bytes", valueBytes, sendLimits.maxHeaderValueBytes));
+		totalBytes += nameBytes + valueBytes;
+		if (!name.toLowerCase().startsWith("x-")) allowlistHeaders += 1;
+	}
+	if (totalBytes > sendLimits.maxHeadersBytes) violations.push(limitViolation("headers", "header bytes", totalBytes, sendLimits.maxHeadersBytes));
+	if (allowlistHeaders > sendLimits.maxAllowlistHeaders) violations.push(limitViolation("headers", "allowlisted custom headers", allowlistHeaders, sendLimits.maxAllowlistHeaders));
+	return violations;
+};
+/**
+* Validates a structured message against documented Cloudflare Email Sending
+* limits and returns every violation found. Total message size is not checked
+* because the encoded MIME size is only known once Cloudflare composes it.
+*/
+const validateMessage = (message) => {
+	const violations = [];
+	const fields = message;
+	if (fields.from === void 0) violations.push({
+		path: "from",
+		message: "A from address is required"
+	});
+	else violations.push(...addressViolations("from", fields.from));
+	if (fields.replyTo !== void 0) violations.push(...addressViolations("replyTo", fields.replyTo));
+	if (typeof fields.subject !== "string" || fields.subject === "") violations.push({
+		path: "subject",
+		message: "A subject is required"
+	});
+	if (typeof fields.text !== "string" && typeof fields.html !== "string") violations.push({
+		path: "$",
+		message: "A message requires either text or html content"
+	});
+	const recipients = addressList(fields.to).length + addressList(fields.cc).length + addressList(fields.bcc).length;
+	if (recipients === 0) violations.push({
+		path: "$",
+		message: "A message requires at least one to, cc, or bcc address"
+	});
+	if (recipients > sendLimits.maxRecipients) violations.push(limitViolation("$", "combined to, cc, and bcc addresses", recipients, sendLimits.maxRecipients));
+	violations.push(...recipientViolations("to", fields.to));
+	violations.push(...recipientViolations("cc", fields.cc));
+	violations.push(...recipientViolations("bcc", fields.bcc));
+	if (fields.attachments !== void 0) violations.push(...attachmentViolations(fields.attachments));
+	if (fields.headers !== void 0) violations.push(...headerViolations(fields.headers));
+	return violations;
+};
+const validateSendInput = (binding, operation, message) => {
+	const violations = validateMessage(message);
+	return violations.length > 0 ? Effect.fail(emailValidationError(binding, operation, violations)) : Effect.succeed(message);
+};
 const isEmailBinding = (value) => {
 	if (typeof value !== "object" || value === null) return false;
 	return typeof value.send === "function";
 };
-const makeClient$5 = (definition) => (email) => {
+const makeClient$6 = (definition, options) => (email) => {
 	const runtime = email;
-	const send = ((message) => tryEmailPromise(definition.binding, "send", () => runtime.send(message)));
+	const validate = options?.validate ?? true;
+	const send = ((message) => {
+		const dispatch = () => tryEmailPromise(definition.binding, "send", () => runtime.send(message));
+		if (!validate || !isEmailMessageBuilder(message)) return dispatch();
+		return validateSendInput(definition.binding, "send", message).pipe(Effect.flatMap(dispatch));
+	});
 	return {
 		definition,
 		send,
 		unsafeRaw: Effect.succeed(email)
 	};
 };
-const layer$5 = (tag, definition) => layer$19(tag, definition.binding, isEmailBinding, makeClient$5(definition), { expected: expectedSendEmailBinding });
+const layer$6 = (tag, definition) => layer$20(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);
+	const makeLayer = (definition) => layer$6(tag, definition);
+	return Object.assign(tag, {
+		id,
+		layer: makeLayer
+	});
+};
+//#endregion
+//#region src/Hyperdrive.ts
+var Hyperdrive_exports = /* @__PURE__ */ __exportAll({
+	Tag: () => Tag$6,
+	isHyperdrive: () => isHyperdrive,
+	layer: () => layer$5,
+	make: () => make$5,
+	makeClient: () => makeClient$5
+});
+const expectedHyperdrive = "Hyperdrive binding with connectionString";
+const isHyperdrive = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	return typeof value.connectionString === "string";
+};
+const makeClient$5 = (definition) => (hyperdrive) => ({
+	definition,
+	connectionString: hyperdrive.connectionString,
+	unsafeRaw: Effect.succeed(hyperdrive)
+});
+const layer$5 = (tag, definition) => layer$20(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);
@@ -2687,7 +3086,7 @@ const makeClient$4 = (definition) => (images) => {
 		unsafeRaw: 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$20(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);
@@ -2709,7 +3108,7 @@ var Kv_exports = /* @__PURE__ */ __exportAll({
 const expectedKvNamespace = "KV namespace binding with get(), put(), delete(), getWithMetadata(), and list()";
 /** Error raised when a KV operation fails. */
 var KvOperationError = class extends Data.TaggedError("KvOperationError") {};
-const maybeString = (value) => value == null ? Option.none() : Option.some(value);
+const maybeString = (value) => value === null || value === void 0 ? Option.none() : Option.some(value);
 const maybeNumber = (value) => value === void 0 ? Option.none() : Option.some(value);
 const kvError = (binding, operation, cause) => new KvOperationError({
 	binding,
@@ -2782,7 +3181,7 @@ const makeClient$3 = (definition) => {
 		unsafeRaw: 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$20(tag, definition.binding, isKvNamespace, makeClient$3(definition), { expected: expectedKvNamespace });
 const makeDefinition$1 = (id, definition) => {
 	const kvDefinition = {
 		id,
@@ -2899,7 +3298,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$20(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);
@@ -2956,7 +3355,7 @@ const makeClient$1 = (definition) => {
 				return {
 					status: status.status,
 					output,
-					error: status.error == null ? Option.none() : Option.some(status.error)
+					error: status.error === null || status.error === void 0 ? Option.none() : Option.some(status.error)
 				};
 			}))),
 			sendEvent: (event) => operation("sendEvent", () => raw.sendEvent(event))
@@ -2965,10 +3364,11 @@ const makeClient$1 = (definition) => {
 	return (workflow) => ({
 		create: Effect.fnUntraced(function* (payload, options) {
 			const encoded = yield* encodePayload(payload);
-			return wrapInstance(yield* tryWorkflowPromise(definition.binding, "create", () => workflow.create({
+			const raw = yield* tryWorkflowPromise(definition.binding, "create", () => workflow.create({
 				...options,
 				params: encoded
-			})));
+			}));
+			return wrapInstance(raw);
 		}),
 		createBatch: Effect.fnUntraced(function* (batch) {
 			const encodedBatch = [];
@@ -2985,7 +3385,7 @@ const makeClient$1 = (definition) => {
 		unsafeRaw: Effect.succeed(workflow)
 	});
 };
-const layer$1 = (tag, definition) => layer$19(tag, definition.binding, (value) => isWorkflow(value), makeClient$1(definition), { expected: expectedWorkflow });
+const layer$1 = (tag, definition) => layer$20(tag, definition.binding, (value) => isWorkflow(value), makeClient$1(definition), { expected: expectedWorkflow });
 //#endregion
 //#region src/WorkflowDefinition.ts
 var WorkflowDefinition_exports = /* @__PURE__ */ __exportAll({
@@ -3045,7 +3445,8 @@ const wrapHandler = (definition, handler) => {
 			...yield* WorkflowEvent$1,
 			payload: decodedPayload
 		};
-		return yield* encodeResult(yield* handler(decodedPayload).pipe(Effect.provideService(WorkflowEvent$1, decodedEvent)));
+		const result = yield* handler(decodedPayload).pipe(Effect.provideService(WorkflowEvent$1, decodedEvent));
+		return yield* encodeResult(result);
 	});
 };
 const implement$1 = (_definition, handler) => handler;
@@ -3102,7 +3503,8 @@ const make$1 = (layer, options) => {
 		constructor(ctx, env) {
 			super(ctx, env);
 			let runWaitUntilEffect = () => Promise.reject(/* @__PURE__ */ new Error("WorkerContext runtime is not initialized"));
-			const runtimeLayer = provideEntrypointServices(layer, Layer.mergeAll(Layer.succeed(ExecutionContext, ctx), ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env))), Layer.succeed(WorkerContext, fromExecutionContext(ctx, (effect) => runWaitUntilEffect(effect))), Layer.succeed(WorkerEnvironment, env)));
+			const services = Layer.mergeAll(Layer.succeed(ExecutionContext, ctx), ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env))), Layer.succeed(WorkerContext, fromExecutionContext(ctx, (effect) => runWaitUntilEffect(effect))), Layer.succeed(WorkerEnvironment, env));
+			const runtimeLayer = provideEntrypointServices(layer, services);
 			this.runtime = ManagedRuntime.make(runtimeLayer);
 			runWaitUntilEffect = (effect) => this.runtime.runPromiseExit(effect);
 		}
@@ -3159,7 +3561,7 @@ const makeClient = (definition) => (index) => {
 		unsafeRaw: Effect.succeed(index)
 	};
 };
-const layer = (tag, definition) => layer$19(tag, definition.binding, isVectorizeBinding, makeClient(definition), { expected: expectedVectorizeBinding });
+const layer = (tag, definition) => layer$20(tag, definition.binding, isVectorizeBinding, makeClient(definition), { expected: expectedVectorizeBinding });
 const make = (id) => Tag()(id);
 const Tag = () => (id) => {
 	const tag = Context.Service()(id);