effect-cf 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1198 @@
+import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
+import { Cause, Config, ConfigProvider, Context, Data, Effect, Exit, Layer, ManagedRuntime, Option, Queue, Schema } from "effect";
+import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint } from "cloudflare:workers";
+import { HttpServerRequest } 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 provider = _WorkerConfig.provider = Effect.map(WorkerEnvironment.asEffect(), ConfigProvider.fromUnknown);
+	_WorkerConfig.layer = _WorkerConfig.providerLayer = ConfigProvider.layer(provider);
+})(WorkerConfig || (WorkerConfig = {}));
+//#endregion
+//#region src/Binding.ts
+var Binding_exports = /* @__PURE__ */ __exportAll({
+	BindingNotFoundError: () => BindingNotFoundError,
+	BindingValidationError: () => BindingValidationError,
+	Service: () => Service$3,
+	TypeId: () => TypeId$3
+});
+/** Internal type id marker used by binding helper services. */
+const TypeId$3 = "effect-cf/Binding";
+/** Error raised when a configured binding does not exist on `env`. */
+var BindingNotFoundError = class extends Data.TaggedError("BindingNotFoundError") {};
+/** Error raised when a binding exists but does not match the expected shape. */
+var BindingValidationError = class extends Data.TaggedError("BindingValidationError") {};
+const 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;
+});
+/**
+* Creates a Context tag + layer for reading and validating a Cloudflare binding.
+*/
+const Service$3 = () => (id, binding, isResource) => {
+	const tag = Context.Service()(id);
+	const layer = Layer.effect(tag, Effect.gen(function* () {
+		return yield* getBinding(yield* WorkerEnvironment, binding, isResource);
+	}));
+	return Object.assign(tag, {
+		[TypeId$3]: TypeId$3,
+		binding,
+		layer
+	});
+};
+//#endregion
+//#region src/RpcDefinition.ts
+var RpcDefinition_exports = /* @__PURE__ */ __exportAll({
+	ReservedMethodNameError: () => ReservedMethodNameError,
+	RpcArgumentCountError: () => RpcArgumentCountError,
+	RpcArgumentDecodeError: () => RpcArgumentDecodeError,
+	RpcArgumentEncodeError: () => RpcArgumentEncodeError,
+	RpcReservedMethodNameError: () => RpcReservedMethodNameError,
+	RpcSuccessDecodeError: () => RpcSuccessDecodeError,
+	RpcSuccessEncodeError: () => RpcSuccessEncodeError,
+	assertNoReservedMethodNames: () => assertNoReservedMethodNames,
+	assertNoReservedMethods: () => assertNoReservedMethods,
+	decodeArgs: () => decodeArgs,
+	decodeSuccess: () => decodeSuccess,
+	encodeArgs: () => encodeArgs,
+	encodeSuccess: () => encodeSuccess,
+	make: () => make$5,
+	method: () => method$4,
+	reservedMethodNames: () => reservedMethodNames$4
+});
+var RpcReservedMethodNameError = class extends Data.TaggedError("RpcReservedMethodNameError") {};
+var RpcArgumentCountError = class extends Data.TaggedError("RpcArgumentCountError") {};
+var RpcArgumentDecodeError = class extends Data.TaggedError("RpcArgumentDecodeError") {};
+var RpcArgumentEncodeError = class extends Data.TaggedError("RpcArgumentEncodeError") {};
+var RpcSuccessDecodeError = class extends Data.TaggedError("RpcSuccessDecodeError") {};
+var RpcSuccessEncodeError = class extends Data.TaggedError("RpcSuccessEncodeError") {};
+const reservedMethodNames$4 = new Set([
+	"constructor",
+	"fetch",
+	"connect",
+	"alarm",
+	"webSocketMessage",
+	"webSocketClose",
+	"webSocketError",
+	"then",
+	"dup",
+	"dispose",
+	"serialize",
+	"deserialize"
+]);
+var ReservedMethodNameError = class extends Error {
+	method;
+	target;
+	constructor(target, method) {
+		super(`${target} RPC method "${method}" is reserved by Cloudflare Workers RPC`);
+		this.name = "ReservedMethodNameError";
+		this.target = target;
+		this.method = method;
+	}
+};
+const assertNoReservedMethods = (target, methods, reserved) => {
+	for (const method of Object.keys(methods)) if (reserved.has(method)) throw new ReservedMethodNameError(target, method);
+};
+function method$4(definition) {
+	return {
+		args: definition.args ?? [],
+		success: definition.success
+	};
+}
+const assertNoReservedMethodNames = (definition) => Effect.forEach(Object.keys(definition.methods), (method) => reservedMethodNames$4.has(method) ? Effect.fail(new RpcReservedMethodNameError({
+	definition: definition.id,
+	method
+})) : Effect.void).pipe(Effect.asVoid);
+const decodeArgs = (definition, methodName, args) => Effect.gen(function* () {
+	const methodDefinition = definition.methods[methodName];
+	if (args.length !== methodDefinition.args.length) return yield* Effect.fail(new RpcArgumentCountError({
+		definition: definition.id,
+		method: methodName,
+		expected: methodDefinition.args.length,
+		actual: args.length
+	}));
+	const decoded = [];
+	for (let index = 0; index < methodDefinition.args.length; index++) {
+		const schema = methodDefinition.args[index];
+		decoded.push(yield* Schema.decodeUnknownEffect(schema)(args[index]).pipe(Effect.mapError((cause) => new RpcArgumentDecodeError({
+			definition: definition.id,
+			method: methodName,
+			index,
+			cause
+		}))));
+	}
+	return decoded;
+});
+const encodeArgs = (definition, methodName, args) => Effect.gen(function* () {
+	const methodDefinition = definition.methods[methodName];
+	if (args.length !== methodDefinition.args.length) return yield* Effect.fail(new RpcArgumentCountError({
+		definition: definition.id,
+		method: methodName,
+		expected: methodDefinition.args.length,
+		actual: args.length
+	}));
+	const encoded = [];
+	for (let index = 0; index < methodDefinition.args.length; index++) {
+		const schema = methodDefinition.args[index];
+		encoded.push(yield* Schema.encodeEffect(schema)(args[index]).pipe(Effect.mapError((cause) => new RpcArgumentEncodeError({
+			definition: definition.id,
+			method: methodName,
+			index,
+			cause
+		}))));
+	}
+	return encoded;
+});
+const encodeSuccess = (definition, methodName, value) => {
+	const methodDefinition = definition.methods[methodName];
+	return Schema.encodeEffect(methodDefinition.success)(value).pipe(Effect.mapError((cause) => new RpcSuccessEncodeError({
+		definition: definition.id,
+		method: methodName,
+		cause
+	})));
+};
+const decodeSuccess = (definition, methodName, value) => {
+	const methodDefinition = definition.methods[methodName];
+	return Schema.decodeUnknownEffect(methodDefinition.success)(value).pipe(Effect.mapError((cause) => new RpcSuccessDecodeError({
+		definition: definition.id,
+		method: methodName,
+		cause
+	})));
+};
+const make$5 = (id, methods) => {
+	const definition = {
+		id,
+		methods
+	};
+	const reserved = Object.keys(definition.methods).find((methodName) => reservedMethodNames$4.has(methodName));
+	if (reserved !== void 0) throw new RpcReservedMethodNameError({
+		definition: id,
+		method: reserved
+	});
+	return definition;
+};
+//#endregion
+//#region src/Rpc.ts
+var Rpc_exports = /* @__PURE__ */ __exportAll({
+	RpcStub: () => RpcStub,
+	RpcTarget: () => RpcTarget,
+	dispose: () => dispose,
+	isDisposable: () => isDisposable,
+	resolve: () => resolve,
+	scoped: () => scoped
+});
+const isDisposable = (value) => (typeof value === "object" || typeof value === "function") && value !== null && Symbol.dispose in value && typeof value[Symbol.dispose] === "function";
+const dispose = (value) => Effect.sync(() => {
+	if (isDisposable(value)) value[Symbol.dispose]();
+});
+const resolve = (value) => isPromiseLike(value) ? Effect.tryPromise({
+	try: () => value,
+	catch: (cause) => cause
+}) : Effect.sync(() => value);
+const scoped = (value) => Effect.acquireRelease(resolve(value), (resolved) => dispose(resolved));
+const isPromiseLike = (value) => (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
+//#endregion
+//#region src/internal/RpcInvocation.ts
+const isPropertyTarget = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
+const lookupRpcMethod = (target, method, makeError) => Effect.try({
+	try: () => {
+		if (!isPropertyTarget(target)) throw new TypeError(`RPC target is not object-like`);
+		const value = Reflect.get(target, method);
+		if (typeof value !== "function") throw new TypeError(`RPC method "${String(method)}" is not callable`);
+		return ((...args) => Reflect.apply(value, target, args));
+	},
+	catch: makeError
+});
+const invokeRpcMethod = (target, method, args, makeError) => Effect.gen(function* () {
+	const fn = yield* lookupRpcMethod(target, method, makeError);
+	return yield* Effect.try({
+		try: () => fn(...args),
+		catch: makeError
+	});
+});
+//#endregion
+//#region src/ServiceBinding.ts
+var ServiceBinding_exports = /* @__PURE__ */ __exportAll({
+	Service: () => Service$2,
+	ServiceBindingFetchError: () => ServiceBindingFetchError,
+	ServiceBindingRpcError: () => ServiceBindingRpcError
+});
+const TypeId$2 = "effect-cf/ServiceBinding";
+/**
+* Failure raised when calling `fetch` on a service binding.
+*/
+var ServiceBindingFetchError = class extends Data.TaggedError("ServiceBindingFetchError") {};
+/**
+* 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$2 = () => (id, definition) => {
+	const tag = Service$3()(id, definition.binding, (value) => typeof value === "object" && value !== null && "fetch" in value);
+	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
+			})
+		});
+	});
+	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
+		}));
+	});
+	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
+		})));
+	});
+	const scopedCall = (method, ...args) => Effect.gen(function* () {
+		return yield* scoped(yield* rpc(method, ...args));
+	});
+	const directMethods = makeDirectMethods$1(definition.definition, call);
+	return Object.assign(tag, directMethods, {
+		[TypeId$2]: TypeId$2,
+		definition,
+		fetch,
+		rpc,
+		call,
+		scopedCall
+	});
+};
+const makeDirectMethods$1 = (rpcDefinition, call) => {
+	const methods = {};
+	if (rpcDefinition !== void 0) for (const methodName of Object.keys(rpcDefinition.methods)) methods[methodName] = (...args) => call(methodName, ...args);
+	return methods;
+};
+//#endregion
+//#region src/WorkerDefinition.ts
+var WorkerDefinition_exports = /* @__PURE__ */ __exportAll({
+	Tag: () => Tag$3,
+	Worker: () => Worker,
+	implement: () => implement$3,
+	make: () => make$4,
+	method: () => method$3
+});
+const reservedMethodNames$3 = new Set([
+	"constructor",
+	"dup",
+	"fetch",
+	"connect",
+	"alarm",
+	"webSocketMessage",
+	"webSocketClose",
+	"webSocketError"
+]);
+/**
+* Defines a single RPC method schema in a worker definition.
+*/
+const method$3 = method$4;
+/**
+* Creates a typed worker RPC definition plus helpers for implementation and bindings.
+*
+* @example
+* ```ts
+* const CounterWorker = WorkerDefinition.make("CounterWorker", {
+*   increment: WorkerDefinition.method({
+*     args: [Schema.Number],
+*     success: Schema.Number,
+*   }),
+* });
+* ```
+*/
+const makeDefinition$1 = (id, methods) => {
+	assertNoReservedMethods("Worker", methods, reservedMethodNames$3);
+	const definition = make$5(id, methods);
+	return Object.assign(definition, {
+		make: (layer, options) => make$3(layer, {
+			...options,
+			rpc: wrapHandlers$1(definition, options.rpc)
+		}),
+		Binding: () => (bindingId, binding) => Service$2()(bindingId, {
+			...binding,
+			definition
+		}),
+		binding: (bindingId, binding) => Service$2()(bindingId, {
+			...binding,
+			definition
+		})
+	});
+};
+const make$4 = makeDefinition$1;
+const Tag$3 = () => (id, methods) => {
+	const definition = makeDefinition$1(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 Worker = Tag$3;
+const wrapHandlers$1 = (definition, handlers) => {
+	const wrapped = {};
+	for (const key of Object.keys(definition.methods)) {
+		const handler = handlers[key];
+		wrapped[key] = (...args) => Effect.gen(function* () {
+			return yield* encodeSuccess(definition, key, yield* handler(...yield* decodeArgs(definition, key, args)));
+		});
+	}
+	return wrapped;
+};
+/**
+* Helper for implementing handlers with the exact method shape of a definition.
+*/
+const implement$3 = (_definition, handlers) => handlers;
+//#endregion
+//#region src/internal/Entrypoint.ts
+const provideEntrypointServices = (layer, services) => layer.pipe(Layer.provideMerge(services));
+const defineEntrypointRpcMethods = (target, prototype, rpc, reservedMethodNames, run) => {
+	const methods = rpc ?? {};
+	assertNoReservedMethods(target, methods, reservedMethodNames);
+	for (const [key, method] of Object.entries(methods)) Object.defineProperty(prototype, key, {
+		enumerable: true,
+		value(...args) {
+			return run(this, Effect.suspend(() => method(...args)));
+		}
+	});
+};
+const assumeEntrypointClass = (entrypoint) => entrypoint;
+//#endregion
+//#region src/Worker.ts
+var Worker_exports = /* @__PURE__ */ __exportAll({
+	ExecutionContext: () => ExecutionContext,
+	NativeRequest: () => NativeRequest,
+	Tag: () => Tag$2,
+	WorkerContext: () => WorkerContext,
+	implement: () => implement$2,
+	isWebSocketUpgrade: () => isWebSocketUpgrade,
+	make: () => make$3,
+	method: () => method$2
+});
+var ExecutionContext = class extends Context.Service()("effect-cf/ExecutionContext") {};
+var WorkerContext = class extends Context.Service()("effect-cf/WorkerContext") {};
+const fromExecutionContext = (ctx, runPromiseExit) => ({
+	raw: ctx,
+	waitUntil: (effect, options) => Effect.context().pipe(Effect.flatMap((context) => Effect.sync(() => {
+		const observed = Effect.exit(effect).pipe(Effect.flatMap((exit) => {
+			if (Exit.isSuccess(exit)) return Effect.void;
+			return (options?.onFailure?.(exit.cause) ?? Effect.logError("WorkerContext.waitUntil failed", Cause.pretty(exit.cause))).pipe(Effect.catchCause((handlerCause) => Effect.logError("WorkerContext.waitUntil failure handler failed", Cause.pretty(exit.cause), Cause.pretty(handlerCause))));
+		}));
+		ctx.waitUntil(runPromiseExit(Effect.scoped(Effect.provideContext(observed, context))).then((exit) => {
+			if (Exit.isFailure(exit)) console.error("WorkerContext.waitUntil failure handler failed", Cause.pretty(exit.cause));
+		}));
+	}))),
+	passThroughOnException: Effect.sync(() => ctx.passThroughOnException())
+});
+var NativeRequest = class extends Context.Service()("effect-cf/NativeRequest") {};
+const isWebSocketUpgrade = (request) => request.headers.get("Upgrade")?.toLowerCase() === "websocket";
+const reservedMethodNames$2 = new Set([
+	"constructor",
+	"dup",
+	"fetch",
+	"connect",
+	"alarm",
+	"webSocketMessage",
+	"webSocketClose",
+	"webSocketError"
+]);
+const RunSymbol$1 = Symbol.for("effect-cf/Worker/run");
+const make$3 = (layer, options) => {
+	class EffectWorker extends WorkerEntrypoint {
+		runtime;
+		constructor(ctx, env) {
+			super(ctx, env);
+			let runWaitUntilEffect = () => Promise.resolve(Exit.die(/* @__PURE__ */ new Error("WorkerContext runtime is not initialized")));
+			const runtimeLayer = provideEntrypointServices(layer, Layer.mergeAll(Layer.succeed(ExecutionContext, ctx), Layer.succeed(WorkerContext, fromExecutionContext(ctx, (effect) => runWaitUntilEffect(effect))), Layer.succeed(WorkerEnvironment, env)));
+			this.runtime = ManagedRuntime.make(runtimeLayer);
+			runWaitUntilEffect = (effect) => this.runtime.runPromiseExit(effect);
+		}
+		[RunSymbol$1](effect) {
+			return this.runtime.runPromise(Effect.scoped(effect));
+		}
+		fetch(request) {
+			const fetchHandler = options.fetch;
+			if (fetchHandler === void 0) return Promise.resolve(new Response("Not Found", { status: 404 }));
+			return this[RunSymbol$1](fetchHandler.pipe(Effect.provideService(NativeRequest, request), Effect.provideService(HttpServerRequest.HttpServerRequest, HttpServerRequest.fromWeb(request))));
+		}
+	}
+	defineEntrypointRpcMethods("Worker", EffectWorker.prototype, options.rpc, reservedMethodNames$2, (self, effect) => self[RunSymbol$1](effect));
+	return assumeEntrypointClass(EffectWorker);
+};
+const Tag$2 = Tag$3;
+const method$2 = method$3;
+const implement$2 = implement$3;
+//#endregion
+//#region src/DurableObjectStorage.ts
+var DurableObjectStorage_exports = /* @__PURE__ */ __exportAll({
+	StorageOperationError: () => StorageOperationError,
+	fromDurableObjectStorage: () => fromDurableObjectStorage
+});
+/** Error type used when a storage operation throws or rejects. */
+var StorageOperationError = class extends Data.TaggedError("StorageOperationError") {};
+const storageError = (operation, cause) => new StorageOperationError({
+	operation,
+	cause
+});
+const tryStorageSync = (operation, evaluate) => Effect.try({
+	try: evaluate,
+	catch: (cause) => storageError(operation, cause)
+});
+const tryStoragePromise = (operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => storageError(operation, cause)
+});
+const fromSqlCursor = (cursor) => ({
+	next: () => tryStorageSync("sql.next", () => cursor.next()),
+	toArray: () => tryStorageSync("sql.toArray", () => cursor.toArray()),
+	one: () => tryStorageSync("sql.one", () => cursor.one()),
+	raw: () => tryStorageSync("sql.raw", () => cursor.raw()),
+	get columnNames() {
+		return cursor.columnNames;
+	},
+	rowsRead: tryStorageSync("sql.rowsRead", () => cursor.rowsRead),
+	rowsWritten: tryStorageSync("sql.rowsWritten", () => cursor.rowsWritten)
+});
+const fromSqlStorage = (sql) => ({
+	exec: (query, ...bindings) => tryStorageSync("sql.exec", () => fromSqlCursor(sql.exec(query, ...bindings))),
+	get databaseSize() {
+		return sql.databaseSize;
+	}
+});
+const schemaBackedSyncKvStorage = (kv, definition) => {
+	const encodeKey = Schema.encodeEffect(definition.key);
+	const decodeKey = Schema.decodeUnknownEffect(definition.key);
+	const encodeValue = Schema.encodeEffect(definition.value);
+	const decodeValue = Schema.decodeUnknownEffect(definition.value);
+	return {
+		get: (key) => Effect.gen(function* () {
+			const encodedKey = yield* encodeKey(key);
+			const encodedValue = yield* tryStorageSync("kv.get", () => kv.get(encodedKey));
+			if (encodedValue === void 0) return Option.none();
+			return yield* decodeValue(encodedValue).pipe(Effect.map(Option.some));
+		}),
+		put: (key, value) => Effect.gen(function* () {
+			const encodedKey = yield* encodeKey(key);
+			const encodedValue = yield* encodeValue(value);
+			yield* tryStorageSync("kv.put", () => kv.put(encodedKey, encodedValue));
+		}),
+		delete: (key) => Effect.gen(function* () {
+			const encodedKey = yield* encodeKey(key);
+			return yield* tryStorageSync("kv.delete", () => kv.delete(encodedKey));
+		}),
+		list: (options) => Effect.gen(function* () {
+			const entries = Array.from(yield* tryStorageSync("kv.list", () => kv.list(options)));
+			const decoded = [];
+			for (const [key, value] of entries) decoded.push([yield* decodeKey(key), yield* decodeValue(value)]);
+			return decoded;
+		})
+	};
+};
+const fromSyncKvStorage = (kv) => ({
+	get: (key) => tryStorageSync("kv.get", () => kv.get(key)),
+	put: (key, value) => tryStorageSync("kv.put", () => kv.put(key, value)),
+	delete: (key) => tryStorageSync("kv.delete", () => kv.delete(key)),
+	list: (options) => tryStorageSync("kv.list", () => Array.from(kv.list(options))),
+	schema: (definition) => schemaBackedSyncKvStorage(kv, definition)
+});
+const fromDurableObjectTransaction = (txn) => ({
+	get: (keyOrKeys, options) => Array.isArray(keyOrKeys) ? tryStoragePromise("transaction.get", () => txn.get(keyOrKeys, options)) : tryStoragePromise("transaction.get", () => txn.get(keyOrKeys, options)),
+	list: (options) => tryStoragePromise("transaction.list", () => txn.list(options)),
+	put: (keyOrEntries, valueOrOptions, maybeOptions) => tryStoragePromise("transaction.put", () => typeof keyOrEntries === "string" ? txn.put(keyOrEntries, valueOrOptions, maybeOptions) : txn.put(keyOrEntries, valueOrOptions)),
+	delete: (keyOrKeys, options) => Array.isArray(keyOrKeys) ? tryStoragePromise("transaction.delete", () => txn.delete(keyOrKeys, options)) : tryStoragePromise("transaction.delete", () => txn.delete(keyOrKeys, options)),
+	rollback: () => tryStorageSync("transaction.rollback", () => txn.rollback()),
+	getAlarm: (options) => tryStoragePromise("transaction.getAlarm", () => txn.getAlarm(options)),
+	setAlarm: (scheduledTime, options) => tryStoragePromise("transaction.setAlarm", () => txn.setAlarm(scheduledTime, options)),
+	deleteAlarm: (options) => tryStoragePromise("transaction.deleteAlarm", () => txn.deleteAlarm(options))
+});
+/**
+* Wraps native Cloudflare storage APIs as Effect-returning helpers.
+*/
+const fromDurableObjectStorage = (storage) => ({
+	get: (key, options) => tryStoragePromise("get", () => storage.get(key, options)),
+	put: (key, value, options) => tryStoragePromise("put", () => storage.put(key, value, options)),
+	delete: (key, options) => tryStoragePromise("delete", () => storage.delete(key, options)),
+	deleteAll: (options) => tryStoragePromise("deleteAll", () => storage.deleteAll(options)),
+	getAlarm: (options) => tryStoragePromise("getAlarm", () => storage.getAlarm(options)),
+	setAlarm: (scheduledTime, options) => tryStoragePromise("setAlarm", () => storage.setAlarm(scheduledTime, options)),
+	deleteAlarm: (options) => tryStoragePromise("deleteAlarm", () => storage.deleteAlarm(options)),
+	transactionSync: (closure) => Effect.context().pipe(Effect.flatMap((context) => Effect.suspend(() => {
+		try {
+			return Effect.succeed(storage.transactionSync(() => {
+				const exit = Effect.runSyncExitWith(context)(closure());
+				if (Exit.isSuccess(exit)) return exit.value;
+				throw exit;
+			}));
+		} catch (cause) {
+			if (Exit.isExit(cause) && Exit.isFailure(cause)) return Effect.failCause(cause.cause);
+			return Effect.fail(storageError("transactionSync", cause));
+		}
+	}))),
+	transaction: (closure) => Effect.context().pipe(Effect.flatMap((context) => Effect.callback((resume) => {
+		storage.transaction(async (txn) => {
+			const exit = await Effect.runPromiseExitWith(context)(closure(fromDurableObjectTransaction(txn)));
+			if (Exit.isSuccess(exit)) return exit.value;
+			throw exit;
+		}).then((value) => resume(Effect.succeed(value)), (cause) => {
+			if (Exit.isExit(cause) && Exit.isFailure(cause)) resume(Effect.failCause(cause.cause));
+			else resume(Effect.fail(storageError("transaction", cause)));
+		});
+	}))),
+	sync: () => tryStoragePromise("sync", () => storage.sync()),
+	getCurrentBookmark: () => tryStoragePromise("getCurrentBookmark", () => storage.getCurrentBookmark()),
+	onNextSessionRestoreBookmark: (bookmark) => tryStoragePromise("onNextSessionRestoreBookmark", () => storage.onNextSessionRestoreBookmark(bookmark)),
+	sql: fromSqlStorage(storage.sql),
+	kv: fromSyncKvStorage(storage.kv)
+});
+//#endregion
+//#region src/DurableObjectState.ts
+var DurableObjectState_exports = /* @__PURE__ */ __exportAll({
+	DurableObjectState: () => DurableObjectState,
+	fromDurableObjectState: () => fromDurableObjectState
+});
+/**
+* Context tag for accessing the current Durable Object state service.
+*/
+var DurableObjectState = class extends Context.Service()("effect-cf/DurableObjectState") {};
+/**
+* Wraps a native Cloudflare `DurableObjectState` as a {@link DurableObjectStateService}.
+*/
+const fromDurableObjectState = (state) => ({
+	raw: state,
+	id: state.id,
+	storage: fromDurableObjectStorage(state.storage),
+	waitUntil: (promise) => Effect.sync(() => state.waitUntil(promise)),
+	blockConcurrencyWhile: (effect) => Effect.context().pipe(Effect.flatMap((context) => Effect.promise(() => state.blockConcurrencyWhile(() => runPromiseExitPreservingTypedFailures(Effect.provideContext(effect, context))))), Effect.flatten),
+	blockConcurrencyWhileOrReset: (effect) => Effect.context().pipe(Effect.flatMap((context) => Effect.promise(() => state.blockConcurrencyWhile(() => Effect.runPromise(Effect.provideContext(effect, context)))))),
+	acceptWebSocket: (ws, tags) => Effect.sync(() => state.acceptWebSocket(ws, tags)),
+	getWebSockets: (tag) => Effect.sync(() => state.getWebSockets(tag)),
+	setWebSocketAutoResponse: (pair) => Effect.sync(() => state.setWebSocketAutoResponse(pair)),
+	getWebSocketAutoResponse: Effect.sync(() => state.getWebSocketAutoResponse()),
+	getWebSocketAutoResponseTimestamp: (ws) => Effect.sync(() => state.getWebSocketAutoResponseTimestamp(ws)),
+	setHibernatableWebSocketEventTimeout: (timeoutMs) => Effect.sync(() => state.setHibernatableWebSocketEventTimeout(timeoutMs)),
+	getHibernatableWebSocketEventTimeout: Effect.sync(() => state.getHibernatableWebSocketEventTimeout()),
+	getTags: (ws) => Effect.sync(() => state.getTags(ws)),
+	abort: (reason) => Effect.sync(() => state.abort(reason))
+});
+const runPromiseExitPreservingTypedFailures = async (effect) => {
+	const exit = await Effect.runPromiseExit(effect);
+	if (Exit.isFailure(exit) && (Cause.hasDies(exit.cause) || Cause.hasInterrupts(exit.cause))) throw Cause.squash(exit.cause);
+	return exit;
+};
+//#endregion
+//#region src/DurableObjectNamespace.ts
+var DurableObjectNamespace_exports = /* @__PURE__ */ __exportAll({
+	DurableObjectFetchError: () => DurableObjectFetchError,
+	DurableObjectRpcError: () => DurableObjectRpcError,
+	Service: () => Service$1
+});
+const TypeId$1 = "effect-cf/DurableObjectNamespace";
+/**
+* Failure raised when invoking an RPC method on a Durable Object stub.
+*/
+var DurableObjectRpcError = class extends Data.TaggedError("DurableObjectRpcError") {};
+/**
+* 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$1 = () => (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$3()(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$1]: TypeId$1,
+		definition,
+		newUniqueId,
+		idFromName,
+		idFromString,
+		get,
+		getByName,
+		jurisdiction,
+		fetch,
+		rpc,
+		call,
+		scopedCall
+	});
+};
+const makeDirectMethods = (rpcDefinition, helpers) => {
+	const methods = {};
+	if (rpcDefinition !== void 0) {
+		for (const methodName of Object.keys(rpcDefinition.methods)) methods[methodName] = (stub, ...args) => helpers.call(stub, methodName, ...args);
+		const makeClient = (getStub) => {
+			const client = { fetch: (input, init) => Effect.gen(function* () {
+				const stub = yield* getStub();
+				return yield* helpers.fetch(stub, input, init);
+			}) };
+			for (const methodName of Object.keys(rpcDefinition.methods)) client[methodName] = (...args) => Effect.gen(function* () {
+				const stub = yield* getStub();
+				return yield* helpers.call(stub, methodName, ...args);
+			});
+			return client;
+		};
+		methods.byName = (name, options) => makeClient(() => helpers.getByName(name, options));
+		methods.byId = (id, options) => makeClient(() => helpers.get(id, options));
+	}
+	return methods;
+};
+//#endregion
+//#region src/DurableObjectDefinition.ts
+var DurableObjectDefinition_exports = /* @__PURE__ */ __exportAll({
+	DurableObject: () => DurableObject$1,
+	Tag: () => Tag$1,
+	implement: () => implement$1,
+	make: () => make$2,
+	method: () => method$1
+});
+const reservedMethodNames$1 = new Set([
+	"constructor",
+	"dup",
+	"fetch",
+	"alarm",
+	"webSocketMessage",
+	"webSocketClose",
+	"webSocketError"
+]);
+/**
+* Defines a single RPC method schema in a Durable Object definition.
+*/
+const method$1 = method$4;
+/**
+* Creates a Durable Object RPC definition plus implementation/binding helpers.
+*
+* @example
+* ```ts
+* const ChatRoom = DurableObjectDefinition.make("ChatRoom", {
+*   postMessage: DurableObjectDefinition.method({
+*     args: [Schema.String],
+*     success: Schema.Void,
+*   }),
+* });
+* ```
+*/
+const makeDefinition = (id, methods) => {
+	assertNoReservedMethods("Durable Object", methods, reservedMethodNames$1);
+	const definition = make$5(id, methods);
+	return Object.assign(definition, {
+		make: (layer, options) => make$1(layer, {
+			...options,
+			rpc: wrapHandlers(definition, options.rpc)
+		}),
+		Namespace: () => (bindingId, binding) => Service$1()(bindingId, {
+			...binding,
+			definition
+		}),
+		namespace: (bindingId, binding) => Service$1()(bindingId, {
+			...binding,
+			definition
+		})
+	});
+};
+const make$2 = makeDefinition;
+const Tag$1 = () => (id, methods) => {
+	const definition = makeDefinition(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 DurableObject$1 = Tag$1;
+const wrapHandlers = (definition, handlers) => {
+	const wrapped = {};
+	for (const key of Object.keys(definition.methods)) {
+		const handler = handlers[key];
+		wrapped[key] = (...args) => Effect.gen(function* () {
+			return yield* encodeSuccess(definition, key, yield* handler(...yield* decodeArgs(definition, key, args)));
+		});
+	}
+	return wrapped;
+};
+/**
+* Helper for implementing handlers with the exact method shape of a definition.
+*/
+const implement$1 = (_definition, handlers) => handlers;
+//#endregion
+//#region src/DurableObject.ts
+var DurableObject_exports = /* @__PURE__ */ __exportAll({
+	Tag: () => Tag,
+	implement: () => implement,
+	make: () => make$1,
+	method: () => method
+});
+const reservedMethodNames = new Set([
+	"constructor",
+	"dup",
+	"fetch",
+	"alarm",
+	"webSocketMessage",
+	"webSocketClose",
+	"webSocketError"
+]);
+const RunSymbol = Symbol.for("effect-cf/DurableObject/run");
+/**
+* Creates a Durable Object class backed by a single managed Effect runtime.
+*/
+const make$1 = (layer, options = {}) => {
+	class EffectDurableObject extends DurableObject {
+		runtime;
+		constructor(state, env) {
+			super(state, env);
+			const runtimeLayer = provideEntrypointServices(layer, Layer.mergeAll(Layer.succeed(DurableObjectState, fromDurableObjectState(state)), Layer.succeed(WorkerEnvironment, env)));
+			this.runtime = ManagedRuntime.make(runtimeLayer);
+		}
+		[RunSymbol](effect) {
+			return this.runtime.runPromise(Effect.scoped(effect));
+		}
+		fetch(request) {
+			const fetchHandler = options.fetch;
+			if (fetchHandler === void 0) return Promise.resolve(new Response("Not Found", { status: 404 }));
+			return this[RunSymbol](Effect.provideService(fetchHandler, NativeRequest, request));
+		}
+		alarm(alarmInfo) {
+			if (options.alarm !== void 0) return this[RunSymbol](options.alarm(alarmInfo));
+		}
+		webSocketMessage(socket, message) {
+			if (options.webSocketMessage !== void 0) return this[RunSymbol](options.webSocketMessage(socket, message));
+		}
+		webSocketClose(socket, code, reason, wasClean) {
+			if (options.webSocketClose !== void 0) return this[RunSymbol](options.webSocketClose(socket, code, reason, wasClean));
+		}
+		webSocketError(socket, error) {
+			if (options.webSocketError !== void 0) return this[RunSymbol](options.webSocketError(socket, error));
+		}
+	}
+	defineEntrypointRpcMethods("Durable Object", EffectDurableObject.prototype, options.rpc, reservedMethodNames, (self, effect) => self[RunSymbol](effect));
+	return assumeEntrypointClass(EffectDurableObject);
+};
+const Tag = Tag$1;
+const method = method$1;
+const implement = implement$1;
+//#endregion
+//#region src/DurableObjectRpcWebSocket.ts
+var DurableObjectRpcWebSocket_exports = /* @__PURE__ */ __exportAll({
+	DurableObjectRpcWebSocket: () => DurableObjectRpcWebSocket,
+	layer: () => layer
+});
+const defaultAttachmentKey = "effectCloudflareRpcClientId";
+const defaultTag = "effect-cf-rpc";
+/**
+* Context tag for the Durable Object RPC websocket service.
+*/
+var DurableObjectRpcWebSocket = class extends Context.Service()("effect-cf/DurableObjectRpcWebSocket") {};
+/**
+* Builds a layer that bridges Durable Object websocket events to `RpcServer.Protocol`.
+*/
+const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
+	const tag = options.tag ?? defaultTag;
+	const attachmentKey = options.attachmentKey ?? defaultAttachmentKey;
+	const durableObjectState = yield* DurableObjectState;
+	const serialization = yield* RpcSerialization.RpcSerialization;
+	const disconnects = yield* Queue.make();
+	const connectionsBySocket = /* @__PURE__ */ new Map();
+	const connectionsById = /* @__PURE__ */ new Map();
+	const clientIds = /* @__PURE__ */ new Set();
+	let nextClientId = 0;
+	let writeRequest;
+	const reserveClientId = (socket) => {
+		const attachment = readAttachment(socket, attachmentKey);
+		if (attachment !== void 0) {
+			nextClientId = Math.max(nextClientId, attachment + 1);
+			return attachment;
+		}
+		const id = nextClientId++;
+		writeAttachment(socket, attachmentKey, id);
+		return id;
+	};
+	const register = (socket) => {
+		const existing = connectionsBySocket.get(socket);
+		if (existing !== void 0) return existing;
+		const connection = {
+			id: reserveClientId(socket),
+			socket,
+			parser: serialization.makeUnsafe()
+		};
+		connectionsBySocket.set(socket, connection);
+		connectionsById.set(connection.id, connection);
+		clientIds.add(connection.id);
+		return connection;
+	};
+	const unregister = (socket) => Effect.sync(() => {
+		const connection = connectionsBySocket.get(socket);
+		if (connection === void 0) return;
+		connectionsBySocket.delete(socket);
+		connectionsById.delete(connection.id);
+		clientIds.delete(connection.id);
+		Queue.offerUnsafe(disconnects, connection.id);
+	});
+	for (const socket of yield* durableObjectState.getWebSockets(tag)) register(socket);
+	const send = (connection, response) => Effect.sync(() => {
+		try {
+			const encoded = connection.parser.encode(response);
+			if (encoded !== void 0) connection.socket.send(encoded);
+		} catch (cause) {
+			const encoded = connection.parser.encode(RpcMessage.ResponseDefectEncoded(cause));
+			if (encoded !== void 0) connection.socket.send(encoded);
+		}
+	});
+	const protocol = yield* RpcServer.Protocol.make((writeRequest_) => {
+		writeRequest = writeRequest_;
+		return Effect.succeed({
+			disconnects,
+			send: (clientId, response) => {
+				const connection = connectionsById.get(clientId);
+				return connection === void 0 ? Effect.void : send(connection, response);
+			},
+			end: (clientId) => Effect.sync(() => {
+				connectionsById.get(clientId)?.socket.close();
+			}),
+			clientIds: Effect.sync(() => clientIds),
+			initialMessage: Effect.succeed(Option.none()),
+			supportsAck: true,
+			supportsTransferables: false,
+			supportsSpanPropagation: true
+		});
+	});
+	const service = DurableObjectRpcWebSocket.of({
+		accept: (socket) => Effect.gen(function* () {
+			register(socket);
+			yield* durableObjectState.acceptWebSocket(socket, [tag]);
+		}),
+		message: (socket, message) => Effect.gen(function* () {
+			const connection = register(socket);
+			const decoded = yield* Effect.try({
+				try: () => connection.parser.decode(normalizeMessage(message)),
+				catch: RpcMessage.ResponseDefectEncoded
+			});
+			const run = writeRequest;
+			if (run === void 0) {
+				yield* send(connection, RpcMessage.ResponseDefectEncoded("RPC server is not ready"));
+				return;
+			}
+			for (const current of decoded) yield* run(connection.id, current);
+		}).pipe(Effect.catch((error) => {
+			return send(register(socket), error);
+		})),
+		close: unregister,
+		error: (socket, error) => Effect.gen(function* () {
+			yield* Effect.logDebug("Durable Object RPC websocket error", error);
+			yield* unregister(socket);
+		})
+	});
+	return Context.mergeAll(Context.make(RpcServer.Protocol, protocol), Context.make(DurableObjectRpcWebSocket, service));
+}));
+const normalizeMessage = (message) => typeof message === "string" ? message : new Uint8Array(message);
+const readAttachment = (socket, key) => {
+	const value = socket.deserializeAttachment();
+	if (value !== null && typeof value === "object" && key in value && typeof value[key] === "number") return value[key];
+};
+const writeAttachment = (socket, key, clientId) => {
+	const current = socket.deserializeAttachment();
+	const attachment = current !== null && typeof current === "object" && !Array.isArray(current) ? current : {};
+	socket.serializeAttachment({
+		...attachment,
+		[key]: clientId
+	});
+};
+//#endregion
+//#region src/DurableObjectWebSocket.ts
+var DurableObjectWebSocket_exports = /* @__PURE__ */ __exportAll({ acceptUpgrade: () => acceptUpgrade });
+/**
+* Accepts a websocket upgrade and registers the server socket on `DurableObjectState`.
+*
+* @example
+* ```ts
+* const response = yield* DurableObjectWebSocket.acceptUpgrade({
+*   tags: ["room:general"],
+* });
+*
+* return response.response;
+* ```
+*/
+const acceptUpgrade = (options = {}) => Effect.gen(function* () {
+	const state = yield* DurableObjectState;
+	const pair = new WebSocketPair();
+	const client = pair[0];
+	const server = pair[1];
+	if (options.attachment !== void 0) server.serializeAttachment(options.attachment);
+	yield* state.acceptWebSocket(server, options.tags === void 0 ? void 0 : [...options.tags]);
+	return {
+		client,
+		server,
+		response: new Response(null, {
+			status: 101,
+			webSocket: client
+		})
+	};
+});
+//#endregion
+//#region src/Kv.ts
+var Kv_exports = /* @__PURE__ */ __exportAll({
+	KvOperationError: () => KvOperationError,
+	Service: () => Service,
+	make: () => make
+});
+const TypeId = "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);
+const maybeNumber = (value) => value === void 0 ? Option.none() : Option.some(value);
+const kvError = (binding, operation, cause) => new KvOperationError({
+	binding,
+	operation,
+	cause
+});
+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 = (id, definition) => Service()(id, definition);
+/**
+* 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 = () => (id, definition) => {
+	const tag = Service$3()(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 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));
+	});
+	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));
+	});
+	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)
+		});
+	});
+	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)
+		};
+	});
+	const remove = Effect.fnUntraced(function* (key) {
+		const kv = yield* tag;
+		const keyEncoded = yield* encodeKey(key);
+		yield* tryKvPromise(definition.binding, "delete", () => kv.delete(keyEncoded));
+	});
+	const unsafeRaw = Effect.fnUntraced(function* () {
+		return yield* tag;
+	});
+	return Object.assign(tag, {
+		[TypeId]: TypeId,
+		definition,
+		put,
+		get,
+		getWithMetadata,
+		list,
+		remove,
+		unsafeRaw
+	});
+};
+//#endregion
+export { Binding_exports as Binding, DurableObject_exports as DurableObject, 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, Rpc_exports as Rpc, RpcDefinition_exports as RpcDefinition, ServiceBinding_exports as ServiceBinding, Worker_exports as Worker, WorkerConfig, WorkerDefinition_exports as WorkerDefinition, WorkerEnvironment };