effect-cf 0.9.0 → 0.9.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # effect-cf
 
+## 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
+
+- [#27](https://github.com/danieljvdm/effect-cf/pull/27) [`ac2fb0f`](https://github.com/danieljvdm/effect-cf/commit/ac2fb0f9b557c1f73d779ed024c03245c1850b02) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Wrap R2 object body reader methods in Effect so `json`, `text`, `bytes`, `arrayBuffer`, and `blob` report read failures as `R2OperationError`.
+
 ## 0.9.0
 
 ### Minor Changes

package/dist/{Hyperdrive-LuQaVhXU.mjs → Hyperdrive-CT6UD37x.mjs}

@@ -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-CT6UD37x.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 };
@@ -1921,7 +1923,7 @@ declare const Tag$4: <Self>() => <Id extends string, Key, Value, EncodedValue>(i
   readonly value: Schema.Codec<Value, EncodedValue>;
 }) => TagClass$3<Self, Id, Key, Value, EncodedValue>;
 declare namespace R2_d_exports {
-  export { LayerOptions$2 as LayerOptions, R2Client, R2Definition, R2GetOptions, R2ListOptions, R2MultipartOptions, R2MultipartUploadClient, R2OperationError, R2PutOptions, R2PutValue, R2Service, R2UploadPartOptions, R2UploadPartValue, Tag$3 as Tag, TagClass$2 as TagClass, isR2Bucket, layer$1 as layer, make$2 as make, makeClient$1 as makeClient };
+  export { LayerOptions$2 as LayerOptions, R2Client, R2Definition, R2GetOptions, R2ListOptions, R2MultipartOptions, R2MultipartUploadClient, R2ObjectBodyClient, R2OperationError, R2PutOptions, R2PutValue, R2Service, R2UploadPartOptions, R2UploadPartValue, Tag$3 as Tag, TagClass$2 as TagClass, isR2Bucket, layer$1 as layer, make$2 as make, makeClient$1 as makeClient };
 }
 declare const R2OperationError_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: "R2OperationError";
@@ -1944,6 +1946,14 @@ type R2MultipartOptions = globalThis.R2MultipartOptions;
 type R2UploadPartOptions = globalThis.R2UploadPartOptions;
 type R2PutValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | null | Blob;
 type R2UploadPartValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | Blob;
+interface R2ObjectBodyClient extends Omit<globalThis.R2ObjectBody, "arrayBuffer" | "blob" | "bytes" | "json" | "text"> {
+  readonly raw: globalThis.R2ObjectBody;
+  readonly arrayBuffer: Effect.Effect<ArrayBuffer, R2OperationError>;
+  readonly bytes: Effect.Effect<Uint8Array, R2OperationError>;
+  readonly text: Effect.Effect<string, R2OperationError>;
+  readonly json: <T = unknown>() => Effect.Effect<T, R2OperationError>;
+  readonly blob: Effect.Effect<Blob, R2OperationError>;
+}
 interface R2MultipartUploadClient {
   readonly raw: globalThis.R2MultipartUpload;
   readonly key: string;
@@ -1957,8 +1967,8 @@ interface R2Client {
   readonly get: {
     (key: string, options: R2GetOptions & {
       readonly onlyIf: globalThis.R2Conditional | Headers;
-    }): Effect.Effect<Option.Option<globalThis.R2ObjectBody | globalThis.R2Object>, R2OperationError>;
-    (key: string, options?: R2GetOptions): Effect.Effect<Option.Option<globalThis.R2ObjectBody>, R2OperationError>;
+    }): Effect.Effect<Option.Option<R2ObjectBodyClient | globalThis.R2Object>, R2OperationError>;
+    (key: string, options?: R2GetOptions): Effect.Effect<Option.Option<R2ObjectBodyClient>, R2OperationError>;
   };
   readonly put: {
     (key: string, value: R2PutValue, options: R2PutOptions & {

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-CT6UD37x.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({
@@ -1978,6 +2003,36 @@ const tryR2Sync = (binding, operation, evaluate) => Effect.try({
 	catch: (cause) => r2Error(binding, operation, cause)
 });
 const maybe = (value) => value === null ? Option.none() : Option.some(value);
+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 wrapObjectBody = (binding, object) => ({
+	key: object.key,
+	version: object.version,
+	size: object.size,
+	etag: object.etag,
+	httpEtag: object.httpEtag,
+	checksums: object.checksums,
+	uploaded: object.uploaded,
+	httpMetadata: object.httpMetadata,
+	customMetadata: object.customMetadata,
+	range: object.range,
+	storageClass: object.storageClass,
+	ssecKeyMd5: object.ssecKeyMd5,
+	writeHttpMetadata: (headers) => object.writeHttpMetadata(headers),
+	raw: object,
+	body: object.body,
+	get bodyUsed() {
+		return object.bodyUsed;
+	},
+	arrayBuffer: tryR2Promise(binding, "arrayBuffer", () => object.arrayBuffer()),
+	bytes: tryR2Promise(binding, "bytes", () => object.bytes()),
+	text: tryR2Promise(binding, "text", () => object.text()),
+	json: () => tryR2Promise(binding, "json", () => object.json()),
+	blob: tryR2Promise(binding, "blob", () => object.blob())
+});
+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;
@@ -1992,26 +2047,29 @@ const makeClient$1 = (definition) => {
 		abort: tryR2Promise(definition.binding, "abortMultipartUpload", () => upload.abort()),
 		complete: (uploadedParts) => tryR2Promise(definition.binding, "completeMultipartUpload", () => upload.complete([...uploadedParts]))
 	});
-	return (bucket) => ({
-		definition,
-		head: (key) => tryR2Promise(definition.binding, "head", () => bucket.head(key)).pipe(Effect.map(maybe)),
-		get: ((key, options) => tryR2Promise(definition.binding, "get", () => bucket.get(key, options)).pipe(Effect.map(maybe))),
-		put: ((key, value, options) => tryR2Promise(definition.binding, "put", () => bucket.put(key, value, options)).pipe(Effect.map((object) => {
-			if (object === null) return Option.none();
-			if (options !== void 0 && "onlyIf" in options) return Option.some(object);
-			return object;
-		}))),
-		createMultipartUpload: (key, options) => tryR2Promise(definition.binding, "createMultipartUpload", () => bucket.createMultipartUpload(key, options)).pipe(Effect.map(wrapUpload)),
-		resumeMultipartUpload: (key, uploadId) => tryR2Sync(definition.binding, "resumeMultipartUpload", () => wrapUpload(bucket.resumeMultipartUpload(key, uploadId))),
-		delete: (keys) => {
-			const nativeKeys = typeof keys === "string" ? keys : [...keys];
-			return tryR2Promise(definition.binding, "delete", () => bucket.delete(nativeKeys));
-		},
-		list: (options) => tryR2Promise(definition.binding, "list", () => bucket.list(options)),
-		unsafeRaw: Effect.succeed(bucket)
-	});
+	return (bucket) => {
+		const get = ((key, options) => tryR2Promise(definition.binding, "get", () => bucket.get(key, options)).pipe(Effect.map((object) => maybe(wrapGetResult(definition.binding, object)))));
+		return {
+			definition,
+			head: (key) => tryR2Promise(definition.binding, "head", () => bucket.head(key)).pipe(Effect.map(maybe)),
+			get,
+			put: ((key, value, options) => tryR2Promise(definition.binding, "put", () => bucket.put(key, value, options)).pipe(Effect.map((object) => {
+				if (object === null) return Option.none();
+				if (options !== void 0 && "onlyIf" in options) return Option.some(object);
+				return object;
+			}))),
+			createMultipartUpload: (key, options) => tryR2Promise(definition.binding, "createMultipartUpload", () => bucket.createMultipartUpload(key, options)).pipe(Effect.map(wrapUpload)),
+			resumeMultipartUpload: (key, uploadId) => tryR2Sync(definition.binding, "resumeMultipartUpload", () => wrapUpload(bucket.resumeMultipartUpload(key, uploadId))),
+			delete: (keys) => {
+				const nativeKeys = typeof keys === "string" ? keys : [...keys];
+				return tryR2Promise(definition.binding, "delete", () => bucket.delete(nativeKeys));
+			},
+			list: (options) => tryR2Promise(definition.binding, "list", () => bucket.list(options)),
+			unsafeRaw: Effect.succeed(bucket)
+		};
+	};
 };
-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);
@@ -2030,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({
@@ -2096,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({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {

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/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;
@@ -24,6 +27,18 @@ export type R2UploadPartOptions = globalThis.R2UploadPartOptions;
 export type R2PutValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | null | Blob;
 export type R2UploadPartValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | Blob;
 
+export interface R2ObjectBodyClient extends Omit<
+  globalThis.R2ObjectBody,
+  "arrayBuffer" | "blob" | "bytes" | "json" | "text"
+> {
+  readonly raw: globalThis.R2ObjectBody;
+  readonly arrayBuffer: Effect.Effect<ArrayBuffer, R2OperationError>;
+  readonly bytes: Effect.Effect<Uint8Array, R2OperationError>;
+  readonly text: Effect.Effect<string, R2OperationError>;
+  readonly json: <T = unknown>() => Effect.Effect<T, R2OperationError>;
+  readonly blob: Effect.Effect<Blob, R2OperationError>;
+}
+
 export interface R2MultipartUploadClient {
   readonly raw: globalThis.R2MultipartUpload;
   readonly key: string;
@@ -47,14 +62,11 @@ export interface R2Client {
     (
       key: string,
       options: R2GetOptions & { readonly onlyIf: globalThis.R2Conditional | Headers },
-    ): Effect.Effect<
-      Option.Option<globalThis.R2ObjectBody | globalThis.R2Object>,
-      R2OperationError
-    >;
+    ): Effect.Effect<Option.Option<R2ObjectBodyClient | globalThis.R2Object>, R2OperationError>;
     (
       key: string,
       options?: R2GetOptions,
-    ): Effect.Effect<Option.Option<globalThis.R2ObjectBody>, R2OperationError>;
+    ): Effect.Effect<Option.Option<R2ObjectBodyClient>, R2OperationError>;
   };
   readonly put: {
     (
@@ -136,6 +148,53 @@ const tryR2Sync = <A>(
 const maybe = <A>(value: A | null): Option.Option<A> =>
   value === null ? Option.none() : Option.some(value);
 
+const isR2ObjectBody = (
+  value: globalThis.R2ObjectBody | globalThis.R2Object,
+): value is globalThis.R2ObjectBody =>
+  "body" in value &&
+  typeof (value as globalThis.R2ObjectBody).arrayBuffer === "function" &&
+  typeof (value as globalThis.R2ObjectBody).bytes === "function" &&
+  typeof (value as globalThis.R2ObjectBody).text === "function" &&
+  typeof (value as globalThis.R2ObjectBody).json === "function" &&
+  typeof (value as globalThis.R2ObjectBody).blob === "function";
+
+const wrapObjectBody = (binding: string, object: globalThis.R2ObjectBody): R2ObjectBodyClient => ({
+  key: object.key,
+  version: object.version,
+  size: object.size,
+  etag: object.etag,
+  httpEtag: object.httpEtag,
+  checksums: object.checksums,
+  uploaded: object.uploaded,
+  httpMetadata: object.httpMetadata,
+  customMetadata: object.customMetadata,
+  range: object.range,
+  storageClass: object.storageClass,
+  ssecKeyMd5: object.ssecKeyMd5,
+  writeHttpMetadata: (headers) => object.writeHttpMetadata(headers),
+  raw: object,
+  body: object.body,
+  get bodyUsed() {
+    return object.bodyUsed;
+  },
+  arrayBuffer: tryR2Promise(binding, "arrayBuffer", () => object.arrayBuffer()),
+  bytes: tryR2Promise(binding, "bytes", () => object.bytes()),
+  text: tryR2Promise(binding, "text", () => object.text()),
+  json: <T = unknown>() => tryR2Promise(binding, "json", () => object.json<T>()),
+  blob: tryR2Promise(binding, "blob", () => object.blob()),
+});
+
+const wrapGetResult = (
+  binding: string,
+  object: globalThis.R2ObjectBody | globalThis.R2Object | null,
+): R2ObjectBodyClient | globalThis.R2Object | null => {
+  if (object === null || !isR2ObjectBody(object)) {
+    return object;
+  }
+
+  return wrapObjectBody(binding, object);
+};
+
 export const isR2Bucket = (value: unknown): value is globalThis.R2Bucket => {
   if (typeof value !== "object" || value === null) {
     return false;
@@ -172,47 +231,53 @@ export const makeClient = (
       ),
   });
 
-  return (bucket) => ({
-    definition,
-    head: (key) =>
-      tryR2Promise(definition.binding, "head", () => bucket.head(key)).pipe(Effect.map(maybe)),
-    get: ((key: string, options?: R2GetOptions) =>
+  return (bucket) => {
+    const get = ((key: string, options?: R2GetOptions) =>
       tryR2Promise(definition.binding, "get", () => bucket.get(key, options)).pipe(
-        Effect.map(maybe),
-      )) as R2Client["get"],
-    put: ((key: string, value: R2PutValue, options?: R2PutOptions) =>
-      tryR2Promise(definition.binding, "put", () => bucket.put(key, value, options)).pipe(
-        Effect.map((object) => {
-          if (object === null) {
-            return Option.none<globalThis.R2Object>();
-          }
-
-          if (options !== undefined && "onlyIf" in options) {
-            return Option.some(object);
-          }
-
-          return object;
-        }),
-      )) as R2Client["put"],
-    createMultipartUpload: (key, options) =>
-      tryR2Promise(definition.binding, "createMultipartUpload", () =>
-        bucket.createMultipartUpload(key, options),
-      ).pipe(Effect.map(wrapUpload)),
-    resumeMultipartUpload: (key, uploadId) =>
-      tryR2Sync(definition.binding, "resumeMultipartUpload", () =>
-        wrapUpload(bucket.resumeMultipartUpload(key, uploadId)),
-      ),
-    delete: (keys) => {
-      const nativeKeys = typeof keys === "string" ? keys : [...keys];
-      return tryR2Promise(definition.binding, "delete", () => bucket.delete(nativeKeys));
-    },
-    list: (options) => tryR2Promise(definition.binding, "list", () => bucket.list(options)),
-    unsafeRaw: Effect.succeed(bucket),
-  });
+        Effect.map((object) => maybe(wrapGetResult(definition.binding, object))),
+      )) as R2Client["get"];
+
+    return {
+      definition,
+      head: (key) =>
+        tryR2Promise(definition.binding, "head", () => bucket.head(key)).pipe(Effect.map(maybe)),
+      get,
+      put: ((key: string, value: R2PutValue, options?: R2PutOptions) =>
+        tryR2Promise(definition.binding, "put", () => bucket.put(key, value, options)).pipe(
+          Effect.map((object) => {
+            if (object === null) {
+              return Option.none<globalThis.R2Object>();
+            }
+
+            if (options !== undefined && "onlyIf" in options) {
+              return Option.some(object);
+            }
+
+            return object;
+          }),
+        )) as R2Client["put"],
+      createMultipartUpload: (key, options) =>
+        tryR2Promise(definition.binding, "createMultipartUpload", () =>
+          bucket.createMultipartUpload(key, options),
+        ).pipe(Effect.map(wrapUpload)),
+      resumeMultipartUpload: (key, uploadId) =>
+        tryR2Sync(definition.binding, "resumeMultipartUpload", () =>
+          wrapUpload(bucket.resumeMultipartUpload(key, uploadId)),
+        ),
+      delete: (keys) => {
+        const nativeKeys = typeof keys === "string" ? keys : [...keys];
+        return tryR2Promise(definition.binding, "delete", () => bucket.delete(nativeKeys));
+      },
+      list: (options) => tryR2Promise(definition.binding, "list", () => bucket.list(options)),
+      unsafeRaw: Effect.succeed(bucket),
+    };
+  };
 };
 
 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/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 },
   );