effect-cf 0.27.0 → 0.28.1

package/dist/index.mjs

@@ -1,8 +1,8 @@
 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-_lg53p3W.mjs";
-import { a as layer$19, i as Service$2, n as Artifacts_exports, r as Binding_exports } from "./Artifacts-BhWrdyqX.mjs";
-import { a as DurableObjectWebSocket_exports, i as fromExecutionContext, n as DurableObjectState_exports, o as fromWebSocket, r as fromDurableObjectState, s as DurableObjectStorage_exports, t as DurableObjectState } from "./DurableObjectState-Dux8KfjG.mjs";
-import { Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Function, Layer, ManagedRuntime, Option, Predicate, Queue, Result, Schema } from "effect";
+import { a as WorkerEnvironment, i as WorkerConfig, n as violationsMessage, r as Environment_exports, t as causeMessage } from "./ErrorMessage-BM0K-Nik.mjs";
+import { a as layer$19, i as Service$2, n as Artifacts_exports, r as Binding_exports } from "./Artifacts-rq3hUKQE.mjs";
+import { a as DurableObjectWebSocket_exports, i as fromExecutionContext, n as DurableObjectState_exports, o as fromWebSocket, r as fromDurableObjectState, s as DurableObjectStorage_exports, t as DurableObjectState } from "./DurableObjectState-BjkK2kwH.mjs";
+import { Cause, Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Function as Function$1, Layer, ManagedRuntime, Option, Predicate, Queue, Result, Schema } from "effect";
 import { FetchHttpClient, HttpClient, HttpClientRequest, HttpEffect, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import { OtlpExporter, OtlpLogger, OtlpMetrics, OtlpSerialization, OtlpTracer } from "effect/unstable/observability";
 import { D1Client } from "@effect/sql-d1";
@@ -11,6 +11,7 @@ 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";
+import { NonRetryableError } from "cloudflare:workflows";
 //#region src/WorkersAi.ts
 var WorkersAi_exports = /* @__PURE__ */ __exportAll({
 	Tag: () => Tag$16,
@@ -28,6 +29,7 @@ var WorkersAiOperationError = class extends Data.TaggedError("WorkersAiOperation
 		return `Workers AI ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
 	}
 };
+const embeddingDimensionsKey = "shape";
 const workersAiError = (binding, operation, cause) => new WorkersAiOperationError({
 	binding,
 	operation,
@@ -41,19 +43,31 @@ const tryWorkersAiSync = (binding, operation, evaluate) => Effect.try({
 	try: evaluate,
 	catch: (cause) => workersAiError(binding, operation, cause)
 });
-const hasFunction$3 = (value, key) => typeof Reflect.get(value, key) === "function";
-const isWorkersAiBinding = (value) => typeof value === "object" && value !== null && hasFunction$3(value, "run") && hasFunction$3(value, "gateway") && hasFunction$3(value, "models");
+const WorkersAiBindingSchema = Schema.declare((value) => Predicate.hasProperty(value, "run") && Predicate.isFunction(value.run) && Predicate.hasProperty(value, "gateway") && Predicate.isFunction(value.gateway) && Predicate.hasProperty(value, "models") && Predicate.isFunction(value.models));
+const decodeWorkersAiBinding = Schema.decodeUnknownOption(WorkersAiBindingSchema);
+const isWorkersAiBinding = (value) => Option.isSome(decodeWorkersAiBinding(value));
 const embeddingResponse = (value) => ({
 	data: value.data ?? [],
-	shape: value.shape ?? []
+	[embeddingDimensionsKey]: value[embeddingDimensionsKey] ?? []
 });
+const decodeEmbeddingResponse = Schema.decodeUnknownOption(Schema.Struct({
+	data: Schema.optional(Schema.Array(Schema.Array(Schema.Number))),
+	[embeddingDimensionsKey]: Schema.optional(Schema.Array(Schema.Number))
+}));
 const makeClient$15 = (definition) => (ai) => {
-	const run = Effect.fn("WorkersAi.run")((model, input, options) => tryWorkersAiPromise(definition.binding, "run", () => ai.run(model, input, options)));
+	const run = Effect.fn("WorkersAi.run")((model, input, options) => tryWorkersAiPromise(definition.binding, "run", () => {
+		return ai.run(model, input, options);
+	}));
 	return {
 		definition,
 		aiGatewayLogId: tryWorkersAiSync(definition.binding, "aiGatewayLogId", () => ai.aiGatewayLogId),
 		run,
-		runEmbedding: Effect.fn("WorkersAi.runEmbedding")((model, input, options) => run(model, input, options).pipe(Effect.map((response) => embeddingResponse(response)))),
+		runEmbedding: Effect.fn("WorkersAi.runEmbedding")((model, input, options) => {
+			return run(model, input, options).pipe(Effect.map((response) => Option.match(decodeEmbeddingResponse(response), {
+				onNone: () => embeddingResponse({}),
+				onSome: embeddingResponse
+			})));
+		}),
 		models: Effect.fn("WorkersAi.models")((params) => tryWorkersAiPromise(definition.binding, "models", () => ai.models(params))),
 		gateway: (gatewayId) => tryWorkersAiSync(definition.binding, "gateway", () => ai.gateway(gatewayId)),
 		rawUnsafe: Effect.succeed(ai)
@@ -88,6 +102,49 @@ var AiGatewayOperationError = class extends Data.TaggedError("AiGatewayOperation
 		return `AI Gateway ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
 	}
 };
+const AiGatewayMetadata = Schema.Record(Schema.String, Schema.Union([
+	Schema.String,
+	Schema.Number,
+	Schema.Boolean,
+	Schema.Null
+]));
+const AiGatewayHttpMetadata = Schema.Union([AiGatewayMetadata, Schema.fromJsonString(AiGatewayMetadata)]);
+const AiGatewayLogResponse = Schema.Struct({
+	success: Schema.Literal(true),
+	result: Schema.Struct({
+		id: Schema.String,
+		provider: Schema.String,
+		model: Schema.String,
+		model_type: Schema.optional(Schema.String),
+		path: Schema.String,
+		duration: Schema.Number,
+		request_type: Schema.optional(Schema.String),
+		request_content_type: Schema.optional(Schema.String),
+		status_code: Schema.Number,
+		response_content_type: Schema.optional(Schema.String),
+		success: Schema.Boolean,
+		cached: Schema.Boolean,
+		tokens_in: Schema.optional(Schema.Number),
+		tokens_out: Schema.optional(Schema.Number),
+		metadata: Schema.optional(AiGatewayHttpMetadata),
+		step: Schema.optional(Schema.Number),
+		cost: Schema.optional(Schema.Number),
+		custom_cost: Schema.optional(Schema.Boolean),
+		request_size: Schema.Number,
+		request_head: Schema.optional(Schema.String),
+		request_head_complete: Schema.Boolean,
+		response_size: Schema.Number,
+		response_head: Schema.optional(Schema.String),
+		response_head_complete: Schema.Boolean,
+		created_at: Schema.DateFromString
+	})
+});
+const AiGatewayPatchLogResponse = Schema.Struct({
+	success: Schema.Literal(true),
+	result: Schema.Unknown
+});
+const decodeAiGatewayLogResponse = Schema.decodeUnknownPromise(AiGatewayLogResponse);
+const decodeAiGatewayPatchLogResponse = Schema.decodeUnknownPromise(AiGatewayPatchLogResponse);
 const aiGatewayError = (binding, operation, cause) => new AiGatewayOperationError({
 	binding,
 	operation,
@@ -108,6 +165,9 @@ const providerUrl = (baseUrl, path = "") => {
 	return normalizedPath === "" ? url : new URL(normalizedPath, url);
 };
 const gatewayUrl = (definition) => `https://gateway.ai.cloudflare.com/v1/${definition.accountId}/${definition.gatewayId}/`;
+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) => ({
 	definition,
@@ -165,14 +225,20 @@ const makeHttpClient = (definition, request = fetch) => {
 			...options.init,
 			signal: mergeAbortSignals(options.init?.signal, signal)
 		}))))),
-		patchLog: Effect.fn("AiGateway.patchLog")((logId, data) => tryAiGatewayPromise(binding, "patchLog", (signal) => request(providerUrl(gatewayUrl(definition), `logs/${logId}`).href, {
-			method: "PATCH",
-			body: JSON.stringify(data),
-			headers: { "content-type": "application/json" },
-			signal
-		}).then(() => void 0))),
+		patchLog: Effect.fn("AiGateway.patchLog")((logId, data) => tryAiGatewayPromise(binding, "patchLog", async (signal) => {
+			const response = await request(providerUrl(gatewayUrl(definition), `logs/${logId}`).href, {
+				method: "PATCH",
+				body: JSON.stringify(data),
+				headers: { "content-type": "application/json" },
+				signal
+			});
+			ensureSuccessfulResponse(response);
+			await decodeAiGatewayPatchLogResponse(await response.json());
+		})),
 		getLog: Effect.fn("AiGateway.getLog")((logId) => tryAiGatewayPromise(binding, "getLog", async (signal) => {
-			return await (await request(providerUrl(gatewayUrl(definition), `logs/${logId}`).href, { signal })).json();
+			const response = await request(providerUrl(gatewayUrl(definition), `logs/${logId}`).href, { signal });
+			ensureSuccessfulResponse(response);
+			return (await decodeAiGatewayLogResponse(await response.json())).result;
 		})),
 		rawUnsafe: Effect.fail(aiGatewayError(binding, "rawUnsafe", /* @__PURE__ */ new TypeError("HTTP AI Gateway clients have no raw binding")))
 	};
@@ -281,7 +347,7 @@ const fieldPath = (prefix, field) => prefix === "" ? field : `${prefix}.${field}
 const indexedPath = (prefix, field, index) => `${fieldPath(prefix, field)}[${index}]`;
 const byteLength$1 = (value) => {
 	if (value === null) return 0;
-	return typeof value === "string" ? textEncoder$1.encode(value).byteLength : value.byteLength;
+	return Predicate.isString(value) ? textEncoder$1.encode(value).byteLength : value.byteLength;
 };
 const lengthViolation = (path, label, actual, limit) => ({
 	path,
@@ -308,11 +374,13 @@ const schemaViolation = (pathPrefix, cause) => ({
 	path: pathPrefix === "" ? "$" : pathPrefix,
 	message: cause.message
 });
-const toAnalyticsEngineDataPoint = (dataPoint) => ({
-	...dataPoint.indexes === void 0 ? {} : { indexes: [...dataPoint.indexes] },
-	...dataPoint.doubles === void 0 ? {} : { doubles: [...dataPoint.doubles] },
-	...dataPoint.blobs === void 0 ? {} : { blobs: [...dataPoint.blobs] }
-});
+const toAnalyticsEngineDataPoint = (dataPoint) => {
+	const result = {};
+	if (dataPoint.indexes !== void 0) result.indexes = [...dataPoint.indexes];
+	if (dataPoint.doubles !== void 0) result.doubles = [...dataPoint.doubles];
+	if (dataPoint.blobs !== void 0) result.blobs = [...dataPoint.blobs];
+	return result;
+};
 const validateDataPoint = (binding, operation, dataPoint, pathPrefix = "") => Effect.gen(function* () {
 	const decoded = yield* decodeDataPoint(dataPoint).pipe(Effect.mapError((cause) => analyticsEngineWriteValidationError(binding, operation, [schemaViolation(pathPrefix, cause)], cause)));
 	const validated = toAnalyticsEngineDataPoint(decoded);
@@ -387,10 +455,7 @@ const makeQueryClientWith = (definition, httpClient) => {
 	};
 };
 const makeQueryClient = (definition) => Effect.map(HttpClient.HttpClient, (httpClient) => makeQueryClientWith(definition, httpClient));
-const isAnalyticsEngineDataset = (value) => {
-	if (typeof value !== "object" || value === null) return false;
-	return typeof Reflect.get(value, "writeDataPoint") === "function";
-};
+const isAnalyticsEngineDataset = (value) => Predicate.hasProperty(value, "writeDataPoint") && Predicate.isFunction(value.writeDataPoint);
 const makeClient$13 = (definition, defaults) => (dataset) => {
 	return {
 		definition,
@@ -482,9 +547,18 @@ const wrapPage = (binding, page) => ({
 	goto: (url, options) => page.goto === void 0 ? missingMethod(binding, "goto") : tryBrowserRenderingPromise(binding, "goto", () => page.goto(url, options)),
 	setContent: (html, options) => page.setContent === void 0 ? missingMethod(binding, "setContent") : tryBrowserRenderingPromise(binding, "setContent", () => page.setContent(html, options)),
 	content: page.content === void 0 ? missingMethod(binding, "content") : tryBrowserRenderingPromise(binding, "content", () => page.content()),
-	screenshot: (options) => page.screenshot === void 0 ? missingMethod(binding, "screenshot") : tryBrowserRenderingPromise(binding, "screenshot", () => page.screenshot(options)),
-	pdf: (options) => page.pdf === void 0 ? missingMethod(binding, "pdf") : tryBrowserRenderingPromise(binding, "pdf", () => page.pdf(options)),
-	evaluate: (pageFunction, ...args) => page.evaluate === void 0 ? missingMethod(binding, "evaluate") : tryBrowserRenderingPromise(binding, "evaluate", () => page.evaluate(pageFunction, ...args)),
+	screenshot: (options) => {
+		const screenshot = page.screenshot?.bind(page);
+		return screenshot === void 0 ? missingMethod(binding, "screenshot") : tryBrowserRenderingPromise(binding, "screenshot", () => screenshot(options));
+	},
+	pdf: (options) => {
+		const pdf = page.pdf?.bind(page);
+		return pdf === void 0 ? missingMethod(binding, "pdf") : tryBrowserRenderingPromise(binding, "pdf", () => pdf(options));
+	},
+	evaluate: (pageFunction, ...args) => {
+		const evaluate = page.evaluate?.bind(page);
+		return evaluate === void 0 ? missingMethod(binding, "evaluate") : tryBrowserRenderingPromise(binding, "evaluate", () => evaluate(pageFunction, ...args));
+	},
 	close: (options) => page.close === void 0 ? Effect.void : tryBrowserRenderingPromise(binding, "closePage", () => page.close(options))
 });
 const wrapBrowser = (binding, browser) => ({
@@ -494,7 +568,7 @@ const wrapBrowser = (binding, browser) => ({
 	close: browser.close === void 0 ? Effect.void : tryBrowserRenderingPromise(binding, "closeBrowser", () => browser.close()),
 	disconnect: browser.disconnect === void 0 ? Effect.void : tryBrowserRenderingSync(binding, "disconnect", () => browser.disconnect())
 });
-const isBrowserRenderingBinding = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
+const isBrowserRenderingBinding = (value) => Predicate.isObjectOrArray(value) || Predicate.isFunction(value);
 const makeClient$12 = (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")),
@@ -569,16 +643,23 @@ const layer$14 = Layer.sync(CacheStorage, () => makeClient$11(caches));
 * telemetry on demand. Cloudflare isolates can freeze before the periodic
 * export interval fires. Effect-backed Worker fetch handlers, Worker or
 * Durable Object native RPC handlers, and Durable Object alarm handlers
-* schedule this flusher automatically.
-* Flush or scheduling failures do not replace the handler outcome and emit
-* only bounded framework diagnostics without attaching the foreign cause.
-* Other entrypoint lifecycles can flush explicitly or hand the flush to their
-* `waitUntil` mechanism:
+* schedule this flusher automatically. These automatic flushes are capped at
+* two seconds and silently discard timeouts and failures so telemetry cannot
+* extend or fail the user event, or recursively log through an unhealthy
+* exporter.
+*
+* Other entrypoint lifecycles, including queue handlers, do not flush
+* automatically. Applications can flush explicitly or hand the flush to their
+* `waitUntil` mechanism, and own the timeout and failure policy at that call
+* site:
 *
 * ```ts
 * const flusher = yield* OtlpExporter.Flusher;
 *
-* yield* flusher.flush;
+* yield* flusher.flush.pipe(
+*   Effect.timeoutOption("2 seconds"),
+*   Effect.ignoreCause,
+* );
 * ```
 */
 var CloudflareOtlp_exports = /* @__PURE__ */ __exportAll({
@@ -768,7 +849,7 @@ const makeInstanceClient = (definition, instance, stub) => {
 		removeDeniedHost: hostnameOperation("removeDeniedHost")
 	};
 };
-const isContainerNamespaceResource = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "getByName") === "function";
+const isContainerNamespaceResource = (value) => Predicate.hasProperty(value, "getByName") && Predicate.isFunction(value.getByName);
 const makeClient$10 = (definition) => (namespace) => {
 	const getByName = (name, options) => Effect.try({
 		try: () => makeInstanceClient(definition, name, namespace.getByName(name, options)),
@@ -805,7 +886,7 @@ const makeClient$10 = (definition) => (namespace) => {
 		rawUnsafe: Effect.succeed(namespace)
 	};
 };
-const layer$12 = (tag, definition) => layer$19(tag, definition.binding, isContainerNamespaceResource, makeClient$10(definition), { expected: expectedContainerNamespace });
+const layer$12 = (tag, definition) => layer$19(tag, definition.binding, (value) => isContainerNamespaceResource(value), makeClient$10(definition), { expected: expectedContainerNamespace });
 const make$14 = (id) => Tag$12()(id);
 /** Creates a typed Effect service for a Cloudflare Container namespace. */
 const Tag$12 = () => (id) => {
@@ -848,11 +929,7 @@ var D1_exports = /* @__PURE__ */ __exportAll({
 });
 const TypeId$2 = "~effect-cf/D1";
 const expectedD1Database = "D1 database binding with prepare(), batch(), and exec()";
-const isD1Database = (value) => {
-	if (typeof value !== "object" || value === null) return false;
-	const resource = value;
-	return typeof resource.prepare === "function" && typeof resource.batch === "function" && typeof resource.exec === "function";
-};
+const isD1Database = (value) => Predicate.hasProperty(value, "prepare") && Predicate.isFunction(value.prepare) && Predicate.hasProperty(value, "batch") && Predicate.isFunction(value.batch) && Predicate.hasProperty(value, "exec") && Predicate.isFunction(value.exec);
 /**
 * Creates a typed D1 service tag plus Effect helpers.
 */
@@ -906,10 +983,7 @@ const tryQueuePromise = (binding, operation, evaluate) => Effect.tryPromise({
 		message: `Cloudflare queue binding "${binding}" operation "${operation}" failed`
 	})
 });
-const isQueue = (value) => {
-	if (typeof value !== "object" || value === null) return false;
-	return typeof value.send === "function";
-};
+const isQueue = (value) => Predicate.hasProperty(value, "send") && Predicate.isFunction(value.send);
 const makeClient$9 = (definition) => {
 	const encodeMessage = Schema.encodeEffect(definition.message);
 	return (queue) => ({
@@ -1142,7 +1216,7 @@ const encodeWireError = (error) => {
 const decodeWireError = (cause) => {
 	if (!(cause instanceof Error)) return cause;
 	try {
-		const parsed = JSON.parse(cause.message);
+		const parsed = Schema.decodeUnknownSync(Schema.Unknown)(JSON.parse(cause.message));
 		if (!Predicate.hasProperty(parsed, wireErrorKey)) return cause;
 		return Schema.decodeUnknownSync(WireErrorSchema)(parsed[wireErrorKey]);
 	} catch {
@@ -1235,6 +1309,10 @@ const make$11 = (id, methods) => {
 };
 //#endregion
 //#region src/internal/Entrypoint.ts
+const invokeEntrypointRpcMethod = (self, method, args, run, onExit) => {
+	const handler = Effect.suspend(() => method(...args)).pipe(Effect.mapError(encodeWireError));
+	return run(self, onExit === void 0 ? handler : handler.pipe(Effect.onExit(() => onExit(self))));
+};
 const provideEntrypointServices = (layer, services) => layer.pipe(Layer.provideMerge(services));
 const defineEntrypointRpcMethods = (target, prototype, rpc, reservedMethodNames, run, onExit) => {
 	const methods = rpc ?? {};
@@ -1242,12 +1320,13 @@ const defineEntrypointRpcMethods = (target, prototype, rpc, reservedMethodNames,
 	for (const [key, method] of Object.entries(methods)) Object.defineProperty(prototype, key, {
 		enumerable: true,
 		value(...args) {
-			const handler = Effect.suspend(() => method(...args)).pipe(Effect.mapError(encodeWireError));
-			return run(this, onExit === void 0 ? handler : handler.pipe(Effect.onExit(() => onExit(this))));
+			return invokeEntrypointRpcMethod(this, method, args, run, onExit);
 		}
 	});
 };
-const assumeEntrypointClass = (entrypoint) => entrypoint;
+const assumeEntrypointClass = (entrypoint) => {
+	return entrypoint;
+};
 //#endregion
 //#region src/internal/Runtime.ts
 /**
@@ -1263,30 +1342,27 @@ const makeEntrypointRuntime = (layer, env, services) => {
 	const entrypointServices = Layer.mergeAll(services, ConfigProvider.layer(WorkerConfig.providerFromEnv(env)), Layer.succeed(WorkerEnvironment, env));
 	return ManagedRuntime.make(provideEntrypointServices(layer, entrypointServices));
 };
-/**
-* Runs a Cloudflare event effect on an entrypoint runtime.
-*
-* When an event layer is given it is built inside the event's Effect scope
-* (finalized when the event effect completes). The casts widen away the
-* `REvent` requirement satisfied by the event layer; TypeScript cannot reduce
-* `Exclude<...>` over the generic union.
-*/
-const runEventPromise = (runtime, effect, eventLayer) => {
-	const withEventLayer = eventLayer === void 0 ? effect : effect.pipe(Effect.provide(eventLayer, { local: true }));
-	return runtime.runPromise(Effect.scoped(withEventLayer));
-};
+function runEventPromise(...args) {
+	const [runtime, effect, eventLayer] = args;
+	if (eventLayer === void 0) return runtime.runPromise(Effect.scoped(effect));
+	return runtime.runPromise(Effect.scoped(effect.pipe(Effect.provide(eventLayer, { local: true }))));
+}
 //#endregion
 //#region src/internal/Telemetry.ts
-const logFlushFailure = Effect.logError("Telemetry flush failed").pipe(Effect.ignoreCause);
-const logFlushSchedulingFailure = Effect.logError("Telemetry flush scheduling failed").pipe(Effect.ignoreCause);
+/** 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.catchCause(() => logFlushFailure)));
-}).pipe(Effect.catchCause(() => logFlushSchedulingFailure));
+	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({
@@ -1297,25 +1373,30 @@ var Rpc_exports = /* @__PURE__ */ __exportAll({
 	resolve: () => resolve,
 	scoped: () => scoped
 });
-const isDisposable = (value) => (typeof value === "object" || typeof value === "function") && value !== null && Symbol.dispose in value && typeof value[Symbol.dispose] === "function";
+const 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) => isPromiseLike(value) ? Effect.tryPromise({
-	try: () => value,
+const resolve = (value) => Predicate.isPromiseLike(value) ? Effect.tryPromise({
+	try: () => Promise.resolve(value),
 	catch: (cause) => decodeWireError(cause)
-}) : Effect.sync(() => value);
+}) : Effect.sync(() => {
+	return value;
+});
 const scoped = (value) => Effect.acquireRelease(resolve(value), (resolved) => dispose(resolved));
-const isPromiseLike = (value) => (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
 //#endregion
 //#region src/internal/RpcInvocation.ts
-const isPropertyTarget = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
+const invokeWithReceiver = (value, receiver, args) => {
+	return Function.prototype.apply.call(value, receiver, args);
+};
 const lookupRpcMethod = (target, method, makeError) => Effect.try({
 	try: () => {
-		if (!isPropertyTarget(target)) throw new TypeError(`RPC target is not object-like`);
-		const value = Reflect.get(target, method);
-		if (typeof value !== "function") throw new TypeError(`RPC method "${String(method)}" is not callable`);
-		return ((...args) => Reflect.apply(value, target, args));
+		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
 });
@@ -1355,7 +1436,9 @@ var ServiceBindingRpcError = class extends Data.TaggedError("ServiceBindingRpcEr
 		return `Service binding "${this.binding}" RPC method "${this.method}" failed: ${causeMessage(this.cause)}`;
 	}
 };
-const isServiceBindingClient = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "fetch") === "function";
+const 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) {
@@ -1468,7 +1551,10 @@ const Service = () => (id, definition) => {
 };
 const makeDirectMethods$1 = (rpcDefinition, call) => {
 	const methods = {};
-	if (rpcDefinition !== void 0) for (const methodName of Object.keys(rpcDefinition.methods)) methods[methodName] = (...args) => call(methodName, ...args);
+	if (rpcDefinition !== void 0) {
+		const invoke = call;
+		for (const methodName of Object.keys(rpcDefinition.methods)) methods[methodName] = (...args) => invoke(methodName, ...args);
+	}
 	return methods;
 };
 //#endregion
@@ -1496,6 +1582,9 @@ const reservedMethodNames$3 = /* @__PURE__ */ new Set([
 	"webSocketClose",
 	"webSocketError"
 ]);
+const assumeTagClass = (value) => {
+	return value;
+};
 /**
 * Defines a single RPC method schema in a worker definition.
 */
@@ -1516,10 +1605,14 @@ 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) => make$9(layer, {
-		...options,
-		rpc: wrapHandlers$1(definition, options.rpc)
-	}) });
+	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) => {
@@ -1543,7 +1636,7 @@ const Tag$9 = () => (id, methods) => {
 		return yield* (yield* tag).scopedCall(method, ...args);
 	});
 	const directMethods = makeDirectMethods$1(definition, call);
-	return Object.assign(tag, directMethods, {
+	return assumeTagClass(Object.assign(tag, directMethods, {
 		id: definition.id,
 		methods: definition.methods,
 		make: definition.make,
@@ -1552,11 +1645,11 @@ const Tag$9 = () => (id, methods) => {
 		rpc,
 		call,
 		scopedCall
-	});
+	}));
 };
 const Worker = Tag$9;
 const wrapHandlers$1 = (definition, handlers) => {
-	const wrapped = {};
+	const wrapped = Object.create(null);
 	for (const key of Object.keys(definition.methods)) {
 		const handler = handlers[key];
 		wrapped[key] = (...args) => Effect.gen(function* () {
@@ -1655,7 +1748,8 @@ const isWorkerOptions = (options) => !Effect.isEffect(options);
 *
 * The flush is handed to `ctx.waitUntil` so it never delays the response
 * (including streaming bodies still being consumed). It is a no-op when the
-* context does not contain an `OtlpExporter.Flusher`.
+* context does not contain an `OtlpExporter.Flusher`. The handed-off effect is
+* best-effort and silently settles within two seconds.
 */
 const scheduleTelemetryFlush$1 = scheduleTelemetryFlush$2((flush) => Effect.flatMap(WorkerContext, (workerContext) => workerContext.waitUntil(flush)));
 function make$9(layer, optionsOrFetch) {
@@ -1666,8 +1760,10 @@ function make$9(layer, optionsOrFetch) {
 			super(ctx, env);
 			this.runtime = makeEntrypointRuntime(layer, env, Layer.mergeAll(Layer.succeed(ExecutionContext, ctx), Layer.succeed(WorkerContext, fromExecutionContext(ctx))));
 		}
-		[RunSymbol$1](effect, runOptions = {}) {
-			return runEventPromise(this.runtime, effect, runOptions.eventLayer === false ? void 0 : options.eventLayer);
+		[RunSymbol$1](effect) {
+			const eventLayer = options.eventLayer;
+			if (eventLayer === void 0) return runEventPromise(this.runtime, effect);
+			return runEventPromise(this.runtime, effect, eventLayer);
 		}
 		fetch(request) {
 			return this[FetchSymbol](request);
@@ -1689,19 +1785,8 @@ function make$9(layer, optionsOrFetch) {
 	defineEntrypointRpcMethods("Worker", EffectWorker.prototype, options.rpc, reservedMethodNames$2, (self, effect) => self[RunSymbol$1](effect), () => scheduleTelemetryFlush$1);
 	return assumeEntrypointClass(EffectWorker);
 }
-/**
-* Creates an `ExportedHandler`-compatible `{ fetch }` object backed by
-* {@link make}.
-*
-* The Effect runtime is cached per `env` identity, so the user layer builds
-* once per isolate instead of once per request. `ExecutionContext`-backed
-* services (`Worker.ExecutionContext`, `Worker.WorkerContext`) are still
-* provided fresh for every request. Layer finalizers do not run when the
-* isolate is evicted; Cloudflare provides no shutdown hook. Use `eventLayer`
-* for resources that must be finalized per event.
-*/
-const makeFetchHandler = (layer, options) => {
-	const WorkerClass = make$9(layer, options);
+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);
@@ -1711,7 +1796,7 @@ const makeFetchHandler = (layer, options) => {
 		}
 		return instance[FetchSymbol](request, ctx);
 	} };
-};
+}
 //#endregion
 //#region src/DurableObjectNamespace.ts
 var DurableObjectNamespace_exports = /* @__PURE__ */ __exportAll({
@@ -1739,8 +1824,8 @@ var DurableObjectFetchError = class extends Data.TaggedError("DurableObjectFetch
 		return `Durable Object fetch failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
 	}
 };
-const hasFunction$2 = (value, key) => typeof Reflect.get(value, key) === "function";
-const isDurableObjectNamespaceClient = (value) => typeof value === "object" && value !== null && hasFunction$2(value, "getByName") && hasFunction$2(value, "get") && hasFunction$2(value, "idFromName") && hasFunction$2(value, "idFromString") && hasFunction$2(value, "newUniqueId") && hasFunction$2(value, "jurisdiction");
+const hasFunction$1 = (value, key) => Predicate.hasProperty(value, key) && Predicate.isFunction(value[key]);
+const isDurableObjectNamespaceClient = (value) => hasFunction$1(value, "getByName") && hasFunction$1(value, "get") && hasFunction$1(value, "idFromName") && hasFunction$1(value, "idFromString") && hasFunction$1(value, "newUniqueId") && hasFunction$1(value, "jurisdiction");
 const makeClient$7 = (definition) => {
 	return (namespace) => {
 		const newUniqueId = (options) => Effect.sync(() => namespace.newUniqueId(options));
@@ -1852,10 +1937,9 @@ const reservedMethodNames$1 = /* @__PURE__ */ new Set([
 	"webSocketClose",
 	"webSocketError"
 ]);
-/**
-* Defines a single RPC method schema in a Durable Object definition.
-*/
-const method = method$2;
+function method(definition) {
+	return method$2(definition);
+}
 /**
 * Creates a Durable Object RPC definition plus implementation/binding helpers.
 *
@@ -1908,14 +1992,17 @@ const Tag$8 = () => (id, methods) => {
 	const fetch = Effect.fn("DurableObject.fetch")(function* (stub, input, init) {
 		return yield* (yield* tag).fetch(stub, input, init);
 	});
-	const rpc = Effect.fn("DurableObject.rpc")(function* (stub, method, ...args) {
-		return yield* (yield* tag).rpc(stub, method, ...args);
+	const rpc = Effect.fn("DurableObject.rpc")(function* (stub, methodName, ...args) {
+		const invokeRpc = (yield* tag).rpc;
+		return yield* invokeRpc(stub, methodName, ...args);
 	});
-	const call = Effect.fn("DurableObject.call")(function* (stub, method, ...args) {
-		return yield* (yield* tag).call(stub, method, ...args);
+	const call = Effect.fn("DurableObject.call")(function* (stub, methodName, ...args) {
+		const invokeCall = (yield* tag).call;
+		return yield* invokeCall(stub, methodName, ...args);
 	});
-	const scopedCall = Effect.fn("DurableObject.scopedCall")(function* (stub, method, ...args) {
-		return yield* (yield* tag).scopedCall(stub, method, ...args);
+	const scopedCall = Effect.fn("DurableObject.scopedCall")(function* (stub, methodName, ...args) {
+		const invokeScopedCall = (yield* tag).scopedCall;
+		return yield* invokeScopedCall(stub, methodName, ...args);
 	});
 	const rawUnsafe = Effect.fnUntraced(function* () {
 		return yield* (yield* tag).rawUnsafe;
@@ -1946,7 +2033,7 @@ const Tag$8 = () => (id, methods) => {
 };
 const DurableObject$1 = Tag$8;
 const wrapHandlers = (definition, handlers) => {
-	const wrapped = {};
+	const wrapped = Object.create(Object.prototype);
 	for (const key of Object.keys(definition.methods)) {
 		const handler = handlers[key];
 		wrapped[key] = (...args) => Effect.gen(function* () {
@@ -1993,7 +2080,9 @@ const make$7 = (layer, options = {}) => {
 			if (initialize !== void 0) state.waitUntil(this[RunSymbol](initialize, { eventLayer: false }));
 		}
 		[RunSymbol](effect, runOptions = {}) {
-			return runEventPromise(this.runtime, effect, runOptions.eventLayer === false ? void 0 : options.eventLayer);
+			const eventLayer = runOptions.eventLayer === false ? void 0 : options.eventLayer;
+			if (eventLayer === void 0) return runEventPromise(this.runtime, effect);
+			return runEventPromise(this.runtime, effect, eventLayer);
 		}
 		fetch(request) {
 			const fetchHandler = options.fetch;
@@ -2015,8 +2104,8 @@ const make$7 = (layer, options = {}) => {
 		webSocketClose(socket, code, reason, wasClean) {
 			if (options.webSocketClose !== void 0) return this[RunSymbol](options.webSocketClose(fromWebSocket(socket), code, reason, wasClean));
 		}
-		webSocketError(socket, error) {
-			if (options.webSocketError !== void 0) return this[RunSymbol](options.webSocketError(fromWebSocket(socket), error));
+		webSocketError(socket, cause) {
+			if (options.webSocketError !== void 0) return this[RunSymbol](options.webSocketError(fromWebSocket(socket), cause));
 		}
 	}
 	defineEntrypointRpcMethods("Durable Object", EffectDurableObject.prototype, options.rpc, reservedMethodNames, (self, effect) => self[RunSymbol](effect), () => scheduleTelemetryFlush);
@@ -2152,12 +2241,12 @@ const toFailureRescheduleMillis = (input) => Effect.try({
 	catch: (cause) => new InvalidProcessDueAlarmsOptionsError({ cause })
 });
 const getFailureRetryDelay = (options) => toFailureRescheduleMillis(options?.retryFailedAfter ?? DEFAULT_PROCESS_DUE_ALARMS_FAILURE_RESCHEDULE_AFTER);
-const getFailureActionMode = (action) => typeof action === "string" ? action : action.mode;
-const getFailureActionRetryDelay = (action) => typeof action === "string" || action.mode !== "retry" ? void 0 : action.retryFailedAfter;
+const getFailureActionMode = (action) => Predicate.isString(action) ? action : action.mode;
+const getFailureActionRetryDelay = (action) => Predicate.isString(action) || action.mode !== "retry" ? void 0 : action.retryFailedAfter;
 const processDue = (handle, options = {}) => Effect.gen(function* () {
 	return yield* (yield* DurableObjectAlarm).processDueAlarms(handle, options);
 });
-const isAlarmDefinitionConfig = (definition) => typeof definition === "object" && definition !== null && "payload" in definition;
+const isAlarmDefinitionConfig = (definition) => Predicate.isObject(definition) && "payload" in definition;
 const getAlarmDefinitionSchema = (definition) => isAlarmDefinitionConfig(definition) ? definition.payload : definition;
 const getAlarmDefinitionFailureAction = (definition) => {
 	if (definition === void 0 || !isAlarmDefinitionConfig(definition)) return;
@@ -2470,21 +2559,21 @@ const layer$8 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 			return Predicate.isTagged(cause, "MaxBufferSizeExceeded") ? Effect.ignore(connection.socket.close(1009, String(cause))) : send(connection, RpcMessage.ResponseDefectEncoded(cause));
 		})),
 		close: unregister,
-		error: (socket, error) => Effect.gen(function* () {
-			yield* Effect.logDebug("Durable Object RPC websocket error", error);
+		error: (socket, cause) => Effect.gen(function* () {
+			yield* Effect.logDebug("Durable Object RPC websocket error", cause);
 			yield* unregister(socket);
 		})
 	});
 	return Context.mergeAll(Context.make(RpcServer.Protocol, protocol), Context.make(DurableObjectRpcWebSocket, service));
 }));
-const normalizeMessage = (message) => typeof message === "string" ? message : new Uint8Array(message);
+const normalizeMessage = (message) => Predicate.isString(message) ? message : new Uint8Array(message);
 const readAttachment = (socket, key) => {
 	const value = socket.deserializeAttachment();
-	if (value !== null && typeof value === "object" && key in value && typeof value[key] === "number") return value[key];
+	if (Predicate.isObjectOrArray(value) && Predicate.hasProperty(value, key) && Predicate.isNumber(value[key])) return value[key];
 };
 const writeAttachment = (socket, key, clientId) => {
 	const current = socket.deserializeAttachment();
-	const attachment = current !== null && typeof current === "object" && !Array.isArray(current) ? current : {};
+	const attachment = Predicate.isObject(current) ? current : {};
 	socket.serializeAttachment({
 		...attachment,
 		[key]: clientId
@@ -2590,9 +2679,9 @@ var EmailValidationError = class extends Data.TaggedError("EmailValidationError"
 * error and strips non-standard properties.
 */
 const emailErrorCode = (cause) => {
-	if (typeof cause !== "object" || cause === null) return;
-	const code = Reflect.get(cause, "code");
-	return typeof code === "string" ? code : void 0;
+	if (!Predicate.isObject(cause)) return;
+	const code = Predicate.hasProperty(cause, "code") ? cause.code : void 0;
+	return Predicate.isString(code) ? code : void 0;
 };
 const emailError = (binding, operation, cause) => new EmailOperationError({
 	binding,
@@ -2621,16 +2710,16 @@ const addressList = (value) => {
 	return Array.isArray(value) ? value : [value];
 };
 const addressViolations = (path, value) => {
-	if (typeof value === "string") return value.includes("@") ? [] : [{
+	if (Predicate.isString(value)) return value.includes("@") ? [] : [{
 		path,
 		message: "Email address must contain an @ symbol"
 	}];
-	if (typeof value !== "object" || value === null) return [{
+	if (!Predicate.isObject(value)) 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 [{
+	const email = Predicate.hasProperty(value, "email") ? value.email : void 0;
+	if (!Predicate.isString(email) || !email.includes("@")) return [{
 		path: `${path}.email`,
 		message: "Email address must contain an @ symbol"
 	}];
@@ -2643,18 +2732,18 @@ const attachmentViolations = (attachments) => {
 	for (let index = 0; index < attachments.length; index++) {
 		const attachment = attachments[index];
 		const path = `attachments[${index}]`;
-		if (typeof attachment !== "object" || attachment === null) {
+		if (!Predicate.isObject(attachment)) {
 			violations.push({
 				path,
 				message: "Attachment must be an object"
 			});
 			continue;
 		}
-		if (typeof attachment.filename !== "string" || attachment.filename === "") violations.push({
+		if (!Predicate.isString(attachment.filename) || attachment.filename === "") violations.push({
 			path: `${path}.filename`,
 			message: "Attachment filename is required"
 		});
-		if (typeof attachment.type !== "string" || attachment.type === "") violations.push({
+		if (!Predicate.isString(attachment.type) || attachment.type === "") violations.push({
 			path: `${path}.type`,
 			message: "Attachment MIME type is required"
 		});
@@ -2662,7 +2751,7 @@ const attachmentViolations = (attachments) => {
 			path: `${path}.content`,
 			message: "Attachment content is required"
 		});
-		if (attachment.disposition === "inline" && typeof attachment.contentId !== "string") violations.push({
+		if (attachment.disposition === "inline" && !Predicate.isString(attachment.contentId)) violations.push({
 			path: `${path}.contentId`,
 			message: "Inline attachments require a contentId"
 		});
@@ -2678,7 +2767,7 @@ const headerViolations = (headers) => {
 		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") {
+		if (!Predicate.isString(value)) {
 			violations.push({
 				path,
 				message: "Header value must be a string"
@@ -2708,11 +2797,11 @@ const validateMessage = (message) => {
 	});
 	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({
+	if (!Predicate.isString(fields.subject) || fields.subject === "") violations.push({
 		path: "subject",
 		message: "A subject is required"
 	});
-	if (typeof fields.text !== "string" && typeof fields.html !== "string") violations.push({
+	if (!Predicate.isString(fields.text) && !Predicate.isString(fields.html)) violations.push({
 		path: "$",
 		message: "A message requires either text or html content"
 	});
@@ -2733,10 +2822,7 @@ 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 isEmailBinding = (value) => Predicate.hasProperty(value, "send") && Predicate.isFunction(value.send);
 const makeClient$6 = (definition, options) => (email) => {
 	const runtime = email;
 	const validate = options?.validate ?? true;
@@ -2769,10 +2855,7 @@ var Hyperdrive_exports = /* @__PURE__ */ __exportAll({
 	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 isHyperdrive = (value) => Predicate.hasProperty(value, "connectionString") && Predicate.isString(value.connectionString);
 const makeClient$5 = (definition) => (hyperdrive) => ({
 	definition,
 	connectionString: hyperdrive.connectionString,
@@ -2817,8 +2900,8 @@ const makeSteps = (steps) => ({
 });
 /** Empty Images transformation pipeline. */
 const empty = makeSteps([]);
-const transform = Function.dual(2, (steps, transformValue) => makeSteps([...steps.steps, Step.Transform({ transform: transformValue })]));
-const draw = Function.dual(2, (steps, drawValue) => makeSteps([...steps.steps, Step.Draw(drawValue)]));
+const transform = Function$1.dual(2, (steps, transformValue) => makeSteps([...steps.steps, Step.Transform({ transform: transformValue })]));
+const draw = Function$1.dual(2, (steps, drawValue) => makeSteps([...steps.steps, Step.Draw(drawValue)]));
 const imagesError = (binding, operation, cause) => new ImagesOperationError({
 	binding,
 	operation,
@@ -2833,9 +2916,9 @@ const tryImagesSync = (binding, operation, evaluate) => Effect.try({
 	catch: (cause) => imagesError(binding, operation, cause)
 });
 const maybe = (value) => value === null ? Option.none() : Option.some(value);
-const hasFunction$1 = (value, key) => typeof Reflect.get(value, key) === "function";
-const isHostedImagesBinding = (value) => typeof value === "object" && value !== null && hasFunction$1(value, "image") && hasFunction$1(value, "upload") && hasFunction$1(value, "list");
-const isImagesBinding = (value) => typeof value === "object" && value !== null && hasFunction$1(value, "info") && hasFunction$1(value, "input");
+const hasFunction = (value, key) => Predicate.hasProperty(value, key) && Predicate.isFunction(value[key]);
+const isHostedImagesBinding = (value) => hasFunction(value, "image") && hasFunction(value, "upload") && hasFunction(value, "list");
+const isImagesBinding = (value) => hasFunction(value, "info") && hasFunction(value, "input");
 const wrapResult = (binding, result) => ({
 	raw: result,
 	response: tryImagesSync(binding, "response", () => result.response()),
@@ -2910,11 +2993,7 @@ const tryKvPromise = (binding, operation, evaluate) => Effect.tryPromise({
 	try: evaluate,
 	catch: (cause) => kvError(binding, operation, cause)
 });
-const isKvNamespace = (value) => {
-	if (typeof value !== "object" || value === null) return false;
-	const resource = value;
-	return typeof resource.get === "function" && typeof resource.put === "function" && typeof resource.delete === "function" && typeof resource.getWithMetadata === "function" && typeof resource.list === "function";
-};
+const isKvNamespace = (value) => Predicate.hasProperty(value, "get") && Predicate.isFunction(value.get) && Predicate.hasProperty(value, "put") && Predicate.isFunction(value.put) && Predicate.hasProperty(value, "delete") && Predicate.isFunction(value.delete) && Predicate.hasProperty(value, "getWithMetadata") && Predicate.isFunction(value.getWithMetadata) && Predicate.hasProperty(value, "list") && Predicate.isFunction(value.list);
 const makeClient$3 = (definition) => {
 	const encodeKey = Schema.encodeEffect(definition.key);
 	const decodeKey = Schema.decodeUnknownEffect(definition.key);
@@ -3046,7 +3125,7 @@ const spanOptions$1 = (binding, operation) => ({ attributes: {
 	binding,
 	operation
 } });
-const isR2ObjectBody = (value) => "body" in value && typeof value.arrayBuffer === "function" && typeof value.bytes === "function" && typeof value.text === "function" && typeof value.json === "function" && typeof value.blob === "function";
+const isR2ObjectBody = (value) => "body" in value && Predicate.isFunction(value.arrayBuffer) && Predicate.isFunction(value.bytes) && Predicate.isFunction(value.text) && Predicate.isFunction(value.json) && Predicate.isFunction(value.blob);
 const wrapObjectBody = (binding, object) => ({
 	key: object.key,
 	version: object.version,
@@ -3076,11 +3155,9 @@ const wrapGetResult = (binding, object) => {
 	if (object === null || !isR2ObjectBody(object)) return object;
 	return wrapObjectBody(binding, object);
 };
-const isR2Bucket = (value) => {
-	if (typeof value !== "object" || value === null) return false;
-	const resource = value;
-	return typeof resource.head === "function" && typeof resource.get === "function" && typeof resource.put === "function" && typeof resource.createMultipartUpload === "function" && typeof resource.resumeMultipartUpload === "function" && typeof resource.delete === "function" && typeof resource.list === "function";
-};
+const R2BucketSchema = Schema.declare((value) => Predicate.hasProperty(value, "head") && Predicate.isFunction(value.head) && Predicate.hasProperty(value, "get") && Predicate.isFunction(value.get) && Predicate.hasProperty(value, "put") && Predicate.isFunction(value.put) && Predicate.hasProperty(value, "createMultipartUpload") && Predicate.isFunction(value.createMultipartUpload) && Predicate.hasProperty(value, "resumeMultipartUpload") && Predicate.isFunction(value.resumeMultipartUpload) && Predicate.hasProperty(value, "delete") && Predicate.isFunction(value.delete) && Predicate.hasProperty(value, "list") && Predicate.isFunction(value.list));
+const decodeR2Bucket = Schema.decodeUnknownOption(R2BucketSchema);
+const isR2Bucket = (value) => Option.isSome(decodeR2Bucket(value));
 const makeClient$2 = (definition) => {
 	const wrapUpload = (upload) => ({
 		raw: upload,
@@ -3104,7 +3181,7 @@ const makeClient$2 = (definition) => {
 			createMultipartUpload: Effect.fn("R2.createMultipartUpload", spanOptions$1(definition.binding, "createMultipartUpload"))((key, options) => tryR2Promise(definition.binding, "createMultipartUpload", () => bucket.createMultipartUpload(key, options)).pipe(Effect.map(wrapUpload))),
 			resumeMultipartUpload: Effect.fn("R2.resumeMultipartUpload", spanOptions$1(definition.binding, "resumeMultipartUpload"))((key, uploadId) => tryR2Sync(definition.binding, "resumeMultipartUpload", () => wrapUpload(bucket.resumeMultipartUpload(key, uploadId)))),
 			delete: Effect.fn("R2.delete", spanOptions$1(definition.binding, "delete"))((keys) => {
-				const nativeKeys = typeof keys === "string" ? keys : [...keys];
+				const nativeKeys = Predicate.isString(keys) ? keys : [...keys];
 				return tryR2Promise(definition.binding, "delete", () => bucket.delete(nativeKeys));
 			}),
 			list: Effect.fn("R2.list", spanOptions$1(definition.binding, "list"))((options) => tryR2Promise(definition.binding, "list", () => bucket.list(options))),
@@ -3152,16 +3229,25 @@ const spanOptions = (binding, operation) => ({ attributes: {
 	binding,
 	operation
 } });
-const hasFunction = (value, key) => typeof Reflect.get(value, key) === "function";
-const isVectorizeBinding = (value) => typeof value === "object" && value !== null && hasFunction(value, "describe") && hasFunction(value, "query") && hasFunction(value, "insert") && hasFunction(value, "upsert") && hasFunction(value, "deleteByIds") && hasFunction(value, "getByIds");
+const invokeVectorizeMethod = (method, receiver, args) => {
+	return Function.prototype.apply.call(method, receiver, args);
+};
+const VectorizeBindingSchema = Schema.declare((value) => Predicate.hasProperty(value, "describe") && Predicate.isFunction(value.describe) && Predicate.hasProperty(value, "query") && Predicate.isFunction(value.query) && Predicate.hasProperty(value, "insert") && Predicate.isFunction(value.insert) && Predicate.hasProperty(value, "upsert") && Predicate.isFunction(value.upsert) && Predicate.hasProperty(value, "deleteByIds") && Predicate.isFunction(value.deleteByIds) && Predicate.hasProperty(value, "getByIds") && Predicate.isFunction(value.getByIds));
+const decodeVectorizeBinding = Schema.decodeUnknownOption(VectorizeBindingSchema);
+const isVectorizeBinding = (value) => Option.isSome(decodeVectorizeBinding(value));
 const makeClient$1 = (definition) => (index) => {
 	const runtime = index;
 	const deleteByIds = Effect.fn("Vectorize.deleteByIds", spanOptions(definition.binding, "deleteByIds"))((ids) => tryVectorizePromise(definition.binding, "deleteByIds", () => runtime.deleteByIds([...ids])));
 	return {
 		definition,
 		describe: tryVectorizePromise(definition.binding, "describe", () => runtime.describe()).pipe(Effect.withSpan("Vectorize.describe", spanOptions(definition.binding, "describe"))),
-		query: Effect.fn("Vectorize.query", spanOptions(definition.binding, "query"))((vector, options) => tryVectorizePromise(definition.binding, "query", () => runtime.query(vector, options))),
-		queryById: Effect.fn("Vectorize.queryById", spanOptions(definition.binding, "queryById"))((vectorId, options) => runtime.queryById !== void 0 ? tryVectorizePromise(definition.binding, "queryById", () => runtime.queryById(vectorId, options)) : Effect.fail(vectorizeError(definition.binding, "queryById", /* @__PURE__ */ new TypeError("Vectorize binding does not expose queryById()")))),
+		query: Effect.fn("Vectorize.query", spanOptions(definition.binding, "query"))((vector, options) => tryVectorizePromise(definition.binding, "query", () => {
+			return runtime.query(vector, options);
+		})),
+		queryById: Effect.fn("Vectorize.queryById", spanOptions(definition.binding, "queryById"))((vectorId, options) => runtime.queryById !== void 0 ? tryVectorizePromise(definition.binding, "queryById", () => {
+			const queryById = runtime.queryById;
+			return queryById === void 0 ? Promise.reject(/* @__PURE__ */ new TypeError("Vectorize binding does not expose queryById()")) : invokeVectorizeMethod(queryById, runtime, [vectorId, options]);
+		}) : Effect.fail(vectorizeError(definition.binding, "queryById", /* @__PURE__ */ new TypeError("Vectorize binding does not expose queryById()")))),
 		insert: Effect.fn("Vectorize.insert", spanOptions(definition.binding, "insert"))((vectors) => tryVectorizePromise(definition.binding, "insert", () => runtime.insert([...vectors]))),
 		upsert: Effect.fn("Vectorize.upsert", spanOptions(definition.binding, "upsert"))((vectors) => tryVectorizePromise(definition.binding, "upsert", () => runtime.upsert([...vectors]))),
 		deleteByIds,
@@ -3226,10 +3312,13 @@ const inboundTransport = (request) => Result.getSuccess(decodeInboundTransport(r
 */
 const isHttp3 = (transport) => transport.clientQuicRtt !== void 0 || transport.httpProtocol === "HTTP/3";
 /** Feature-detects the WebTransport capabilities of the current runtime. */
-const capabilities = Effect.sync(() => ({
-	inboundSessions: false,
-	outboundSessions: typeof globalThis["WebTransport"] === "function"
-}));
+const capabilities = Effect.sync(() => {
+	const runtime = globalThis;
+	return {
+		inboundSessions: false,
+		outboundSessions: Predicate.hasProperty(runtime, "WebTransport") && Predicate.isFunction(runtime["WebTransport"])
+	};
+});
 /** Raised when a WebTransport capability is unavailable in this runtime. */
 var WebTransportUnsupportedError = class extends Data.TaggedError("WebTransportUnsupportedError") {
 	get message() {
@@ -3274,11 +3363,9 @@ const tryWorkflowPromise = (binding, operation, evaluate) => Effect.tryPromise({
 	try: evaluate,
 	catch: (cause) => workflowError(binding, operation, cause)
 });
-const isWorkflow = (value) => {
-	if (typeof value !== "object" || value === null) return false;
-	const resource = value;
-	return typeof resource.create === "function" && typeof resource.createBatch === "function" && typeof resource.get === "function";
-};
+const WorkflowBindingSchema = Schema.declare((value) => Predicate.hasProperty(value, "create") && Predicate.isFunction(value.create) && Predicate.hasProperty(value, "createBatch") && Predicate.isFunction(value.createBatch) && Predicate.hasProperty(value, "get") && Predicate.isFunction(value.get));
+const decodeWorkflowBinding = Schema.decodeUnknownOption(WorkflowBindingSchema);
+const isWorkflow = (value) => Option.isSome(decodeWorkflowBinding(value));
 const makeClient = (definition) => {
 	const encodePayload = Schema.encodeEffect(definition.payload);
 	const decodeResult = Schema.decodeUnknownEffect(definition.result);
@@ -3411,6 +3498,7 @@ var Workflow_exports = /* @__PURE__ */ __exportAll({
 	WorkflowStep: () => WorkflowStep$1,
 	WorkflowStepContext: () => WorkflowStepContext$1,
 	WorkflowStepError: () => WorkflowStepError,
+	WorkflowStepNonRetryableError: () => WorkflowStepNonRetryableError,
 	implement: () => implement,
 	make: () => make,
 	sleep: () => sleep,
@@ -3426,6 +3514,17 @@ var WorkflowStepError = class extends Data.TaggedError("WorkflowStepError") {
 		return `Workflow ${this.operation} failed${step}: ${causeMessage(this.cause)}`;
 	}
 };
+/**
+* Typed step failure that Cloudflare must treat as terminal instead of retrying.
+*
+* The workflow boundary converts this value into Cloudflare's native
+* `NonRetryableError` while preserving the original cause and its message.
+*/
+var WorkflowStepNonRetryableError = class extends Data.TaggedError("WorkflowStepNonRetryableError") {
+	get message() {
+		return `Workflow step failed without retry: ${causeMessage(this.cause)}`;
+	}
+};
 var WorkflowStep$1 = class extends Context.Service()("effect-cf/WorkflowStep") {};
 var WorkflowStepContext$1 = class extends Context.Service()("effect-cf/WorkflowStepContext") {};
 const fromWorkflowEvent = (event) => ({
@@ -3435,11 +3534,20 @@ const fromWorkflowEvent = (event) => ({
 	instanceId: event.instanceId,
 	workflowName: event.workflowName
 });
+const toCloudflareNonRetryableError = (error) => {
+	const cloudflareError = new NonRetryableError(error.message);
+	cloudflareError.cause = error.cause;
+	return cloudflareError;
+};
+const exposeCloudflareNonRetryableError = (effect) => Effect.catchCause(effect, (cause) => {
+	const error = Cause.findErrorOption(cause);
+	return Option.isSome(error) && error.value instanceof WorkflowStepNonRetryableError ? Effect.die(toCloudflareNonRetryableError(error.value)) : Effect.failCause(cause);
+});
 const fromWorkflowStep = (step, runPromise) => ({
 	raw: step,
 	do: (name, effect, config) => Effect.context().pipe(Effect.flatMap((context) => Effect.tryPromise({
 		try: () => {
-			const run = (stepContext) => runPromise(Effect.scoped(Effect.provideService(Effect.provideContext(effect, context), WorkflowStepContext$1, stepContext)));
+			const run = (stepContext) => runPromise(exposeCloudflareNonRetryableError(Effect.scoped(Effect.provideService(Effect.provideContext(effect, context), WorkflowStepContext$1, stepContext))));
 			const rawStep = step;
 			return config === void 0 ? rawStep.do(name, run) : rawStep.do(name, config, run);
 		},
@@ -3466,7 +3574,9 @@ const fromWorkflowStep = (step, runPromise) => ({
 		})
 	}),
 	waitForEvent: (name, options) => Effect.tryPromise({
-		try: () => step.waitForEvent(name, options),
+		try: () => {
+			return step.waitForEvent(name, options);
+		},
 		catch: (cause) => new WorkflowStepError({
 			step: name,
 			operation: "waitForEvent",