effect-cf 0.26.0 → 0.28.0

package/dist/index.mjs

@@ -1,7 +1,8 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { a as DurableObjectWebSocket_exports, c as causeMessage, d as WorkerConfig, f as WorkerEnvironment, i as fromExecutionContext, l as violationsMessage, n as DurableObjectState_exports, o as fromWebSocket, r as fromDurableObjectState, s as DurableObjectStorage_exports, t as DurableObjectState, u as Environment_exports } from "./DurableObjectState-CEh0DVw7.mjs";
-import { t as lookup } from "./ComputerWorkspaceHostRegistry-CY5Fv4Ng.mjs";
-import { Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Function as Function$1, Layer, ManagedRuntime, Option, Predicate, Queue, Result, Schema, Stream } 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";
@@ -10,133 +11,16 @@ 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/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;
-});
-/**
-* The overloads on {@link layer} and {@link Service} guarantee that
-* `Service = Resource` whenever `wrap` is absent, making the fallback cast
-* safe.
-*/
-const makeBindingLayer = (tag, binding, isResource, wrap, options) => Layer.effect(tag, Effect.gen(function* () {
-	const env = yield* WorkerEnvironment;
-	const resource = yield* getBinding(env, binding, isResource, options);
-	return wrap === void 0 ? resource : wrap(resource);
-}));
-function layer$20(tag, binding, isResource, wrap, options) {
-	return makeBindingLayer(tag, binding, isResource, wrap, options);
-}
-const Service$2 = () => {
-	function makeService(id, binding, isResource, wrap, options) {
-		const tag = Context.Service()(`effect-cf/Binding/${id}`);
-		const serviceLayer = makeBindingLayer(tag, binding, isResource, wrap, options);
-		return Object.assign(tag, {
-			[TypeId$3]: TypeId$3,
-			id,
-			binding,
-			layer: serviceLayer
-		});
-	}
-	return makeService;
-};
-//#endregion
+import { NonRetryableError } from "cloudflare:workflows";
 //#region src/WorkersAi.ts
 var WorkersAi_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$17,
+	Tag: () => Tag$16,
 	WorkersAiOperationError: () => WorkersAiOperationError,
 	embeddingResponse: () => embeddingResponse,
 	isWorkersAiBinding: () => isWorkersAiBinding,
-	layer: () => layer$19,
-	make: () => make$19,
-	makeClient: () => makeClient$17
+	layer: () => layer$18,
+	make: () => make$18,
+	makeClient: () => makeClient$15
 });
 const expectedWorkersAiBinding = "Workers AI binding with run(), gateway(), and models()";
 /** Error raised when a Workers AI operation fails. */
@@ -145,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,
@@ -158,29 +43,41 @@ const tryWorkersAiSync = (binding, operation, evaluate) => Effect.try({
 	try: evaluate,
 	catch: (cause) => workersAiError(binding, operation, cause)
 });
-const hasFunction$4 = (value, key) => typeof Reflect.get(value, key) === "function";
-const isWorkersAiBinding = (value) => typeof value === "object" && value !== null && hasFunction$4(value, "run") && hasFunction$4(value, "gateway") && hasFunction$4(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 makeClient$17 = (definition) => (ai) => {
-	const run = Effect.fn("WorkersAi.run")((model, input, options) => tryWorkersAiPromise(definition.binding, "run", () => ai.run(model, input, options)));
+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", () => {
+		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)
 	};
 };
-const layer$19 = (tag, definition) => layer$20(tag, definition.binding, (value) => isWorkersAiBinding(value), makeClient$17(definition), { expected: expectedWorkersAiBinding });
-const make$19 = (id) => Tag$17()(id);
-const Tag$17 = () => (id) => {
+const layer$18 = (tag, definition) => layer$19(tag, definition.binding, (value) => isWorkersAiBinding(value), makeClient$15(definition), { expected: expectedWorkersAiBinding });
+const make$18 = (id) => Tag$16()(id);
+const Tag$16 = () => (id) => {
 	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$19(tag, definition);
+	const makeLayer = (definition) => layer$18(tag, definition);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer
@@ -190,11 +87,11 @@ const Tag$17 = () => (id) => {
 //#region src/AiGateway.ts
 var AiGateway_exports = /* @__PURE__ */ __exportAll({
 	AiGatewayOperationError: () => AiGatewayOperationError,
-	Tag: () => Tag$16,
+	Tag: () => Tag$15,
 	isAiGatewayBinding: () => isAiGatewayBinding,
-	layer: () => layer$18,
-	make: () => make$18,
-	makeClient: () => makeClient$16,
+	layer: () => layer$17,
+	make: () => make$17,
+	makeClient: () => makeClient$14,
 	makeClientFromAi: () => makeClientFromAi,
 	makeHttpClient: () => makeHttpClient
 });
@@ -205,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,
@@ -225,8 +165,11 @@ 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$16 = (definition, gateway) => ({
+const makeClient$14 = (definition, gateway) => ({
 	definition,
 	run: Effect.fn("AiGateway.run")((data, options) => tryAiGatewayPromise(definition.binding, "run", () => gateway.run(Array.isArray(data) ? [...data] : data, options))),
 	getUrl: Effect.fn("AiGateway.getUrl")((provider) => tryAiGatewayPromise(definition.binding, "getUrl", () => gateway.getUrl(provider))),
@@ -246,11 +189,11 @@ const makeClientFromAi = (definition, ai) => {
 	const withGateway = (operation) => gateway.pipe(Effect.flatMap(operation));
 	return {
 		definition,
-		run: (data, options) => withGateway((raw) => makeClient$16(definition, raw).run(data, options)),
-		getUrl: (provider) => withGateway((raw) => makeClient$16(definition, raw).getUrl(provider)),
-		fetch: (options) => withGateway((raw) => makeClient$16(definition, raw).fetch(options)),
-		patchLog: (logId, data) => withGateway((raw) => makeClient$16(definition, raw).patchLog(logId, data)),
-		getLog: (logId) => withGateway((raw) => makeClient$16(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)),
 		rawUnsafe: gateway
 	};
 };
@@ -282,23 +225,29 @@ 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")))
 	};
 };
-const layer$18 = (tag, definition) => layer$20(tag, definition.binding, isAiGatewayBinding, (ai) => makeClientFromAi(definition, ai), { expected: expectedAiGatewayBinding });
-const make$18 = (id) => Tag$16()(id);
-const Tag$16 = () => (id) => {
+const layer$17 = (tag, definition) => layer$19(tag, definition.binding, isAiGatewayBinding, (ai) => makeClientFromAi(definition, ai), { expected: expectedAiGatewayBinding });
+const make$17 = (id) => Tag$15()(id);
+const Tag$15 = () => (id) => {
 	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$18(tag, definition);
+	const makeLayer = (definition) => layer$17(tag, definition);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer
@@ -313,13 +262,13 @@ var AnalyticsEngine_exports = /* @__PURE__ */ __exportAll({
 	AnalyticsEngineQueryError: () => AnalyticsEngineQueryError,
 	AnalyticsEngineWriteValidationError: () => AnalyticsEngineWriteValidationError,
 	QueryTag: () => QueryTag,
-	Tag: () => Tag$15,
+	Tag: () => Tag$14,
 	isAnalyticsEngineDataset: () => isAnalyticsEngineDataset,
-	layer: () => layer$17,
+	layer: () => layer$16,
 	layerFetch: () => layerFetch,
 	layerFetchConfig: () => layerFetchConfig,
-	make: () => make$17,
-	makeClient: () => makeClient$15,
+	make: () => make$16,
+	makeClient: () => makeClient$13,
 	makeQuery: () => makeQuery,
 	makeQueryClient: () => makeQueryClient,
 	queryConfig: () => queryConfig,
@@ -398,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,
@@ -425,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);
@@ -504,11 +455,8 @@ 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 makeClient$15 = (definition, defaults) => (dataset) => {
+const isAnalyticsEngineDataset = (value) => Predicate.hasProperty(value, "writeDataPoint") && Predicate.isFunction(value.writeDataPoint);
+const makeClient$13 = (definition, defaults) => (dataset) => {
 	return {
 		definition,
 		writeDataPoint: Effect.fn("AnalyticsEngine.writeDataPoint")((dataPoint, options) => {
@@ -538,12 +486,12 @@ const queryLayerConfig = (tag, config = queryConfig()) => Layer.effect(tag, Effe
 	return yield* makeQueryClient(definition);
 }));
 const layerFetchConfig = (tag, config = queryConfig()) => queryLayerConfig(tag, config).pipe(Layer.provide(FetchHttpClient.layer));
-const layer$17 = (tag, definition) => layer$20(tag, definition.binding, isAnalyticsEngineDataset, makeClient$15(definition, definition.write), { expected: expectedAnalyticsEngineDataset });
-const make$17 = (id) => Tag$15()(id);
+const layer$16 = (tag, definition) => layer$19(tag, definition.binding, isAnalyticsEngineDataset, makeClient$13(definition, definition.write), { expected: expectedAnalyticsEngineDataset });
+const make$16 = (id) => Tag$14()(id);
 const makeQuery = (id) => QueryTag()(id);
-const Tag$15 = () => (id) => {
+const Tag$14 = () => (id) => {
 	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$17(tag, definition);
+	const makeLayer = (definition) => layer$16(tag, definition);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer
@@ -564,125 +512,6 @@ const QueryTag = () => (id) => {
 	});
 };
 //#endregion
-//#region src/Artifacts.ts
-var Artifacts_exports = /* @__PURE__ */ __exportAll({
-	ArtifactsOperationError: () => ArtifactsOperationError,
-	Tag: () => Tag$14,
-	artifactsErrorCodes: () => artifactsErrorCodes,
-	artifactsErrorNumericCodes: () => artifactsErrorNumericCodes,
-	isArtifactsBinding: () => isArtifactsBinding,
-	isArtifactsRepoBinding: () => isArtifactsRepoBinding,
-	layer: () => layer$16,
-	make: () => make$16,
-	makeClient: () => makeClient$14
-});
-const expectedArtifactsBinding = "Artifacts binding with create(), get(), import(), list(), and delete()";
-const expectedArtifactsRepo = "Artifacts repo handle with createToken(), listTokens(), revokeToken(), fork(), log(), readCommit(), and readTree()";
-/** Documented string error codes returned by Cloudflare Artifacts. */
-const artifactsErrorCodes = [
-	"ALREADY_EXISTS",
-	"NOT_FOUND",
-	"IMPORT_IN_PROGRESS",
-	"FORK_IN_PROGRESS",
-	"INVALID_INPUT",
-	"INVALID_REPO_NAME",
-	"INVALID_TTL",
-	"INVALID_URL",
-	"REMOTE_AUTH_REQUIRED",
-	"UPSTREAM_UNAVAILABLE",
-	"MEMORY_LIMIT",
-	"INTERNAL_ERROR"
-];
-/** Documented numeric error codes returned by Cloudflare Artifacts. */
-const artifactsErrorNumericCodes = {
-	ALREADY_EXISTS: 10201,
-	NOT_FOUND: 10200,
-	IMPORT_IN_PROGRESS: 10302,
-	FORK_IN_PROGRESS: 10303,
-	INVALID_INPUT: 10100,
-	INVALID_REPO_NAME: 10101,
-	INVALID_TTL: 10103,
-	INVALID_URL: 10104,
-	REMOTE_AUTH_REQUIRED: 10106,
-	UPSTREAM_UNAVAILABLE: 10401,
-	MEMORY_LIMIT: 10402,
-	INTERNAL_ERROR: 10400
-};
-/** Error raised when a Cloudflare Artifacts operation fails. */
-var ArtifactsOperationError = class extends Data.TaggedError("ArtifactsOperationError") {
-	get message() {
-		const code = this.code === void 0 ? "" : ` (${this.code})`;
-		return `Artifacts ${this.operation} failed for binding "${this.binding}"${code}: ${causeMessage(this.cause)}`;
-	}
-};
-const artifactsErrorDetails$1 = (cause) => {
-	if (typeof cause !== "object" || cause === null) return {};
-	const code = Reflect.get(cause, "code");
-	const numericCode = Reflect.get(cause, "numericCode");
-	return {
-		...typeof code === "string" ? { code } : {},
-		...typeof numericCode === "number" ? { numericCode } : {}
-	};
-};
-const artifactsError = (binding, operation, cause) => new ArtifactsOperationError({
-	binding,
-	operation,
-	cause,
-	...artifactsErrorDetails$1(cause)
-});
-const tryArtifactsPromise = (binding, operation, evaluate) => Effect.tryPromise({
-	try: evaluate,
-	catch: (cause) => artifactsError(binding, operation, cause)
-});
-const spanOptions$4 = (binding, operation) => ({ attributes: {
-	binding,
-	operation
-} });
-const hasFunction$3 = (value, key) => typeof Reflect.get(value, key) === "function";
-/** Tests whether a value exposes the complete documented Artifacts repo handle API. */
-const isArtifactsRepoBinding = (value) => typeof value === "object" && value !== null && hasFunction$3(value, "createToken") && hasFunction$3(value, "listTokens") && hasFunction$3(value, "revokeToken") && hasFunction$3(value, "fork") && hasFunction$3(value, "log") && hasFunction$3(value, "readCommit") && hasFunction$3(value, "readTree");
-/** Tests whether a value exposes the complete documented Artifacts namespace API. */
-const isArtifactsBinding = (value) => typeof value === "object" && value !== null && hasFunction$3(value, "create") && hasFunction$3(value, "get") && hasFunction$3(value, "import") && hasFunction$3(value, "list") && hasFunction$3(value, "delete");
-const wrapRepo = (binding, repo) => ({
-	id: repo.id,
-	name: repo.name,
-	description: repo.description,
-	defaultBranch: repo.defaultBranch,
-	createdAt: repo.createdAt,
-	updatedAt: repo.updatedAt,
-	lastPushAt: repo.lastPushAt,
-	source: repo.source,
-	readOnly: repo.readOnly,
-	remote: repo.remote,
-	createToken: Effect.fn("Artifacts.createToken", spanOptions$4(binding, "createToken"))((scope, ttl) => tryArtifactsPromise(binding, "createToken", () => repo.createToken(scope, ttl))),
-	listTokens: tryArtifactsPromise(binding, "listTokens", () => repo.listTokens()).pipe(Effect.withSpan("Artifacts.listTokens", spanOptions$4(binding, "listTokens"))),
-	revokeToken: Effect.fn("Artifacts.revokeToken", spanOptions$4(binding, "revokeToken"))((tokenOrId) => tryArtifactsPromise(binding, "revokeToken", () => repo.revokeToken(tokenOrId))),
-	fork: Effect.fn("Artifacts.fork", spanOptions$4(binding, "fork"))((name, options) => tryArtifactsPromise(binding, "fork", () => repo.fork(name, options))),
-	log: Effect.fn("Artifacts.log", spanOptions$4(binding, "log"))((options) => tryArtifactsPromise(binding, "log", () => repo.log(options))),
-	readCommit: Effect.fn("Artifacts.readCommit", spanOptions$4(binding, "readCommit"))((hash) => tryArtifactsPromise(binding, "readCommit", () => repo.readCommit(hash))),
-	readTree: Effect.fn("Artifacts.readTree", spanOptions$4(binding, "readTree"))((hash) => tryArtifactsPromise(binding, "readTree", () => repo.readTree(hash))),
-	raw: repo
-});
-const makeClient$14 = (definition) => (artifacts) => ({
-	definition,
-	create: Effect.fn("Artifacts.create", spanOptions$4(definition.binding, "create"))((name, options) => tryArtifactsPromise(definition.binding, "create", () => artifacts.create(name, options))),
-	get: Effect.fn("Artifacts.get", spanOptions$4(definition.binding, "get"))((name) => tryArtifactsPromise(definition.binding, "get", () => artifacts.get(name)).pipe(Effect.flatMap((repo) => isArtifactsRepoBinding(repo) ? Effect.succeed(wrapRepo(definition.binding, repo)) : Effect.fail(artifactsError(definition.binding, "get", /* @__PURE__ */ new TypeError(`Expected ${expectedArtifactsRepo}`)))))),
-	import: Effect.fn("Artifacts.import", spanOptions$4(definition.binding, "import"))((params) => tryArtifactsPromise(definition.binding, "import", () => artifacts.import(params))),
-	list: Effect.fn("Artifacts.list", spanOptions$4(definition.binding, "list"))((options) => tryArtifactsPromise(definition.binding, "list", () => artifacts.list(options))),
-	delete: Effect.fn("Artifacts.delete", spanOptions$4(definition.binding, "delete"))((name) => tryArtifactsPromise(definition.binding, "delete", () => artifacts.delete(name))),
-	rawUnsafe: Effect.succeed(artifacts)
-});
-const layer$16 = (tag, definition) => layer$20(tag, definition.binding, isArtifactsBinding, makeClient$14(definition), { expected: expectedArtifactsBinding });
-const make$16 = (id) => Tag$14()(id);
-const Tag$14 = () => (id) => {
-	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$16(tag, definition);
-	return Object.assign(tag, {
-		id,
-		layer: makeLayer
-	});
-};
-//#endregion
 //#region src/BrowserRendering.ts
 var BrowserRendering_exports = /* @__PURE__ */ __exportAll({
 	BrowserRenderingOperationError: () => BrowserRenderingOperationError,
@@ -690,7 +519,7 @@ var BrowserRendering_exports = /* @__PURE__ */ __exportAll({
 	isBrowserRenderingBinding: () => isBrowserRenderingBinding,
 	layer: () => layer$15,
 	make: () => make$15,
-	makeClient: () => makeClient$13
+	makeClient: () => makeClient$12
 });
 const expectedBrowserRenderingBinding = "Browser Rendering binding resource";
 /** Error raised when a Browser Rendering operation fails. */
@@ -718,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) => ({
@@ -730,14 +568,14 @@ 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 makeClient$13 = (definition) => (binding) => ({
+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")),
 	connectWith: (connect, options) => tryBrowserRenderingPromise(definition.binding, "connect", () => connect(binding, options)).pipe(Effect.map((browser) => wrapBrowser(definition.binding, browser)), Effect.withSpan("BrowserRendering.connectWith")),
 	rawUnsafe: Effect.succeed(binding)
 });
-const layer$15 = (tag, definition) => layer$20(tag, definition.binding, isBrowserRenderingBinding, makeClient$13(definition), { expected: expectedBrowserRenderingBinding });
+const layer$15 = (tag, definition) => layer$19(tag, definition.binding, isBrowserRenderingBinding, makeClient$12(definition), { expected: expectedBrowserRenderingBinding });
 const make$15 = (id) => Tag$13()(id);
 const Tag$13 = () => (id) => {
 	const tag = Context.Service()(id);
@@ -755,7 +593,7 @@ var Cache_exports = /* @__PURE__ */ __exportAll({
 	layer: () => layer$14,
 	layerFrom: () => layerFrom,
 	makeCacheClient: () => makeCacheClient,
-	makeClient: () => makeClient$12
+	makeClient: () => makeClient$11
 });
 /** Error raised when a Cloudflare Cache API operation fails. */
 var CacheOperationError = class extends Data.TaggedError("CacheOperationError") {
@@ -774,28 +612,28 @@ const tryCachePromise = (cache, operation, evaluate) => Effect.tryPromise({
 	try: evaluate,
 	catch: (cause) => cacheError(cache, operation, cause)
 });
-const spanOptions$3 = (cache, operation) => ({ attributes: {
+const spanOptions$2 = (cache, operation) => ({ attributes: {
 	cache,
 	operation
 } });
 /** Wraps a native Cloudflare `Cache` instance. */
 const makeCacheClient = (cache, name = "default") => ({
 	name,
-	match: Effect.fn("Cache.match", spanOptions$3(name, "match"))((request, options) => tryCachePromise(name, "match", () => cache.match(request, options)).pipe(Effect.map(Option.fromUndefinedOr))),
-	put: Effect.fn("Cache.put", spanOptions$3(name, "put"))((request, response) => tryCachePromise(name, "put", () => cache.put(request, response))),
-	delete: Effect.fn("Cache.delete", spanOptions$3(name, "delete"))((request, options) => tryCachePromise(name, "delete", () => cache.delete(request, options))),
+	match: Effect.fn("Cache.match", spanOptions$2(name, "match"))((request, options) => tryCachePromise(name, "match", () => cache.match(request, options)).pipe(Effect.map(Option.fromUndefinedOr))),
+	put: Effect.fn("Cache.put", spanOptions$2(name, "put"))((request, response) => tryCachePromise(name, "put", () => cache.put(request, response))),
+	delete: Effect.fn("Cache.delete", spanOptions$2(name, "delete"))((request, options) => tryCachePromise(name, "delete", () => cache.delete(request, options))),
 	rawUnsafe: Effect.succeed(cache)
 });
 /** Wraps a native Cloudflare `CacheStorage` instance. */
-const makeClient$12 = (storage) => ({
+const makeClient$11 = (storage) => ({
 	default: makeCacheClient(storage.default),
-	open: (name) => tryCachePromise(name, "open", () => storage.open(name)).pipe(Effect.map((cache) => makeCacheClient(cache, name)), Effect.withSpan("Cache.open", spanOptions$3(name, "open"))),
+	open: (name) => tryCachePromise(name, "open", () => storage.open(name)).pipe(Effect.map((cache) => makeCacheClient(cache, name)), Effect.withSpan("Cache.open", spanOptions$2(name, "open"))),
 	rawUnsafe: Effect.succeed(storage)
 });
 /** Provides Cache API services from an explicit native `CacheStorage` instance. */
-const layerFrom = (storage) => Layer.succeed(CacheStorage, makeClient$12(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$12(caches));
+const layer$14 = Layer.sync(CacheStorage, () => makeClient$11(caches));
 //#endregion
 //#region src/CloudflareOtlp.ts
 /**
@@ -919,650 +757,6 @@ const layerDurableObject = (options = {}) => Layer.unwrap(Effect.map(DurableObje
 	"cloudflare.durable_object.id": options.includeObjectId ? state.id.toString() : void 0
 })));
 //#endregion
-//#region src/ComputerArtifacts.ts
-var ComputerArtifacts_exports = /* @__PURE__ */ __exportAll({
-	fromClient: () => fromClient,
-	makeClient: () => makeClient$11
-});
-const artifactsErrorDetails = (cause) => {
-	if (typeof cause !== "object" || cause === null) return {};
-	const code = Reflect.get(cause, "code");
-	const numericCode = Reflect.get(cause, "numericCode");
-	return {
-		...typeof code === "string" ? { code } : {},
-		...typeof numericCode === "number" ? { numericCode } : {}
-	};
-};
-const operationError = (binding, operation, cause) => new ArtifactsOperationError({
-	binding,
-	operation,
-	cause,
-	...artifactsErrorDetails(cause)
-});
-const tryOperation = (binding, operation, evaluate) => Effect.tryPromise({
-	try: evaluate,
-	catch: (cause) => operationError(binding, operation, cause)
-});
-const spanOptions$2 = (binding, sessionId, operation) => ({ attributes: {
-	binding,
-	sessionId,
-	operation
-} });
-/** Wraps an already-created upstream session client. */
-const fromClient = (client, options = {}) => {
-	const binding = options.binding ?? "ARTIFACTS";
-	const { sessionId } = client;
-	return {
-		sessionId,
-		create: Effect.fn("ComputerArtifacts.create", spanOptions$2(binding, sessionId, "create"))(function* (name, createOptions) {
-			yield* Effect.annotateCurrentSpan("repo", name);
-			return yield* tryOperation(binding, "create", () => client.create(name, createOptions));
-		}),
-		get: Effect.fn("ComputerArtifacts.get", spanOptions$2(binding, sessionId, "get"))(function* (name) {
-			yield* Effect.annotateCurrentSpan("repo", name);
-			return yield* tryOperation(binding, "get", () => client.get(name));
-		}),
-		list: tryOperation(binding, "list", () => client.list()).pipe(Effect.withSpan("ComputerArtifacts.list", spanOptions$2(binding, sessionId, "list"))),
-		import: Effect.fn("ComputerArtifacts.import", spanOptions$2(binding, sessionId, "import"))(function* (name, source, importOptions) {
-			yield* Effect.annotateCurrentSpan("repo", name);
-			return yield* tryOperation(binding, "import", () => client.import(name, source, importOptions));
-		}),
-		delete: Effect.fn("ComputerArtifacts.delete", spanOptions$2(binding, sessionId, "delete"))(function* (name) {
-			yield* Effect.annotateCurrentSpan("repo", name);
-			return yield* tryOperation(binding, "delete", () => client.delete(name));
-		}),
-		createToken: Effect.fn("ComputerArtifacts.createToken", spanOptions$2(binding, sessionId, "createToken"))(function* (name, scope, ttl) {
-			yield* Effect.annotateCurrentSpan("repo", name);
-			return yield* tryOperation(binding, "createToken", () => client.createToken(name, scope, ttl));
-		}),
-		listTokens: Effect.fn("ComputerArtifacts.listTokens", spanOptions$2(binding, sessionId, "listTokens"))(function* (name) {
-			yield* Effect.annotateCurrentSpan("repo", name);
-			return yield* tryOperation(binding, "listTokens", () => client.listTokens(name));
-		}),
-		getToken: Effect.fn("ComputerArtifacts.getToken", spanOptions$2(binding, sessionId, "getToken"))(function* (name, id) {
-			yield* Effect.annotateCurrentSpan({
-				repo: name,
-				tokenId: id
-			});
-			return yield* tryOperation(binding, "getToken", () => client.getToken(name, id));
-		}),
-		revokeToken: Effect.fn("ComputerArtifacts.revokeToken", spanOptions$2(binding, sessionId, "revokeToken"))(function* (name, tokenOrId) {
-			yield* Effect.annotateCurrentSpan("repo", name);
-			return yield* tryOperation(binding, "revokeToken", () => client.revokeToken(name, tokenOrId));
-		}),
-		cli: Effect.fn("ComputerArtifacts.cli", spanOptions$2(binding, sessionId, "cli"))(function* (input) {
-			yield* Effect.annotateCurrentSpan("argv", input.argv.join(" "));
-			return yield* tryOperation(binding, "cli", () => client.cli(input));
-		}),
-		rawUnsafe: Effect.succeed(client)
-	};
-};
-/**
-* Creates an Effect-native session client directly from a Worker Artifacts
-* binding. `@cloudflare/computer` is loaded only when this Effect runs, keeping
-* the optional peer out of applications that do not use this integration.
-*/
-const makeClient$11 = Effect.fn("ComputerArtifacts.makeClient")(function* (bindingValue, sessionId, options = {}) {
-	const binding = options.binding ?? "ARTIFACTS";
-	const computerArtifacts = yield* Effect.tryPromise({
-		try: () => import("@cloudflare/computer/artifacts"),
-		catch: (cause) => operationError(binding, "createClient", cause)
-	});
-	const client = yield* Effect.try({
-		try: () => computerArtifacts.createArtifact(bindingValue, sessionId),
-		catch: (cause) => operationError(binding, "createClient", cause)
-	});
-	return fromClient(client, { binding });
-});
-//#endregion
-//#region src/ComputerWorkspace.ts
-var ComputerWorkspace_exports = /* @__PURE__ */ __exportAll({
-	ComputerWorkspace: () => ComputerWorkspace,
-	WorkspaceAssetsError: () => WorkspaceAssetsError,
-	WorkspaceExecError: () => WorkspaceExecError,
-	WorkspaceFsError: () => WorkspaceFsError,
-	WorkspaceGitError: () => WorkspaceGitError,
-	fromWorkspaceClient: () => fromWorkspaceClient
-});
-/**
-* Workspace errors use `Schema.TaggedError`, unlike most local binding errors,
-* because workspace operations commonly sit behind Durable Object RPC methods.
-* The schema form preserves the operation-family tags across that boundary.
-*/
-var WorkspaceFsError = class extends Schema.TaggedError()("WorkspaceFsError", {
-	operation: Schema.String,
-	path: Schema.String,
-	message: Schema.String,
-	code: Schema.optionalKey(Schema.String),
-	cause: Schema.optionalKey(Schema.Defect({ includeStack: true }))
-}) {};
-/** Schema-serializable error for a workspace Git operation. */
-var WorkspaceGitError = class extends Schema.TaggedError()("WorkspaceGitError", {
-	operation: Schema.String,
-	message: Schema.String,
-	code: Schema.optionalKey(Schema.String),
-	cause: Schema.optionalKey(Schema.Defect({ includeStack: true }))
-}) {};
-/** Schema-serializable error for a workspace runtime operation. */
-var WorkspaceExecError = class extends Schema.TaggedError()("WorkspaceExecError", {
-	operation: Schema.String,
-	message: Schema.String,
-	code: Schema.optionalKey(Schema.String),
-	cause: Schema.optionalKey(Schema.Defect({ includeStack: true }))
-}) {};
-/** Schema-serializable error for a workspace Assets operation. */
-var WorkspaceAssetsError = class extends Schema.TaggedError()("WorkspaceAssetsError", {
-	operation: Schema.String,
-	path: Schema.String,
-	message: Schema.String,
-	code: Schema.optionalKey(Schema.String),
-	cause: Schema.optionalKey(Schema.Defect({ includeStack: true }))
-}) {};
-const errorMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
-const errorCode = (cause) => {
-	if (typeof cause !== "object" || cause === null) return;
-	const code = Reflect.get(cause, "code");
-	return typeof code === "string" ? code : void 0;
-};
-const fsError = (operation, path, cause) => WorkspaceFsError.make({
-	operation,
-	path,
-	message: errorMessage(cause),
-	cause,
-	...errorCode(cause) === void 0 ? {} : { code: errorCode(cause) }
-});
-const gitError = (operation, cause) => WorkspaceGitError.make({
-	operation,
-	message: errorMessage(cause),
-	cause,
-	...errorCode(cause) === void 0 ? {} : { code: errorCode(cause) }
-});
-const execError = (operation, cause) => WorkspaceExecError.make({
-	operation,
-	message: errorMessage(cause),
-	cause,
-	...errorCode(cause) === void 0 ? {} : { code: errorCode(cause) }
-});
-const assetsError = (operation, path, cause) => WorkspaceAssetsError.make({
-	operation,
-	path,
-	message: errorMessage(cause),
-	cause,
-	...errorCode(cause) === void 0 ? {} : { code: errorCode(cause) }
-});
-const tryFs = (operation, path, evaluate) => Effect.tryPromise({
-	try: evaluate,
-	catch: (cause) => fsError(operation, path, cause)
-});
-const isNotFound = (error) => error.code === "ENOENT" || /ENOENT|no such/i.test(error.message);
-const makeFilesystem = (fsClient) => {
-	const readFile = Effect.fn("ComputerWorkspace.fs.readFile", { attributes: {
-		family: "fs",
-		operation: "readFile"
-	} })(function* (path, options = {}) {
-		yield* Effect.annotateCurrentSpan("path", path);
-		const { encoding = "utf8", ...readOptions } = options;
-		if (encoding === "stream") return yield* tryFs("readFile", path, () => fsClient.readFile(path, readOptions));
-		return yield* tryFs("readFile", path, () => fsClient.readFile(path, {
-			...readOptions,
-			encoding: "utf8"
-		}));
-	});
-	const stat = Effect.fn("ComputerWorkspace.fs.stat", { attributes: {
-		family: "fs",
-		operation: "stat"
-	} })(function* (path) {
-		yield* Effect.annotateCurrentSpan("path", path);
-		return yield* tryFs("stat", path, () => fsClient.stat(path));
-	});
-	return {
-		readFile,
-		stat,
-		lstat: Effect.fn("ComputerWorkspace.fs.lstat", { attributes: {
-			family: "fs",
-			operation: "lstat"
-		} })(function* (path) {
-			yield* Effect.annotateCurrentSpan("path", path);
-			return yield* tryFs("lstat", path, () => fsClient.lstat(path));
-		}),
-		exists: Effect.fn("ComputerWorkspace.fs.exists", { attributes: {
-			family: "fs",
-			operation: "exists"
-		} })(function* (path) {
-			yield* Effect.annotateCurrentSpan("path", path);
-			return yield* stat(path).pipe(Effect.as(true), Effect.catch((error) => isNotFound(error) ? Effect.succeed(false) : Effect.fail(error)));
-		}),
-		readlink: Effect.fn("ComputerWorkspace.fs.readlink", { attributes: {
-			family: "fs",
-			operation: "readlink"
-		} })(function* (path) {
-			yield* Effect.annotateCurrentSpan("path", path);
-			return yield* tryFs("readlink", path, () => fsClient.readlink(path));
-		}),
-		readdir: Effect.fn("ComputerWorkspace.fs.readdir", { attributes: {
-			family: "fs",
-			operation: "readdir"
-		} })(function* (path, options) {
-			yield* Effect.annotateCurrentSpan("path", path);
-			return yield* tryFs("readdir", path, () => fsClient.readdir(path, options));
-		}),
-		find: Effect.fn("ComputerWorkspace.fs.find", { attributes: {
-			family: "fs",
-			operation: "find"
-		} })(function* (directory, pattern, options) {
-			yield* Effect.annotateCurrentSpan({
-				path: directory,
-				pattern
-			});
-			return yield* tryFs("find", directory, () => fsClient.find(directory, pattern, options));
-		}),
-		ls: Effect.fn("ComputerWorkspace.fs.ls", { attributes: {
-			family: "fs",
-			operation: "ls"
-		} })(function* (prefix) {
-			yield* Effect.annotateCurrentSpan("path", prefix);
-			return yield* tryFs("ls", prefix, () => fsClient.ls(prefix));
-		}),
-		grep: Effect.fn("ComputerWorkspace.fs.grep", { attributes: {
-			family: "fs",
-			operation: "grep"
-		} })(function* (pattern, path, options) {
-			yield* Effect.annotateCurrentSpan({
-				path,
-				pattern
-			});
-			return yield* tryFs("grep", path, () => fsClient.grep(pattern, path, options));
-		}),
-		writeFile: Effect.fn("ComputerWorkspace.fs.writeFile", { attributes: {
-			family: "fs",
-			operation: "writeFile"
-		} })(function* (path, content, options) {
-			yield* Effect.annotateCurrentSpan("path", path);
-			yield* tryFs("writeFile", path, () => fsClient.writeFile(path, content, options));
-		}),
-		mkdir: Effect.fn("ComputerWorkspace.fs.mkdir", { attributes: {
-			family: "fs",
-			operation: "mkdir"
-		} })(function* (path, options) {
-			yield* Effect.annotateCurrentSpan("path", path);
-			yield* tryFs("mkdir", path, () => fsClient.mkdir(path, options));
-		}),
-		rm: Effect.fn("ComputerWorkspace.fs.rm", { attributes: {
-			family: "fs",
-			operation: "rm"
-		} })(function* (path, options) {
-			yield* Effect.annotateCurrentSpan("path", path);
-			yield* tryFs("rm", path, () => fsClient.rm(path, options));
-		}),
-		chmod: Effect.fn("ComputerWorkspace.fs.chmod", { attributes: {
-			family: "fs",
-			operation: "chmod"
-		} })(function* (path, mode) {
-			yield* Effect.annotateCurrentSpan({
-				path,
-				mode
-			});
-			yield* tryFs("chmod", path, () => fsClient.chmod(path, mode));
-		}),
-		symlink: Effect.fn("ComputerWorkspace.fs.symlink", { attributes: {
-			family: "fs",
-			operation: "symlink"
-		} })(function* (target, path) {
-			yield* Effect.annotateCurrentSpan({
-				path,
-				target
-			});
-			yield* tryFs("symlink", path, () => fsClient.symlink(target, path));
-		})
-	};
-};
-const gitPerson = (person) => ({
-	...person,
-	timestampSeconds: person.timestamp
-});
-const gitCommit = (commit) => ({
-	oid: commit.oid,
-	message: commit.message,
-	tree: commit.tree,
-	parent: commit.parent,
-	parents: commit.parent,
-	author: gitPerson(commit.author),
-	committer: gitPerson(commit.committer)
-});
-const makeGit = (gitClient) => {
-	const method = (operation, evaluate) => Effect.fn(`ComputerWorkspace.git.${operation}`, { attributes: {
-		family: "git",
-		operation
-	} })(function* (...args) {
-		return yield* Effect.tryPromise({
-			try: () => evaluate(...args),
-			catch: (cause) => gitError(operation, cause)
-		});
-	});
-	const log = Effect.fn("ComputerWorkspace.git.log", { attributes: {
-		family: "git",
-		operation: "log"
-	} })(function* (options) {
-		const { maxCount, ...upstreamOptions } = options ?? {};
-		return (yield* Effect.tryPromise({
-			try: () => gitClient.log({
-				...upstreamOptions,
-				...upstreamOptions.depth === void 0 && maxCount !== void 0 ? { depth: maxCount } : {}
-			}),
-			catch: (cause) => gitError("log", cause)
-		})).map(gitCommit);
-	});
-	const revParse = Effect.fn("ComputerWorkspace.git.revParse", { attributes: {
-		family: "git",
-		operation: "revParse"
-	} })(function* (input) {
-		const options = typeof input === "string" ? { ref: input } : input;
-		return yield* Effect.tryPromise({
-			try: () => gitClient.revParse(options),
-			catch: (cause) => gitError("revParse", cause)
-		});
-	});
-	return {
-		clone: method("clone", (options) => gitClient.clone(options)),
-		diff: method("diff", (options) => gitClient.diff(options)),
-		diffSummary: method("diffSummary", (options) => gitClient.diffSummary(options)),
-		init: method("init", (options) => gitClient.init(options)),
-		status: method("status", (options) => gitClient.status(options)),
-		add: method("add", (options) => gitClient.add(options)),
-		rm: method("rm", (options) => gitClient.rm(options)),
-		commit: method("commit", (options) => gitClient.commit(options)),
-		log,
-		show: method("show", (options) => gitClient.show(options)),
-		revParse,
-		repoRoot: method("repoRoot", (options) => gitClient.repoRoot(options)),
-		currentBranch: method("currentBranch", (options) => gitClient.currentBranch(options)),
-		lsFiles: method("lsFiles", (options) => gitClient.lsFiles(options)),
-		lsTree: method("lsTree", (options) => gitClient.lsTree(options)),
-		branch: method("branch", (options) => gitClient.branch(options)),
-		branchDelete: method("branchDelete", (options) => gitClient.branchDelete(options)),
-		branchList: method("branchList", (options) => gitClient.branchList(options)),
-		tag: method("tag", (options) => gitClient.tag(options)),
-		tagDelete: method("tagDelete", (options) => gitClient.tagDelete(options)),
-		tagList: method("tagList", (options) => gitClient.tagList(options)),
-		checkout: method("checkout", (options) => gitClient.checkout(options)),
-		fetch: method("fetch", (options) => gitClient.fetch(options)),
-		push: method("push", (options) => gitClient.push(options)),
-		pull: method("pull", (options) => gitClient.pull(options)),
-		merge: method("merge", (options) => gitClient.merge(options)),
-		remoteAdd: method("remoteAdd", (options) => gitClient.remoteAdd(options)),
-		remoteRemove: method("remoteRemove", (options) => gitClient.remoteRemove(options)),
-		remoteList: method("remoteList", (options) => gitClient.remoteList(options)),
-		hashObject: method("hashObject", (options) => gitClient.hashObject(options)),
-		catFile: method("catFile", (options) => gitClient.catFile(options)),
-		updateRef: method("updateRef", (options) => gitClient.updateRef(options)),
-		configGet: method("configGet", (options) => gitClient.configGet(options)),
-		configSet: method("configSet", (options) => gitClient.configSet(options)),
-		stashPush: method("stashPush", (options) => gitClient.stashPush(options)),
-		stashList: method("stashList", (options) => gitClient.stashList(options)),
-		stashPop: method("stashPop", (options) => gitClient.stashPop(options)),
-		reset: method("reset", (options) => gitClient.reset(options)),
-		clean: method("clean", (options) => gitClient.clean(options)),
-		cli: method("cli", (input) => gitClient.cli(input))
-	};
-};
-const runtimeExecOptions = (options) => {
-	const { encoding = "utf8", timeoutMillis, timeoutMs, ...rest } = options ?? {};
-	return {
-		...rest,
-		...encoding === "utf8" ? { encoding: "utf8" } : {},
-		...timeoutMs === void 0 && timeoutMillis === void 0 ? {} : { timeoutMs: timeoutMs ?? timeoutMillis }
-	};
-};
-const runtimeGetOptions = (options) => {
-	const { encoding = "utf8", ...rest } = options ?? {};
-	return {
-		...rest,
-		...encoding === "utf8" ? { encoding: "utf8" } : {}
-	};
-};
-const wrapRuntimeResult = (result) => ({
-	status: result.status,
-	exitCode: result.exitCode,
-	stdout: result.stdout,
-	stderr: result.stderr,
-	...result.value === void 0 ? {} : { value: result.value },
-	pushed: result.pushed,
-	pulled: result.pulled,
-	skipped: result.skipped,
-	sync: result.sync
-});
-const wrapRuntimeEvent = (event) => {
-	switch (event.name) {
-		case "stdout": {
-			const chunk = event.value;
-			return typeof chunk === "string" ? {
-				_tag: "Stdout",
-				id: event.id,
-				sequence: event.seq,
-				chunk,
-				text: chunk
-			} : {
-				_tag: "Stdout",
-				id: event.id,
-				sequence: event.seq,
-				chunk,
-				bytes: chunk
-			};
-		}
-		case "stderr": {
-			const chunk = event.value;
-			return typeof chunk === "string" ? {
-				_tag: "Stderr",
-				id: event.id,
-				sequence: event.seq,
-				chunk,
-				text: chunk
-			} : {
-				_tag: "Stderr",
-				id: event.id,
-				sequence: event.seq,
-				chunk,
-				bytes: chunk
-			};
-		}
-		case "exit": return {
-			_tag: "Exit",
-			id: event.id,
-			sequence: event.seq,
-			exitCode: event.code,
-			...event.result === void 0 ? {} : { value: event.result }
-		};
-	}
-};
-const wrapRun = (handle) => {
-	const events = Stream.fromReadableStream({
-		evaluate: () => handle,
-		onError: (cause) => execError("events", cause)
-	}).pipe(Stream.map(wrapRuntimeEvent));
-	const result = Effect.tryPromise({
-		try: () => handle.result(),
-		catch: (cause) => execError("result", cause)
-	}).pipe(Effect.map(wrapRuntimeResult));
-	const kill = Effect.fn("ComputerWorkspace.runtime.run.kill", { attributes: {
-		family: "runtime",
-		operation: "run.kill",
-		runId: handle.id
-	} })(function* (signal) {
-		yield* Effect.tryPromise({
-			try: () => handle.kill(signal),
-			catch: (cause) => execError("run.kill", cause)
-		});
-	});
-	return {
-		id: handle.id,
-		backend: handle.backend,
-		events,
-		result,
-		kill
-	};
-};
-const releaseRun = (handle) => Effect.sync(() => handle[Symbol.dispose]());
-const makeRuntime = (client) => {
-	const execImplementation = Effect.fn("ComputerWorkspace.runtime.exec", { attributes: {
-		family: "runtime",
-		operation: "exec"
-	} })(function* (source, optionsOrValue, ...remainingValues) {
-		const options = typeof source === "string" ? optionsOrValue : void 0;
-		yield* Effect.annotateCurrentSpan({
-			backend: options?.backend,
-			runId: options?.id
-		});
-		const handle = yield* Effect.acquireRelease(Effect.tryPromise({
-			try: () => {
-				if (typeof source === "string") return client.runtime.exec(source, runtimeExecOptions(options));
-				const values = optionsOrValue === void 0 ? remainingValues : [optionsOrValue, ...remainingValues];
-				return client.runtime.exec(source, ...values);
-			},
-			catch: (cause) => execError("exec", cause)
-		}), releaseRun);
-		return wrapRun(handle);
-	});
-	const exec = execImplementation;
-	const getExec = Effect.fn("ComputerWorkspace.runtime.getExec", { attributes: {
-		family: "runtime",
-		operation: "getExec"
-	} })(function* (id, options) {
-		yield* Effect.annotateCurrentSpan({
-			backend: options?.backend,
-			runId: id
-		});
-		const handle = yield* Effect.acquireRelease(Effect.tryPromise({
-			try: () => client.runtime.getExec(id, runtimeGetOptions(options)),
-			catch: (cause) => execError("getExec", cause)
-		}), releaseRun);
-		return wrapRun(handle);
-	});
-	const killExec = Effect.fn("ComputerWorkspace.runtime.killExec", { attributes: {
-		family: "runtime",
-		operation: "killExec"
-	} })(function* (id, options) {
-		yield* Effect.annotateCurrentSpan({
-			backend: options?.backend,
-			runId: id
-		});
-		yield* Effect.tryPromise({
-			try: () => client.runtime.killExec(id, options),
-			catch: (cause) => execError("killExec", cause)
-		});
-	});
-	const disposeExec = Effect.fn("ComputerWorkspace.runtime.disposeExec", { attributes: {
-		family: "runtime",
-		operation: "disposeExec"
-	} })(function* (id, options) {
-		yield* Effect.annotateCurrentSpan({
-			backend: options?.backend,
-			runId: id
-		});
-		yield* Effect.tryPromise({
-			try: () => client.runtime.disposeExec(id, options),
-			catch: (cause) => execError("disposeExec", cause)
-		});
-	});
-	return {
-		exec,
-		execCollect: Effect.fn("ComputerWorkspace.runtime.execCollect", { attributes: {
-			family: "runtime",
-			operation: "execCollect"
-		} })(function* (source, optionsOrValue, ...remainingValues) {
-			return yield* Effect.scoped(Effect.gen(function* () {
-				return yield* (yield* execImplementation(source, optionsOrValue, ...remainingValues)).result;
-			}));
-		}),
-		getExec,
-		killExec,
-		disposeExec
-	};
-};
-const makeAssets = (client) => client === void 0 ? void 0 : { share: Effect.fn("ComputerWorkspace.assets.share", { attributes: {
-	family: "assets",
-	operation: "share"
-} })(function* (path, options) {
-	yield* Effect.annotateCurrentSpan("path", path);
-	return yield* Effect.tryPromise({
-		try: () => client.share(path, options),
-		catch: (cause) => assetsError("share", path, cause)
-	});
-}) };
-const makeThink = (client) => {
-	if (client.readFile === void 0 || client.readFileBytes === void 0 || client.writeFile === void 0 || client.readDir === void 0 || client.rm === void 0 || client.glob === void 0 || client.mkdir === void 0 || client.stat === void 0) return;
-	const method = (operation, pathOf, evaluate) => Effect.fn(`ComputerWorkspace.think.${operation}`, { attributes: {
-		family: "think",
-		operation
-	} })(function* (...args) {
-		const path = pathOf(...args);
-		yield* Effect.annotateCurrentSpan("path", path);
-		return yield* tryFs(`think.${operation}`, path, () => evaluate(...args));
-	});
-	return {
-		readFile: method("readFile", (path) => path, (path) => client.readFile(path)),
-		readFileBytes: method("readFileBytes", (path) => path, (path) => client.readFileBytes(path)),
-		writeFile: method("writeFile", (path, _content) => path, (path, content) => client.writeFile(path, content)),
-		readDir: method("readDir", (path, _options) => path, (path, options) => client.readDir(path, options)),
-		rm: method("rm", (path, _options) => path, (path, options) => client.rm(path, options)),
-		glob: method("glob", (pattern) => pattern, (pattern) => client.glob(pattern)),
-		mkdir: method("mkdir", (path, _options) => path, (path, options) => client.mkdir(path, options)),
-		stat: method("stat", (path) => path, (path) => client.stat(path))
-	};
-};
-/**
-* Wraps a client whose lifetime is owned by the caller. Prefer
-* {@link ComputerWorkspace.layer} in Durable Objects so the parent client and
-* every runtime handle are disposed by Effect `Scope`.
-*/
-const fromWorkspaceClient = (client) => {
-	const fs = makeFilesystem(client.fs);
-	const git = makeGit(client.git);
-	const runtime = makeRuntime(client);
-	return {
-		fs,
-		git,
-		runtime,
-		artifacts: fromClient(client.artifacts, { binding: "ComputerWorkspace.artifacts" }),
-		assets: makeAssets(client.assets),
-		think: makeThink(client),
-		readFile: fs.readFile,
-		stat: fs.stat,
-		lstat: fs.lstat,
-		exists: fs.exists,
-		readlink: fs.readlink,
-		readdir: fs.readdir,
-		listDirectory: fs.readdir,
-		find: fs.find,
-		ls: fs.ls,
-		grep: fs.grep,
-		writeFile: fs.writeFile,
-		mkdir: fs.mkdir,
-		rm: fs.rm,
-		removePath: fs.rm,
-		chmod: fs.chmod,
-		symlink: fs.symlink,
-		exec: runtime.exec,
-		execCollect: runtime.execCollect,
-		getExec: runtime.getExec,
-		killExec: runtime.killExec,
-		disposeExec: runtime.disposeExec
-	};
-};
-/** Effect service for the workspace owned by the enclosing Durable Object. */
-var ComputerWorkspace = class ComputerWorkspace extends Context.Service()("effect-cf/ComputerWorkspace") {
-	/**
-	* Acquires the single workspace registered by `withComputerWorkspace` and
-	* releases its RPC client when the layer scope closes.
-	*/
-	static layer = Layer.effect(ComputerWorkspace, Effect.gen(function* () {
-		const host = lookup((yield* DurableObjectState).raw);
-		if (host === void 0) return yield* Effect.die("ComputerWorkspace.layer requires a Durable Object class built with withComputerWorkspace");
-		const computer = yield* Effect.promise(() => import("@cloudflare/computer"));
-		const client = yield* Effect.acquireRelease(Effect.promise(() => computer.getWorkspace(host)), (workspace) => Effect.sync(() => workspace[Symbol.dispose]()));
-		return ComputerWorkspace.of(fromWorkspaceClient(client));
-	}));
-};
-//#endregion
 //#region src/ContainerNamespace.ts
 var ContainerNamespace_exports = /* @__PURE__ */ __exportAll({
 	ContainerNamespace: () => ContainerNamespace,
@@ -1648,7 +842,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)),
@@ -1685,7 +879,7 @@ const makeClient$10 = (definition) => (namespace) => {
 		rawUnsafe: Effect.succeed(namespace)
 	};
 };
-const layer$12 = (tag, definition) => layer$20(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) => {
@@ -1728,11 +922,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.
 */
@@ -1786,10 +976,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) => ({
@@ -1831,7 +1018,7 @@ const makeClient$9 = (definition) => {
 		rawUnsafe: Effect.succeed(queue)
 	});
 };
-const layer$11 = (tag, definition) => layer$20(tag, definition.binding, (value) => isQueue(value), makeClient$9(definition), { expected: expectedQueueProducer });
+const layer$11 = (tag, definition) => layer$19(tag, definition.binding, (value) => isQueue(value), makeClient$9(definition), { expected: expectedQueueProducer });
 //#endregion
 //#region src/QueueDefinition.ts
 var QueueDefinition_exports = /* @__PURE__ */ __exportAll({
@@ -2022,7 +1209,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 {
@@ -2115,6 +1302,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 ?? {};
@@ -2122,12 +1313,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
 /**
@@ -2143,18 +1335,11 @@ 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);
@@ -2177,25 +1362,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
 });
@@ -2235,7 +1425,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) {
@@ -2292,7 +1484,7 @@ const makeClient$8 = (definition) => {
 		});
 	};
 };
-const layer$10 = (tag, definition) => layer$20(tag, definition.binding, (value) => isServiceBindingClient(value), makeClient$8(definition), { expected: expectedServiceBinding });
+const layer$10 = (tag, definition) => layer$19(tag, definition.binding, (value) => isServiceBindingClient(value), makeClient$8(definition), { expected: expectedServiceBinding });
 /**
 * Creates a typed Effect service for a Worker service binding.
 *
@@ -2348,7 +1540,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
@@ -2376,6 +1571,9 @@ const reservedMethodNames$3 = /* @__PURE__ */ new Set([
 	"webSocketClose",
 	"webSocketError"
 ]);
+const assumeTagClass = (value) => {
+	return value;
+};
 /**
 * Defines a single RPC method schema in a worker definition.
 */
@@ -2396,10 +1594,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) => {
@@ -2423,7 +1625,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,
@@ -2432,11 +1634,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* () {
@@ -2546,8 +1748,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);
@@ -2569,19 +1773,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);
@@ -2591,7 +1784,7 @@ const makeFetchHandler = (layer, options) => {
 		}
 		return instance[FetchSymbol](request, ctx);
 	} };
-};
+}
 //#endregion
 //#region src/DurableObjectNamespace.ts
 var DurableObjectNamespace_exports = /* @__PURE__ */ __exportAll({
@@ -2619,8 +1812,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));
@@ -2693,7 +1886,7 @@ const makeClient$7 = (definition) => {
 		});
 	};
 };
-const layer$9 = (tag, definition) => layer$20(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$7(definition), { expected: expectedDurableObjectNamespace });
+const layer$9 = (tag, definition) => layer$19(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$7(definition), { expected: expectedDurableObjectNamespace });
 const makeDirectMethods = (rpcDefinition, helpers) => {
 	const methods = {};
 	if (rpcDefinition !== void 0) {
@@ -2732,10 +1925,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.
 *
@@ -2788,14 +1980,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;
@@ -2826,7 +2021,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* () {
@@ -2873,7 +2068,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;
@@ -2895,8 +2092,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);
@@ -3032,12 +2229,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;
@@ -3350,21 +2547,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
@@ -3470,9 +2667,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,
@@ -3501,16 +2698,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"
 	}];
@@ -3523,18 +2720,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"
 		});
@@ -3542,7 +2739,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"
 		});
@@ -3558,7 +2755,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"
@@ -3588,11 +2785,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"
 	});
@@ -3613,10 +2810,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;
@@ -3629,7 +2823,7 @@ const makeClient$6 = (definition, options) => (email) => {
 		rawUnsafe: Effect.succeed(email)
 	};
 };
-const layer$6 = (tag, definition) => layer$20(tag, definition.binding, isEmailBinding, makeClient$6(definition, definition.send), { expected: expectedSendEmailBinding });
+const layer$6 = (tag, definition) => layer$19(tag, definition.binding, isEmailBinding, makeClient$6(definition, definition.send), { expected: expectedSendEmailBinding });
 const make$6 = (id) => Tag$7()(id);
 const Tag$7 = () => (id) => {
 	const tag = Context.Service()(id);
@@ -3649,16 +2843,13 @@ 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,
 	rawUnsafe: Effect.succeed(hyperdrive)
 });
-const layer$5 = (tag, definition) => layer$20(tag, definition.binding, isHyperdrive, makeClient$5(definition), { expected: expectedHyperdrive });
+const layer$5 = (tag, definition) => layer$19(tag, definition.binding, isHyperdrive, makeClient$5(definition), { expected: expectedHyperdrive });
 const make$5 = (id) => Tag$6()(id);
 const Tag$6 = () => (id) => {
 	const tag = Context.Service()(id);
@@ -3713,9 +2904,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()),
@@ -3755,7 +2946,7 @@ const makeClient$4 = (definition) => (images) => {
 		rawUnsafe: Effect.succeed(images)
 	};
 };
-const layer$4 = (tag, definition) => layer$20(tag, definition.binding, isImagesBinding, makeClient$4(definition), { expected: expectedImagesBinding });
+const layer$4 = (tag, definition) => layer$19(tag, definition.binding, isImagesBinding, makeClient$4(definition), { expected: expectedImagesBinding });
 const make$4 = (id) => Tag$5()(id);
 const Tag$5 = () => (id) => {
 	const tag = Context.Service()(id);
@@ -3790,11 +2981,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);
@@ -3868,7 +3055,7 @@ const makeClient$3 = (definition) => {
 		rawUnsafe: Effect.succeed(kv)
 	});
 };
-const layer$3 = (tag, definition) => layer$20(tag, definition.binding, isKvNamespace, makeClient$3(definition), { expected: expectedKvNamespace });
+const layer$3 = (tag, definition) => layer$19(tag, definition.binding, isKvNamespace, makeClient$3(definition), { expected: expectedKvNamespace });
 const makeDefinition$1 = (id, definition) => {
 	const kvDefinition = {
 		id,
@@ -3926,7 +3113,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,
@@ -3956,11 +3143,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,
@@ -3984,7 +3169,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))),
@@ -3992,7 +3177,7 @@ const makeClient$2 = (definition) => {
 		};
 	};
 };
-const layer$2 = (tag, definition) => layer$20(tag, definition.binding, isR2Bucket, makeClient$2(definition), { expected: expectedR2Bucket });
+const layer$2 = (tag, definition) => layer$19(tag, definition.binding, isR2Bucket, makeClient$2(definition), { expected: expectedR2Bucket });
 const make$3 = (id) => Tag$3()(id);
 const Tag$3 = () => (id) => {
 	const tag = Context.Service()(id);
@@ -4032,16 +3217,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,
@@ -4050,7 +3244,7 @@ const makeClient$1 = (definition) => (index) => {
 		rawUnsafe: Effect.succeed(index)
 	};
 };
-const layer$1 = (tag, definition) => layer$20(tag, definition.binding, isVectorizeBinding, makeClient$1(definition), { expected: expectedVectorizeBinding });
+const layer$1 = (tag, definition) => layer$19(tag, definition.binding, isVectorizeBinding, makeClient$1(definition), { expected: expectedVectorizeBinding });
 const make$2 = (id) => Tag$2()(id);
 const Tag$2 = () => (id) => {
 	const tag = Context.Service()(id);
@@ -4106,10 +3300,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() {
@@ -4154,11 +3351,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);
@@ -4216,7 +3411,7 @@ const makeClient = (definition) => {
 		rawUnsafe: Effect.succeed(workflow)
 	});
 };
-const layer = (tag, definition) => layer$20(tag, definition.binding, (value) => isWorkflow(value), makeClient(definition), { expected: expectedWorkflow });
+const layer = (tag, definition) => layer$19(tag, definition.binding, (value) => isWorkflow(value), makeClient(definition), { expected: expectedWorkflow });
 //#endregion
 //#region src/WorkflowDefinition.ts
 var WorkflowDefinition_exports = /* @__PURE__ */ __exportAll({
@@ -4237,7 +3432,7 @@ const make$1 = (id, definition) => Tag$1()(id, definition);
 const Tag$1 = () => (id, definition) => {
 	const workflowDefinition = makeDefinition(id, definition);
 	const tag = Context.Service()(`effect-cf/Workflow/${id}`);
-	const layer$21 = (binding) => layer(tag, {
+	const layer$20 = (binding) => layer(tag, {
 		...binding,
 		payload: definition.payload,
 		result: definition.result
@@ -4257,7 +3452,7 @@ const Tag$1 = () => (id, definition) => {
 		payload: workflowDefinition.payload,
 		result: workflowDefinition.result,
 		make: workflowDefinition.make,
-		layer: layer$21,
+		layer: layer$20,
 		create,
 		createBatch,
 		get,
@@ -4291,6 +3486,7 @@ var Workflow_exports = /* @__PURE__ */ __exportAll({
 	WorkflowStep: () => WorkflowStep$1,
 	WorkflowStepContext: () => WorkflowStepContext$1,
 	WorkflowStepError: () => WorkflowStepError,
+	WorkflowStepNonRetryableError: () => WorkflowStepNonRetryableError,
 	implement: () => implement,
 	make: () => make,
 	sleep: () => sleep,
@@ -4306,6 +3502,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) => ({
@@ -4315,11 +3522,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);
 		},
@@ -4346,7 +3562,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",
@@ -4375,4 +3593,4 @@ const waitForEvent = (name, options) => Effect.flatMap(WorkflowStep$1, (workflow
 const Tag = Tag$1;
 const implement = implement$1;
 //#endregion
-export { AiGateway_exports as AiGateway, AnalyticsEngine_exports as AnalyticsEngine, Artifacts_exports as Artifacts, Binding_exports as Binding, BrowserRendering_exports as BrowserRendering, Cache_exports as Cache, CloudflareOtlp_exports as CloudflareOtlp, ComputerArtifacts_exports as ComputerArtifacts, ComputerWorkspace_exports as ComputerWorkspace, ContainerNamespace_exports as ContainerNamespace, D1_exports as D1, DurableObject_exports as DurableObject, DurableObjectAlarm_exports as DurableObjectAlarm, DurableObjectDefinition_exports as DurableObjectDefinition, DurableObjectNamespace_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_exports as DurableObjectSqlite, DurableObjectState_exports as DurableObjectState, DurableObjectStorage_exports as DurableObjectStorage, DurableObjectWebSocket_exports as DurableObjectWebSocket, Email_exports as Email, Environment_exports as Environment, Hyperdrive_exports as Hyperdrive, Images_exports as Images, Kv_exports as Kv, Queue_exports as Queue, QueueBinding_exports as QueueBinding, QueueDefinition_exports as QueueDefinition, R2_exports as R2, Rpc_exports as Rpc, RpcDefinition_exports as RpcDefinition, ServiceBinding_exports as ServiceBinding, Vectorize_exports as Vectorize, WebTransport_exports as WebTransport, Worker_exports as Worker, WorkerConfig, WorkerDefinition_exports as WorkerDefinition, WorkerEnvironment, WorkersAi_exports as WorkersAi, Workflow_exports as Workflow, WorkflowBinding_exports as WorkflowBinding, WorkflowDefinition_exports as WorkflowDefinition };
+export { AiGateway_exports as AiGateway, AnalyticsEngine_exports as AnalyticsEngine, Artifacts_exports as Artifacts, Binding_exports as Binding, BrowserRendering_exports as BrowserRendering, Cache_exports as Cache, CloudflareOtlp_exports as CloudflareOtlp, ContainerNamespace_exports as ContainerNamespace, D1_exports as D1, DurableObject_exports as DurableObject, DurableObjectAlarm_exports as DurableObjectAlarm, DurableObjectDefinition_exports as DurableObjectDefinition, DurableObjectNamespace_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_exports as DurableObjectSqlite, DurableObjectState_exports as DurableObjectState, DurableObjectStorage_exports as DurableObjectStorage, DurableObjectWebSocket_exports as DurableObjectWebSocket, Email_exports as Email, Environment_exports as Environment, Hyperdrive_exports as Hyperdrive, Images_exports as Images, Kv_exports as Kv, Queue_exports as Queue, QueueBinding_exports as QueueBinding, QueueDefinition_exports as QueueDefinition, R2_exports as R2, Rpc_exports as Rpc, RpcDefinition_exports as RpcDefinition, ServiceBinding_exports as ServiceBinding, Vectorize_exports as Vectorize, WebTransport_exports as WebTransport, Worker_exports as Worker, WorkerConfig, WorkerDefinition_exports as WorkerDefinition, WorkerEnvironment, WorkersAi_exports as WorkersAi, Workflow_exports as Workflow, WorkflowBinding_exports as WorkflowBinding, WorkflowDefinition_exports as WorkflowDefinition };