effect-cf 0.0.4 → 0.2.0

package/dist/index.mjs

@@ -1,6 +1,6 @@
 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 { Cause, Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Layer, ManagedRuntime, Option, Queue, Schema } from "effect";
+import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, WorkflowEntrypoint } from "cloudflare:workers";
 import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
@@ -28,11 +28,11 @@ let WorkerConfig;
 var Binding_exports = /* @__PURE__ */ __exportAll({
 	BindingNotFoundError: () => BindingNotFoundError,
 	BindingValidationError: () => BindingValidationError,
-	Service: () => Service$3,
-	TypeId: () => TypeId$3
+	Service: () => Service$5,
+	TypeId: () => TypeId$5
 });
 /** Internal type id marker used by binding helper services. */
-const TypeId$3 = "effect-cf/Binding";
+const TypeId$5 = "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. */
@@ -48,18 +48,167 @@ const getBinding = (env, binding, isResource) => Effect.gen(function* () {
 /**
 * Creates a Context tag + layer for reading and validating a Cloudflare binding.
 */
-const Service$3 = () => (id, binding, isResource) => {
+const Service$5 = () => (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,
+		[TypeId$5]: TypeId$5,
 		binding,
 		layer
 	});
 };
 //#endregion
+//#region src/QueueBinding.ts
+var QueueBinding_exports = /* @__PURE__ */ __exportAll({
+	QueueOperationError: () => QueueOperationError,
+	Service: () => Service$4,
+	make: () => make$10
+});
+const TypeId$4 = "effect-cf/QueueBinding";
+var QueueOperationError = class extends Data.TaggedError("QueueOperationError") {};
+const queueError = (binding, operation, cause) => new QueueOperationError({
+	binding,
+	operation,
+	cause
+});
+const tryQueuePromise = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => queueError(binding, operation, cause)
+});
+const isQueue = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const resource = value;
+	return typeof resource.send === "function" && typeof resource.sendBatch === "function" && typeof resource.metrics === "function";
+};
+/** 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$5()(id, definition.binding, (value) => isQueue(value));
+	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
+	});
+};
+//#endregion
+//#region src/QueueDefinition.ts
+var QueueDefinition_exports = /* @__PURE__ */ __exportAll({
+	Queue: () => Queue$1,
+	Tag: () => Tag$7,
+	implement: () => implement$7,
+	make: () => make$9
+});
+const makeDefinition$3 = (id, definition) => {
+	const queueDefinition = {
+		id,
+		message: definition.message
+	};
+	return Object.assign(queueDefinition, {
+		make: (layer, options) => make$6(layer, {
+			...options,
+			queue: wrapHandler$1(queueDefinition, options.queue)
+		}),
+		Binding: () => (bindingId, binding) => Service$4()(bindingId, {
+			...binding,
+			message: definition.message
+		}),
+		binding: (bindingId, binding) => Service$4()(bindingId, {
+			...binding,
+			message: definition.message
+		})
+	});
+};
+const make$9 = makeDefinition$3;
+const Tag$7 = () => (id, definition) => {
+	const queueDefinition = makeDefinition$3(id, definition);
+	class QueueDefinitionClass {
+		static id = queueDefinition.id;
+		static message = queueDefinition.message;
+		static make = queueDefinition.make;
+		static Binding = queueDefinition.Binding;
+		static binding = queueDefinition.binding;
+	}
+	return QueueDefinitionClass;
+};
+const Queue$1 = Tag$7;
+const wrapHandler$1 = (definition, handler) => {
+	const decodeBody = Schema.decodeUnknownEffect(definition.message);
+	return (batch) => Effect.gen(function* () {
+		yield* handler(yield* decodeBatch(batch.raw, decodeBody));
+	});
+};
+const implement$7 = (_definition, handler) => handler;
+//#endregion
+//#region src/Queue.ts
+var Queue_exports = /* @__PURE__ */ __exportAll({
+	QueueMessageDecodeError: () => QueueMessageDecodeError,
+	Tag: () => Tag$6,
+	decodeBatch: () => decodeBatch,
+	fromMessage: () => fromMessage,
+	fromMessageBatch: () => fromMessageBatch,
+	implement: () => implement$6
+});
+var QueueMessageDecodeError = class extends Data.TaggedError("QueueMessageDecodeError") {};
+const fromMessage = (message, body) => ({
+	raw: message,
+	id: message.id,
+	timestamp: message.timestamp,
+	body,
+	attempts: message.attempts,
+	ack: Effect.sync(() => message.ack()),
+	retry: (options) => Effect.sync(() => message.retry(options))
+});
+const fromMessageBatch = (batch, messages) => ({
+	raw: batch,
+	messages,
+	queue: batch.queue,
+	metadata: batch.metadata,
+	ackAll: Effect.sync(() => batch.ackAll()),
+	retryAll: (options) => Effect.sync(() => batch.retryAll(options))
+});
+const decodeBatch = (batch, decodeBody) => Effect.gen(function* () {
+	const messages = [];
+	for (let index = 0; index < batch.messages.length; index++) {
+		const message = batch.messages[index];
+		const body = yield* decodeBody(message.body).pipe(Effect.mapError((cause) => new QueueMessageDecodeError({
+			queue: batch.queue,
+			messageId: message.id,
+			index,
+			cause
+		})));
+		messages.push(fromMessage(message, body));
+	}
+	return fromMessageBatch(batch, messages);
+});
+const Tag$6 = Tag$7;
+const implement$6 = implement$7;
+//#endregion
 //#region src/RpcDefinition.ts
 var RpcDefinition_exports = /* @__PURE__ */ __exportAll({
 	ReservedMethodNameError: () => ReservedMethodNameError,
@@ -75,7 +224,7 @@ var RpcDefinition_exports = /* @__PURE__ */ __exportAll({
 	decodeSuccess: () => decodeSuccess,
 	encodeArgs: () => encodeArgs,
 	encodeSuccess: () => encodeSuccess,
-	make: () => make$5,
+	make: () => make$8,
 	method: () => method$4,
 	reservedMethodNames: () => reservedMethodNames$4
 });
@@ -178,7 +327,7 @@ const decodeSuccess = (definition, methodName, value) => {
 		cause
 	})));
 };
-const make$5 = (id, methods) => {
+const make$8 = (id, methods) => {
 	const definition = {
 		id,
 		methods
@@ -232,11 +381,11 @@ const invokeRpcMethod = (target, method, args, makeError) => Effect.gen(function
 //#endregion
 //#region src/ServiceBinding.ts
 var ServiceBinding_exports = /* @__PURE__ */ __exportAll({
-	Service: () => Service$2,
+	Service: () => Service$3,
 	ServiceBindingFetchError: () => ServiceBindingFetchError,
 	ServiceBindingRpcError: () => ServiceBindingRpcError
 });
-const TypeId$2 = "effect-cf/ServiceBinding";
+const TypeId$3 = "effect-cf/ServiceBinding";
 /**
 * Failure raised when calling `fetch` on a service binding.
 */
@@ -271,8 +420,8 @@ var ServiceBindingRpcError = class extends Data.TaggedError("ServiceBindingRpcEr
 * });
 * ```
 */
-const Service$2 = () => (id, definition) => {
-	const tag = Service$3()(id, definition.binding, (value) => typeof value === "object" && value !== null && "fetch" in value);
+const Service$3 = () => (id, definition) => {
+	const tag = Service$5()(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({
@@ -315,7 +464,7 @@ const Service$2 = () => (id, definition) => {
 	});
 	const directMethods = makeDirectMethods$1(definition.definition, call);
 	return Object.assign(tag, directMethods, {
-		[TypeId$2]: TypeId$2,
+		[TypeId$3]: TypeId$3,
 		definition,
 		fetch,
 		rpc,
@@ -331,10 +480,10 @@ const makeDirectMethods$1 = (rpcDefinition, call) => {
 //#endregion
 //#region src/WorkerDefinition.ts
 var WorkerDefinition_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$3,
+	Tag: () => Tag$5,
 	Worker: () => Worker,
-	implement: () => implement$3,
-	make: () => make$4,
+	implement: () => implement$5,
+	make: () => make$7,
 	method: () => method$3
 });
 const reservedMethodNames$3 = new Set([
@@ -342,6 +491,12 @@ const reservedMethodNames$3 = new Set([
 	"dup",
 	"fetch",
 	"connect",
+	"queue",
+	"scheduled",
+	"tail",
+	"tailStream",
+	"test",
+	"trace",
 	"alarm",
 	"webSocketMessage",
 	"webSocketClose",
@@ -364,27 +519,27 @@ const method$3 = method$4;
 * });
 * ```
 */
-const makeDefinition$1 = (id, methods) => {
+const makeDefinition$2 = (id, methods) => {
 	assertNoReservedMethods("Worker", methods, reservedMethodNames$3);
-	const definition = make$5(id, methods);
+	const definition = make$8(id, methods);
 	return Object.assign(definition, {
-		make: (layer, options) => make$3(layer, {
+		make: (layer, options) => make$6(layer, {
 			...options,
 			rpc: wrapHandlers$1(definition, options.rpc)
 		}),
-		Binding: () => (bindingId, binding) => Service$2()(bindingId, {
+		Binding: () => (bindingId, binding) => Service$3()(bindingId, {
 			...binding,
 			definition
 		}),
-		binding: (bindingId, binding) => Service$2()(bindingId, {
+		binding: (bindingId, binding) => Service$3()(bindingId, {
 			...binding,
 			definition
 		})
 	});
 };
-const make$4 = makeDefinition$1;
-const Tag$3 = () => (id, methods) => {
-	const definition = makeDefinition$1(id, methods);
+const make$7 = makeDefinition$2;
+const Tag$5 = () => (id, methods) => {
+	const definition = makeDefinition$2(id, methods);
 	class WorkerDefinitionClass {
 		static id = definition.id;
 		static methods = definition.methods;
@@ -394,7 +549,7 @@ const Tag$3 = () => (id, methods) => {
 	}
 	return WorkerDefinitionClass;
 };
-const Worker = Tag$3;
+const Worker = Tag$5;
 const wrapHandlers$1 = (definition, handlers) => {
 	const wrapped = {};
 	for (const key of Object.keys(definition.methods)) {
@@ -408,7 +563,7 @@ const wrapHandlers$1 = (definition, handlers) => {
 /**
 * Helper for implementing handlers with the exact method shape of a definition.
 */
-const implement$3 = (_definition, handlers) => handlers;
+const implement$5 = (_definition, handlers) => handlers;
 //#endregion
 //#region src/internal/Entrypoint.ts
 const provideEntrypointServices = (layer, services) => layer.pipe(Layer.provideMerge(services));
@@ -424,34 +579,43 @@ const defineEntrypointRpcMethods = (target, prototype, rpc, reservedMethodNames,
 };
 const assumeEntrypointClass = (entrypoint) => entrypoint;
 //#endregion
+//#region src/internal/WorkerContext.ts
+const causeError = (cause) => new Error(Cause.pretty(cause));
+const failureHandler = (cause, options) => (options?.onFailure?.(cause) ?? Effect.logError("WorkerContext.waitUntil failed", Cause.pretty(cause))).pipe(Effect.catchCause((handlerCause) => Effect.logError("WorkerContext.waitUntil failure handler failed", Cause.pretty(cause), Cause.pretty(handlerCause))));
+const fromExecutionContext = (ctx, runPromiseExit) => {
+	const schedule = (effect, options, mode) => Effect.context().pipe(Effect.flatMap((context) => Effect.sync(() => {
+		const runHandler = (cause) => runPromiseExit(Effect.scoped(Effect.provideContext(failureHandler(cause, options), context))).then((exit) => {
+			if (Exit.isFailure(exit)) console.error("WorkerContext.waitUntil failure handler failed", Cause.pretty(exit.cause));
+		});
+		ctx.waitUntil(runPromiseExit(Effect.scoped(Effect.provideContext(effect, context))).then(async (exit) => {
+			if (Exit.isSuccess(exit)) return;
+			await runHandler(exit.cause);
+			if (mode === "propagate") throw causeError(exit.cause);
+		}));
+	})));
+	return {
+		raw: ctx,
+		waitUntil: (effect, options) => schedule(effect, options, options?.mode ?? "observe"),
+		waitUntilPropagating: (effect, options) => schedule(effect, options, "propagate"),
+		passThroughOnException: Effect.sync(() => ctx.passThroughOnException())
+	};
+};
+//#endregion
 //#region src/Worker.ts
 var Worker_exports = /* @__PURE__ */ __exportAll({
 	ExecutionContext: () => ExecutionContext,
 	NativeRequest: () => NativeRequest,
-	Tag: () => Tag$2,
+	Tag: () => Tag$4,
 	WorkerContext: () => WorkerContext,
-	implement: () => implement$2,
+	implement: () => implement$4,
 	isWebSocketUpgrade: () => isWebSocketUpgrade,
-	make: () => make$3,
+	make: () => make$6,
 	makeFetchHandler: () => makeFetchHandler,
 	method: () => method$2,
 	renderHttpResponse: () => renderHttpResponse
 });
 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([
@@ -459,6 +623,12 @@ const reservedMethodNames$2 = new Set([
 	"dup",
 	"fetch",
 	"connect",
+	"queue",
+	"scheduled",
+	"tail",
+	"tailStream",
+	"test",
+	"trace",
 	"alarm",
 	"webSocketMessage",
 	"webSocketClose",
@@ -467,12 +637,14 @@ const reservedMethodNames$2 = new Set([
 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 make$3 = (layer, options) => {
+const isWorkerOptions = (options) => typeof options === "object" && options !== null && ("fetch" in options || "queue" in options || "rpc" in options);
+function make$6(layer, optionsOrFetch) {
+	const options = isWorkerOptions(optionsOrFetch) ? optionsOrFetch : { fetch: optionsOrFetch };
 	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")));
+			let runWaitUntilEffect = () => Promise.reject(/* @__PURE__ */ new Error("WorkerContext runtime is not initialized"));
 			const runtimeLayer = provideEntrypointServices(layer, Layer.mergeAll(Layer.succeed(ExecutionContext, ctx), ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env))), Layer.succeed(WorkerContext, fromExecutionContext(ctx, (effect) => runWaitUntilEffect(effect))), Layer.succeed(WorkerEnvironment, env)));
 			this.runtime = ManagedRuntime.make(runtimeLayer);
 			runWaitUntilEffect = (effect) => this.runtime.runPromiseExit(effect);
@@ -486,17 +658,23 @@ const make$3 = (layer, options) => {
 			const requestServices = Layer.mergeAll(Layer.succeed(NativeRequest, request), Layer.succeed(HttpServerRequest.HttpServerRequest, HttpServerRequest.fromWeb(request)));
 			return this[RunSymbol$1](renderFetchSuccess(fetchHandler).pipe(Effect.provide(requestServices)));
 		}
+		queue(batch) {
+			const queueHandler = options.queue;
+			if (queueHandler === void 0) return Promise.resolve();
+			const messages = batch.messages.map((message) => fromMessage(message, message.body));
+			return this[RunSymbol$1](queueHandler(fromMessageBatch(batch, messages)));
+		}
 	}
 	defineEntrypointRpcMethods("Worker", EffectWorker.prototype, options.rpc, reservedMethodNames$2, (self, effect) => self[RunSymbol$1](effect));
 	return assumeEntrypointClass(EffectWorker);
-};
+}
 const makeFetchHandler = (layer, options) => {
-	const WorkerClass = make$3(layer, options);
+	const WorkerClass = make$6(layer, options);
 	return { fetch: (request, env, ctx) => Promise.resolve(new WorkerClass(ctx, env).fetch(request)) };
 };
-const Tag$2 = Tag$3;
+const Tag$4 = Tag$5;
 const method$2 = method$3;
-const implement$2 = implement$3;
+const implement$4 = implement$5;
 //#endregion
 //#region src/DurableObjectStorage.ts
 var DurableObjectStorage_exports = /* @__PURE__ */ __exportAll({
@@ -620,6 +798,138 @@ const fromDurableObjectStorage = (storage) => ({
 	kv: fromSyncKvStorage(storage.kv)
 });
 //#endregion
+//#region src/DurableObjectWebSocket.ts
+var DurableObjectWebSocket_exports = /* @__PURE__ */ __exportAll({
+	DurableWebSocketAttachmentError: () => DurableWebSocketAttachmentError,
+	DurableWebSocketCloseError: () => DurableWebSocketCloseError,
+	DurableWebSocketSendError: () => DurableWebSocketSendError,
+	acceptUpgrade: () => acceptUpgrade,
+	attachment: () => attachment,
+	fromWebSocket: () => fromWebSocket,
+	handlers: () => handlers
+});
+/** Error raised when sending on a Durable Object websocket fails. */
+var DurableWebSocketSendError = class extends Data.TaggedError("DurableWebSocketSendError") {};
+/** Error raised when closing a Durable Object websocket fails. */
+var DurableWebSocketCloseError = class extends Data.TaggedError("DurableWebSocketCloseError") {};
+/** Error raised when serializing or deserializing a websocket attachment fails. */
+var DurableWebSocketAttachmentError = class extends Data.TaggedError("DurableWebSocketAttachmentError") {};
+const wrappers = /* @__PURE__ */ new WeakMap();
+/** Wraps a native Cloudflare websocket in the Effect-native Durable Object API. */
+const fromWebSocket = (raw) => {
+	const existing = wrappers.get(raw);
+	if (existing !== void 0) return existing;
+	const socket = {
+		raw,
+		send: (data) => Effect.try({
+			try: () => raw.send(data),
+			catch: (cause) => new DurableWebSocketSendError({ cause })
+		}),
+		close: (code, reason) => Effect.try({
+			try: () => raw.close(code, reason),
+			catch: (cause) => new DurableWebSocketCloseError({ cause })
+		}),
+		serializeAttachment: (value) => Effect.try({
+			try: () => raw.serializeAttachment(value),
+			catch: (cause) => new DurableWebSocketAttachmentError({
+				operation: "serialize",
+				cause
+			})
+		}),
+		deserializeAttachment: Effect.try({
+			try: () => raw.deserializeAttachment(),
+			catch: (cause) => new DurableWebSocketAttachmentError({
+				operation: "deserialize",
+				cause
+			})
+		})
+	};
+	wrappers.set(raw, socket);
+	return socket;
+};
+/**
+* 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 = fromWebSocket(pair[1]);
+	if (options.attachment !== void 0) server.raw.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
+		})
+	};
+});
+/** Creates typed attachment helpers for accepted and rehydrated sockets. */
+const attachment = (schema) => {
+	const serialize = (socket, value) => Schema.encodeEffect(schema)(value).pipe(Effect.mapError((cause) => new DurableWebSocketAttachmentError({
+		operation: "serialize",
+		cause
+	})), Effect.flatMap((encoded) => socket.serializeAttachment(encoded)));
+	const deserialize = (socket) => Effect.gen(function* () {
+		const value = yield* socket.deserializeAttachment;
+		if (value == null) return Option.none();
+		return Option.some(yield* Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError((cause) => new DurableWebSocketAttachmentError({
+			operation: "deserialize",
+			cause
+		}))));
+	});
+	const rehydrate = (options = {}) => Effect.gen(function* () {
+		const sockets = yield* (yield* DurableObjectState).getWebSockets(options.tag);
+		const restored = [];
+		const onInvalid = options.onInvalid ?? "ignore";
+		for (const socket of sockets) {
+			const decoded = yield* deserialize(socket).pipe(Effect.match({
+				onFailure: (error) => ({
+					_tag: "Failure",
+					error
+				}),
+				onSuccess: (value) => ({
+					_tag: "Success",
+					value
+				})
+			}));
+			if (decoded._tag === "Success" && Option.isSome(decoded.value)) {
+				restored.push({
+					socket,
+					attachment: decoded.value.value
+				});
+				continue;
+			}
+			if (decoded._tag === "Failure" && onInvalid === "fail") return yield* Effect.fail(decoded.error);
+			if (decoded._tag === "Failure" && onInvalid === "ignore-and-close") yield* socket.close(1008, "invalid websocket attachment").pipe(Effect.ignore);
+		}
+		return restored;
+	});
+	return {
+		serialize,
+		deserialize,
+		rehydrate,
+		schema
+	};
+};
+/** Adapts wrapped websocket lifecycle handlers to `DurableObject.make` raw callbacks. */
+const handlers = (options) => ({
+	webSocketMessage: options.message === void 0 ? void 0 : (socket, message) => options.message?.(fromWebSocket(socket), message) ?? Effect.void,
+	webSocketClose: options.close === void 0 ? void 0 : (socket, code, reason, wasClean) => options.close?.(fromWebSocket(socket), code, reason, wasClean) ?? Effect.void,
+	webSocketError: options.error === void 0 ? void 0 : (socket, error) => options.error?.(fromWebSocket(socket), error) ?? Effect.void
+});
+//#endregion
 //#region src/DurableObjectState.ts
 var DurableObjectState_exports = /* @__PURE__ */ __exportAll({
 	DurableObjectState: () => DurableObjectState,
@@ -639,14 +949,14 @@ const fromDurableObjectState = (state) => ({
 	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)),
+	acceptWebSocket: (ws, tags) => Effect.sync(() => state.acceptWebSocket(ws.raw, tags)),
+	getWebSockets: (tag) => Effect.sync(() => state.getWebSockets(tag).map((socket) => fromWebSocket(socket))),
 	setWebSocketAutoResponse: (pair) => Effect.sync(() => state.setWebSocketAutoResponse(pair)),
 	getWebSocketAutoResponse: Effect.sync(() => state.getWebSocketAutoResponse()),
-	getWebSocketAutoResponseTimestamp: (ws) => Effect.sync(() => state.getWebSocketAutoResponseTimestamp(ws)),
+	getWebSocketAutoResponseTimestamp: (ws) => Effect.sync(() => state.getWebSocketAutoResponseTimestamp(ws.raw)),
 	setHibernatableWebSocketEventTimeout: (timeoutMs) => Effect.sync(() => state.setHibernatableWebSocketEventTimeout(timeoutMs)),
 	getHibernatableWebSocketEventTimeout: Effect.sync(() => state.getHibernatableWebSocketEventTimeout()),
-	getTags: (ws) => Effect.sync(() => state.getTags(ws)),
+	getTags: (ws) => Effect.sync(() => state.getTags(ws.raw)),
 	abort: (reason) => Effect.sync(() => state.abort(reason))
 });
 const runPromiseExitPreservingTypedFailures = async (effect) => {
@@ -659,9 +969,9 @@ const runPromiseExitPreservingTypedFailures = async (effect) => {
 var DurableObjectNamespace_exports = /* @__PURE__ */ __exportAll({
 	DurableObjectFetchError: () => DurableObjectFetchError,
 	DurableObjectRpcError: () => DurableObjectRpcError,
-	Service: () => Service$1
+	Service: () => Service$2
 });
-const TypeId$1 = "effect-cf/DurableObjectNamespace";
+const TypeId$2 = "effect-cf/DurableObjectNamespace";
 /**
 * Failure raised when invoking an RPC method on a Durable Object stub.
 */
@@ -693,10 +1003,10 @@ var DurableObjectFetchError = class extends Data.TaggedError("DurableObjectFetch
 * });
 * ```
 */
-const Service$1 = () => (id, definition) => {
+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$3()(id, definition.binding, (value) => isDurableObjectNamespaceClient(value));
+	const tag = Service$5()(id, definition.binding, (value) => isDurableObjectNamespaceClient(value));
 	const newUniqueId = Effect.fnUntraced(function* (options) {
 		return (yield* tag).newUniqueId(options);
 	});
@@ -758,7 +1068,7 @@ const Service$1 = () => (id, definition) => {
 		getByName
 	});
 	return Object.assign(tag, directMethods, {
-		[TypeId$1]: TypeId$1,
+		[TypeId$2]: TypeId$2,
 		definition,
 		newUniqueId,
 		idFromName,
@@ -796,9 +1106,9 @@ const makeDirectMethods = (rpcDefinition, helpers) => {
 //#region src/DurableObjectDefinition.ts
 var DurableObjectDefinition_exports = /* @__PURE__ */ __exportAll({
 	DurableObject: () => DurableObject$1,
-	Tag: () => Tag$1,
-	implement: () => implement$1,
-	make: () => make$2,
+	Tag: () => Tag$3,
+	implement: () => implement$3,
+	make: () => make$5,
 	method: () => method$1
 });
 const reservedMethodNames$1 = new Set([
@@ -827,27 +1137,27 @@ const method$1 = method$4;
 * });
 * ```
 */
-const makeDefinition = (id, methods) => {
+const makeDefinition$1 = (id, methods) => {
 	assertNoReservedMethods("Durable Object", methods, reservedMethodNames$1);
-	const definition = make$5(id, methods);
+	const definition = make$8(id, methods);
 	return Object.assign(definition, {
-		make: (layer, options) => make$1(layer, {
+		make: (layer, options) => make$4(layer, {
 			...options,
 			rpc: wrapHandlers(definition, options.rpc)
 		}),
-		Namespace: () => (bindingId, binding) => Service$1()(bindingId, {
+		Namespace: () => (bindingId, binding) => Service$2()(bindingId, {
 			...binding,
 			definition
 		}),
-		namespace: (bindingId, binding) => Service$1()(bindingId, {
+		namespace: (bindingId, binding) => Service$2()(bindingId, {
 			...binding,
 			definition
 		})
 	});
 };
-const make$2 = makeDefinition;
-const Tag$1 = () => (id, methods) => {
-	const definition = makeDefinition(id, methods);
+const make$5 = makeDefinition$1;
+const Tag$3 = () => (id, methods) => {
+	const definition = makeDefinition$1(id, methods);
 	class DurableObjectDefinitionClass {
 		static id = definition.id;
 		static methods = definition.methods;
@@ -857,7 +1167,7 @@ const Tag$1 = () => (id, methods) => {
 	}
 	return DurableObjectDefinitionClass;
 };
-const DurableObject$1 = Tag$1;
+const DurableObject$1 = Tag$3;
 const wrapHandlers = (definition, handlers) => {
 	const wrapped = {};
 	for (const key of Object.keys(definition.methods)) {
@@ -871,13 +1181,13 @@ const wrapHandlers = (definition, handlers) => {
 /**
 * Helper for implementing handlers with the exact method shape of a definition.
 */
-const implement$1 = (_definition, handlers) => handlers;
+const implement$3 = (_definition, handlers) => handlers;
 //#endregion
 //#region src/DurableObject.ts
 var DurableObject_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag,
-	implement: () => implement,
-	make: () => make$1,
+	Tag: () => Tag$2,
+	implement: () => implement$2,
+	make: () => make$4,
 	method: () => method
 });
 const reservedMethodNames = new Set([
@@ -893,7 +1203,7 @@ 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 = {}) => {
+const make$4 = (layer, options = {}) => {
 	class EffectDurableObject extends DurableObject {
 		runtime;
 		constructor(state, env) {
@@ -910,7 +1220,14 @@ const make$1 = (layer, options = {}) => {
 			return this[RunSymbol](Effect.provideService(fetchHandler, NativeRequest, request));
 		}
 		alarm(alarmInfo) {
-			if (options.alarm !== void 0) return this[RunSymbol](options.alarm(alarmInfo));
+			const logicalAlarms = options.alarms?.pipe(Effect.asVoid);
+			const rawAlarm = options.alarm?.(alarmInfo);
+			if (logicalAlarms !== void 0 && rawAlarm !== void 0) return this[RunSymbol](Effect.gen(function* () {
+				yield* logicalAlarms;
+				yield* rawAlarm;
+			}));
+			if (logicalAlarms !== void 0) return this[RunSymbol](logicalAlarms);
+			if (rawAlarm !== void 0) return this[RunSymbol](rawAlarm);
 		}
 		webSocketMessage(socket, message) {
 			if (options.webSocketMessage !== void 0) return this[RunSymbol](options.webSocketMessage(socket, message));
@@ -925,9 +1242,331 @@ const make$1 = (layer, options = {}) => {
 	defineEntrypointRpcMethods("Durable Object", EffectDurableObject.prototype, options.rpc, reservedMethodNames, (self, effect) => self[RunSymbol](effect));
 	return assumeEntrypointClass(EffectDurableObject);
 };
-const Tag = Tag$1;
+const Tag$2 = Tag$3;
 const method = method$1;
-const implement = implement$1;
+const implement$2 = implement$3;
+//#endregion
+//#region src/DurableObjectAlarm.ts
+var DurableObjectAlarm_exports = /* @__PURE__ */ __exportAll({
+	DurableObjectAlarm: () => DurableObjectAlarm,
+	DurableObjectAlarmEvent: () => DurableObjectAlarmEvent,
+	InvalidAlarmPayloadError: () => InvalidAlarmPayloadError,
+	InvalidAlarmRefError: () => InvalidAlarmRefError,
+	InvalidProcessDueAlarmsOptionsError: () => InvalidProcessDueAlarmsOptionsError,
+	InvalidRepeatEveryError: () => InvalidRepeatEveryError,
+	StoredAlarmDecodeError: () => StoredAlarmDecodeError,
+	define: () => define,
+	process: () => process,
+	processDue: () => processDue
+});
+const INIT_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS effect_cf_scheduled_alarms (
+  storage_id TEXT PRIMARY KEY,
+  alarm_id TEXT NOT NULL,
+  tag TEXT NOT NULL,
+  run_at INTEGER NOT NULL,
+  repeat_every_ms INTEGER,
+  payload TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_effect_cf_scheduled_alarms_run_at_storage_id
+  ON effect_cf_scheduled_alarms (run_at, storage_id);
+`;
+const DEFAULT_PROCESS_DUE_ALARMS_LIMIT = 100;
+const DEFAULT_PROCESS_DUE_ALARMS_FAILURE_RESCHEDULE_AFTER = "30 seconds";
+const getScheduledEventId = (input) => `effect-cf-alarm:${encodeURIComponent(input.tag)}:${encodeURIComponent(input.id)}`;
+var InvalidAlarmRefError = class extends Data.TaggedError("InvalidAlarmRefError") {};
+var InvalidAlarmPayloadError = class extends Data.TaggedError("InvalidAlarmPayloadError") {};
+var InvalidRepeatEveryError = class extends Data.TaggedError("InvalidRepeatEveryError") {};
+var InvalidProcessDueAlarmsOptionsError = class extends Data.TaggedError("InvalidProcessDueAlarmsOptionsError") {};
+var StoredAlarmDecodeError = class extends Data.TaggedError("StoredAlarmDecodeError") {};
+/**
+* Events handled by `processDueAlarms`.
+*
+* `AlarmDue` represents one durable alarm whose scheduled time is now due. The
+* `tag` is the consumer-owned routing key, while `id` is the stable alarm id
+* within that tag.
+*
+* `scheduledAt` is the logical due-after timestamp from durable storage. It is
+* not expected to match the current Durable Object alarm invocation time,
+* especially during retries. Retries re-scan durable rows with `run_at <= now`
+* and identify logical events by `{ tag, id }`.
+*
+* @example Handling events by tag
+* ```ts
+* yield* durableObjectAlarm.processDueAlarms((event) =>
+*   event.tag === "heartbeat"
+*     ? heartbeatManager.handleAlarmEvent(event).pipe(Effect.asVoid)
+*     : Effect.void
+* );
+* ```
+*/
+const DurableObjectAlarmEvent = Schema.TaggedUnion({ AlarmDue: {
+	id: Schema.NonEmptyString,
+	payload: Schema.Json,
+	scheduledAt: Schema.DateTimeUtc,
+	tag: Schema.NonEmptyString
+} });
+const AlarmRefSchema = Schema.Struct({
+	id: Schema.NonEmptyString,
+	tag: Schema.NonEmptyString
+});
+const decodeAlarmRef = (input) => Schema.decodeUnknownEffect(AlarmRefSchema)(input).pipe(Effect.mapError((cause) => new InvalidAlarmRefError({ cause })));
+const StoredPayloadString = Schema.fromJsonString(Schema.Json);
+const decodeStoredPayload = (row) => Schema.decodeUnknownEffect(StoredPayloadString)(row.payload).pipe(Effect.mapError((cause) => new StoredAlarmDecodeError({
+	cause,
+	storageId: row.storage_id
+})));
+const encodeStoredPayload = (payload) => Schema.encodeEffect(StoredPayloadString)(payload).pipe(Effect.mapError((cause) => new InvalidAlarmPayloadError({ cause })));
+const ensureTable = (state) => state.storage.sql.exec(INIT_TABLE_SQL).pipe(Effect.asVoid);
+const toRepeatEveryMillis = (input) => {
+	if (input === void 0) return Effect.succeed(null);
+	return Effect.try({
+		try: () => {
+			const millis = Duration.toMillis(Duration.fromInputUnsafe(input));
+			if (!Number.isFinite(millis) || millis <= 0) throw new Error("Alarm repeatEvery must be a positive finite duration");
+			return Math.ceil(millis);
+		},
+		catch: (cause) => new InvalidRepeatEveryError({ cause })
+	});
+};
+const toAlarmDue = (row) => Effect.gen(function* () {
+	if (!Number.isFinite(row.run_at)) return yield* Effect.fail(new StoredAlarmDecodeError({
+		cause: /* @__PURE__ */ new Error("Stored alarm run_at must be a finite number"),
+		storageId: row.storage_id
+	}));
+	return DurableObjectAlarmEvent.make({
+		_tag: "AlarmDue",
+		id: row.alarm_id,
+		payload: yield* decodeStoredPayload(row),
+		scheduledAt: DateTime.toUtc(DateTime.makeUnsafe(row.run_at)),
+		tag: row.tag
+	});
+});
+const getProcessLimit = (options) => {
+	const limit = options?.limit ?? DEFAULT_PROCESS_DUE_ALARMS_LIMIT;
+	if (!Number.isSafeInteger(limit) || limit <= 0) return Effect.fail(new InvalidProcessDueAlarmsOptionsError({ cause: /* @__PURE__ */ new Error("processDueAlarms limit must be a positive safe integer") }));
+	return Effect.succeed(limit);
+};
+const toFailureRescheduleMillis = (input) => Effect.try({
+	try: () => {
+		const millis = Duration.toMillis(Duration.fromInputUnsafe(input));
+		if (!Number.isFinite(millis) || millis <= 0) throw new Error("Alarm failure rescheduleAfter must be a positive finite duration");
+		return Math.ceil(millis);
+	},
+	catch: (cause) => new InvalidProcessDueAlarmsOptionsError({ cause })
+});
+const getFailureRetryDelay = (options) => toFailureRescheduleMillis(options?.retryFailedAfter ?? DEFAULT_PROCESS_DUE_ALARMS_FAILURE_RESCHEDULE_AFTER);
+const getFailureActionMode = (action) => typeof action === "string" ? action : action.mode;
+const getFailureActionRetryDelay = (action) => typeof action === "string" || action.mode !== "retry" ? void 0 : action.retryFailedAfter;
+const processDue = (handle, options = {}) => Effect.gen(function* () {
+	return yield* (yield* DurableObjectAlarm).processDueAlarms(handle, options);
+});
+const process = processDue;
+const isAlarmDefinitionConfig = (definition) => typeof definition === "object" && definition !== null && "payload" in definition;
+const getAlarmDefinitionSchema = (definition) => isAlarmDefinitionConfig(definition) ? definition.payload : definition;
+const getAlarmDefinitionFailureAction = (definition) => {
+	if (definition === void 0 || !isAlarmDefinitionConfig(definition)) return;
+	if (definition.failure === void 0) return;
+	return definition.failure === "retry" ? {
+		mode: "retry",
+		retryFailedAfter: definition.retry?.initialDelay
+	} : { mode: definition.failure };
+};
+const define = (definitions) => ({ handlers: (handlers, options) => processDue((event) => Effect.gen(function* () {
+	const definition = definitions[event.tag];
+	if (definition === void 0) return;
+	const schema = getAlarmDefinitionSchema(definition);
+	const payload = yield* Schema.decodeUnknownEffect(schema)(event.payload).pipe(Effect.mapError((cause) => new StoredAlarmDecodeError({
+		cause,
+		storageId: getScheduledEventId(event)
+	})));
+	const handler = handlers[event.tag];
+	yield* handler({
+		...event,
+		payload
+	});
+}), {
+	...options,
+	onFailure: (failure) => Effect.gen(function* () {
+		const action = getAlarmDefinitionFailureAction(definitions[failure.tag]);
+		const optionAction = options?.onFailure === void 0 ? void 0 : yield* options.onFailure(failure);
+		return action ?? optionAction;
+	})
+}) });
+/**
+* SQLite-backed Durable Object alarm scheduler.
+*
+* `DurableObjectAlarm` stores alarms in the current Durable Object's SQLite storage
+* and keeps the platform alarm set to the earliest pending scheduled alarm. The
+* platform alarm timestamp is only a wake-up hint; logical event identity comes
+* from persisted `{ tag, id }` rows.
+*
+* Retry safety depends on acknowledgement ordering. `processDueAlarms` runs the
+* caller's handler first and only then conditionally deletes or advances the
+* same selected row. By default, handler failures are isolated: the failed row
+* is retried after a delay, later due rows continue, and the platform alarm is
+* reconciled once at the end. Use `mode: "ordered"` for strict workflows where
+* one failed logical alarm should block later due alarms.
+*
+* Provide `DurableObjectAlarm.layer` anywhere `DurableObjectState` is available.
+*
+* @example Providing the service
+* ```ts
+* const program = Effect.gen(function* () {
+*   const durableObjectAlarm = yield* DurableObjectAlarm;
+*   const now = yield* DateTime.now;
+*
+*   yield* durableObjectAlarm.scheduleAlarm({
+*     tag: "heartbeat",
+*     id: "heartbeat-check",
+*     runAt: DateTime.add(now, { seconds: 5 }),
+*     repeatEvery: Duration.seconds(5),
+*     payload: null,
+*   });
+* }).pipe(Effect.provide(DurableObjectAlarm.layer));
+* ```
+*
+* @example Processing due alarms
+* ```ts
+* const handledEvents = yield* durableObjectAlarm.processDueAlarms((event) =>
+*   Effect.gen(function* () {
+*     if (event.tag === "heartbeat") {
+*       yield* heartbeatManager.handleAlarmEvent(event);
+*     }
+*   })
+* );
+* ```
+*/
+var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("effect-cf/DurableObjectAlarm") {
+	static layer = Layer.effect(DurableObjectAlarm, Effect.gen(function* () {
+		const state = yield* DurableObjectState;
+		const reconcileAlarm = Effect.fn("DurableObjectAlarm.reconcileAlarm")(function* () {
+			const next = (yield* (yield* state.storage.sql.exec(`SELECT run_at FROM effect_cf_scheduled_alarms ORDER BY run_at ASC, storage_id ASC LIMIT 1`)).toArray())[0];
+			if (next === void 0) {
+				yield* state.storage.deleteAlarm();
+				return;
+			}
+			yield* state.storage.setAlarm(next.run_at);
+		});
+		const rescheduleFailedAlarm = Effect.fn("DurableObjectAlarm.rescheduleFailedAlarm")(function* (row, retryDelayMillis) {
+			const retryAt = (yield* Clock.currentTimeMillis) + retryDelayMillis;
+			if (row.repeat_every_ms === null) {
+				yield* (yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms
+                  SET run_at = ?
+                WHERE storage_id = ?
+                  AND run_at = ?
+                  AND repeat_every_ms IS NULL
+                  AND payload = ?`, retryAt, row.storage_id, row.run_at, row.payload)).rowsWritten;
+				return;
+			}
+			yield* (yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms
+                SET run_at = ?
+              WHERE storage_id = ?
+                AND run_at = ?
+                AND repeat_every_ms = ?
+                AND payload = ?`, retryAt, row.storage_id, row.run_at, row.repeat_every_ms, row.payload)).rowsWritten;
+		});
+		const acknowledgeAlarm = Effect.fn("DurableObjectAlarm.acknowledgeAlarm")(function* (row) {
+			if (row.repeat_every_ms === null) {
+				yield* (yield* state.storage.sql.exec(`DELETE FROM effect_cf_scheduled_alarms
+              WHERE storage_id = ?
+                AND run_at = ?
+                AND repeat_every_ms IS NULL
+                AND payload = ?`, row.storage_id, row.run_at, row.payload)).rowsWritten;
+				return;
+			}
+			const acknowledgedAt = yield* Clock.currentTimeMillis;
+			yield* (yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms
+              SET run_at = ?
+            WHERE storage_id = ?
+              AND run_at = ?
+              AND repeat_every_ms = ?
+              AND payload = ?`, acknowledgedAt + row.repeat_every_ms, row.storage_id, row.run_at, row.repeat_every_ms, row.payload)).rowsWritten;
+		});
+		const cancelAlarm = Effect.fn("DurableObjectAlarm.cancelAlarm")(function* (input) {
+			const ref = yield* decodeAlarmRef(input);
+			yield* state.storage.transaction(() => Effect.gen(function* () {
+				yield* ensureTable(state);
+				yield* state.storage.sql.exec(`DELETE FROM effect_cf_scheduled_alarms WHERE storage_id = ?`, getScheduledEventId(ref)).pipe(Effect.asVoid);
+				yield* reconcileAlarm();
+			}));
+		});
+		const scheduleAlarm = Effect.fn("DurableObjectAlarm.scheduleAlarm")(function* (input) {
+			const ref = yield* decodeAlarmRef(input);
+			const repeatEveryMillis = yield* toRepeatEveryMillis(input.repeatEvery);
+			const payload = yield* encodeStoredPayload(input.payload);
+			const runAt = DateTime.toEpochMillis(input.runAt);
+			yield* state.storage.transaction(() => Effect.gen(function* () {
+				yield* ensureTable(state);
+				yield* state.storage.sql.exec(`INSERT OR REPLACE INTO effect_cf_scheduled_alarms
+                   (storage_id, alarm_id, tag, run_at, repeat_every_ms, payload)
+                 VALUES (?, ?, ?, ?, ?, ?)`, getScheduledEventId(ref), ref.id, ref.tag, runAt, repeatEveryMillis, payload).pipe(Effect.asVoid);
+				yield* reconcileAlarm();
+			}));
+		});
+		const processDueAlarms = Effect.fn("DurableObjectAlarm.processDueAlarms")(function* (handle, options) {
+			yield* ensureTable(state);
+			const mode = options?.mode ?? "isolated";
+			const limit = yield* getProcessLimit(options);
+			const now = yield* Clock.currentTimeMillis;
+			const dueRows = yield* (yield* state.storage.sql.exec(`SELECT storage_id, alarm_id, tag, run_at, repeat_every_ms, payload
+             FROM effect_cf_scheduled_alarms
+            WHERE run_at <= ?
+            ORDER BY run_at ASC, storage_id ASC
+            LIMIT ?`, now, limit)).toArray();
+			const handled = [];
+			const failed = [];
+			const handleFailure = function* (row, event, cause) {
+				const failure = {
+					cause,
+					event,
+					id: row.alarm_id,
+					storageId: row.storage_id,
+					tag: row.tag
+				};
+				failed.push(failure);
+				const failureAction = options?.onFailure === void 0 ? void 0 : yield* options.onFailure(failure);
+				const actionMode = failureAction === void 0 ? mode : getFailureActionMode(failureAction);
+				if (actionMode === "retry" || actionMode === "isolated") {
+					const actionRetryDelay = failureAction === void 0 ? void 0 : getFailureActionRetryDelay(failureAction);
+					yield* rescheduleFailedAlarm(row, actionRetryDelay === void 0 ? yield* getFailureRetryDelay(options) : yield* toFailureRescheduleMillis(actionRetryDelay));
+					return "continue";
+				}
+				if (actionMode === "skip-and-advance-repeat") {
+					yield* acknowledgeAlarm(row);
+					return "continue";
+				}
+				yield* reconcileAlarm();
+				return "stop";
+			};
+			for (const row of dueRows) {
+				const eventExit = yield* Effect.exit(toAlarmDue(row));
+				if (Exit.isFailure(eventExit)) {
+					if ((yield* handleFailure(row, void 0, eventExit.cause)) === "stop") return yield* Effect.failCause(eventExit.cause);
+					continue;
+				}
+				const event = eventExit.value;
+				const handleExit = yield* Effect.exit(handle(event));
+				if (Exit.isFailure(handleExit)) {
+					if ((yield* handleFailure(row, event, handleExit.cause)) === "stop") return yield* Effect.failCause(handleExit.cause);
+					continue;
+				}
+				yield* acknowledgeAlarm(row);
+				handled.push(event);
+			}
+			yield* reconcileAlarm();
+			return {
+				failed,
+				handled
+			};
+		});
+		return DurableObjectAlarm.of({
+			cancelAlarm,
+			processDueAlarms,
+			scheduleAlarm
+		});
+	}).pipe(Effect.withSpan("DurableObjectAlarm.layer")));
+};
 //#endregion
 //#region src/DurableObjectRpcWebSocket.ts
 var DurableObjectRpcWebSocket_exports = /* @__PURE__ */ __exportAll({
@@ -955,32 +1594,32 @@ const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 	let nextClientId = 0;
 	let writeRequest;
 	const reserveClientId = (socket) => {
-		const attachment = readAttachment(socket, attachmentKey);
+		const attachment = readAttachment(socket.raw, attachmentKey);
 		if (attachment !== void 0) {
 			nextClientId = Math.max(nextClientId, attachment + 1);
 			return attachment;
 		}
 		const id = nextClientId++;
-		writeAttachment(socket, attachmentKey, id);
+		writeAttachment(socket.raw, attachmentKey, id);
 		return id;
 	};
 	const register = (socket) => {
-		const existing = connectionsBySocket.get(socket);
+		const existing = connectionsBySocket.get(socket.raw);
 		if (existing !== void 0) return existing;
 		const connection = {
 			id: reserveClientId(socket),
 			socket,
 			parser: serialization.makeUnsafe()
 		};
-		connectionsBySocket.set(socket, connection);
+		connectionsBySocket.set(socket.raw, connection);
 		connectionsById.set(connection.id, connection);
 		clientIds.add(connection.id);
 		return connection;
 	};
 	const unregister = (socket) => Effect.sync(() => {
-		const connection = connectionsBySocket.get(socket);
+		const connection = connectionsBySocket.get(socket.raw);
 		if (connection === void 0) return;
-		connectionsBySocket.delete(socket);
+		connectionsBySocket.delete(socket.raw);
 		connectionsById.delete(connection.id);
 		clientIds.delete(connection.id);
 		Queue.offerUnsafe(disconnects, connection.id);
@@ -989,10 +1628,10 @@ const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 	const send = (connection, response) => Effect.sync(() => {
 		try {
 			const encoded = connection.parser.encode(response);
-			if (encoded !== void 0) connection.socket.send(encoded);
+			if (encoded !== void 0) connection.socket.raw.send(encoded);
 		} catch (cause) {
 			const encoded = connection.parser.encode(RpcMessage.ResponseDefectEncoded(cause));
-			if (encoded !== void 0) connection.socket.send(encoded);
+			if (encoded !== void 0) connection.socket.raw.send(encoded);
 		}
 	});
 	const protocol = yield* RpcServer.Protocol.make((writeRequest_) => {
@@ -1004,7 +1643,7 @@ const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 				return connection === void 0 ? Effect.void : send(connection, response);
 			},
 			end: (clientId) => Effect.sync(() => {
-				connectionsById.get(clientId)?.socket.close();
+				connectionsById.get(clientId)?.socket.raw.close();
 			}),
 			clientIds: Effect.sync(() => clientIds),
 			initialMessage: Effect.succeed(Option.none()),
@@ -1055,44 +1694,13 @@ const writeAttachment = (socket, 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
+	Service: () => Service$1,
+	make: () => make$3
 });
-const TypeId = "effect-cf/Kv";
+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);
@@ -1109,7 +1717,7 @@ const tryKvPromise = (binding, operation, evaluate) => Effect.tryPromise({
 /**
 * Creates a typed KV service tag plus Effect helpers.
 */
-const make = (id, definition) => Service()(id, definition);
+const make$3 = (id, definition) => Service$1()(id, definition);
 /**
 * Builds a KV service around a Cloudflare KV namespace binding.
 *
@@ -1130,8 +1738,8 @@ const make = (id, definition) => Service()(id, definition);
 * });
 * ```
 */
-const Service = () => (id, definition) => {
-	const tag = Service$3()(id, definition.binding, (value) => {
+const Service$1 = () => (id, definition) => {
+	const tag = Service$5()(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";
@@ -1196,7 +1804,7 @@ const Service = () => (id, definition) => {
 		return yield* tag;
 	});
 	return Object.assign(tag, {
-		[TypeId]: TypeId,
+		[TypeId$1]: TypeId$1,
 		definition,
 		put,
 		get,
@@ -1207,4 +1815,214 @@ const Service = () => (id, definition) => {
 	});
 };
 //#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 };
+//#region src/WorkflowBinding.ts
+var WorkflowBinding_exports = /* @__PURE__ */ __exportAll({
+	Service: () => Service,
+	WorkflowOperationError: () => WorkflowOperationError,
+	WorkflowResultDecodeError: () => WorkflowResultDecodeError,
+	make: () => make$2
+});
+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({
+	binding,
+	operation,
+	cause
+});
+const tryWorkflowPromise = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => workflowError(binding, operation, cause)
+});
+const isWorkflow = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	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$5()(id, definition.binding, (value) => isWorkflow(value));
+	const encodePayload = Schema.encodeEffect(definition.payload);
+	const decodeResult = Schema.decodeUnknownEffect(definition.result);
+	const wrapInstance = (raw) => {
+		const operation = (name, evaluate) => tryWorkflowPromise(definition.binding, name, evaluate);
+		return {
+			raw,
+			id: raw.id,
+			pause: operation("pause", () => raw.pause()),
+			resume: operation("resume", () => raw.resume()),
+			terminate: operation("terminate", () => raw.terminate()),
+			restart: (options) => operation("restart", () => raw.restart(options)),
+			status: operation("status", () => raw.status()).pipe(Effect.flatMap((status) => Effect.gen(function* () {
+				const output = status.output === void 0 ? Option.none() : Option.some(yield* decodeResult(status.output).pipe(Effect.mapError((cause) => new WorkflowResultDecodeError({
+					binding: definition.binding,
+					instanceId: raw.id,
+					cause
+				}))));
+				return {
+					status: status.status,
+					output,
+					error: status.error === void 0 ? Option.none() : Option.some(status.error)
+				};
+			}))),
+			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({
+				...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
+	});
+};
+//#endregion
+//#region src/WorkflowDefinition.ts
+var WorkflowDefinition_exports = /* @__PURE__ */ __exportAll({
+	Tag: () => Tag$1,
+	Workflow: () => Workflow,
+	implement: () => implement$1,
+	make: () => make$1
+});
+const makeDefinition = (id, definition) => {
+	const workflowDefinition = {
+		id,
+		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
+		})
+	});
+};
+const make$1 = makeDefinition;
+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 Workflow = Tag$1;
+const wrapHandler = (definition, handler) => {
+	const decodePayload = Schema.decodeUnknownEffect(definition.payload);
+	const encodeResult = Schema.encodeEffect(definition.result);
+	return (payload) => Effect.gen(function* () {
+		const decodedPayload = yield* decodePayload(payload);
+		const decodedEvent = {
+			...yield* WorkflowEvent$1,
+			payload: decodedPayload
+		};
+		return yield* encodeResult(yield* handler(decodedPayload).pipe(Effect.provideService(WorkflowEvent$1, decodedEvent)));
+	});
+};
+const implement$1 = (_definition, handler) => handler;
+//#endregion
+//#region src/Workflow.ts
+var Workflow_exports = /* @__PURE__ */ __exportAll({
+	Tag: () => Tag,
+	WorkflowEvent: () => WorkflowEvent$1,
+	WorkflowStep: () => WorkflowStep$1,
+	WorkflowStepContext: () => WorkflowStepContext$1,
+	implement: () => implement,
+	make: () => make,
+	sleep: () => sleep,
+	sleepUntil: () => sleepUntil,
+	step: () => step,
+	waitForEvent: () => waitForEvent
+});
+var WorkflowEvent$1 = class extends Context.Service()("effect-cf/WorkflowEvent") {};
+var WorkflowStep$1 = class extends Context.Service()("effect-cf/WorkflowStep") {};
+var WorkflowStepContext$1 = class extends Context.Service()("effect-cf/WorkflowStepContext") {};
+const fromWorkflowEvent = (event) => ({
+	raw: event,
+	payload: event.payload,
+	timestamp: event.timestamp,
+	instanceId: event.instanceId
+});
+const fromWorkflowStep = (step, runPromise) => ({
+	raw: step,
+	do: (name, effect, config) => Effect.context().pipe(Effect.flatMap((context) => Effect.tryPromise({
+		try: () => {
+			const run = (stepContext) => runPromise(Effect.scoped(Effect.provideService(Effect.provideContext(effect, context), WorkflowStepContext$1, stepContext)));
+			const rawStep = step;
+			return config === void 0 ? rawStep.do(name, run) : rawStep.do(name, config, run);
+		},
+		catch: (cause) => cause
+	}))),
+	sleep: (name, duration) => Effect.tryPromise({
+		try: () => step.sleep(name, duration),
+		catch: (cause) => cause
+	}),
+	sleepUntil: (name, timestamp) => Effect.tryPromise({
+		try: () => step.sleepUntil(name, timestamp),
+		catch: (cause) => cause
+	}),
+	waitForEvent: (name, options) => Effect.tryPromise({
+		try: () => step.waitForEvent(name, options),
+		catch: (cause) => cause
+	})
+});
+const make = (layer, options) => {
+	class EffectWorkflow extends WorkflowEntrypoint {
+		runtime;
+		constructor(ctx, env) {
+			super(ctx, env);
+			let runWaitUntilEffect = () => Promise.reject(/* @__PURE__ */ new Error("WorkerContext runtime is not initialized"));
+			const runtimeLayer = provideEntrypointServices(layer, Layer.mergeAll(Layer.succeed(ExecutionContext, ctx), ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env))), Layer.succeed(WorkerContext, fromExecutionContext(ctx, (effect) => runWaitUntilEffect(effect))), Layer.succeed(WorkerEnvironment, env)));
+			this.runtime = ManagedRuntime.make(runtimeLayer);
+			runWaitUntilEffect = (effect) => this.runtime.runPromiseExit(effect);
+		}
+		run(event, step) {
+			const workflowServices = Layer.mergeAll(Layer.succeed(WorkflowEvent$1, fromWorkflowEvent(event)), Layer.succeed(WorkflowStep$1, fromWorkflowStep(step, (effect) => this.runtime.runPromise(effect))));
+			return this.runtime.runPromise(Effect.scoped(options.run(event.payload).pipe(Effect.provide(workflowServices))));
+		}
+	}
+	return assumeEntrypointClass(EffectWorkflow);
+};
+const step = (name, effect, config) => Effect.flatMap(WorkflowStep$1.asEffect(), (workflowStep) => workflowStep.do(name, effect, config));
+const sleep = (name, duration) => Effect.flatMap(WorkflowStep$1.asEffect(), (workflowStep) => workflowStep.sleep(name, duration));
+const sleepUntil = (name, timestamp) => Effect.flatMap(WorkflowStep$1.asEffect(), (workflowStep) => workflowStep.sleepUntil(name, timestamp));
+const waitForEvent = (name, options) => Effect.flatMap(WorkflowStep$1.asEffect(), (workflowStep) => workflowStep.waitForEvent(name, options));
+const Tag = Tag$1;
+const implement = implement$1;
+//#endregion
+export { Binding_exports as Binding, DurableObject_exports as DurableObject, DurableObjectAlarm_exports as DurableObjectAlarm, DurableObjectDefinition_exports as DurableObjectDefinition, DurableObjectNamespace_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_exports as DurableObjectRpcWebSocket, DurableObjectState_exports as DurableObjectState, DurableObjectStorage_exports as DurableObjectStorage, DurableObjectWebSocket_exports as DurableObjectWebSocket, Kv_exports as Kv, Queue_exports as Queue, QueueBinding_exports as QueueBinding, QueueDefinition_exports as QueueDefinition, Rpc_exports as Rpc, RpcDefinition_exports as RpcDefinition, ServiceBinding_exports as ServiceBinding, Worker_exports as Worker, WorkerConfig, WorkerDefinition_exports as WorkerDefinition, WorkerEnvironment, Workflow_exports as Workflow, WorkflowBinding_exports as WorkflowBinding, WorkflowDefinition_exports as WorkflowDefinition };