effect-cf 0.5.0 → 0.7.0

package/dist/index.mjs

@@ -29,11 +29,12 @@ let WorkerConfig;
 var Binding_exports = /* @__PURE__ */ __exportAll({
 	BindingNotFoundError: () => BindingNotFoundError,
 	BindingValidationError: () => BindingValidationError,
-	Service: () => Service$6,
-	TypeId: () => TypeId$6
+	Service: () => Service$2,
+	TypeId: () => TypeId$2,
+	layer: () => layer$6
 });
 /** Internal type id marker used by binding helper services. */
-const TypeId$6 = "effect-cf/Binding";
+const TypeId$2 = "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. */
@@ -46,28 +47,27 @@ const getBinding = (env, binding, isResource) => Effect.gen(function* () {
 	if (!isResource(resource)) return yield* Effect.fail(new BindingValidationError({ binding }));
 	return resource;
 });
-/**
-* Creates a Context tag + layer for reading and validating a Cloudflare binding.
-*/
-const Service$6 = () => (id, binding, isResource) => {
+const layer$6 = (tag, binding, isResource, wrap) => Layer.effect(tag, Effect.gen(function* () {
+	const resource = yield* getBinding(yield* WorkerEnvironment, binding, isResource);
+	return wrap === void 0 ? resource : wrap(resource);
+}));
+const Service$2 = () => (id, binding, isResource, wrap) => {
 	const tag = Context.Service()(id);
-	const layer = Layer.effect(tag, Effect.gen(function* () {
-		return yield* getBinding(yield* WorkerEnvironment, binding, isResource);
-	}));
+	const serviceLayer = layer$6(tag, binding, isResource, wrap);
 	return Object.assign(tag, {
-		[TypeId$6]: TypeId$6,
+		[TypeId$2]: TypeId$2,
 		binding,
-		layer
+		layer: serviceLayer
 	});
 };
 //#endregion
 //#region src/D1.ts
 var D1_exports = /* @__PURE__ */ __exportAll({
 	D1OperationError: () => D1OperationError,
-	Service: () => Service$5,
-	make: () => make$11
+	Service: () => Service$1,
+	make: () => make$8
 });
-const TypeId$5 = "effect-cf/D1";
+const TypeId$1 = "effect-cf/D1";
 /** Error raised when a D1 operation fails. */
 var D1OperationError = class extends Data.TaggedError("D1OperationError") {};
 const isD1Database = (value) => {
@@ -91,7 +91,7 @@ const tryD1Sync = (binding, operation, evaluate) => Effect.try({
 /**
 * Creates a typed D1 service tag plus Effect helpers.
 */
-const make$11 = (id, definition) => Service$5()(id, definition);
+const make$8 = (id, definition) => Service$1()(id, definition);
 /**
 * Builds a D1 service around a Cloudflare D1 database binding.
 *
@@ -108,8 +108,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({
@@ -133,7 +133,7 @@ const Service$5 = () => (id, definition) => {
 		return yield* tag;
 	});
 	return Object.assign(tag, {
-		[TypeId$5]: TypeId$5,
+		[TypeId$1]: TypeId$1,
 		definition,
 		sqlLayer,
 		prepare,
@@ -146,10 +146,10 @@ const Service$5 = () => (id, definition) => {
 //#region src/QueueBinding.ts
 var QueueBinding_exports = /* @__PURE__ */ __exportAll({
 	QueueOperationError: () => QueueOperationError,
-	Service: () => Service$4,
-	make: () => make$10
+	isQueue: () => isQueue,
+	layer: () => layer$5,
+	makeClient: () => makeClient$4
 });
-const TypeId$4 = "effect-cf/QueueBinding";
 var QueueOperationError = class extends Data.TaggedError("QueueOperationError") {};
 const queueError = (binding, operation, cause) => new QueueOperationError({
 	binding,
@@ -165,79 +165,74 @@ 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 tag = Service$6()(id, definition.binding, (value) => isQueue(value));
+const makeClient$4 = (definition) => {
 	const encodeMessage = Schema.encodeEffect(definition.message);
-	const send = Effect.fnUntraced(function* (message, options) {
-		const queue = yield* tag;
-		const encoded = yield* encodeMessage(message);
-		return yield* tryQueuePromise(definition.binding, "send", () => queue.send(encoded, options));
-	});
-	const sendBatch = Effect.fnUntraced(function* (messages, options) {
-		const queue = yield* tag;
-		const encodedMessages = [];
-		for (const message of messages) encodedMessages.push({
-			...message,
-			body: yield* encodeMessage(message.body)
-		});
-		return yield* tryQueuePromise(definition.binding, "sendBatch", () => queue.sendBatch(encodedMessages, options));
-	});
-	const metrics = Effect.fnUntraced(function* () {
-		const queue = yield* tag;
-		return yield* tryQueuePromise(definition.binding, "metrics", () => queue.metrics());
-	});
-	return Object.assign(tag, {
-		[TypeId$4]: TypeId$4,
-		binding: definition.binding,
-		send,
-		sendBatch,
-		metrics
+	return (queue) => ({
+		send: Effect.fnUntraced(function* (message, options) {
+			const encoded = yield* encodeMessage(message);
+			yield* tryQueuePromise(definition.binding, "send", () => queue.send(encoded, options));
+		}),
+		sendBatch: Effect.fnUntraced(function* (messages, options) {
+			const encodedMessages = [];
+			for (const message of messages) encodedMessages.push({
+				...message,
+				body: yield* encodeMessage(message.body)
+			});
+			yield* tryQueuePromise(definition.binding, "sendBatch", () => queue.sendBatch(encodedMessages, options));
+		}),
+		metrics: () => tryQueuePromise(definition.binding, "metrics", () => queue.metrics()),
+		unsafeRaw: Effect.succeed(queue)
 	});
 };
+const layer$5 = (tag, definition) => layer$6(tag, definition.binding, (value) => isQueue(value), makeClient$4(definition));
 //#endregion
 //#region src/QueueDefinition.ts
 var QueueDefinition_exports = /* @__PURE__ */ __exportAll({
 	Queue: () => Queue$1,
 	Tag: () => Tag$8,
 	implement: () => implement$7,
-	make: () => make$9
+	make: () => make$7
 });
 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
-		})
-	});
+	return Object.assign(queueDefinition, { make: (layer, options) => make$4(layer, {
+		...options,
+		queue: wrapHandler$1(queueDefinition, options.queue)
+	}) });
 };
-const make$9 = makeDefinition$4;
+const make$7 = (id, definition) => Tag$8()(id, definition);
 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 tag = Context.Service()(id);
+	const layer = (binding) => layer$5(tag, {
+		...binding,
+		message: definition.message
+	});
+	const send = Effect.fnUntraced(function* (message, options) {
+		yield* (yield* tag).send(message, options);
+	});
+	const sendBatch = Effect.fnUntraced(function* (messages, options) {
+		yield* (yield* tag).sendBatch(messages, options);
+	});
+	const metrics = Effect.fnUntraced(function* () {
+		return yield* (yield* tag).metrics();
+	});
+	const unsafeRaw = Effect.fnUntraced(function* () {
+		return yield* (yield* tag).unsafeRaw;
+	});
+	return Object.assign(tag, {
+		id: queueDefinition.id,
+		message: queueDefinition.message,
+		make: queueDefinition.make,
+		layer,
+		send,
+		sendBatch,
+		metrics,
+		unsafeRaw
+	});
 };
 const Queue$1 = Tag$8;
 const wrapHandler$1 = (definition, handler) => {
@@ -307,7 +302,7 @@ var RpcDefinition_exports = /* @__PURE__ */ __exportAll({
 	decodeSuccess: () => decodeSuccess,
 	encodeArgs: () => encodeArgs,
 	encodeSuccess: () => encodeSuccess,
-	make: () => make$8,
+	make: () => make$6,
 	method: () => method$4,
 	reservedMethodNames: () => reservedMethodNames$4
 });
@@ -410,7 +405,7 @@ const decodeSuccess = (definition, methodName, value) => {
 		cause
 	})));
 };
-const make$8 = (id, methods) => {
+const make$6 = (id, methods) => {
 	const definition = {
 		id,
 		methods
@@ -464,11 +459,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$4,
+	makeClient: () => makeClient$3,
+	makeDirectMethods: () => makeDirectMethods$1
 });
-const TypeId$3 = "effect-cf/ServiceBinding";
+const TypeId = "effect-cf/ServiceBinding";
 /**
 * Failure raised when calling `fetch` on a service binding.
 */
@@ -477,13 +476,66 @@ 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") {};
+const isServiceBindingClient = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "fetch") === "function";
+const makeClient$3 = (definition) => {
+	return (service) => {
+		const fetch = (input, init) => Effect.tryPromise({
+			try: () => service.fetch(input, init),
+			catch: (cause) => new ServiceBindingFetchError({
+				binding: definition.binding,
+				cause
+			})
+		});
+		const rpc = (method, ...args) => Effect.gen(function* () {
+			const methodName = String(method);
+			return yield* invokeRpcMethod(service, method, definition.definition === void 0 ? args : yield* encodeArgs(definition.definition, methodName, args).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			}))), (cause) => new ServiceBindingRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			}));
+		});
+		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
+			})));
+		});
+		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* decodeSuccess$2(String(method), yield* scoped(yield* rpc(method, ...args)));
+		});
+		const directMethods = makeDirectMethods$1(definition.definition, call);
+		return Object.assign(directMethods, {
+			fetch,
+			rpc,
+			call,
+			scopedCall
+		});
+	};
+};
+const layer$4 = (tag, definition) => layer$6(tag, definition.binding, (value) => isServiceBindingClient(value), makeClient$3(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
-* - `call(...)` for generic RPC invocation
+* - `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
@@ -495,59 +547,32 @@ var ServiceBindingRpcError = class extends Data.TaggedError("ServiceBindingRpcEr
 *   }),
 * });
 *
-* const CounterService = Counter.binding("COUNTER", { binding: "COUNTER" });
+* const CounterLive = Counter.layer({ binding: "COUNTER" });
 *
 * const program = Effect.gen(function* () {
-*   const next = yield* CounterService.increment(1);
+*   const counter = yield* Counter;
+*   const next = yield* counter.increment(1);
 *   return next;
 * });
 * ```
 */
-const Service$3 = () => (id, definition) => {
-	const tag = Service$6()(id, definition.binding, (value) => typeof value === "object" && value !== null && "fetch" in value);
+const Service = () => (id, definition) => {
+	const tag = Service$2()(id, definition.binding, (value) => isServiceBindingClient(value), makeClient$3(definition));
 	const fetch = (input, init) => Effect.gen(function* () {
-		const service = yield* tag;
-		return yield* Effect.tryPromise({
-			try: () => service.fetch(input, init),
-			catch: (cause) => new ServiceBindingFetchError({
-				binding: definition.binding,
-				cause
-			})
-		});
+		return yield* (yield* tag).fetch(input, init);
 	});
 	const rpc = (method, ...args) => Effect.gen(function* () {
-		const service = yield* tag;
-		const methodName = String(method);
-		return yield* invokeRpcMethod(service, method, definition.definition === void 0 ? args : yield* encodeArgs(definition.definition, methodName, args).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
-			binding: definition.binding,
-			method: methodName,
-			cause
-		}))), (cause) => new ServiceBindingRpcError({
-			binding: definition.binding,
-			method: methodName,
-			cause
-		}));
+		return yield* (yield* tag).rpc(method, ...args);
 	});
 	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({
-			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({
-			binding: definition.binding,
-			method: methodName,
-			cause
-		})));
+		return yield* (yield* tag).call(method, ...args);
 	});
 	const scopedCall = (method, ...args) => Effect.gen(function* () {
-		return yield* scoped(yield* rpc(method, ...args));
+		return yield* (yield* tag).scopedCall(method, ...args);
 	});
 	const directMethods = makeDirectMethods$1(definition.definition, call);
 	return Object.assign(tag, directMethods, {
-		[TypeId$3]: TypeId$3,
+		[TypeId]: TypeId,
 		definition,
 		fetch,
 		rpc,
@@ -566,7 +591,7 @@ var WorkerDefinition_exports = /* @__PURE__ */ __exportAll({
 	Tag: () => Tag$6,
 	Worker: () => Worker,
 	implement: () => implement$5,
-	make: () => make$7,
+	make: () => make$5,
 	method: () => method$3
 });
 const reservedMethodNames$3 = new Set([
@@ -604,33 +629,44 @@ 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
-		})
-	});
+	const definition = make$6(id, methods);
+	return Object.assign(definition, { make: (layer, options) => make$4(layer, {
+		...options,
+		rpc: wrapHandlers$1(definition, options.rpc)
+	}) });
 };
-const make$7 = makeDefinition$3;
+const make$5 = (id, methods) => Tag$6()(id, methods);
 const Tag$6 = () => (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$4(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 wrapHandlers$1 = (definition, handlers) => {
@@ -692,7 +728,7 @@ var Worker_exports = /* @__PURE__ */ __exportAll({
 	WorkerContext: () => WorkerContext,
 	implement: () => implement$4,
 	isWebSocketUpgrade: () => isWebSocketUpgrade,
-	make: () => make$6,
+	make: () => make$4,
 	makeFetchHandler: () => makeFetchHandler,
 	method: () => method$2,
 	renderHttpResponse: () => renderHttpResponse
@@ -721,7 +757,7 @@ const RunSymbol$1 = Symbol.for("effect-cf/Worker/run");
 const renderHttpResponse = (effect) => Effect.flatMap(effect, (response) => Effect.map(Effect.context(), (context) => HttpServerResponse.toWeb(response, { context })));
 const renderFetchSuccess = (effect) => Effect.flatMap(effect, (response) => response instanceof Response ? Effect.succeed(response) : Effect.map(Effect.context(), (context) => HttpServerResponse.toWeb(response, { context })));
 const isWorkerOptions = (options) => typeof options === "object" && options !== null && ("fetch" in options || "queue" in options || "rpc" in options);
-function make$6(layer, optionsOrFetch) {
+function make$4(layer, optionsOrFetch) {
 	const options = isWorkerOptions(optionsOrFetch) ? optionsOrFetch : { fetch: optionsOrFetch };
 	class EffectWorker extends WorkerEntrypoint {
 		runtime;
@@ -752,7 +788,7 @@ function make$6(layer, optionsOrFetch) {
 	return assumeEntrypointClass(EffectWorker);
 }
 const makeFetchHandler = (layer, options) => {
-	const WorkerClass = make$6(layer, options);
+	const WorkerClass = make$4(layer, options);
 	return { fetch: (request, env, ctx) => Promise.resolve(new WorkerClass(ctx, env).fetch(request)) };
 };
 const Tag$5 = Tag$6;
@@ -1052,9 +1088,11 @@ const runPromiseExitPreservingTypedFailures = async (effect) => {
 var DurableObjectNamespace_exports = /* @__PURE__ */ __exportAll({
 	DurableObjectFetchError: () => DurableObjectFetchError,
 	DurableObjectRpcError: () => DurableObjectRpcError,
-	Service: () => Service$2
+	isDurableObjectNamespaceClient: () => isDurableObjectNamespaceClient,
+	layer: () => layer$3,
+	makeClient: () => makeClient$2,
+	makeDirectMethods: () => makeDirectMethods
 });
-const TypeId$2 = "effect-cf/DurableObjectNamespace";
 /**
 * Failure raised when invoking an RPC method on a Durable Object stub.
 */
@@ -1063,108 +1101,76 @@ 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 tag = Service$6()(id, definition.binding, (value) => isDurableObjectNamespaceClient(value));
-	const newUniqueId = Effect.fnUntraced(function* (options) {
-		return (yield* tag).newUniqueId(options);
-	});
-	const idFromName = Effect.fnUntraced(function* (name) {
-		return (yield* tag).idFromName(name);
-	});
-	const idFromString = Effect.fnUntraced(function* (id) {
-		return (yield* tag).idFromString(id);
-	});
-	const get = Effect.fnUntraced(function* (id, options) {
-		return (yield* tag).get(id, options);
-	});
-	const getByName = Effect.fnUntraced(function* (name, options) {
-		return (yield* tag).getByName(name, options);
-	});
-	const jurisdiction = Effect.fnUntraced(function* (value) {
-		return (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 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
-	});
+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$2 = (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));
+		const get = (id, options) => Effect.sync(() => namespace.get(id, options));
+		const getByName = (name, options) => Effect.sync(() => namespace.getByName(name, options));
+		const jurisdiction = (value) => Effect.sync(() => namespace.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 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
+			})));
+		});
+		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* decodeSuccess$1(String(method), yield* scoped(yield* rpc(stub, method, ...args)));
+		});
+		const directMethods = makeDirectMethods(definition.definition, {
+			call,
+			fetch,
+			get,
+			getByName
+		});
+		return Object.assign(directMethods, {
+			newUniqueId,
+			idFromName,
+			idFromString,
+			get,
+			getByName,
+			jurisdiction,
+			fetch,
+			rpc,
+			call,
+			scopedCall,
+			unsafeRaw: Effect.succeed(namespace)
+		});
+	};
 };
+const layer$3 = (tag, definition) => layer$6(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$2(definition));
 const makeDirectMethods = (rpcDefinition, helpers) => {
 	const methods = {};
 	if (rpcDefinition !== void 0) {
@@ -1191,7 +1197,7 @@ var DurableObjectDefinition_exports = /* @__PURE__ */ __exportAll({
 	DurableObject: () => DurableObject$1,
 	Tag: () => Tag$4,
 	implement: () => implement$3,
-	make: () => make$5,
+	make: () => make$3,
 	method: () => method$1
 });
 const reservedMethodNames$1 = new Set([
@@ -1222,33 +1228,77 @@ 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
-		})
-	});
+	const definition = make$6(id, methods);
+	return Object.assign(definition, { make: (layer, options) => make$2(layer, {
+		...options,
+		rpc: wrapHandlers(definition, options.rpc)
+	}) });
 };
-const make$5 = makeDefinition$2;
+const make$3 = (id, methods) => Tag$4()(id, methods);
 const Tag$4 = () => (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$3(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 wrapHandlers = (definition, handlers) => {
@@ -1270,7 +1320,7 @@ const implement$3 = (_definition, handlers) => handlers;
 var DurableObject_exports = /* @__PURE__ */ __exportAll({
 	Tag: () => Tag$3,
 	implement: () => implement$2,
-	make: () => make$4,
+	make: () => make$2,
 	method: () => method
 });
 const reservedMethodNames = new Set([
@@ -1286,7 +1336,7 @@ const RunSymbol = Symbol.for("effect-cf/DurableObject/run");
 /**
 * Creates a Durable Object class backed by a single managed Effect runtime.
 */
-const make$4 = (layer, options = {}) => {
+const make$2 = (layer, options = {}) => {
 	class EffectDurableObject extends DurableObject {
 		runtime;
 		constructor(state, env) {
@@ -1654,7 +1704,7 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 //#region src/DurableObjectRpcWebSocket.ts
 var DurableObjectRpcWebSocket_exports = /* @__PURE__ */ __exportAll({
 	DurableObjectRpcWebSocket: () => DurableObjectRpcWebSocket,
-	layer: () => layer
+	layer: () => layer$2
 });
 const defaultAttachmentKey = "effectCloudflareRpcClientId";
 const defaultTag = "effect-cf-rpc";
@@ -1665,7 +1715,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$2 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 	const tag = options.tag ?? defaultTag;
 	const attachmentKey = options.attachmentKey ?? defaultAttachmentKey;
 	const durableObjectState = yield* DurableObjectState;
@@ -1780,11 +1830,11 @@ const writeAttachment = (socket, key, clientId) => {
 //#region src/Kv.ts
 var Kv_exports = /* @__PURE__ */ __exportAll({
 	KvOperationError: () => KvOperationError,
-	Service: () => Service$1,
 	Tag: () => Tag$2,
-	make: () => make$3
+	isKvNamespace: () => isKvNamespace,
+	layer: () => layer$1,
+	makeClient: () => makeClient$1
 });
-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);
@@ -1798,128 +1848,108 @@ 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 isKvNamespace = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const resource = value;
+	return typeof resource.get === "function" && typeof resource.put === "function" && typeof resource.delete === "function" && typeof resource.getWithMetadata === "function" && typeof resource.list === "function";
+};
+const makeClient$1 = (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)));
+	return (kv) => ({
+		definition,
+		put: Effect.fnUntraced(function* (key, value, options) {
+			const keyEncoded = yield* encodeKey(key);
+			const valueEncoded = yield* encodeValue(value);
+			yield* tryKvPromise(definition.binding, "put", () => kv.put(keyEncoded, valueEncoded, options));
+		}),
+		get: Effect.fnUntraced(function* (key) {
+			const keyEncoded = yield* encodeKey(key);
+			const valueEncoded = yield* tryKvPromise(definition.binding, "get", () => kv.get(keyEncoded));
+			if (valueEncoded === null) return Option.none();
+			return yield* decodeValue(valueEncoded).pipe(Effect.map(Option.some));
+		}),
+		getWithMetadata: Effect.fnUntraced(function* (key, metadataSchema) {
+			const keyEncoded = yield* encodeKey(key);
+			const result = yield* tryKvPromise(definition.binding, "getWithMetadata", () => kv.getWithMetadata(keyEncoded));
+			if (result.value === null) return Option.none();
+			const value = yield* decodeValue(result.value);
+			const metadata = result.metadata === null ? Option.none() : Option.some(yield* Schema.decodeUnknownEffect(metadataSchema)(result.metadata));
+			return Option.some({
+				value,
+				metadata,
+				cacheStatus: maybeString(result.cacheStatus)
+			});
+		}),
+		list: Effect.fnUntraced(function* (options) {
+			const { metadataSchema, ...kvOptions } = options ?? {};
+			const result = yield* tryKvPromise(definition.binding, "list", () => kv.list(kvOptions));
+			const keys = [];
+			for (const key of result.keys) {
+				const decodedName = yield* decodeKey(key.name);
+				const decodedMetadata = key.metadata === void 0 ? Option.none() : metadataSchema === void 0 ? Option.some(key.metadata) : Option.some(yield* Schema.decodeUnknownEffect(metadataSchema)(key.metadata));
+				keys.push({
+					name: decodedName,
+					expiration: maybeNumber(key.expiration),
+					metadata: decodedMetadata
+				});
+			}
+			return {
+				keys,
+				listComplete: result.list_complete,
+				cursor: maybeString("cursor" in result ? result.cursor : void 0),
+				cacheStatus: maybeString(result.cacheStatus)
+			};
+		}),
+		remove: Effect.fnUntraced(function* (key) {
+			const keyEncoded = yield* encodeKey(key);
+			yield* tryKvPromise(definition.binding, "delete", () => kv.delete(keyEncoded));
+		}),
+		unsafeRaw: Effect.succeed(kv)
+	});
+};
+const layer$1 = (tag, definition) => layer$6(tag, definition.binding, isKvNamespace, makeClient$1(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
-		})
-	});
+	return Object.assign(kvDefinition, { layer: (tag, binding) => layer$1(tag, {
+		...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;
-};
-/**
-* 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 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";
-	});
-	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 tag = Context.Service()(id);
+	const makeLayer = (binding) => kvDefinition.layer(tag, binding);
 	const put = Effect.fnUntraced(function* (key, value, options) {
-		const kv = yield* tag;
-		const keyEncoded = yield* encodeKey(key);
-		const valueEncoded = yield* encodeValue(value);
-		yield* tryKvPromise(definition.binding, "put", () => kv.put(keyEncoded, valueEncoded, options));
+		yield* (yield* tag).put(key, value, options);
 	});
 	const get = Effect.fnUntraced(function* (key) {
-		const kv = yield* tag;
-		const keyEncoded = yield* encodeKey(key);
-		const valueEncoded = yield* tryKvPromise(definition.binding, "get", () => kv.get(keyEncoded));
-		if (valueEncoded === null) return Option.none();
-		return yield* decodeValue(valueEncoded).pipe(Effect.map(Option.some));
+		return yield* (yield* tag).get(key);
 	});
 	const getWithMetadata = Effect.fnUntraced(function* (key, metadataSchema) {
-		const kv = yield* tag;
-		const keyEncoded = yield* encodeKey(key);
-		const result = yield* tryKvPromise(definition.binding, "getWithMetadata", () => kv.getWithMetadata(keyEncoded));
-		if (result.value === null) return Option.none();
-		const value = yield* decodeValue(result.value);
-		const metadata = result.metadata === null ? Option.none() : Option.some(yield* Schema.decodeUnknownEffect(metadataSchema)(result.metadata));
-		return Option.some({
-			value,
-			metadata,
-			cacheStatus: maybeString(result.cacheStatus)
-		});
+		return yield* (yield* tag).getWithMetadata(key, metadataSchema);
 	});
 	const list = Effect.fnUntraced(function* (options) {
-		const kv = yield* tag;
-		const { metadataSchema, ...kvOptions } = options ?? {};
-		const result = yield* tryKvPromise(definition.binding, "list", () => kv.list(kvOptions));
-		const keys = [];
-		for (const key of result.keys) {
-			const decodedName = yield* decodeKey(key.name);
-			const decodedMetadata = key.metadata === void 0 ? Option.none() : metadataSchema === void 0 ? Option.some(key.metadata) : Option.some(yield* Schema.decodeUnknownEffect(metadataSchema)(key.metadata));
-			keys.push({
-				name: decodedName,
-				expiration: maybeNumber(key.expiration),
-				metadata: decodedMetadata
-			});
-		}
-		return {
-			keys,
-			listComplete: result.list_complete,
-			cursor: maybeString("cursor" in result ? result.cursor : void 0),
-			cacheStatus: maybeString(result.cacheStatus)
-		};
+		return yield* (yield* tag).list(options);
 	});
 	const remove = Effect.fnUntraced(function* (key) {
-		const kv = yield* tag;
-		const keyEncoded = yield* encodeKey(key);
-		yield* tryKvPromise(definition.binding, "delete", () => kv.delete(keyEncoded));
+		yield* (yield* tag).remove(key);
 	});
 	const unsafeRaw = Effect.fnUntraced(function* () {
-		return yield* tag;
+		return yield* (yield* tag).unsafeRaw;
 	});
 	return Object.assign(tag, {
-		[TypeId$1]: TypeId$1,
-		definition,
+		id: kvDefinition.id,
+		keySchema: kvDefinition.key,
+		valueSchema: kvDefinition.value,
+		layer: makeLayer,
 		put,
 		get,
 		getWithMetadata,
@@ -1931,12 +1961,12 @@ const Service$1 = () => (id, definition) => {
 //#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({
@@ -1953,9 +1983,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) => {
@@ -1982,38 +2010,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$6(tag, definition.binding, (value) => isWorkflow(value), makeClient(definition));
 //#endregion
 //#region src/WorkflowDefinition.ts
 var WorkflowDefinition_exports = /* @__PURE__ */ __exportAll({
@@ -2028,32 +2048,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$7 = (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$7,
+		create,
+		createBatch,
+		get,
+		unsafeRaw
+	});
 };
 const Workflow = Tag$1;
 const wrapHandler = (definition, handler) => {