effect-cf 0.6.0 → 0.8.0

package/dist/index.mjs

@@ -1,101 +1,32 @@
 import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
-import { Cause, Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Layer, ManagedRuntime, Option, Queue, Schema } from "effect";
+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 { 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";
 import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
 import * as RpcServer from "effect/unstable/rpc/RpcServer";
-//#region src/Environment.ts
-/**
-* Context service for reading worker bindings from the current `env` object.
-*/
-var WorkerEnvironment = class extends Context.Service()("effect-cf/WorkerEnvironment") {};
-let WorkerConfig;
-(function(_WorkerConfig) {
-	_WorkerConfig.string = (name) => Config.string(name);
-	_WorkerConfig.redacted = (name) => Config.redacted(name);
-	_WorkerConfig.number = (name) => Config.number(name);
-	_WorkerConfig.integer = (name) => Config.int(name);
-	_WorkerConfig.boolean = (name) => Config.boolean(name);
-	const providerFromEnv = _WorkerConfig.providerFromEnv = (env) => ConfigProvider.fromUnknown(env);
-	const providerWith = _WorkerConfig.providerWith = (makeProvider) => Effect.map(WorkerEnvironment.asEffect(), makeProvider);
-	const provider = _WorkerConfig.provider = providerWith(providerFromEnv);
-	_WorkerConfig.layer = _WorkerConfig.providerLayer = ConfigProvider.layer(provider);
-	_WorkerConfig.layerWith = (makeProvider) => ConfigProvider.layer(providerWith(makeProvider));
-})(WorkerConfig || (WorkerConfig = {}));
-//#endregion
-//#region src/Binding.ts
-var Binding_exports = /* @__PURE__ */ __exportAll({
-	BindingNotFoundError: () => BindingNotFoundError,
-	BindingValidationError: () => BindingValidationError,
-	Service: () => Service$6,
-	TypeId: () => TypeId$6
-});
-/** Internal type id marker used by binding helper services. */
-const TypeId$6 = "effect-cf/Binding";
-/** Error raised when a configured binding does not exist on `env`. */
-var BindingNotFoundError = class extends Data.TaggedError("BindingNotFoundError") {};
-/** Error raised when a binding exists but does not match the expected shape. */
-var BindingValidationError = class extends Data.TaggedError("BindingValidationError") {};
-const isPropertyTarget$1 = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
-const getBinding = (env, binding, isResource) => Effect.gen(function* () {
-	if (!isPropertyTarget$1(env)) return yield* Effect.fail(new BindingValidationError({ binding }));
-	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 }));
-	return resource;
-});
-const Service$6 = () => (id, binding, isResource, wrap) => {
-	const tag = Context.Service()(id);
-	const layer = Layer.effect(tag, Effect.gen(function* () {
-		const resource = yield* getBinding(yield* WorkerEnvironment, binding, isResource);
-		return wrap === void 0 ? resource : wrap(resource);
-	}));
-	return Object.assign(tag, {
-		[TypeId$6]: TypeId$6,
-		binding,
-		layer
-	});
-};
-//#endregion
 //#region src/D1.ts
 var D1_exports = /* @__PURE__ */ __exportAll({
-	D1OperationError: () => D1OperationError,
-	Service: () => Service$5,
-	make: () => make$11
+	Service: () => Service$1,
+	make: () => make$10
 });
-const TypeId$5 = "effect-cf/D1";
-/** Error raised when a D1 operation fails. */
-var D1OperationError = class extends Data.TaggedError("D1OperationError") {};
+const TypeId$2 = "effect-cf/D1";
 const isD1Database = (value) => {
 	if (typeof value !== "object" || value === null) return false;
 	const resource = value;
 	return typeof resource.prepare === "function" && typeof resource.batch === "function" && typeof resource.exec === "function";
 };
-const d1Error = (binding, operation, cause) => new D1OperationError({
-	binding,
-	operation,
-	cause
-});
-const tryD1Promise = (binding, operation, evaluate) => Effect.tryPromise({
-	try: evaluate,
-	catch: (cause) => d1Error(binding, operation, cause)
-});
-const tryD1Sync = (binding, operation, evaluate) => Effect.try({
-	try: evaluate,
-	catch: (cause) => d1Error(binding, operation, cause)
-});
 /**
 * Creates a typed D1 service tag plus Effect helpers.
 */
-const make$11 = (id, definition) => Service$5()(id, definition);
+const make$10 = (id, definition) => Service$1()(id, definition);
 /**
 * Builds a D1 service around a Cloudflare D1 database binding.
 *
-* The returned service exposes the raw `D1Database` binding, small native D1
-* helpers, and `sqlLayer(...)` for providing `effect/unstable/sql` via
-* `@effect/sql-d1`.
+* The returned service exposes the raw `D1Database` binding and `sqlLayer(...)`
+* for providing `effect/unstable/sql` via `@effect/sql-d1`.
 *
 * @example
 * ```ts
@@ -106,8 +37,8 @@ const make$11 = (id, definition) => Service$5()(id, definition);
 * const SqlLive = TodoDatabase.sqlLayer();
 * ```
 */
-const Service$5 = () => (id, definition) => {
-	const tag = Service$6()(id, definition.binding, isD1Database);
+const Service$1 = () => (id, definition) => {
+	const tag = Service$2()(id, definition.binding, isD1Database);
 	const sqlLayer = (options) => Layer.unwrap(Effect.gen(function* () {
 		const db = yield* tag;
 		return D1Client.layer({
@@ -115,39 +46,20 @@ const Service$5 = () => (id, definition) => {
 			db
 		});
 	})).pipe(Layer.provide(tag.layer));
-	const prepare = Effect.fnUntraced(function* (query) {
-		const db = yield* tag;
-		return yield* tryD1Sync(definition.binding, "prepare", () => db.prepare(query));
-	});
-	const batch = Effect.fnUntraced(function* (statements) {
-		const db = yield* tag;
-		return yield* tryD1Promise(definition.binding, "batch", () => db.batch([...statements]));
-	});
-	const exec = Effect.fnUntraced(function* (query) {
-		const db = yield* tag;
-		return yield* tryD1Promise(definition.binding, "exec", () => db.exec(query));
-	});
-	const unsafeRaw = Effect.fnUntraced(function* () {
-		return yield* tag;
-	});
 	return Object.assign(tag, {
-		[TypeId$5]: TypeId$5,
+		[TypeId$2]: TypeId$2,
 		definition,
-		sqlLayer,
-		prepare,
-		batch,
-		exec,
-		unsafeRaw
+		sqlLayer
 	});
 };
 //#endregion
 //#region src/QueueBinding.ts
 var QueueBinding_exports = /* @__PURE__ */ __exportAll({
 	QueueOperationError: () => QueueOperationError,
-	Service: () => Service$4,
-	make: () => make$10
+	isQueue: () => isQueue,
+	layer: () => layer$7,
+	makeClient: () => makeClient$6
 });
-const TypeId$4 = "effect-cf/QueueBinding";
 var QueueOperationError = class extends Data.TaggedError("QueueOperationError") {};
 const queueError = (binding, operation, cause) => new QueueOperationError({
 	binding,
@@ -163,14 +75,9 @@ const isQueue = (value) => {
 	const resource = value;
 	return typeof resource.send === "function" && typeof resource.sendBatch === "function" && typeof resource.metrics === "function";
 };
-/** Creates a typed Queue binding service tag plus Effect helpers. */
-const make$10 = (id, definition) => Service$4()(id, definition);
-/**
-* Builds an Effect service around a Cloudflare Queue producer binding.
-*/
-const Service$4 = () => (id, definition) => {
+const makeClient$6 = (definition) => {
 	const encodeMessage = Schema.encodeEffect(definition.message);
-	const makeClient = (queue) => ({
+	return (queue) => ({
 		send: Effect.fnUntraced(function* (message, options) {
 			const encoded = yield* encodeMessage(message);
 			yield* tryQueuePromise(definition.binding, "send", () => queue.send(encoded, options));
@@ -186,7 +93,34 @@ const Service$4 = () => (id, definition) => {
 		metrics: () => tryQueuePromise(definition.binding, "metrics", () => queue.metrics()),
 		unsafeRaw: Effect.succeed(queue)
 	});
-	const tag = Service$6()(id, definition.binding, (value) => isQueue(value), makeClient);
+};
+const layer$7 = (tag, definition) => layer$8(tag, definition.binding, (value) => isQueue(value), makeClient$6(definition));
+//#endregion
+//#region src/QueueDefinition.ts
+var QueueDefinition_exports = /* @__PURE__ */ __exportAll({
+	Queue: () => Queue$1,
+	Tag: () => Tag$10,
+	implement: () => implement$7,
+	make: () => make$9
+});
+const makeDefinition$4 = (id, definition) => {
+	const queueDefinition = {
+		id,
+		message: definition.message
+	};
+	return Object.assign(queueDefinition, { make: (layer, options) => make$6(layer, {
+		...options,
+		queue: wrapHandler$1(queueDefinition, options.queue)
+	}) });
+};
+const make$9 = (id, definition) => Tag$10()(id, definition);
+const Tag$10 = () => (id, definition) => {
+	const queueDefinition = makeDefinition$4(id, definition);
+	const tag = Context.Service()(id);
+	const layer = (binding) => layer$7(tag, {
+		...binding,
+		message: definition.message
+	});
 	const send = Effect.fnUntraced(function* (message, options) {
 		yield* (yield* tag).send(message, options);
 	});
@@ -200,55 +134,17 @@ const Service$4 = () => (id, definition) => {
 		return yield* (yield* tag).unsafeRaw;
 	});
 	return Object.assign(tag, {
-		[TypeId$4]: TypeId$4,
-		binding: definition.binding,
+		id: queueDefinition.id,
+		message: queueDefinition.message,
+		make: queueDefinition.make,
+		layer,
 		send,
 		sendBatch,
 		metrics,
 		unsafeRaw
 	});
 };
-//#endregion
-//#region src/QueueDefinition.ts
-var QueueDefinition_exports = /* @__PURE__ */ __exportAll({
-	Queue: () => Queue$1,
-	Tag: () => Tag$8,
-	implement: () => implement$7,
-	make: () => make$9
-});
-const makeDefinition$4 = (id, definition) => {
-	const queueDefinition = {
-		id,
-		message: definition.message
-	};
-	return Object.assign(queueDefinition, {
-		make: (layer, options) => make$6(layer, {
-			...options,
-			queue: wrapHandler$1(queueDefinition, options.queue)
-		}),
-		Binding: () => (bindingId, binding) => Service$4()(bindingId, {
-			...binding,
-			message: definition.message
-		}),
-		binding: (bindingId, binding) => Service$4()(bindingId, {
-			...binding,
-			message: definition.message
-		})
-	});
-};
-const make$9 = makeDefinition$4;
-const Tag$8 = () => (id, definition) => {
-	const queueDefinition = makeDefinition$4(id, definition);
-	class QueueDefinitionClass {
-		static id = queueDefinition.id;
-		static message = queueDefinition.message;
-		static make = queueDefinition.make;
-		static Binding = queueDefinition.Binding;
-		static binding = queueDefinition.binding;
-	}
-	return QueueDefinitionClass;
-};
-const Queue$1 = Tag$8;
+const Queue$1 = Tag$10;
 const wrapHandler$1 = (definition, handler) => {
 	const decodeBody = Schema.decodeUnknownEffect(definition.message);
 	return (batch) => Effect.gen(function* () {
@@ -260,7 +156,7 @@ const implement$7 = (_definition, handler) => handler;
 //#region src/Queue.ts
 var Queue_exports = /* @__PURE__ */ __exportAll({
 	QueueMessageDecodeError: () => QueueMessageDecodeError,
-	Tag: () => Tag$7,
+	Tag: () => Tag$9,
 	decodeBatch: () => decodeBatch,
 	fromMessage: () => fromMessage,
 	fromMessageBatch: () => fromMessageBatch,
@@ -298,7 +194,7 @@ const decodeBatch = (batch, decodeBody) => Effect.gen(function* () {
 	}
 	return fromMessageBatch(batch, messages);
 });
-const Tag$7 = Tag$8;
+const Tag$9 = Tag$10;
 const implement$6 = implement$7;
 //#endregion
 //#region src/RpcDefinition.ts
@@ -473,11 +369,15 @@ const invokeRpcMethod = (target, method, args, makeError) => Effect.gen(function
 //#endregion
 //#region src/ServiceBinding.ts
 var ServiceBinding_exports = /* @__PURE__ */ __exportAll({
-	Service: () => Service$3,
+	Service: () => Service,
 	ServiceBindingFetchError: () => ServiceBindingFetchError,
-	ServiceBindingRpcError: () => ServiceBindingRpcError
+	ServiceBindingRpcError: () => ServiceBindingRpcError,
+	isServiceBindingClient: () => isServiceBindingClient,
+	layer: () => layer$6,
+	makeClient: () => makeClient$5,
+	makeDirectMethods: () => makeDirectMethods$1
 });
-const TypeId$3 = "effect-cf/ServiceBinding";
+const TypeId$1 = "effect-cf/ServiceBinding";
 /**
 * Failure raised when calling `fetch` on a service binding.
 */
@@ -486,34 +386,9 @@ var ServiceBindingFetchError = class extends Data.TaggedError("ServiceBindingFet
 * Failure raised when invoking an RPC method on a service binding.
 */
 var ServiceBindingRpcError = class extends Data.TaggedError("ServiceBindingRpcError") {};
-/**
-* Creates a typed Effect service for a Worker service binding.
-*
-* Returned value includes:
-* - a Context tag for dependency injection
-* - `fetch(...)` for raw HTTP forwarding
-* - `call(...)` for generic RPC invocation
-* - direct RPC methods when `definition` is provided
-*
-* @example
-* ```ts
-* const Counter = WorkerDefinition.make("Counter", {
-*   increment: WorkerDefinition.method({
-*     args: [Schema.Number],
-*     success: Schema.Number,
-*   }),
-* });
-*
-* const CounterService = Counter.binding("COUNTER", { binding: "COUNTER" });
-*
-* const program = Effect.gen(function* () {
-*   const next = yield* CounterService.increment(1);
-*   return next;
-* });
-* ```
-*/
-const Service$3 = () => (id, definition) => {
-	const makeClient = (service) => {
+const isServiceBindingClient = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "fetch") === "function";
+const makeClient$5 = (definition) => {
+	return (service) => {
 		const fetch = (input, init) => Effect.tryPromise({
 			try: () => service.fetch(input, init),
 			catch: (cause) => new ServiceBindingFetchError({
@@ -533,22 +408,24 @@ const Service$3 = () => (id, definition) => {
 				cause
 			}));
 		});
-		const call = (method, ...args) => Effect.gen(function* () {
-			const methodName = String(method);
-			const value = yield* resolve(yield* rpc(method, ...args)).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
+		const decodeSuccess$2 = (methodName, value) => Effect.gen(function* () {
+			if (definition.definition === void 0) return value;
+			return yield* decodeSuccess(definition.definition, methodName, value).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
 				binding: definition.binding,
 				method: methodName,
 				cause
 			})));
-			if (definition.definition === void 0) return value;
-			return yield* decodeSuccess(definition.definition, methodName, value).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
+		});
+		const call = (method, ...args) => Effect.gen(function* () {
+			const methodName = String(method);
+			return yield* decodeSuccess$2(methodName, yield* resolve(yield* rpc(method, ...args)).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
 				binding: definition.binding,
 				method: methodName,
 				cause
-			})));
+			}))));
 		});
 		const scopedCall = (method, ...args) => Effect.gen(function* () {
-			return yield* scoped(yield* rpc(method, ...args));
+			return yield* decodeSuccess$2(String(method), yield* scoped(yield* rpc(method, ...args)));
 		});
 		const directMethods = makeDirectMethods$1(definition.definition, call);
 		return Object.assign(directMethods, {
@@ -558,7 +435,39 @@ const Service$3 = () => (id, definition) => {
 			scopedCall
 		});
 	};
-	const tag = Service$6()(id, definition.binding, (value) => typeof value === "object" && value !== null && "fetch" in value, makeClient);
+};
+const layer$6 = (tag, definition) => layer$8(tag, definition.binding, (value) => isServiceBindingClient(value), makeClient$5(definition));
+/**
+* Creates a typed Effect service for a Worker service binding.
+*
+* Returned value includes:
+* - a Context tag for dependency injection
+* - `fetch(...)` for raw HTTP forwarding
+* - `rpc(...)` for raw Cloudflare RPC results
+* - `call(...)` for resolved and decoded RPC results
+* - `scopedCall(...)` for scoped and decoded disposable RPC results
+* - direct RPC methods when `definition` is provided
+*
+* @example
+* ```ts
+* const Counter = WorkerDefinition.make("Counter", {
+*   increment: WorkerDefinition.method({
+*     args: [Schema.Number],
+*     success: Schema.Number,
+*   }),
+* });
+*
+* const CounterLive = Counter.layer({ binding: "COUNTER" });
+*
+* const program = Effect.gen(function* () {
+*   const counter = yield* Counter;
+*   const next = yield* counter.increment(1);
+*   return next;
+* });
+* ```
+*/
+const Service = () => (id, definition) => {
+	const tag = Service$2()(id, definition.binding, (value) => isServiceBindingClient(value), makeClient$5(definition));
 	const fetch = (input, init) => Effect.gen(function* () {
 		return yield* (yield* tag).fetch(input, init);
 	});
@@ -573,7 +482,7 @@ const Service$3 = () => (id, definition) => {
 	});
 	const directMethods = makeDirectMethods$1(definition.definition, call);
 	return Object.assign(tag, directMethods, {
-		[TypeId$3]: TypeId$3,
+		[TypeId$1]: TypeId$1,
 		definition,
 		fetch,
 		rpc,
@@ -589,7 +498,7 @@ const makeDirectMethods$1 = (rpcDefinition, call) => {
 //#endregion
 //#region src/WorkerDefinition.ts
 var WorkerDefinition_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$6,
+	Tag: () => Tag$8,
 	Worker: () => Worker,
 	implement: () => implement$5,
 	make: () => make$7,
@@ -631,34 +540,45 @@ const method$3 = method$4;
 const makeDefinition$3 = (id, methods) => {
 	assertNoReservedMethods("Worker", methods, reservedMethodNames$3);
 	const definition = make$8(id, methods);
-	return Object.assign(definition, {
-		make: (layer, options) => make$6(layer, {
-			...options,
-			rpc: wrapHandlers$1(definition, options.rpc)
-		}),
-		Binding: () => (bindingId, binding) => Service$3()(bindingId, {
-			...binding,
-			definition
-		}),
-		binding: (bindingId, binding) => Service$3()(bindingId, {
-			...binding,
-			definition
-		})
-	});
+	return Object.assign(definition, { make: (layer, options) => make$6(layer, {
+		...options,
+		rpc: wrapHandlers$1(definition, options.rpc)
+	}) });
 };
-const make$7 = makeDefinition$3;
-const Tag$6 = () => (id, methods) => {
+const make$7 = (id, methods) => Tag$8()(id, methods);
+const Tag$8 = () => (id, methods) => {
 	const definition = makeDefinition$3(id, methods);
-	class WorkerDefinitionClass {
-		static id = definition.id;
-		static methods = definition.methods;
-		static make = definition.make;
-		static Binding = definition.Binding;
-		static binding = definition.binding;
-	}
-	return WorkerDefinitionClass;
+	const tag = Context.Service()(id);
+	const bindingDefinition = (binding) => ({
+		...binding,
+		definition
+	});
+	const layer = (binding) => layer$6(tag, bindingDefinition(binding));
+	const fetch = (input, init) => Effect.gen(function* () {
+		return yield* (yield* tag).fetch(input, init);
+	});
+	const rpc = (method, ...args) => Effect.gen(function* () {
+		return yield* (yield* tag).rpc(method, ...args);
+	});
+	const call = (method, ...args) => Effect.gen(function* () {
+		return yield* (yield* tag).call(method, ...args);
+	});
+	const scopedCall = (method, ...args) => Effect.gen(function* () {
+		return yield* (yield* tag).scopedCall(method, ...args);
+	});
+	const directMethods = makeDirectMethods$1(definition, call);
+	return Object.assign(tag, directMethods, {
+		id: definition.id,
+		methods: definition.methods,
+		make: definition.make,
+		layer,
+		fetch,
+		rpc,
+		call,
+		scopedCall
+	});
 };
-const Worker = Tag$6;
+const Worker = Tag$8;
 const wrapHandlers$1 = (definition, handlers) => {
 	const wrapped = {};
 	for (const key of Object.keys(definition.methods)) {
@@ -714,7 +634,7 @@ const fromExecutionContext = (ctx, runPromiseExit) => {
 var Worker_exports = /* @__PURE__ */ __exportAll({
 	ExecutionContext: () => ExecutionContext,
 	NativeRequest: () => NativeRequest,
-	Tag: () => Tag$5,
+	Tag: () => Tag$7,
 	WorkerContext: () => WorkerContext,
 	implement: () => implement$4,
 	isWebSocketUpgrade: () => isWebSocketUpgrade,
@@ -781,7 +701,7 @@ const makeFetchHandler = (layer, options) => {
 	const WorkerClass = make$6(layer, options);
 	return { fetch: (request, env, ctx) => Promise.resolve(new WorkerClass(ctx, env).fetch(request)) };
 };
-const Tag$5 = Tag$6;
+const Tag$7 = Tag$8;
 const method$2 = method$3;
 const implement$4 = implement$5;
 //#endregion
@@ -1078,9 +998,11 @@ const runPromiseExitPreservingTypedFailures = async (effect) => {
 var DurableObjectNamespace_exports = /* @__PURE__ */ __exportAll({
 	DurableObjectFetchError: () => DurableObjectFetchError,
 	DurableObjectRpcError: () => DurableObjectRpcError,
-	Service: () => Service$2
+	isDurableObjectNamespaceClient: () => isDurableObjectNamespaceClient,
+	layer: () => layer$5,
+	makeClient: () => makeClient$4,
+	makeDirectMethods: () => makeDirectMethods
 });
-const TypeId$2 = "effect-cf/DurableObjectNamespace";
 /**
 * Failure raised when invoking an RPC method on a Durable Object stub.
 */
@@ -1089,33 +1011,10 @@ var DurableObjectRpcError = class extends Data.TaggedError("DurableObjectRpcErro
 * Failure raised when forwarding a request to a Durable Object stub.
 */
 var DurableObjectFetchError = class extends Data.TaggedError("DurableObjectFetchError") {};
-/**
-* Creates a typed Effect service for a Durable Object namespace binding.
-*
-* Returned value includes namespace helpers (`get`, `getByName`, `newUniqueId`),
-* raw `fetch` / `call` helpers, and direct RPC helpers when `definition` is provided.
-*
-* @example
-* ```ts
-* const ChatRoom = DurableObjectDefinition.make("ChatRoom", {
-*   postMessage: DurableObjectDefinition.method({
-*     args: [Schema.String],
-*     success: Schema.Void,
-*   }),
-* });
-*
-* const ChatRooms = ChatRoom.namespace("CHAT_ROOMS", { binding: "CHAT_ROOMS" });
-*
-* const program = Effect.gen(function* () {
-*   const room = ChatRooms.byName("general");
-*   yield* room.postMessage("hello");
-* });
-* ```
-*/
-const Service$2 = () => (id, definition) => {
-	const hasFunction = (value, key) => typeof Reflect.get(value, key) === "function";
-	const isDurableObjectNamespaceClient = (value) => typeof value === "object" && value !== null && hasFunction(value, "getByName") && hasFunction(value, "get") && hasFunction(value, "idFromName") && hasFunction(value, "idFromString") && hasFunction(value, "newUniqueId") && hasFunction(value, "jurisdiction");
-	const makeClient = (namespace) => {
+const hasFunction$1 = (value, key) => typeof Reflect.get(value, key) === "function";
+const isDurableObjectNamespaceClient = (value) => typeof value === "object" && value !== null && hasFunction$1(value, "getByName") && hasFunction$1(value, "get") && hasFunction$1(value, "idFromName") && hasFunction$1(value, "idFromString") && hasFunction$1(value, "newUniqueId") && hasFunction$1(value, "jurisdiction");
+const makeClient$4 = (definition) => {
+	return (namespace) => {
 		const newUniqueId = (options) => Effect.sync(() => namespace.newUniqueId(options));
 		const idFromName = (name) => Effect.sync(() => namespace.idFromName(name));
 		const idFromString = (id) => Effect.sync(() => namespace.idFromString(id));
@@ -1141,22 +1040,24 @@ const Service$2 = () => (id, definition) => {
 				cause
 			}));
 		});
-		const call = (stub, method, ...args) => Effect.gen(function* () {
-			const methodName = String(method);
-			const value = yield* resolve(yield* rpc(stub, method, ...args)).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+		const decodeSuccess$1 = (methodName, value) => Effect.gen(function* () {
+			if (definition.definition === void 0) return value;
+			return yield* decodeSuccess(definition.definition, methodName, value).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
 				binding: definition.binding,
 				method: methodName,
 				cause
 			})));
-			if (definition.definition === void 0) return value;
-			return yield* decodeSuccess(definition.definition, methodName, value).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+		});
+		const call = (stub, method, ...args) => Effect.gen(function* () {
+			const methodName = String(method);
+			return yield* decodeSuccess$1(methodName, yield* resolve(yield* rpc(stub, method, ...args)).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
 				binding: definition.binding,
 				method: methodName,
 				cause
-			})));
+			}))));
 		});
 		const scopedCall = (stub, method, ...args) => Effect.gen(function* () {
-			return yield* scoped(yield* rpc(stub, method, ...args));
+			return yield* decodeSuccess$1(String(method), yield* scoped(yield* rpc(stub, method, ...args)));
 		});
 		const directMethods = makeDirectMethods(definition.definition, {
 			call,
@@ -1178,86 +1079,8 @@ const Service$2 = () => (id, definition) => {
 			unsafeRaw: Effect.succeed(namespace)
 		});
 	};
-	const tag = Service$6()(id, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient);
-	const newUniqueId = Effect.fnUntraced(function* (options) {
-		return yield* (yield* tag).newUniqueId(options);
-	});
-	const idFromName = Effect.fnUntraced(function* (name) {
-		return yield* (yield* tag).idFromName(name);
-	});
-	const idFromString = Effect.fnUntraced(function* (id) {
-		return yield* (yield* tag).idFromString(id);
-	});
-	const get = Effect.fnUntraced(function* (id, options) {
-		return yield* (yield* tag).get(id, options);
-	});
-	const getByName = Effect.fnUntraced(function* (name, options) {
-		return yield* (yield* tag).getByName(name, options);
-	});
-	const jurisdiction = Effect.fnUntraced(function* (value) {
-		return yield* (yield* tag).jurisdiction(value);
-	});
-	const fetch = (stub, input, init) => Effect.tryPromise({
-		try: () => stub.fetch(input, init),
-		catch: (cause) => new DurableObjectFetchError({
-			binding: definition.binding,
-			cause
-		})
-	});
-	const rpc = (stub, method, ...args) => Effect.gen(function* () {
-		const methodName = String(method);
-		return yield* invokeRpcMethod(stub, method, definition.definition === void 0 ? args : yield* encodeArgs(definition.definition, methodName, args).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
-			binding: definition.binding,
-			method: methodName,
-			cause
-		}))), (cause) => new DurableObjectRpcError({
-			binding: definition.binding,
-			method: methodName,
-			cause
-		}));
-	});
-	const call = (stub, method, ...args) => Effect.gen(function* () {
-		const methodName = String(method);
-		const value = yield* resolve(yield* rpc(stub, method, ...args)).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
-			binding: definition.binding,
-			method: methodName,
-			cause
-		})));
-		if (definition.definition === void 0) return value;
-		return yield* decodeSuccess(definition.definition, methodName, value).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
-			binding: definition.binding,
-			method: methodName,
-			cause
-		})));
-	});
-	const scopedCall = (stub, method, ...args) => Effect.gen(function* () {
-		return yield* scoped(yield* rpc(stub, method, ...args));
-	});
-	const unsafeRaw = Effect.fnUntraced(function* () {
-		return yield* (yield* tag).unsafeRaw;
-	});
-	const directMethods = makeDirectMethods(definition.definition, {
-		call,
-		fetch,
-		get,
-		getByName
-	});
-	return Object.assign(tag, directMethods, {
-		[TypeId$2]: TypeId$2,
-		definition,
-		newUniqueId,
-		idFromName,
-		idFromString,
-		get,
-		getByName,
-		jurisdiction,
-		fetch,
-		rpc,
-		call,
-		scopedCall,
-		unsafeRaw
-	});
 };
+const layer$5 = (tag, definition) => layer$8(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$4(definition));
 const makeDirectMethods = (rpcDefinition, helpers) => {
 	const methods = {};
 	if (rpcDefinition !== void 0) {
@@ -1282,7 +1105,7 @@ const makeDirectMethods = (rpcDefinition, helpers) => {
 //#region src/DurableObjectDefinition.ts
 var DurableObjectDefinition_exports = /* @__PURE__ */ __exportAll({
 	DurableObject: () => DurableObject$1,
-	Tag: () => Tag$4,
+	Tag: () => Tag$6,
 	implement: () => implement$3,
 	make: () => make$5,
 	method: () => method$1
@@ -1316,34 +1139,78 @@ const method$1 = method$4;
 const makeDefinition$2 = (id, methods) => {
 	assertNoReservedMethods("Durable Object", methods, reservedMethodNames$1);
 	const definition = make$8(id, methods);
-	return Object.assign(definition, {
-		make: (layer, options) => make$4(layer, {
-			...options,
-			rpc: wrapHandlers(definition, options.rpc)
-		}),
-		Namespace: () => (bindingId, binding) => Service$2()(bindingId, {
-			...binding,
-			definition
-		}),
-		namespace: (bindingId, binding) => Service$2()(bindingId, {
-			...binding,
-			definition
-		})
-	});
+	return Object.assign(definition, { make: (layer, options) => make$4(layer, {
+		...options,
+		rpc: wrapHandlers(definition, options.rpc)
+	}) });
 };
-const make$5 = makeDefinition$2;
-const Tag$4 = () => (id, methods) => {
+const make$5 = (id, methods) => Tag$6()(id, methods);
+const Tag$6 = () => (id, methods) => {
 	const definition = makeDefinition$2(id, methods);
-	class DurableObjectDefinitionClass {
-		static id = definition.id;
-		static methods = definition.methods;
-		static make = definition.make;
-		static Namespace = definition.Namespace;
-		static namespace = definition.namespace;
-	}
-	return DurableObjectDefinitionClass;
+	const tag = Context.Service()(id);
+	const bindingDefinition = (binding) => ({
+		...binding,
+		definition
+	});
+	const layer = (binding) => layer$5(tag, bindingDefinition(binding));
+	const newUniqueId = Effect.fnUntraced(function* (options) {
+		return yield* (yield* tag).newUniqueId(options);
+	});
+	const idFromName = Effect.fnUntraced(function* (name) {
+		return yield* (yield* tag).idFromName(name);
+	});
+	const idFromString = Effect.fnUntraced(function* (value) {
+		return yield* (yield* tag).idFromString(value);
+	});
+	const get = Effect.fnUntraced(function* (objectId, options) {
+		return yield* (yield* tag).get(objectId, options);
+	});
+	const getByName = Effect.fnUntraced(function* (name, options) {
+		return yield* (yield* tag).getByName(name, options);
+	});
+	const jurisdiction = Effect.fnUntraced(function* (value) {
+		return yield* (yield* tag).jurisdiction(value);
+	});
+	const fetch = (stub, input, init) => Effect.gen(function* () {
+		return yield* (yield* tag).fetch(stub, input, init);
+	});
+	const rpc = (stub, method, ...args) => Effect.gen(function* () {
+		return yield* (yield* tag).rpc(stub, method, ...args);
+	});
+	const call = (stub, method, ...args) => Effect.gen(function* () {
+		return yield* (yield* tag).call(stub, method, ...args);
+	});
+	const scopedCall = (stub, method, ...args) => Effect.gen(function* () {
+		return yield* (yield* tag).scopedCall(stub, method, ...args);
+	});
+	const unsafeRaw = Effect.fnUntraced(function* () {
+		return yield* (yield* tag).unsafeRaw;
+	});
+	const directMethods = makeDirectMethods(definition, {
+		call,
+		fetch,
+		get,
+		getByName
+	});
+	return Object.assign(tag, directMethods, {
+		id: definition.id,
+		methods: definition.methods,
+		make: definition.make,
+		layer,
+		newUniqueId,
+		idFromName,
+		idFromString,
+		get,
+		getByName,
+		jurisdiction,
+		fetch,
+		rpc,
+		call,
+		scopedCall,
+		unsafeRaw
+	});
 };
-const DurableObject$1 = Tag$4;
+const DurableObject$1 = Tag$6;
 const wrapHandlers = (definition, handlers) => {
 	const wrapped = {};
 	for (const key of Object.keys(definition.methods)) {
@@ -1361,7 +1228,7 @@ const implement$3 = (_definition, handlers) => handlers;
 //#endregion
 //#region src/DurableObject.ts
 var DurableObject_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$3,
+	Tag: () => Tag$5,
 	implement: () => implement$2,
 	make: () => make$4,
 	method: () => method
@@ -1418,7 +1285,7 @@ const make$4 = (layer, options = {}) => {
 	defineEntrypointRpcMethods("Durable Object", EffectDurableObject.prototype, options.rpc, reservedMethodNames, (self, effect) => self[RunSymbol](effect));
 	return assumeEntrypointClass(EffectDurableObject);
 };
-const Tag$3 = Tag$4;
+const Tag$5 = Tag$6;
 const method = method$1;
 const implement$2 = implement$3;
 //#endregion
@@ -1747,7 +1614,7 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 //#region src/DurableObjectRpcWebSocket.ts
 var DurableObjectRpcWebSocket_exports = /* @__PURE__ */ __exportAll({
 	DurableObjectRpcWebSocket: () => DurableObjectRpcWebSocket,
-	layer: () => layer
+	layer: () => layer$4
 });
 const defaultAttachmentKey = "effectCloudflareRpcClientId";
 const defaultTag = "effect-cf-rpc";
@@ -1758,7 +1625,7 @@ var DurableObjectRpcWebSocket = class extends Context.Service()("effect-cf/Durab
 /**
 * Builds a layer that bridges Durable Object websocket events to `RpcServer.Protocol`.
 */
-const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
+const layer$4 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 	const tag = options.tag ?? defaultTag;
 	const attachmentKey = options.attachmentKey ?? defaultAttachmentKey;
 	const durableObjectState = yield* DurableObjectState;
@@ -1870,14 +1737,120 @@ const writeAttachment = (socket, key, clientId) => {
 	});
 };
 //#endregion
+//#region src/Images.ts
+var Images_exports = /* @__PURE__ */ __exportAll({
+	ImagesOperationError: () => ImagesOperationError,
+	Tag: () => Tag$4,
+	draw: () => draw,
+	empty: () => empty,
+	isImagesBinding: () => isImagesBinding,
+	layer: () => layer$3,
+	make: () => make$3,
+	makeClient: () => makeClient$3,
+	transform: () => transform
+});
+const TypeId = "effect-cf/Images/Steps";
+/** Error raised when a Cloudflare Images operation fails. */
+var ImagesOperationError = class extends Data.TaggedError("ImagesOperationError") {};
+const makeSteps = (steps) => ({
+	[TypeId]: TypeId,
+	steps
+});
+/** Empty Images transformation pipeline. */
+const empty = makeSteps([]);
+function transform(stepsOrTransform, transformValue) {
+	if (transformValue === void 0) return (steps) => transform(steps, stepsOrTransform);
+	return makeSteps([...stepsOrTransform.steps, {
+		_tag: "Transform",
+		transform: transformValue
+	}]);
+}
+function draw(stepsOrDraw, drawValue) {
+	if (drawValue === void 0) return (steps) => draw(steps, stepsOrDraw);
+	return makeSteps([...stepsOrDraw.steps, {
+		_tag: "Draw",
+		...drawValue
+	}]);
+}
+const imagesError = (binding, operation, cause) => new ImagesOperationError({
+	binding,
+	operation,
+	cause
+});
+const tryImagesPromise = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => imagesError(binding, operation, cause)
+});
+const tryImagesSync = (binding, operation, evaluate) => Effect.try({
+	try: evaluate,
+	catch: (cause) => imagesError(binding, operation, cause)
+});
+const maybe$1 = (value) => value === null ? Option.none() : Option.some(value);
+const hasFunction = (value, key) => typeof Reflect.get(value, key) === "function";
+const isHostedImagesBinding = (value) => typeof value === "object" && value !== null && hasFunction(value, "image") && hasFunction(value, "upload") && hasFunction(value, "list");
+const isImagesBinding = (value) => typeof value === "object" && value !== null && hasFunction(value, "info") && hasFunction(value, "input");
+const wrapResult = (binding, result) => ({
+	raw: result,
+	response: tryImagesSync(binding, "response", () => result.response()),
+	contentType: tryImagesSync(binding, "contentType", () => result.contentType()),
+	image: (options) => tryImagesSync(binding, "image", () => result.image(options))
+});
+const wrapHandle = (binding, handle) => ({
+	raw: handle,
+	details: tryImagesPromise(binding, "details", () => handle.details()).pipe(Effect.map(maybe$1)),
+	bytes: tryImagesPromise(binding, "bytes", () => handle.bytes()).pipe(Effect.map(maybe$1)),
+	update: (options) => tryImagesPromise(binding, "update", () => handle.update(options)),
+	delete: tryImagesPromise(binding, "delete", () => handle.delete())
+});
+const wrapHosted = (binding, hosted) => ({
+	image: (imageId) => wrapHandle(binding, hosted.image(imageId)),
+	upload: (image, options) => tryImagesPromise(binding, "upload", () => hosted.upload(image, options)),
+	list: (options) => tryImagesPromise(binding, "list", () => hosted.list(options)),
+	unsafeRaw: Effect.succeed(hosted)
+});
+const makeClient$3 = (definition) => (images) => {
+	const input = (image, options) => tryImagesSync(definition.binding, "input", () => images.input(image, options));
+	const process = (steps, options) => Effect.gen(function* () {
+		let transformer = yield* input(options.stream, options.inputOptions);
+		for (const step of steps.steps) switch (step._tag) {
+			case "Draw":
+				transformer = yield* tryImagesSync(definition.binding, "draw", () => transformer.draw(step.image, step.options));
+				break;
+			case "Transform":
+				transformer = yield* tryImagesSync(definition.binding, "transform", () => transformer.transform(step.transform));
+				break;
+		}
+		const result = yield* tryImagesPromise(definition.binding, "output", () => transformer.output(options.outputOptions));
+		return wrapResult(definition.binding, result);
+	});
+	return {
+		definition,
+		info: (image, options) => tryImagesPromise(definition.binding, "info", () => images.info(image, options)),
+		input,
+		process,
+		hosted: isHostedImagesBinding(images.hosted) ? Option.some(wrapHosted(definition.binding, images.hosted)) : Option.none(),
+		unsafeRaw: Effect.succeed(images)
+	};
+};
+const layer$3 = (tag, definition) => layer$8(tag, definition.binding, isImagesBinding, makeClient$3(definition));
+const make$3 = (id) => Tag$4()(id);
+const Tag$4 = () => (id) => {
+	const tag = Context.Service()(id);
+	const makeLayer = (definition) => layer$3(tag, definition);
+	return Object.assign(tag, {
+		id,
+		layer: makeLayer
+	});
+};
+//#endregion
 //#region src/Kv.ts
 var Kv_exports = /* @__PURE__ */ __exportAll({
 	KvOperationError: () => KvOperationError,
-	Service: () => Service$1,
-	Tag: () => Tag$2,
-	make: () => make$3
+	Tag: () => Tag$3,
+	isKvNamespace: () => isKvNamespace,
+	layer: () => layer$2,
+	makeClient: () => makeClient$2
 });
-const TypeId$1 = "effect-cf/Kv";
 /** Error raised when a KV operation fails. */
 var KvOperationError = class extends Data.TaggedError("KvOperationError") {};
 const maybeString = (value) => value == null ? Option.none() : Option.some(value);
@@ -1891,66 +1864,17 @@ const tryKvPromise = (binding, operation, evaluate) => Effect.tryPromise({
 	try: evaluate,
 	catch: (cause) => kvError(binding, operation, cause)
 });
-/**
-* Creates a typed KV service tag plus Effect helpers.
-*/
-const make$3 = (id, definition) => Service$1()(id, definition);
-const makeDefinition$1 = (id, definition) => {
-	const kvDefinition = {
-		id,
-		key: definition.key,
-		value: definition.value
-	};
-	return Object.assign(kvDefinition, {
-		Binding: () => (bindingId, binding) => Service$1()(bindingId, {
-			...binding,
-			key: definition.key,
-			value: definition.value
-		}),
-		binding: (bindingId, binding) => Service$1()(bindingId, {
-			...binding,
-			key: definition.key,
-			value: definition.value
-		})
-	});
-};
-const Tag$2 = () => (id, definition) => {
-	const kvDefinition = makeDefinition$1(id, definition);
-	class KvDefinitionClass {
-		static id = kvDefinition.id;
-		static key = kvDefinition.key;
-		static value = kvDefinition.value;
-		static Binding = kvDefinition.Binding;
-		static binding = kvDefinition.binding;
-	}
-	return KvDefinitionClass;
+const isKvNamespace = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const resource = value;
+	return typeof resource.get === "function" && typeof resource.put === "function" && typeof resource.delete === "function" && typeof resource.getWithMetadata === "function" && typeof resource.list === "function";
 };
-/**
-* Builds a KV service around a Cloudflare KV namespace binding.
-*
-* Returned service includes schema-aware `put`, `get`, `getWithMetadata`,
-* `list`, and `remove` helpers.
-*
-* @example
-* ```ts
-* const Sessions = Kv.make("Sessions", {
-*   binding: "SESSIONS",
-*   key: Schema.String,
-*   value: Schema.Struct({ userId: Schema.String }),
-* });
-*
-* const program = Effect.gen(function* () {
-*   yield* Sessions.put("abc", { userId: "u_1" });
-*   return yield* Sessions.get("abc");
-* });
-* ```
-*/
-const Service$1 = () => (id, definition) => {
+const makeClient$2 = (definition) => {
 	const encodeKey = Schema.encodeEffect(definition.key);
 	const decodeKey = Schema.decodeUnknownEffect(definition.key);
 	const encodeValue = Schema.encodeEffect(Schema.fromJsonString(Schema.toCodecJson(definition.value)));
 	const decodeValue = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.toCodecJson(definition.value)));
-	const makeClient = (kv) => ({
+	return (kv) => ({
 		definition,
 		put: Effect.fnUntraced(function* (key, value, options) {
 			const keyEncoded = yield* encodeKey(key);
@@ -2001,49 +1925,109 @@ const Service$1 = () => (id, definition) => {
 		}),
 		unsafeRaw: Effect.succeed(kv)
 	});
-	const tag = Service$6()(id, definition.binding, (value) => {
-		if (typeof value !== "object" || value === null) return false;
-		const resource = value;
-		return typeof resource.get === "function" && typeof resource.put === "function" && typeof resource.delete === "function" && typeof resource.getWithMetadata === "function" && typeof resource.list === "function";
-	}, makeClient);
-	const put = Effect.fnUntraced(function* (key, value, options) {
-		yield* (yield* tag).put(key, value, options);
-	});
-	const get = Effect.fnUntraced(function* (key) {
-		return yield* (yield* tag).get(key);
-	});
-	const getWithMetadata = Effect.fnUntraced(function* (key, metadataSchema) {
-		return yield* (yield* tag).getWithMetadata(key, metadataSchema);
-	});
-	const list = Effect.fnUntraced(function* (options) {
-		return yield* (yield* tag).list(options);
+};
+const layer$2 = (tag, definition) => layer$8(tag, definition.binding, isKvNamespace, makeClient$2(definition));
+const makeDefinition$1 = (id, definition) => {
+	const kvDefinition = {
+		id,
+		key: definition.key,
+		value: definition.value
+	};
+	return Object.assign(kvDefinition, { layer: (tag, binding) => layer$2(tag, {
+		...binding,
+		key: definition.key,
+		value: definition.value
+	}) });
+};
+const Tag$3 = () => (id, definition) => {
+	const kvDefinition = makeDefinition$1(id, definition);
+	const tag = Context.Service()(id);
+	const makeLayer = (binding) => kvDefinition.layer(tag, binding);
+	return Object.assign(tag, {
+		id: kvDefinition.id,
+		keySchema: kvDefinition.key,
+		valueSchema: kvDefinition.value,
+		layer: makeLayer
 	});
-	const remove = Effect.fnUntraced(function* (key) {
-		yield* (yield* tag).remove(key);
+};
+//#endregion
+//#region src/R2.ts
+var R2_exports = /* @__PURE__ */ __exportAll({
+	R2OperationError: () => R2OperationError,
+	Tag: () => Tag$2,
+	isR2Bucket: () => isR2Bucket,
+	layer: () => layer$1,
+	make: () => make$2,
+	makeClient: () => makeClient$1
+});
+/** Error raised when an R2 operation fails. */
+var R2OperationError = class extends Data.TaggedError("R2OperationError") {};
+const r2Error = (binding, operation, cause) => new R2OperationError({
+	binding,
+	operation,
+	cause
+});
+const tryR2Promise = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => r2Error(binding, operation, cause)
+});
+const tryR2Sync = (binding, operation, evaluate) => Effect.try({
+	try: evaluate,
+	catch: (cause) => r2Error(binding, operation, cause)
+});
+const maybe = (value) => value === null ? Option.none() : Option.some(value);
+const isR2Bucket = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const resource = value;
+	return typeof resource.head === "function" && typeof resource.get === "function" && typeof resource.put === "function" && typeof resource.createMultipartUpload === "function" && typeof resource.resumeMultipartUpload === "function" && typeof resource.delete === "function" && typeof resource.list === "function";
+};
+const makeClient$1 = (definition) => {
+	const wrapUpload = (upload) => ({
+		raw: upload,
+		key: upload.key,
+		uploadId: upload.uploadId,
+		uploadPart: (partNumber, value, options) => tryR2Promise(definition.binding, "uploadPart", () => upload.uploadPart(partNumber, value, options)),
+		abort: tryR2Promise(definition.binding, "abortMultipartUpload", () => upload.abort()),
+		complete: (uploadedParts) => tryR2Promise(definition.binding, "completeMultipartUpload", () => upload.complete([...uploadedParts]))
 	});
-	const unsafeRaw = Effect.fnUntraced(function* () {
-		return yield* (yield* tag).unsafeRaw;
+	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)
 	});
+};
+const layer$1 = (tag, definition) => layer$8(tag, definition.binding, isR2Bucket, makeClient$1(definition));
+const make$2 = (id) => Tag$2()(id);
+const Tag$2 = () => (id) => {
+	const tag = Context.Service()(id);
+	const makeLayer = (definition) => layer$1(tag, definition);
 	return Object.assign(tag, {
-		[TypeId$1]: TypeId$1,
-		definition,
-		put,
-		get,
-		getWithMetadata,
-		list,
-		remove,
-		unsafeRaw
+		id,
+		layer: makeLayer
 	});
 };
 //#endregion
 //#region src/WorkflowBinding.ts
 var WorkflowBinding_exports = /* @__PURE__ */ __exportAll({
-	Service: () => Service,
 	WorkflowOperationError: () => WorkflowOperationError,
 	WorkflowResultDecodeError: () => WorkflowResultDecodeError,
-	make: () => make$2
+	isWorkflow: () => isWorkflow,
+	layer: () => layer,
+	makeClient: () => makeClient
 });
-const TypeId = "effect-cf/WorkflowBinding";
 var WorkflowOperationError = class extends Data.TaggedError("WorkflowOperationError") {};
 var WorkflowResultDecodeError = class extends Data.TaggedError("WorkflowResultDecodeError") {};
 const workflowError = (binding, operation, cause) => new WorkflowOperationError({
@@ -2060,9 +2044,7 @@ const isWorkflow = (value) => {
 	const resource = value;
 	return typeof resource.create === "function" && typeof resource.createBatch === "function" && typeof resource.get === "function";
 };
-const make$2 = (id, definition) => Service()(id, definition);
-const Service = () => (id, definition) => {
-	const tag = Service$6()(id, definition.binding, (value) => isWorkflow(value));
+const makeClient = (definition) => {
 	const encodePayload = Schema.encodeEffect(definition.payload);
 	const decodeResult = Schema.decodeUnknownEffect(definition.result);
 	const wrapInstance = (raw) => {
@@ -2089,38 +2071,30 @@ const Service = () => (id, definition) => {
 			sendEvent: (event) => operation("sendEvent", () => raw.sendEvent(event))
 		};
 	};
-	const create = Effect.fnUntraced(function* (payload, options) {
-		const workflow = yield* tag;
-		const encoded = yield* encodePayload(payload);
-		return wrapInstance(yield* tryWorkflowPromise(definition.binding, "create", () => workflow.create({
-			...options,
-			params: encoded
-		})));
-	});
-	const createBatch = Effect.fnUntraced(function* (batch) {
-		const workflow = yield* tag;
-		const encodedBatch = [];
-		for (const item of batch) {
-			const { payload, ...options } = item;
-			encodedBatch.push({
+	return (workflow) => ({
+		create: Effect.fnUntraced(function* (payload, options) {
+			const encoded = yield* encodePayload(payload);
+			return wrapInstance(yield* tryWorkflowPromise(definition.binding, "create", () => workflow.create({
 				...options,
-				params: yield* encodePayload(payload)
-			});
-		}
-		return (yield* tryWorkflowPromise(definition.binding, "createBatch", () => workflow.createBatch(encodedBatch))).map(wrapInstance);
-	});
-	const get = Effect.fnUntraced(function* (instanceId) {
-		const workflow = yield* tag;
-		return wrapInstance(yield* tryWorkflowPromise(definition.binding, "get", () => workflow.get(instanceId)));
-	});
-	return Object.assign(tag, {
-		[TypeId]: TypeId,
-		binding: definition.binding,
-		create,
-		createBatch,
-		get
+				params: encoded
+			})));
+		}),
+		createBatch: Effect.fnUntraced(function* (batch) {
+			const encodedBatch = [];
+			for (const item of batch) {
+				const { payload, ...options } = item;
+				encodedBatch.push({
+					...options,
+					params: yield* encodePayload(payload)
+				});
+			}
+			return (yield* tryWorkflowPromise(definition.binding, "createBatch", () => workflow.createBatch(encodedBatch))).map(wrapInstance);
+		}),
+		get: (instanceId) => tryWorkflowPromise(definition.binding, "get", () => workflow.get(instanceId)).pipe(Effect.map(wrapInstance)),
+		unsafeRaw: Effect.succeed(workflow)
 	});
 };
+const layer = (tag, definition) => layer$8(tag, definition.binding, (value) => isWorkflow(value), makeClient(definition));
 //#endregion
 //#region src/WorkflowDefinition.ts
 var WorkflowDefinition_exports = /* @__PURE__ */ __exportAll({
@@ -2135,32 +2109,40 @@ const makeDefinition = (id, definition) => {
 		payload: definition.payload,
 		result: definition.result
 	};
-	return Object.assign(workflowDefinition, {
-		make: (layer, options) => make(layer, { run: wrapHandler(workflowDefinition, options.run) }),
-		Binding: () => (bindingId, binding) => Service()(bindingId, {
-			...binding,
-			payload: definition.payload,
-			result: definition.result
-		}),
-		binding: (bindingId, binding) => Service()(bindingId, {
-			...binding,
-			payload: definition.payload,
-			result: definition.result
-		})
-	});
+	return Object.assign(workflowDefinition, { make: (layer, options) => make(layer, { run: wrapHandler(workflowDefinition, options.run) }) });
 };
-const make$1 = makeDefinition;
+const make$1 = (id, definition) => Tag$1()(id, definition);
 const Tag$1 = () => (id, definition) => {
 	const workflowDefinition = makeDefinition(id, definition);
-	class WorkflowDefinitionClass {
-		static id = workflowDefinition.id;
-		static payload = workflowDefinition.payload;
-		static result = workflowDefinition.result;
-		static make = workflowDefinition.make;
-		static Binding = workflowDefinition.Binding;
-		static binding = workflowDefinition.binding;
-	}
-	return WorkflowDefinitionClass;
+	const tag = Context.Service()(id);
+	const layer$9 = (binding) => layer(tag, {
+		...binding,
+		payload: definition.payload,
+		result: definition.result
+	});
+	const create = Effect.fnUntraced(function* (payload, options) {
+		return yield* (yield* tag).create(payload, options);
+	});
+	const createBatch = Effect.fnUntraced(function* (batch) {
+		return yield* (yield* tag).createBatch(batch);
+	});
+	const get = Effect.fnUntraced(function* (instanceId) {
+		return yield* (yield* tag).get(instanceId);
+	});
+	const unsafeRaw = Effect.fnUntraced(function* () {
+		return yield* (yield* tag).unsafeRaw;
+	});
+	return Object.assign(tag, {
+		id: workflowDefinition.id,
+		payload: workflowDefinition.payload,
+		result: workflowDefinition.result,
+		make: workflowDefinition.make,
+		layer: layer$9,
+		create,
+		createBatch,
+		get,
+		unsafeRaw
+	});
 };
 const Workflow = Tag$1;
 const wrapHandler = (definition, handler) => {
@@ -2246,4 +2228,4 @@ const waitForEvent = (name, options) => Effect.flatMap(WorkflowStep$1.asEffect()
 const Tag = Tag$1;
 const implement = implement$1;
 //#endregion
-export { Binding_exports as Binding, D1_exports as D1, DurableObject_exports as DurableObject, DurableObjectAlarm_exports as DurableObjectAlarm, DurableObjectDefinition_exports as DurableObjectDefinition, DurableObjectNamespace_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_exports as DurableObjectRpcWebSocket, DurableObjectState_exports as DurableObjectState, DurableObjectStorage_exports as DurableObjectStorage, DurableObjectWebSocket_exports as DurableObjectWebSocket, Kv_exports as Kv, Queue_exports as Queue, QueueBinding_exports as QueueBinding, QueueDefinition_exports as QueueDefinition, Rpc_exports as Rpc, RpcDefinition_exports as RpcDefinition, ServiceBinding_exports as ServiceBinding, Worker_exports as Worker, WorkerConfig, WorkerDefinition_exports as WorkerDefinition, WorkerEnvironment, Workflow_exports as Workflow, WorkflowBinding_exports as WorkflowBinding, WorkflowDefinition_exports as WorkflowDefinition };
+export { Binding_exports as Binding, D1_exports as D1, DurableObject_exports as DurableObject, DurableObjectAlarm_exports as DurableObjectAlarm, DurableObjectDefinition_exports as DurableObjectDefinition, DurableObjectNamespace_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_exports as DurableObjectRpcWebSocket, DurableObjectState_exports as DurableObjectState, DurableObjectStorage_exports as DurableObjectStorage, DurableObjectWebSocket_exports as DurableObjectWebSocket, Hyperdrive_exports as Hyperdrive, Images_exports as Images, Kv_exports as Kv, Queue_exports as Queue, QueueBinding_exports as QueueBinding, QueueDefinition_exports as QueueDefinition, R2_exports as R2, Rpc_exports as Rpc, RpcDefinition_exports as RpcDefinition, ServiceBinding_exports as ServiceBinding, Worker_exports as Worker, WorkerConfig, WorkerDefinition_exports as WorkerDefinition, WorkerEnvironment, Workflow_exports as Workflow, WorkflowBinding_exports as WorkflowBinding, WorkflowDefinition_exports as WorkflowDefinition };