effect-cf 0.9.1 → 0.10.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # effect-cf
 
+## 0.10.0
+
+### Minor Changes
+
+- [#32](https://github.com/danieljvdm/effect-cf/pull/32) [`4812c94`](https://github.com/danieljvdm/effect-cf/commit/4812c9457592f3416f6f303f0b8620ba52e46765) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Raise the minimum supported Effect beta to `4.0.0-beta.70` and update service tag access to use beta 70's direct yieldable tags instead of the removed `.asEffect()` helper.
+
+## 0.9.2
+
+### Patch Changes
+
+- [#30](https://github.com/danieljvdm/effect-cf/pull/30) [`29c3fd4`](https://github.com/danieljvdm/effect-cf/commit/29c3fd491bad0c8d6994e9a666f6e501c1a337a2) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Accept local queue producer bindings that only expose `send`, including Wrangler local dev bindings. Binding validation errors now include the binding name, expected shape, and actual resource shape in pretty output across Cloudflare bindings.
+
 ## 0.9.1
 
 ### Patch Changes

package/dist/{Hyperdrive-LuQaVhXU.mjs → Hyperdrive-89hg_Fck.mjs}

@@ -13,7 +13,7 @@ let WorkerConfig;
 	_WorkerConfig.integer = (name) => Config.int(name);
 	_WorkerConfig.boolean = (name) => Config.boolean(name);
 	const providerFromEnv = _WorkerConfig.providerFromEnv = (env) => ConfigProvider.fromUnknown(env);
-	const providerWith = _WorkerConfig.providerWith = (makeProvider) => Effect.map(WorkerEnvironment.asEffect(), makeProvider);
+	const providerWith = _WorkerConfig.providerWith = (makeProvider) => Effect.map(WorkerEnvironment, makeProvider);
 	const provider = _WorkerConfig.provider = providerWith(providerFromEnv);
 	_WorkerConfig.layer = _WorkerConfig.providerLayer = ConfigProvider.layer(provider);
 	_WorkerConfig.layerWith = (makeProvider) => ConfigProvider.layer(providerWith(makeProvider));
@@ -33,21 +33,90 @@ const TypeId = "effect-cf/Binding";
 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 = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
-const getBinding = (env, binding, isResource) => Effect.gen(function* () {
-	if (!isPropertyTarget(env)) return yield* Effect.fail(new BindingValidationError({ binding }));
+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(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 }));
-	if (!isResource(resource)) return yield* Effect.fail(new BindingValidationError({ binding }));
+	if (resource === void 0) return yield* Effect.fail(new BindingNotFoundError({
+		binding,
+		message: `Cloudflare binding "${binding}" was not found in WorkerEnvironment`
+	}));
+	if (!isResource(resource)) {
+		const expected = options?.expected ?? defaultExpected;
+		const actual = describeActual(resource);
+		return yield* Effect.fail(new BindingValidationError({
+			binding,
+			expected,
+			actual,
+			message: `Cloudflare binding "${binding}" failed validation. Expected ${expected}; got ${actual}`
+		}));
+	}
 	return resource;
 });
-const layer$1 = (tag, binding, isResource, wrap) => Layer.effect(tag, Effect.gen(function* () {
-	const resource = yield* getBinding(yield* WorkerEnvironment, binding, isResource);
+const layer$1 = (tag, binding, isResource, wrap, options) => Layer.effect(tag, Effect.gen(function* () {
+	const resource = yield* getBinding(yield* WorkerEnvironment, binding, isResource, options);
 	return wrap === void 0 ? resource : wrap(resource);
 }));
-const Service = () => (id, binding, isResource, wrap) => {
+const Service = () => (id, binding, isResource, wrap, options) => {
 	const tag = Context.Service()(id);
-	const serviceLayer = layer$1(tag, binding, isResource, wrap);
+	const serviceLayer = layer$1(tag, binding, isResource, wrap, options);
 	return Object.assign(tag, {
 		[TypeId]: TypeId,
 		binding,
@@ -63,6 +132,7 @@ var Hyperdrive_exports = /* @__PURE__ */ __exportAll({
 	make: () => make,
 	makeClient: () => makeClient
 });
+const expectedHyperdrive = "Hyperdrive binding with connectionString";
 const isHyperdrive = (value) => {
 	if (typeof value !== "object" || value === null) return false;
 	return typeof value.connectionString === "string";
@@ -72,7 +142,7 @@ const makeClient = (definition) => (hyperdrive) => ({
 	connectionString: hyperdrive.connectionString,
 	unsafeRaw: Effect.succeed(hyperdrive)
 });
-const layer = (tag, definition) => layer$1(tag, definition.binding, isHyperdrive, makeClient(definition));
+const layer = (tag, definition) => layer$1(tag, definition.binding, isHyperdrive, makeClient(definition), { expected: expectedHyperdrive });
 const make = (id) => Tag()(id);
 const Tag = () => (id) => {
 	const tag = Context.Service()(id);

package/dist/{Hyperdrive-By6DrSS_.d.mts → Hyperdrive-L6ldMlRF.d.mts}

@@ -76,7 +76,7 @@ declare namespace WorkerConfig {
   const layerWith: (makeProvider: (env: WorkerEnv) => ConfigProvider.ConfigProvider) => _$effect_Layer0.Layer<never, never, WorkerEnvironment>;
 }
 declare namespace Binding_d_exports {
-  export { BindingNotFoundError, BindingService, BindingValidationError, Service, TypeId, layer$1 as layer };
+  export { BindingNotFoundError, BindingService, BindingValidationError, Service, TypeId, ValidationOptions, layer$1 as layer };
 }
 /** Internal type id marker used by binding helper services. */
 declare const TypeId: "effect-cf/Binding";
@@ -86,6 +86,7 @@ declare const BindingNotFoundError_base: new <A extends Record<string, any> = {}
 /** Error raised when a configured binding does not exist on `env`. */
 declare class BindingNotFoundError extends BindingNotFoundError_base<{
   readonly binding: string;
+  readonly message: string;
 }> {}
 declare const BindingValidationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
   readonly _tag: "BindingValidationError";
@@ -93,7 +94,13 @@ declare const BindingValidationError_base: new <A extends Record<string, any> =
 /** Error raised when a binding exists but does not match the expected shape. */
 declare class BindingValidationError extends BindingValidationError_base<{
   readonly binding: string;
+  readonly expected: string;
+  readonly actual: string;
+  readonly message: string;
 }> {}
+interface ValidationOptions {
+  readonly expected?: string;
+}
 /**
  * Creates a Context tag + layer for reading and validating a Cloudflare binding.
  */
@@ -102,8 +109,8 @@ interface BindingService<Self, Id extends string, Service> extends Context.Servi
   readonly binding: string;
   readonly layer: Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
-declare const layer$1: <Self, Resource, Service = Resource>(tag: Context.Service<Self, Service>, binding: string, isResource: (value: unknown) => value is Resource, wrap?: (resource: Resource) => Service) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const Service: <Self>() => <Id extends string, Resource, Service = Resource>(id: Id, binding: string, isResource: (value: unknown) => value is Resource, wrap?: (resource: Resource) => Service) => BindingService<Self, Id, Service>;
+declare const layer$1: <Self, Resource, Service = Resource>(tag: Context.Service<Self, Service>, binding: string, isResource: (value: unknown) => value is Resource, wrap?: (resource: Resource) => Service, options?: ValidationOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const Service: <Self>() => <Id extends string, Resource, Service = Resource>(id: Id, binding: string, isResource: (value: unknown) => value is Resource, wrap?: (resource: Resource) => Service, options?: ValidationOptions) => BindingService<Self, Id, Service>;
 declare namespace Hyperdrive_d_exports {
   export { HyperdriveClient, HyperdriveDefinition, HyperdriveService, LayerOptions, Tag, TagClass, isHyperdrive, layer, make, makeClient };
 }

package/dist/HyperdrivePg.d.mts

@@ -1,4 +1,4 @@
-import { i as BindingNotFoundError, n as LayerOptions, o as BindingValidationError, r as TagClass, u as WorkerEnvironment } from "./Hyperdrive-By6DrSS_.mjs";
+import { i as BindingNotFoundError, n as LayerOptions, o as BindingValidationError, r as TagClass, u as WorkerEnvironment } from "./Hyperdrive-L6ldMlRF.mjs";
 import { Layer } from "effect";
 import { PgClient } from "@effect/sql-pg";
 import * as _$effect_unstable_sql_SqlClient0 from "effect/unstable/sql/SqlClient";

package/dist/HyperdrivePg.mjs

@@ -1,4 +1,4 @@
-import "./Hyperdrive-LuQaVhXU.mjs";
+import "./Hyperdrive-89hg_Fck.mjs";
 import { Effect, Layer, Redacted } from "effect";
 import { PgClient } from "@effect/sql-pg";
 //#region src/HyperdrivePg.ts

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { a as BindingService, c as WorkerConfig, i as BindingNotFoundError, l as WorkerEnv, o as BindingValidationError, s as Binding_d_exports, t as Hyperdrive_d_exports, u as WorkerEnvironment } from "./Hyperdrive-By6DrSS_.mjs";
+import { a as BindingService, c as WorkerConfig, i as BindingNotFoundError, l as WorkerEnv, o as BindingValidationError, s as Binding_d_exports, t as Hyperdrive_d_exports, u as WorkerEnvironment } from "./Hyperdrive-L6ldMlRF.mjs";
 import { Cause, Context, Data, DateTime, Duration, Effect, Layer, Option, Schema, Scope } from "effect";
 import { D1Client } from "@effect/sql-d1";
 import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, WorkflowEntrypoint, WorkflowEvent, WorkflowSleepDuration, WorkflowStep, WorkflowStepConfig, WorkflowStepContext, WorkflowStepEvent, WorkflowTimeoutDuration } from "cloudflare:workers";
@@ -184,7 +184,7 @@ declare const encodeSuccess: <const Self extends Definition$9.Any, MethodName ex
 declare const decodeSuccess: <const Self extends Definition$9.Any, MethodName extends Definition$9.MethodNames<Self>>(definition: Self, methodName: MethodName, value: unknown) => Effect.Effect<Method$5.Success<Self["methods"][MethodName]>, RpcSuccessDecodeError>;
 declare const make$9: <Id extends string, const MethodsShape extends Methods$4>(id: Id, methods: MethodsShape) => Definition$9<Id, MethodsShape>;
 declare namespace QueueBinding_d_exports {
-  export { MessageSendRequest, QueueBindingClient, QueueBindingDefinition, QueueMetrics, QueueOperationError, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse, isQueue, layer$7 as layer, makeClient$6 as makeClient };
+  export { MessageSendRequest, QueueBindingClient, QueueBindingDefinition, QueueMetrics, QueueOperationError, QueueProducer, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse, isQueue, layer$7 as layer, makeClient$6 as makeClient };
 }
 type QueueSendOptions = globalThis.QueueSendOptions;
 type QueueSendResponse = globalThis.QueueSendResponse;
@@ -192,6 +192,7 @@ type QueueSendBatchOptions = globalThis.QueueSendBatchOptions;
 type QueueSendBatchResponse = globalThis.QueueSendBatchResponse;
 type QueueMetrics = globalThis.QueueMetrics;
 type MessageSendRequest<Body> = globalThis.MessageSendRequest<Body>;
+type QueueProducer<Body> = Pick<globalThis.Queue<Body>, "send"> & Partial<Pick<globalThis.Queue<Body>, "sendBatch" | "metrics">>;
 interface QueueBindingDefinition<Message extends ServiceFreeSchema$4> {
   /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
@@ -211,9 +212,10 @@ declare class QueueOperationError extends QueueOperationError_base<{
   readonly binding: string;
   readonly operation: string;
   readonly cause: unknown;
+  readonly message: string;
 }> {}
-declare const isQueue: <Body>(value: unknown) => value is globalThis.Queue<Body>;
-declare const makeClient$6: <Message extends ServiceFreeSchema$4>(definition: QueueBindingDefinition<Message>) => ((queue: globalThis.Queue<Schema.Codec.Encoded<Message>>) => QueueBindingClient<Message>);
+declare const isQueue: <Body>(value: unknown) => value is QueueProducer<Body>;
+declare const makeClient$6: <Message extends ServiceFreeSchema$4>(definition: QueueBindingDefinition<Message>) => ((queue: QueueProducer<Schema.Codec.Encoded<Message>>) => QueueBindingClient<Message>);
 declare const layer$7: <Self, Message extends ServiceFreeSchema$4>(tag: Context.Service<Self, QueueBindingClient<Message>>, definition: QueueBindingDefinition<Message>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare namespace QueueDefinition_d_exports {
   export { Definition$8 as Definition, Handler$3 as Handler, LayerOptions$11 as LayerOptions, Options$7 as Options, Queue$1 as Queue, Tag$11 as Tag, TagClass$10 as TagClass, implement$7 as implement, make$8 as make };

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
-import { a as WorkerConfig, i as layer$8, n as Binding_exports, o as WorkerEnvironment, r as Service$2, t as Hyperdrive_exports } from "./Hyperdrive-LuQaVhXU.mjs";
+import { a as WorkerConfig, i as layer$8, n as Binding_exports, o as WorkerEnvironment, r as Service$2, t as Hyperdrive_exports } from "./Hyperdrive-89hg_Fck.mjs";
 import { Cause, Clock, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Layer, ManagedRuntime, Option, Queue, Schema } from "effect";
 import { D1Client } from "@effect/sql-d1";
 import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, WorkflowEntrypoint } from "cloudflare:workers";
@@ -13,6 +13,7 @@ var D1_exports = /* @__PURE__ */ __exportAll({
 	make: () => make$10
 });
 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;
@@ -38,7 +39,7 @@ const make$10 = (id, definition) => Service$1()(id, definition);
 * ```
 */
 const Service$1 = () => (id, definition) => {
-	const tag = Service$2()(id, definition.binding, isD1Database);
+	const tag = Service$2()(id, definition.binding, isD1Database, void 0, { expected: expectedD1Database });
 	const sqlLayer = (options) => Layer.unwrap(Effect.gen(function* () {
 		const db = yield* tag;
 		return D1Client.layer({
@@ -60,20 +61,20 @@ var QueueBinding_exports = /* @__PURE__ */ __exportAll({
 	layer: () => layer$7,
 	makeClient: () => makeClient$6
 });
+const expectedQueueProducer = "Queue producer binding with send(); optional sendBatch()/metrics()";
 var QueueOperationError = class extends Data.TaggedError("QueueOperationError") {};
-const queueError = (binding, operation, cause) => new QueueOperationError({
-	binding,
-	operation,
-	cause
-});
 const tryQueuePromise = (binding, operation, evaluate) => Effect.tryPromise({
 	try: evaluate,
-	catch: (cause) => queueError(binding, operation, cause)
+	catch: (cause) => new QueueOperationError({
+		binding,
+		operation,
+		cause,
+		message: `Cloudflare queue binding "${binding}" operation "${operation}" failed`
+	})
 });
 const isQueue = (value) => {
 	if (typeof value !== "object" || value === null) return false;
-	const resource = value;
-	return typeof resource.send === "function" && typeof resource.sendBatch === "function" && typeof resource.metrics === "function";
+	return typeof value.send === "function";
 };
 const makeClient$6 = (definition) => {
 	const encodeMessage = Schema.encodeEffect(definition.message);
@@ -88,13 +89,32 @@ const makeClient$6 = (definition) => {
 				...message,
 				body: yield* encodeMessage(message.body)
 			});
-			yield* tryQueuePromise(definition.binding, "sendBatch", () => queue.sendBatch(encodedMessages, options));
+			const sendBatch = queue.sendBatch;
+			if (sendBatch !== void 0) {
+				yield* tryQueuePromise(definition.binding, "sendBatch", () => sendBatch.call(queue, encodedMessages, options));
+				return;
+			}
+			yield* tryQueuePromise(definition.binding, "sendBatch", async () => {
+				for (const message of encodedMessages) await queue.send(message.body, {
+					contentType: message.contentType,
+					delaySeconds: message.delaySeconds ?? options?.delaySeconds
+				});
+			});
 		}),
-		metrics: () => tryQueuePromise(definition.binding, "metrics", () => queue.metrics()),
+		metrics: () => {
+			const metrics = queue.metrics;
+			if (metrics === void 0) return Effect.fail(new QueueOperationError({
+				binding: definition.binding,
+				operation: "metrics",
+				cause: /* @__PURE__ */ new Error(`Queue binding "${definition.binding}" does not provide metrics()`),
+				message: `Cloudflare queue binding "${definition.binding}" does not provide metrics()`
+			}));
+			return tryQueuePromise(definition.binding, "metrics", () => metrics.call(queue));
+		},
 		unsafeRaw: Effect.succeed(queue)
 	});
 };
-const layer$7 = (tag, definition) => layer$8(tag, definition.binding, (value) => isQueue(value), makeClient$6(definition));
+const layer$7 = (tag, definition) => layer$8(tag, definition.binding, (value) => isQueue(value), makeClient$6(definition), { expected: expectedQueueProducer });
 //#endregion
 //#region src/QueueDefinition.ts
 var QueueDefinition_exports = /* @__PURE__ */ __exportAll({
@@ -378,6 +398,7 @@ var ServiceBinding_exports = /* @__PURE__ */ __exportAll({
 	makeDirectMethods: () => makeDirectMethods$1
 });
 const TypeId$1 = "effect-cf/ServiceBinding";
+const expectedServiceBinding = "Worker service binding with fetch()";
 /**
 * Failure raised when calling `fetch` on a service binding.
 */
@@ -436,7 +457,7 @@ const makeClient$5 = (definition) => {
 		});
 	};
 };
-const layer$6 = (tag, definition) => layer$8(tag, definition.binding, (value) => isServiceBindingClient(value), makeClient$5(definition));
+const layer$6 = (tag, definition) => layer$8(tag, definition.binding, (value) => isServiceBindingClient(value), makeClient$5(definition), { expected: expectedServiceBinding });
 /**
 * Creates a typed Effect service for a Worker service binding.
 *
@@ -1003,6 +1024,7 @@ var DurableObjectNamespace_exports = /* @__PURE__ */ __exportAll({
 	makeClient: () => makeClient$4,
 	makeDirectMethods: () => makeDirectMethods
 });
+const expectedDurableObjectNamespace = "Durable Object namespace binding with getByName(), get(), idFromName(), idFromString(), newUniqueId(), and jurisdiction()";
 /**
 * Failure raised when invoking an RPC method on a Durable Object stub.
 */
@@ -1080,7 +1102,7 @@ const makeClient$4 = (definition) => {
 		});
 	};
 };
-const layer$5 = (tag, definition) => layer$8(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$4(definition));
+const layer$5 = (tag, definition) => layer$8(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$4(definition), { expected: expectedDurableObjectNamespace });
 const makeDirectMethods = (rpcDefinition, helpers) => {
 	const methods = {};
 	if (rpcDefinition !== void 0) {
@@ -1752,6 +1774,7 @@ var Images_exports = /* @__PURE__ */ __exportAll({
 	transform: () => transform
 });
 const TypeId = "effect-cf/Images/Steps";
+const expectedImagesBinding = "Images binding with info() and input()";
 /** Error raised when a Cloudflare Images operation fails. */
 var ImagesOperationError = class extends Data.TaggedError("ImagesOperationError") {};
 const makeSteps = (steps) => ({
@@ -1834,7 +1857,7 @@ const makeClient$3 = (definition) => (images) => {
 		unsafeRaw: Effect.succeed(images)
 	};
 };
-const layer$3 = (tag, definition) => layer$8(tag, definition.binding, isImagesBinding, makeClient$3(definition));
+const layer$3 = (tag, definition) => layer$8(tag, definition.binding, isImagesBinding, makeClient$3(definition), { expected: expectedImagesBinding });
 const make$3 = (id) => Tag$4()(id);
 const Tag$4 = () => (id) => {
 	const tag = Context.Service()(id);
@@ -1853,6 +1876,7 @@ var Kv_exports = /* @__PURE__ */ __exportAll({
 	layer: () => layer$2,
 	makeClient: () => makeClient$2
 });
+const expectedKvNamespace = "KV namespace binding with get(), put(), delete(), getWithMetadata(), and list()";
 /** Error raised when a KV operation fails. */
 var KvOperationError = class extends Data.TaggedError("KvOperationError") {};
 const maybeString = (value) => value == null ? Option.none() : Option.some(value);
@@ -1928,7 +1952,7 @@ const makeClient$2 = (definition) => {
 		unsafeRaw: Effect.succeed(kv)
 	});
 };
-const layer$2 = (tag, definition) => layer$8(tag, definition.binding, isKvNamespace, makeClient$2(definition));
+const layer$2 = (tag, definition) => layer$8(tag, definition.binding, isKvNamespace, makeClient$2(definition), { expected: expectedKvNamespace });
 const makeDefinition$1 = (id, definition) => {
 	const kvDefinition = {
 		id,
@@ -1962,6 +1986,7 @@ var R2_exports = /* @__PURE__ */ __exportAll({
 	make: () => make$2,
 	makeClient: () => makeClient$1
 });
+const expectedR2Bucket = "R2 bucket binding with head(), get(), put(), createMultipartUpload(), resumeMultipartUpload(), delete(), and list()";
 /** Error raised when an R2 operation fails. */
 var R2OperationError = class extends Data.TaggedError("R2OperationError") {};
 const r2Error = (binding, operation, cause) => new R2OperationError({
@@ -2044,7 +2069,7 @@ const makeClient$1 = (definition) => {
 		};
 	};
 };
-const layer$1 = (tag, definition) => layer$8(tag, definition.binding, isR2Bucket, makeClient$1(definition));
+const layer$1 = (tag, definition) => layer$8(tag, definition.binding, isR2Bucket, makeClient$1(definition), { expected: expectedR2Bucket });
 const make$2 = (id) => Tag$2()(id);
 const Tag$2 = () => (id) => {
 	const tag = Context.Service()(id);
@@ -2063,6 +2088,7 @@ var WorkflowBinding_exports = /* @__PURE__ */ __exportAll({
 	layer: () => layer,
 	makeClient: () => makeClient
 });
+const expectedWorkflow = "Workflow binding with create(), createBatch(), and get()";
 var WorkflowOperationError = class extends Data.TaggedError("WorkflowOperationError") {};
 var WorkflowResultDecodeError = class extends Data.TaggedError("WorkflowResultDecodeError") {};
 const workflowError = (binding, operation, cause) => new WorkflowOperationError({
@@ -2129,7 +2155,7 @@ const makeClient = (definition) => {
 		unsafeRaw: Effect.succeed(workflow)
 	});
 };
-const layer = (tag, definition) => layer$8(tag, definition.binding, (value) => isWorkflow(value), makeClient(definition));
+const layer = (tag, definition) => layer$8(tag, definition.binding, (value) => isWorkflow(value), makeClient(definition), { expected: expectedWorkflow });
 //#endregion
 //#region src/WorkflowDefinition.ts
 var WorkflowDefinition_exports = /* @__PURE__ */ __exportAll({
@@ -2256,10 +2282,10 @@ const make = (layer, options) => {
 	}
 	return assumeEntrypointClass(EffectWorkflow);
 };
-const step = (name, effect, config) => Effect.flatMap(WorkflowStep$1.asEffect(), (workflowStep) => workflowStep.do(name, effect, config));
-const sleep = (name, duration) => Effect.flatMap(WorkflowStep$1.asEffect(), (workflowStep) => workflowStep.sleep(name, duration));
-const sleepUntil = (name, timestamp) => Effect.flatMap(WorkflowStep$1.asEffect(), (workflowStep) => workflowStep.sleepUntil(name, timestamp));
-const waitForEvent = (name, options) => Effect.flatMap(WorkflowStep$1.asEffect(), (workflowStep) => workflowStep.waitForEvent(name, options));
+const step = (name, effect, config) => Effect.flatMap(WorkflowStep$1, (workflowStep) => workflowStep.do(name, effect, config));
+const sleep = (name, duration) => Effect.flatMap(WorkflowStep$1, (workflowStep) => workflowStep.sleep(name, duration));
+const sleepUntil = (name, timestamp) => Effect.flatMap(WorkflowStep$1, (workflowStep) => workflowStep.sleepUntil(name, timestamp));
+const waitForEvent = (name, options) => Effect.flatMap(WorkflowStep$1, (workflowStep) => workflowStep.waitForEvent(name, options));
 const Tag = Tag$1;
 const implement = implement$1;
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {
@@ -42,7 +42,7 @@
     "@cloudflare/vitest-pool-workers": "^0.15.0",
     "@cloudflare/workers-types": "^4.20260421.1",
     "@effect/sql-d1": "catalog:",
-    "@effect/sql-pg": "4.0.0-beta.65",
+    "@effect/sql-pg": "catalog:",
     "@effect/vitest": "catalog:",
     "effect": "catalog:",
     "typescript": "^6.0.2",
@@ -50,9 +50,9 @@
     "vitest": "catalog:"
   },
   "peerDependencies": {
-    "@effect/sql-d1": "^4.0.0-beta.65",
-    "@effect/sql-pg": "^4.0.0-beta.65",
-    "effect": "^4.0.0-beta.65"
+    "@effect/sql-d1": "^4.0.0-beta.70",
+    "@effect/sql-pg": "^4.0.0-beta.70",
+    "effect": "^4.0.0-beta.70"
   },
   "peerDependenciesMeta": {
     "@effect/sql-pg": {

package/src/Binding.ts

@@ -9,34 +9,150 @@ export const TypeId = "effect-cf/Binding" as const;
 /** Error raised when a configured binding does not exist on `env`. */
 export class BindingNotFoundError extends Data.TaggedError("BindingNotFoundError")<{
   readonly binding: string;
+  readonly message: string;
 }> {}
 
 /** Error raised when a binding exists but does not match the expected shape. */
 export class BindingValidationError extends Data.TaggedError("BindingValidationError")<{
   readonly binding: string;
+  readonly expected: string;
+  readonly actual: string;
+  readonly message: string;
 }> {}
 
+export interface ValidationOptions {
+  readonly expected?: string;
+}
+
+const defaultExpected = "Cloudflare binding resource";
+
 const isPropertyTarget = (value: unknown): value is object =>
   (typeof value === "object" || typeof value === "function") && value !== null;
 
+const getObjectName = (value: object | Function): string => {
+  const tag = (() => {
+    try {
+      return Object.prototype.toString.call(value).slice("[object ".length, -1);
+    } catch {
+      return typeof value;
+    }
+  })();
+  const constructorName = (() => {
+    try {
+      return "constructor" in value &&
+        typeof value.constructor === "function" &&
+        typeof value.constructor.name === "string"
+        ? value.constructor.name
+        : undefined;
+    } catch {
+      return undefined;
+    }
+  })();
+
+  if (tag !== "Object") {
+    return tag;
+  }
+
+  if (constructorName !== undefined && constructorName !== "" && constructorName !== "Object") {
+    return constructorName;
+  }
+
+  return tag;
+};
+
+const propertyNames = (value: object | Function): ReadonlyArray<string> => {
+  const names = new Set<string>();
+
+  for (const target of [value, Object.getPrototypeOf(value)] as const) {
+    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: object | Function, name: string): boolean => {
+  try {
+    return typeof Reflect.get(value, name) === "function";
+  } catch {
+    return false;
+  }
+};
+
+const describeActual = (value: unknown): string => {
+  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(", ")}` : undefined,
+    properties.length > 0 ? `properties ${properties.join(", ")}` : undefined,
+  ].filter((detail) => detail !== undefined);
+
+  if (details.length === 0) {
+    return getObjectName(value);
+  }
+
+  return `${getObjectName(value)} with ${details.join("; ")}`;
+};
+
 const getBinding = <Resource>(
   env: WorkerEnv,
   binding: string,
   isResource: (value: unknown) => value is Resource,
+  options?: ValidationOptions,
 ): Effect.Effect<Resource, BindingNotFoundError | BindingValidationError> =>
   Effect.gen(function* () {
     if (!isPropertyTarget(env)) {
-      return yield* Effect.fail(new BindingValidationError({ binding }));
+      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 === undefined) {
-      return yield* Effect.fail(new BindingNotFoundError({ binding }));
+      return yield* Effect.fail(
+        new BindingNotFoundError({
+          binding,
+          message: `Cloudflare binding "${binding}" was not found in WorkerEnvironment`,
+        }),
+      );
     }
 
     if (!isResource(resource)) {
-      return yield* Effect.fail(new BindingValidationError({ binding }));
+      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;
@@ -64,12 +180,13 @@ export const layer = <Self, Resource, Service = Resource>(
   binding: string,
   isResource: (value: unknown) => value is Resource,
   wrap?: (resource: Resource) => Service,
+  options?: ValidationOptions,
 ): Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment> =>
   Layer.effect(
     tag,
     Effect.gen(function* () {
       const env = yield* WorkerEnvironment;
-      const resource = yield* getBinding(env, binding, isResource);
+      const resource = yield* getBinding(env, binding, isResource, options);
       return wrap === undefined ? (resource as unknown as Service) : wrap(resource);
     }),
   );
@@ -81,9 +198,10 @@ export const Service =
     binding: string,
     isResource: (value: unknown) => value is Resource,
     wrap?: (resource: Resource) => Service,
+    options?: ValidationOptions,
   ): BindingService<Self, Id, Service> => {
     const tag = Context.Service<Self, Service>()(id);
-    const serviceLayer = layer(tag, binding, isResource, wrap);
+    const serviceLayer = layer(tag, binding, isResource, wrap, options);
 
     return Object.assign(tag, {
       [TypeId]: TypeId,

package/src/D1.ts

@@ -4,6 +4,7 @@ import { Effect, Layer } from "effect";
 import * as Binding from "./Binding";
 
 const TypeId = "effect-cf/D1" as const;
+const expectedD1Database = "D1 database binding with prepare(), batch(), and exec()";
 
 /** Typed D1 binding definition. */
 export interface D1Definition {
@@ -61,7 +62,9 @@ export const make = <Id extends string>(id: Id, definition: D1Definition) =>
 export const Service =
   <Self>() =>
   <Id extends string>(id: Id, definition: D1Definition) => {
-    const tag = Binding.Service<Self>()(id, definition.binding, isD1Database);
+    const tag = Binding.Service<Self>()(id, definition.binding, isD1Database, undefined, {
+      expected: expectedD1Database,
+    });
 
     const sqlLayer = (options?: D1SqlLayerOptions) =>
       Layer.unwrap(

package/src/DurableObjectNamespace.ts

@@ -6,6 +6,9 @@ import type * as DurableObjectDefinition from "./DurableObjectDefinition";
 import * as RpcDefinition from "./RpcDefinition";
 import * as RpcInvocation from "./internal/RpcInvocation";
 
+const expectedDurableObjectNamespace =
+  "Durable Object namespace binding with getByName(), get(), idFromName(), idFromString(), newUniqueId(), and jurisdiction()";
+
 interface DurableObjectFetcher {
   fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
 }
@@ -548,6 +551,7 @@ export const layer = <
     (value): value is DurableObjectNamespaceClient<Api> =>
       isDurableObjectNamespaceClient<Api>(value),
     makeClient<Api, Definition>(definition),
+    { expected: expectedDurableObjectNamespace },
   );
 
 export const makeDirectMethods = <

package/src/Environment.ts

@@ -80,7 +80,7 @@ export namespace WorkerConfig {
    * conversion function.
    */
   export const providerWith = (makeProvider: (env: WorkerEnv) => ConfigProvider.ConfigProvider) =>
-    Effect.map(WorkerEnvironment.asEffect(), makeProvider);
+    Effect.map(WorkerEnvironment, makeProvider);
 
   /** Build a `ConfigProvider` from the current `WorkerEnvironment`. */
   export const provider = providerWith(providerFromEnv);

package/src/Hyperdrive.ts

@@ -3,6 +3,8 @@ import { Context, Effect, type Layer } from "effect";
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 
+const expectedHyperdrive = "Hyperdrive binding with connectionString";
+
 /** Typed Hyperdrive binding definition. */
 export interface HyperdriveDefinition {
   /** Binding name as configured in `wrangler.jsonc`. */
@@ -64,7 +66,10 @@ export const makeClient =
 export const layer = <Self>(
   tag: Context.Service<Self, HyperdriveClient>,
   definition: HyperdriveDefinition,
-) => Binding.layer(tag, definition.binding, isHyperdrive, makeClient(definition));
+) =>
+  Binding.layer(tag, definition.binding, isHyperdrive, makeClient(definition), {
+    expected: expectedHyperdrive,
+  });
 
 export const make = <Id extends string>(id: Id) => Tag<HyperdriveService<Id>>()<Id>(id);
 

package/src/Images.ts

@@ -4,6 +4,7 @@ import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 
 const TypeId = "effect-cf/Images/Steps" as const;
+const expectedImagesBinding = "Images binding with info() and input()";
 
 /** Error raised when a Cloudflare Images operation fails. */
 export class ImagesOperationError extends Data.TaggedError("ImagesOperationError")<{
@@ -314,7 +315,10 @@ export const makeClient =
 export const layer = <Self>(
   tag: Context.Service<Self, ImagesClient>,
   definition: ImagesDefinition,
-) => Binding.layer(tag, definition.binding, isImagesBinding, makeClient(definition));
+) =>
+  Binding.layer(tag, definition.binding, isImagesBinding, makeClient(definition), {
+    expected: expectedImagesBinding,
+  });
 
 export const make = <Id extends string>(id: Id) => Tag<ImagesService<Id>>()<Id>(id);
 

package/src/Kv.ts

@@ -3,6 +3,9 @@ import { Context, Data, Effect, Option, Schema as S, type Layer } from "effect";
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 
+const expectedKvNamespace =
+  "KV namespace binding with get(), put(), delete(), getWithMetadata(), and list()";
+
 /** Error raised when a KV operation fails. */
 export class KvOperationError extends Data.TaggedError("KvOperationError")<{
   readonly binding: string;
@@ -250,6 +253,7 @@ export const layer = <Self, Key, Value, EncodedValue>(
     definition.binding,
     isKvNamespace,
     makeClient<Key, Value, EncodedValue>(definition),
+    { expected: expectedKvNamespace },
   );
 
 const makeDefinition = <Id extends string, Key, Value, EncodedValue>(

package/src/QueueBinding.ts

@@ -10,6 +10,11 @@ export type QueueSendBatchResponse = globalThis.QueueSendBatchResponse;
 export type QueueMetrics = globalThis.QueueMetrics;
 export type MessageSendRequest<Body> = globalThis.MessageSendRequest<Body>;
 
+export type QueueProducer<Body> = Pick<globalThis.Queue<Body>, "send"> &
+  Partial<Pick<globalThis.Queue<Body>, "sendBatch" | "metrics">>;
+
+const expectedQueueProducer = "Queue producer binding with send(); optional sendBatch()/metrics()";
+
 export interface QueueBindingDefinition<Message extends RpcDefinition.ServiceFreeSchema> {
   /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
@@ -34,11 +39,9 @@ export class QueueOperationError extends Data.TaggedError("QueueOperationError")
   readonly binding: string;
   readonly operation: string;
   readonly cause: unknown;
+  readonly message: string;
 }> {}
 
-const queueError = (binding: string, operation: string, cause: unknown) =>
-  new QueueOperationError({ binding, operation, cause });
-
 const tryQueuePromise = <A>(
   binding: string,
   operation: string,
@@ -46,26 +49,28 @@ const tryQueuePromise = <A>(
 ): Effect.Effect<A, QueueOperationError> =>
   Effect.tryPromise({
     try: evaluate,
-    catch: (cause) => queueError(binding, operation, cause),
+    catch: (cause) =>
+      new QueueOperationError({
+        binding,
+        operation,
+        cause,
+        message: `Cloudflare queue binding "${binding}" operation "${operation}" failed`,
+      }),
   });
 
-export const isQueue = <Body>(value: unknown): value is globalThis.Queue<Body> => {
+export const isQueue = <Body>(value: unknown): value is QueueProducer<Body> => {
   if (typeof value !== "object" || value === null) {
     return false;
   }
 
   const resource = value as Record<string, unknown>;
 
-  return (
-    typeof resource.send === "function" &&
-    typeof resource.sendBatch === "function" &&
-    typeof resource.metrics === "function"
-  );
+  return typeof resource.send === "function";
 };
 
 export const makeClient = <Message extends RpcDefinition.ServiceFreeSchema>(
   definition: QueueBindingDefinition<Message>,
-): ((queue: globalThis.Queue<S.Codec.Encoded<Message>>) => QueueBindingClient<Message>) => {
+): ((queue: QueueProducer<S.Codec.Encoded<Message>>) => QueueBindingClient<Message>) => {
   type Body = S.Schema.Type<Message>;
   type EncodedBody = S.Codec.Encoded<Message>;
 
@@ -90,12 +95,41 @@ export const makeClient = <Message extends RpcDefinition.ServiceFreeSchema>(
         });
       }
 
-      yield* tryQueuePromise(definition.binding, "sendBatch", () =>
-        queue.sendBatch(encodedMessages, options),
-      );
+      const sendBatch = queue.sendBatch;
+
+      if (sendBatch !== undefined) {
+        yield* tryQueuePromise(definition.binding, "sendBatch", () =>
+          sendBatch.call(queue, encodedMessages, options),
+        );
+        return;
+      }
+
+      yield* tryQueuePromise(definition.binding, "sendBatch", async () => {
+        for (const message of encodedMessages) {
+          await queue.send(message.body, {
+            contentType: message.contentType,
+            delaySeconds: message.delaySeconds ?? options?.delaySeconds,
+          });
+        }
+      });
     }),
-    metrics: () => tryQueuePromise(definition.binding, "metrics", () => queue.metrics()),
-    unsafeRaw: Effect.succeed(queue),
+    metrics: () => {
+      const metrics = queue.metrics;
+
+      if (metrics === undefined) {
+        return Effect.fail(
+          new QueueOperationError({
+            binding: definition.binding,
+            operation: "metrics",
+            cause: new Error(`Queue binding "${definition.binding}" does not provide metrics()`),
+            message: `Cloudflare queue binding "${definition.binding}" does not provide metrics()`,
+          }),
+        );
+      }
+
+      return tryQueuePromise(definition.binding, "metrics", () => metrics.call(queue));
+    },
+    unsafeRaw: Effect.succeed(queue as globalThis.Queue<EncodedBody>),
   });
 };
 
@@ -106,7 +140,8 @@ export const layer = <Self, Message extends RpcDefinition.ServiceFreeSchema>(
   Binding.layer(
     tag,
     definition.binding,
-    (value): value is globalThis.Queue<S.Codec.Encoded<Message>> =>
+    (value): value is QueueProducer<S.Codec.Encoded<Message>> =>
       isQueue<S.Codec.Encoded<Message>>(value),
     makeClient(definition),
+    { expected: expectedQueueProducer },
   );

package/src/R2.ts

@@ -3,6 +3,9 @@ import { Context, Data, Effect, Option, type Layer } from "effect";
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 
+const expectedR2Bucket =
+  "R2 bucket binding with head(), get(), put(), createMultipartUpload(), resumeMultipartUpload(), delete(), and list()";
+
 /** Error raised when an R2 operation fails. */
 export class R2OperationError extends Data.TaggedError("R2OperationError")<{
   readonly binding: string;
@@ -272,7 +275,9 @@ export const makeClient = (
 };
 
 export const layer = <Self>(tag: Context.Service<Self, R2Client>, definition: R2Definition) =>
-  Binding.layer(tag, definition.binding, isR2Bucket, makeClient(definition));
+  Binding.layer(tag, definition.binding, isR2Bucket, makeClient(definition), {
+    expected: expectedR2Bucket,
+  });
 
 export const make = <Id extends string>(id: Id) => Tag<R2Service<Id>>()<Id>(id);
 

package/src/ServiceBinding.ts

@@ -7,6 +7,7 @@ import type * as WorkerDefinition from "./WorkerDefinition";
 import * as RpcInvocation from "./internal/RpcInvocation";
 
 const TypeId = "effect-cf/ServiceBinding" as const;
+const expectedServiceBinding = "Worker service binding with fetch()";
 
 /**
  * Minimum shape for a Cloudflare service binding.
@@ -359,6 +360,7 @@ export const layer = <
     definition.binding,
     (value): value is ServiceBindingClient<Api> => isServiceBindingClient<Api>(value),
     makeClient<Api, Definition>(definition),
+    { expected: expectedServiceBinding },
   );
 
 /**

package/src/Workflow.ts

@@ -223,7 +223,7 @@ export const step = <A, E, R>(
   effect: Effect.Effect<A, E, R>,
   config?: WorkflowStepConfig,
 ): Effect.Effect<A, unknown, WorkflowStep | Exclude<R, WorkflowStepContext>> =>
-  Effect.flatMap(WorkflowStep.asEffect(), (workflowStep) =>
+  Effect.flatMap(WorkflowStep, (workflowStep) =>
     workflowStep.do(name, effect, config),
   ) as Effect.Effect<A, unknown, WorkflowStep | Exclude<R, WorkflowStepContext>>;
 
@@ -231,15 +231,13 @@ export const sleep = (
   name: string,
   duration: WorkflowSleepDuration,
 ): Effect.Effect<void, unknown, WorkflowStep> =>
-  Effect.flatMap(WorkflowStep.asEffect(), (workflowStep) => workflowStep.sleep(name, duration));
+  Effect.flatMap(WorkflowStep, (workflowStep) => workflowStep.sleep(name, duration));
 
 export const sleepUntil = (
   name: string,
   timestamp: Date | number,
 ): Effect.Effect<void, unknown, WorkflowStep> =>
-  Effect.flatMap(WorkflowStep.asEffect(), (workflowStep) =>
-    workflowStep.sleepUntil(name, timestamp),
-  );
+  Effect.flatMap(WorkflowStep, (workflowStep) => workflowStep.sleepUntil(name, timestamp));
 
 export const waitForEvent = <Payload>(
   name: string,
@@ -248,9 +246,7 @@ export const waitForEvent = <Payload>(
     readonly timeout?: WorkflowTimeoutDuration | number;
   },
 ): Effect.Effect<WorkflowStepEvent<Payload>, unknown, WorkflowStep> =>
-  Effect.flatMap(WorkflowStep.asEffect(), (workflowStep) =>
-    workflowStep.waitForEvent<Payload>(name, options),
-  );
+  Effect.flatMap(WorkflowStep, (workflowStep) => workflowStep.waitForEvent<Payload>(name, options));
 
 export type Definition<
   Id extends string = string,

package/src/WorkflowBinding.ts

@@ -3,6 +3,8 @@ import { Context, Data, Effect, Option, Schema as S } from "effect";
 import * as Binding from "./Binding";
 import type * as RpcDefinition from "./RpcDefinition";
 
+const expectedWorkflow = "Workflow binding with create(), createBatch(), and get()";
+
 export type WorkflowInstanceCreateOptions<Payload> = Omit<
   globalThis.WorkflowInstanceCreateOptions<Payload>,
   "params"
@@ -242,4 +244,5 @@ export const layer = <
     (value): value is globalThis.Workflow<S.Codec.Encoded<Payload>> =>
       isWorkflow<S.Codec.Encoded<Payload>>(value),
     makeClient(definition),
+    { expected: expectedWorkflow },
   );