effect-cf 0.40.0 → 0.40.2

package/dist/DurableObjectRpcWebSocket.mjs

@@ -0,0 +1,547 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { DurableWebSocketAttachmentError, fromWebSocket } from "./DurableObjectWebSocket.mjs";
+import { DurableObjectState } from "./DurableObjectState.mjs";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
+import * as Option from "effect/Option";
+import * as Queue from "effect/Queue";
+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/DurableObjectRpcWebSocket.ts
+var DurableObjectRpcWebSocket_exports = /* @__PURE__ */ __exportAll({
+	DurableObjectRpcWebSocket: () => DurableObjectRpcWebSocket,
+	layer: () => layer,
+	resumableStream: () => resumableStream
+});
+const defaultAttachmentKey = "effectCloudflareRpcClientId";
+const defaultTag = "effect-cf-rpc";
+const legacyAttachmentVersion = 1;
+const resumableAttachmentVersion = 2;
+const serviceRestartCode = 1012;
+const serviceRestartReason = "Durable Object RPC activation reset";
+/** Declares an explicitly resumable RPC stream. */
+const resumableStream = (declaration) => declaration;
+const PersistedPendingBatchSchema = Schema.Struct({ checkpointTokens: Schema.Array(Schema.String) });
+const PersistedSubscriptionSchema = Schema.Struct({
+	definitionId: Schema.String,
+	subscriptionKey: Schema.String,
+	requestId: Schema.Union([Schema.String, Schema.Finite]),
+	rpcTag: Schema.String,
+	resumeDescriptor: Schema.Unknown,
+	acknowledgedCheckpoint: Schema.Unknown,
+	pending: Schema.optionalKey(PersistedPendingBatchSchema)
+});
+const ResumableAttachmentMetadataSchema = Schema.Struct({
+	version: Schema.Literal(resumableAttachmentVersion),
+	clientId: Schema.Finite,
+	hasPendingRequests: Schema.Boolean,
+	hasNonResumableRequests: Schema.Boolean,
+	subscriptions: Schema.Array(PersistedSubscriptionSchema)
+});
+const decodeResumableAttachment = Schema.decodeUnknownOption(ResumableAttachmentMetadataSchema);
+var DurableObjectRpcWebSocket = class extends Context.Service()("effect-cf/DurableObjectRpcWebSocket") {};
+/**
+* Builds a hibernation-aware transport that bridges Durable Object websocket
+* events to `RpcServer.Protocol`.
+*
+* The layer restores idle tagged sockets and explicitly declared resumable
+* streams after constructor recreation. A socket that lost any other in-flight
+* request is closed with code 1012, which the stock Effect socket protocol
+* reports as an `RpcClientError` containing `SocketCloseError`.
+*/
+const layer = (options = {}) => Layer.effectContext(Effect.gen(function* () {
+	const tag = options.tag ?? defaultTag;
+	const attachmentKey = options.attachmentKey ?? defaultAttachmentKey;
+	const heartbeatPolicy = options.heartbeat ?? "auto-response";
+	const declarations = options.resumableStreams ?? [];
+	const durableObjectState = yield* DurableObjectState;
+	const serialization = yield* RpcSerialization.RpcSerialization;
+	const encodeDefect = Schema.encodeSync(serialization.codecFor(Schema.Defect()));
+	const disconnects = yield* Queue.make();
+	const connectionsBySocket = /* @__PURE__ */ new Map();
+	const connectionsById = /* @__PURE__ */ new Map();
+	const resetSockets = /* @__PURE__ */ new WeakSet();
+	const declarationsById = /* @__PURE__ */ new Map();
+	const declarationsByTag = /* @__PURE__ */ new Map();
+	const replayRequests = [];
+	let nextClientId = 0;
+	let activeNonResumableRequestCount = 0;
+	let writeRequest;
+	for (const declaration of declarations) {
+		if (declaration.id.length === 0 || declaration.rpcTag.length === 0) return yield* Effect.die(/* @__PURE__ */ new Error("Resumable RPC stream declaration ids and tags must be non-empty"));
+		if (declarationsById.has(declaration.id)) return yield* Effect.die(/* @__PURE__ */ new Error(`Duplicate resumable RPC stream declaration id: ${declaration.id}`));
+		if (declarationsByTag.has(declaration.rpcTag)) return yield* Effect.die(/* @__PURE__ */ new Error(`Duplicate resumable RPC stream tag: ${declaration.rpcTag}`));
+		declarationsById.set(declaration.id, declaration);
+		declarationsByTag.set(declaration.rpcTag, declaration);
+	}
+	const reserveClientId = (socket) => {
+		const id = nextClientId++;
+		const created = {
+			version: legacyAttachmentVersion,
+			clientId: id,
+			hasPendingRequests: false
+		};
+		writeAttachment(socket.raw, attachmentKey, created);
+		return created;
+	};
+	const addSubscription = (connection, subscription) => {
+		if (connection.subscriptionsByRequestId.has(subscription.requestId)) return false;
+		let byKey = connection.subscriptionsByDefinition.get(subscription.definitionId);
+		if (byKey?.has(subscription.subscriptionKey) === true) return false;
+		if (byKey === void 0) {
+			byKey = /* @__PURE__ */ new Map();
+			connection.subscriptionsByDefinition.set(subscription.definitionId, byKey);
+		}
+		byKey.set(subscription.subscriptionKey, subscription);
+		connection.subscriptionsByRequestId.set(subscription.requestId, subscription);
+		connection.requestIds.add(subscription.requestId);
+		connection.metadataVersion = resumableAttachmentVersion;
+		return true;
+	};
+	const removeSubscription = (connection, requestId) => {
+		const subscription = connection.subscriptionsByRequestId.get(requestId);
+		if (subscription === void 0) return;
+		connection.subscriptionsByRequestId.delete(requestId);
+		const byKey = connection.subscriptionsByDefinition.get(subscription.definitionId);
+		byKey?.delete(subscription.subscriptionKey);
+		if (byKey?.size === 0) connection.subscriptionsByDefinition.delete(subscription.definitionId);
+		return subscription;
+	};
+	const register = (socket, restoredMetadata, restoredSubscriptions = []) => {
+		const existing = connectionsBySocket.get(socket.raw);
+		if (existing !== void 0) return existing;
+		const metadata = restoredMetadata ?? reserveClientId(socket);
+		const connection = {
+			id: metadata.clientId,
+			socket,
+			parser: serialization.makeUnsafe(),
+			requestIds: /* @__PURE__ */ new Set(),
+			nonResumableRequestIds: /* @__PURE__ */ new Set(),
+			subscriptionsByRequestId: /* @__PURE__ */ new Map(),
+			subscriptionsByDefinition: /* @__PURE__ */ new Map(),
+			suppressedAckRequestIds: /* @__PURE__ */ new Set(),
+			currentPendingRequestIds: /* @__PURE__ */ new Set(),
+			metadataVersion: metadata.version
+		};
+		if (connectionsById.has(connection.id)) throw new Error(`Duplicate Durable Object RPC websocket client id: ${connection.id}`);
+		for (const subscription of restoredSubscriptions) if (!addSubscription(connection, subscription)) throw new Error("Duplicate restored resumable RPC stream subscription identity");
+		connectionsBySocket.set(socket.raw, connection);
+		connectionsById.set(connection.id, connection);
+		nextClientId = Math.max(nextClientId, connection.id + 1);
+		return connection;
+	};
+	const heartbeat = yield* makeHeartbeatController(durableObjectState, serialization, heartbeatPolicy);
+	const syncHeartbeat = () => heartbeat.setEnabled(connectionsBySocket.size > 0 && activeNonResumableRequestCount === 0);
+	const persistConnection = Effect.fn("DurableObjectRpcWebSocket.persistConnection")(function* (connection) {
+		return yield* Effect.try({
+			try: () => {
+				if (connection.metadataVersion === legacyAttachmentVersion) {
+					writeAttachment(connection.socket.raw, attachmentKey, {
+						version: legacyAttachmentVersion,
+						clientId: connection.id,
+						hasPendingRequests: connection.requestIds.size > 0
+					});
+					return;
+				}
+				const subscriptions = Array.from(connection.subscriptionsByRequestId.values()).map(({ declaration: _, ...subscription }) => subscription);
+				writeAttachment(connection.socket.raw, attachmentKey, {
+					version: resumableAttachmentVersion,
+					clientId: connection.id,
+					hasPendingRequests: connection.requestIds.size > 0,
+					hasNonResumableRequests: connection.nonResumableRequestIds.size > 0,
+					subscriptions
+				});
+			},
+			catch: (cause) => new DurableWebSocketAttachmentError({
+				operation: "serialize",
+				cause
+			})
+		});
+	});
+	const unregister = Effect.fn("DurableObjectRpcWebSocket.unregister")(function* (socket) {
+		const connection = connectionsBySocket.get(socket.raw);
+		if (connection === void 0) return;
+		connectionsBySocket.delete(socket.raw);
+		connectionsById.delete(connection.id);
+		activeNonResumableRequestCount -= connection.nonResumableRequestIds.size;
+		connection.requestIds.clear();
+		connection.nonResumableRequestIds.clear();
+		connection.subscriptionsByRequestId.clear();
+		connection.subscriptionsByDefinition.clear();
+		connection.suppressedAckRequestIds.clear();
+		connection.currentPendingRequestIds.clear();
+		Queue.offerUnsafe(disconnects, connection.id);
+		yield* syncHeartbeat();
+	});
+	const resetSocket = Effect.fn("DurableObjectRpcWebSocket.resetSocket")(function* (socket, cause) {
+		resetSockets.add(socket.raw);
+		yield* unregister(socket).pipe(Effect.catchCause((unregisterCause) => Effect.logDebug("Failed to unregister Durable Object RPC websocket", unregisterCause)));
+		if (cause !== void 0) yield* Effect.logDebug("Resetting Durable Object RPC websocket", cause);
+		yield* socket.close(serviceRestartCode, serviceRestartReason).pipe(Effect.catch((closeError) => Effect.logDebug("Failed to close Durable Object RPC websocket", closeError)));
+	});
+	const persistOrReset = Effect.fn("DurableObjectRpcWebSocket.persistOrReset")(function* (connection) {
+		return yield* persistConnection(connection).pipe(Effect.as(true), Effect.catch((cause) => resetSocket(connection.socket, cause).pipe(Effect.as(false))));
+	});
+	const trackRequest = Effect.fn("DurableObjectRpcWebSocket.trackRequest")(function* (connection, request) {
+		if (connection.requestIds.has(request.id)) return true;
+		const declaration = declarationsByTag.get(request.tag);
+		const identified = declaration === void 0 ? Option.none() : yield* Effect.sync(() => declaration.identify(request));
+		if (declaration !== void 0 && Option.isSome(identified)) {
+			if (!addSubscription(connection, {
+				declaration,
+				definitionId: declaration.id,
+				subscriptionKey: identified.value.subscriptionKey,
+				requestId: request.id,
+				rpcTag: declaration.rpcTag,
+				resumeDescriptor: identified.value.resumeDescriptor,
+				acknowledgedCheckpoint: identified.value.acknowledgedCheckpoint
+			})) {
+				yield* resetSocket(connection.socket, /* @__PURE__ */ new Error(`Duplicate resumable RPC stream subscription: ${declaration.id}`));
+				return false;
+			}
+		} else {
+			connection.requestIds.add(request.id);
+			connection.nonResumableRequestIds.add(request.id);
+			activeNonResumableRequestCount++;
+		}
+		if (!(yield* persistOrReset(connection))) return false;
+		yield* syncHeartbeat();
+		return true;
+	});
+	const completeRequest = Effect.fn("DurableObjectRpcWebSocket.completeRequest")(function* (connection, requestId, preserveAckFilter = false) {
+		if (connection.requestIds.delete(requestId)) {
+			if (connection.nonResumableRequestIds.delete(requestId)) activeNonResumableRequestCount--;
+			const subscription = removeSubscription(connection, requestId);
+			connection.currentPendingRequestIds.delete(requestId);
+			if (preserveAckFilter && subscription !== void 0) connection.suppressedAckRequestIds.add(requestId);
+			if (!(yield* persistOrReset(connection))) return;
+		}
+		if (!preserveAckFilter) connection.suppressedAckRequestIds.delete(requestId);
+		yield* syncHeartbeat();
+	});
+	const completeAllRequests = Effect.fn("DurableObjectRpcWebSocket.completeAllRequests")(function* (connection) {
+		const hadRequests = connection.requestIds.size > 0;
+		if (connection.requestIds.size > 0) activeNonResumableRequestCount -= connection.nonResumableRequestIds.size;
+		connection.requestIds.clear();
+		connection.nonResumableRequestIds.clear();
+		connection.subscriptionsByRequestId.clear();
+		connection.subscriptionsByDefinition.clear();
+		connection.suppressedAckRequestIds.clear();
+		connection.currentPendingRequestIds.clear();
+		if (hadRequests && !(yield* persistOrReset(connection))) return;
+		yield* syncHeartbeat();
+	});
+	const restoredAttachments = (yield* durableObjectState.getWebSockets(tag)).map((socket) => ({
+		socket,
+		attachment: readAttachment(socket.raw, attachmentKey)
+	}));
+	for (const { attachment, socket } of restoredAttachments) {
+		if (attachment._tag === "Invalid") {
+			yield* resetSocket(socket);
+			continue;
+		}
+		if (attachment._tag === "Missing") {
+			yield* resetSocket(socket);
+			continue;
+		}
+		const metadata = attachment.metadata;
+		if (metadata.version === legacyAttachmentVersion) {
+			if (metadata.hasPendingRequests) yield* resetSocket(socket);
+			else if (connectionsById.has(metadata.clientId)) yield* resetSocket(socket);
+			else yield* persistOrReset(register(socket, metadata));
+			continue;
+		}
+		const prepared = yield* Effect.sync(() => {
+			try {
+				if (metadata.hasNonResumableRequests || metadata.hasPendingRequests !== (metadata.hasNonResumableRequests || metadata.subscriptions.length > 0)) throw new Error("Dirty resumable RPC websocket attachment metadata");
+				const requestIds = /* @__PURE__ */ new Set();
+				const subscriptionKeys = /* @__PURE__ */ new Map();
+				const subscriptions = [];
+				const requests = [];
+				for (const persisted of metadata.subscriptions) {
+					const declaration = declarationsById.get(persisted.definitionId);
+					if (declaration === void 0 || declaration.rpcTag !== persisted.rpcTag) throw new Error("Missing resumable RPC stream declaration");
+					let keys = subscriptionKeys.get(persisted.definitionId);
+					if (keys === void 0) {
+						keys = /* @__PURE__ */ new Set();
+						subscriptionKeys.set(persisted.definitionId, keys);
+					}
+					if (requestIds.has(persisted.requestId) || keys.has(persisted.subscriptionKey)) throw new Error("Duplicate persisted resumable RPC stream subscription");
+					requestIds.add(persisted.requestId);
+					keys.add(persisted.subscriptionKey);
+					if (persisted.pending !== void 0) {
+						const { checkpointTokens } = persisted.pending;
+						if (checkpointTokens.length === 0 || checkpointTokens.some((token) => token.length === 0) || new Set(checkpointTokens).size !== checkpointTokens.length) throw new Error("Invalid persisted resumable RPC stream pending batch");
+					}
+					const resumeDescriptor = Schema.decodeUnknownOption(declaration.resumeDescriptorSchema)(persisted.resumeDescriptor);
+					const acknowledgedCheckpoint = Schema.decodeUnknownOption(declaration.checkpointSchema)(persisted.acknowledgedCheckpoint);
+					if (Option.isNone(resumeDescriptor) || Option.isNone(acknowledgedCheckpoint)) throw new Error("Invalid persisted resumable RPC stream state");
+					const rebuilt = declaration.rebuild({
+						subscriptionKey: persisted.subscriptionKey,
+						resumeDescriptor: resumeDescriptor.value,
+						acknowledgedCheckpoint: acknowledgedCheckpoint.value
+					});
+					const request = {
+						_tag: "Request",
+						id: persisted.requestId,
+						tag: declaration.rpcTag,
+						payload: rebuilt.payload,
+						headers: rebuilt.headers?.map(([name, value]) => [name, value]) ?? []
+					};
+					if (rebuilt.traceId !== void 0) Object.assign(request, { traceId: rebuilt.traceId });
+					if (rebuilt.spanId !== void 0) Object.assign(request, { spanId: rebuilt.spanId });
+					if (rebuilt.sampled !== void 0) Object.assign(request, { sampled: rebuilt.sampled });
+					subscriptions.push({
+						...persisted,
+						resumeDescriptor: resumeDescriptor.value,
+						acknowledgedCheckpoint: acknowledgedCheckpoint.value,
+						declaration
+					});
+					requests.push(request);
+				}
+				return {
+					_tag: "Success",
+					requests,
+					subscriptions
+				};
+			} catch (cause) {
+				return {
+					_tag: "Failure",
+					cause
+				};
+			}
+		});
+		if (prepared._tag === "Failure") {
+			yield* Effect.logDebug("Invalid resumable RPC websocket attachment", prepared.cause);
+			yield* resetSocket(socket);
+			continue;
+		}
+		if (connectionsById.has(metadata.clientId)) {
+			yield* resetSocket(socket);
+			continue;
+		}
+		const connection = register(socket, metadata, prepared.subscriptions);
+		for (const request of prepared.requests) replayRequests.push({
+			clientId: connection.id,
+			request
+		});
+	}
+	yield* syncHeartbeat();
+	const send = (connection, response) => Effect.gen(function* () {
+		let delivered = response;
+		if (response._tag === "Chunk") {
+			const subscription = connection.subscriptionsByRequestId.get(response.requestId);
+			if (subscription !== void 0) {
+				subscription.pending = { checkpointTokens: yield* Effect.sync(() => {
+					const tokens = [];
+					for (const value of response.values) {
+						const checkpoint = subscription.declaration.checkpointFromValue(value);
+						if (Option.isNone(checkpoint)) throw new Error(`Resumable RPC stream ${subscription.definitionId} did not identify a checkpoint`);
+						const token = subscription.declaration.checkpointToken(checkpoint.value);
+						if (token.length === 0 || tokens.includes(token)) throw new Error(`Resumable RPC stream ${subscription.definitionId} produced invalid checkpoint tokens`);
+						tokens.push(token);
+					}
+					if (tokens.length === 0) throw new Error("Resumable RPC stream chunks must contain checkpointed values");
+					return tokens;
+				}) };
+				connection.currentPendingRequestIds.add(subscription.requestId);
+				if (!(yield* persistOrReset(connection))) return;
+			}
+		}
+		if (!(yield* Effect.sync(() => {
+			try {
+				const encoded = connection.parser.encode(response);
+				if (encoded === void 0) return false;
+				connection.socket.raw.send(encoded);
+				return true;
+			} catch (cause) {
+				delivered = RpcMessage.ResponseDefectEncoded(encodeDefect(cause));
+				const encoded = connection.parser.encode(delivered);
+				if (encoded === void 0) return false;
+				connection.socket.raw.send(encoded);
+				return true;
+			}
+		}).pipe(Effect.catchCause((cause) => Effect.logDebug("Durable Object RPC websocket send failed", cause).pipe(Effect.as(false)))))) {
+			resetSockets.add(connection.socket.raw);
+			yield* connection.socket.close(serviceRestartCode, serviceRestartReason).pipe(Effect.ignore);
+			yield* unregister(connection.socket);
+			return;
+		}
+		if (delivered._tag === "Exit") yield* completeRequest(connection, delivered.requestId);
+		else if (delivered._tag === "Defect" || delivered._tag === "ClientProtocolError") yield* completeAllRequests(connection);
+	});
+	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.raw.close();
+			}),
+			clientIds: Effect.sync(() => new Set(connectionsById.keys())),
+			initialMessage: Effect.succeedNone,
+			supportsAck: true,
+			supportsTransferables: false,
+			supportsSpanPropagation: true,
+			supportsNotifications: true,
+			codecFor: serialization.codecFor
+		});
+	});
+	const replay = writeRequest;
+	if (replay === void 0) return yield* Effect.die(/* @__PURE__ */ new Error("RPC server protocol did not install its request writer"));
+	for (const restoredRequest of replayRequests) yield* replay(restoredRequest.clientId, restoredRequest.request);
+	const checkpoint = Effect.fn("DurableObjectRpcWebSocket.checkpoint")(function* (declaration, checkpointOptions) {
+		const connection = connectionsById.get(checkpointOptions.clientId);
+		const configured = declarationsById.get(declaration.id);
+		const subscription = connection?.subscriptionsByDefinition.get(declaration.id)?.get(checkpointOptions.subscriptionKey);
+		if (connection === void 0 || configured === void 0 || configured.rpcTag !== declaration.rpcTag || subscription === void 0 || subscription.pending === void 0) return false;
+		const token = configured.checkpointToken(checkpointOptions.checkpoint);
+		const checkpointIndex = subscription.pending.checkpointTokens.indexOf(token);
+		if (token.length === 0 || checkpointIndex < 0) return false;
+		const pending = subscription.pending;
+		const isFinal = checkpointIndex === pending.checkpointTokens.length - 1;
+		const shouldAck = isFinal && connection.currentPendingRequestIds.has(subscription.requestId);
+		return yield* Effect.uninterruptible(Effect.gen(function* () {
+			subscription.acknowledgedCheckpoint = checkpointOptions.checkpoint;
+			if (isFinal) {
+				connection.currentPendingRequestIds.delete(subscription.requestId);
+				delete subscription.pending;
+			} else subscription.pending = { checkpointTokens: pending.checkpointTokens.slice(checkpointIndex + 1) };
+			yield* persistConnection(connection).pipe(Effect.catch((cause) => Effect.gen(function* () {
+				yield* resetSocket(connection.socket, cause);
+				return yield* cause;
+			})));
+			if (shouldAck) {
+				const run = writeRequest;
+				if (run === void 0) return yield* Effect.die(/* @__PURE__ */ new Error("RPC server is not ready to accept a checkpoint Ack"));
+				yield* run(connection.id, {
+					_tag: "Ack",
+					requestId: subscription.requestId
+				});
+			}
+			return true;
+		}));
+	});
+	const service = DurableObjectRpcWebSocket.of({
+		accept: (socket, tags = []) => Effect.gen(function* () {
+			register(socket);
+			yield* durableObjectState.acceptWebSocket(socket, Array.from(/* @__PURE__ */ new Set([tag, ...tags])));
+			yield* syncHeartbeat();
+		}),
+		acceptUpgrade: (upgradeOptions = {}) => Effect.gen(function* () {
+			const pair = new WebSocketPair();
+			const client = pair[0];
+			const server = fromWebSocket(pair[1]);
+			if (upgradeOptions.attachment !== void 0) yield* server.serializeAttachment(upgradeOptions.attachment);
+			yield* service.accept(server, upgradeOptions.tags);
+			return {
+				client,
+				server,
+				response: new Response(null, {
+					status: 101,
+					webSocket: client
+				})
+			};
+		}),
+		message: (socket, message) => Effect.gen(function* () {
+			if (resetSockets.has(socket.raw)) return;
+			const connection = register(socket);
+			const decoded = yield* Effect.try({
+				try: () => connection.parser.decode(normalizeMessage(message)),
+				catch: (cause) => cause
+			});
+			const run = writeRequest;
+			if (run === void 0) {
+				yield* send(connection, RpcMessage.ResponseDefectEncoded(encodeDefect("RPC server is not ready")));
+				return;
+			}
+			for (const current of decoded) {
+				const request = current;
+				if (request._tag === "Request" && request.isNotification !== true) {
+					if (!(yield* trackRequest(connection, request))) return;
+				}
+				if (request._tag === "Ack" && (connection.subscriptionsByRequestId.has(request.requestId) || connection.suppressedAckRequestIds.has(request.requestId))) continue;
+				if (request._tag === "Interrupt" && connection.subscriptionsByRequestId.has(request.requestId)) yield* completeRequest(connection, request.requestId, true);
+				yield* run(connection.id, request);
+				if (request._tag === "Interrupt" && !connection.suppressedAckRequestIds.has(request.requestId)) yield* completeRequest(connection, request.requestId);
+			}
+		}).pipe(Effect.catch((cause) => {
+			const connection = register(socket);
+			return Predicate.isTagged(cause, "MaxBufferSizeExceeded") ? Effect.ignore(connection.socket.close(1009, String(cause))) : send(connection, RpcMessage.ResponseDefectEncoded(encodeDefect(cause)));
+		})),
+		close: unregister,
+		error: resetSocket,
+		checkpoint
+	});
+	return Context.mergeAll(Context.make(RpcServer.Protocol, protocol), Context.make(DurableObjectRpcWebSocket, service));
+}));
+const normalizeMessage = (message) => Predicate.isString(message) ? message : new Uint8Array(message);
+const readAttachment = (socket, key) => {
+	const value = socket.deserializeAttachment();
+	if (value === null || value === void 0) return { _tag: "Missing" };
+	if (!Predicate.isObject(value)) return { _tag: "Invalid" };
+	if (!Predicate.hasProperty(value, key)) return { _tag: "Missing" };
+	const metadata = value[key];
+	if (Predicate.isNumber(metadata) && isClientId(metadata)) return {
+		_tag: "Valid",
+		metadata: {
+			version: legacyAttachmentVersion,
+			clientId: metadata,
+			hasPendingRequests: false
+		}
+	};
+	if (!Predicate.isObject(metadata)) return { _tag: "Invalid" };
+	if (Predicate.hasProperty(metadata, "version") && metadata.version === resumableAttachmentVersion) {
+		const decoded = decodeResumableAttachment(metadata);
+		return Option.isSome(decoded) && isClientId(decoded.value.clientId) ? {
+			_tag: "Valid",
+			metadata: decoded.value
+		} : { _tag: "Invalid" };
+	}
+	const hasPendingRequests = Predicate.hasProperty(metadata, "hasPendingRequests") ? metadata.hasPendingRequests : false;
+	if ((!Predicate.hasProperty(metadata, "version") || metadata.version === legacyAttachmentVersion) && Predicate.hasProperty(metadata, "clientId") && Predicate.isNumber(metadata.clientId) && isClientId(metadata.clientId) && Predicate.isBoolean(hasPendingRequests)) return {
+		_tag: "Valid",
+		metadata: {
+			version: legacyAttachmentVersion,
+			clientId: metadata.clientId,
+			hasPendingRequests
+		}
+	};
+	return { _tag: "Invalid" };
+};
+const isClientId = (value) => Number.isSafeInteger(value) && value >= 0;
+const writeAttachment = (socket, key, metadata) => {
+	const current = socket.deserializeAttachment();
+	if (current !== null && current !== void 0 && !Predicate.isObject(current)) throw new Error("DurableObjectRpcWebSocket requires object-shaped websocket attachments so adapter metadata can preserve application fields");
+	const attachment = Predicate.isObject(current) ? current : {};
+	socket.serializeAttachment({
+		...attachment,
+		[key]: metadata
+	});
+};
+const makeHeartbeatController = (state, serialization, policy) => Effect.gen(function* () {
+	if (policy === "passthrough") return { setEnabled: () => Effect.void };
+	const parser = serialization.makeUnsafe();
+	const request = parser.encode(RpcMessage.constPing);
+	const response = parser.encode(RpcMessage.constPong);
+	if (!Predicate.isString(request) || !Predicate.isString(response)) return yield* Effect.die(/* @__PURE__ */ new Error("DurableObjectRpcWebSocket heartbeat auto-response requires a text RPC serialization; use heartbeat: \"passthrough\" to manage heartbeats externally"));
+	const configured = yield* state.getWebSocketAutoResponse;
+	if (configured !== null && (configured.request !== request || configured.response !== response)) return yield* Effect.die(/* @__PURE__ */ new Error("DurableObjectRpcWebSocket cannot replace the application WebSocket auto-response; use heartbeat: \"passthrough\" to preserve it"));
+	const pair = new WebSocketRequestResponsePair(request, response);
+	let enabled = configured !== null;
+	return { setEnabled: (nextEnabled) => {
+		if (enabled === nextEnabled) return Effect.void;
+		return state.setWebSocketAutoResponse(nextEnabled ? pair : void 0).pipe(Effect.tap(() => Effect.sync(() => {
+			enabled = nextEnabled;
+		})));
+	} };
+});
+//#endregion
+export { DurableObjectRpcWebSocket, DurableObjectRpcWebSocket_exports, layer, resumableStream };

package/dist/DurableObjectSqlite.d.mts

@@ -0,0 +1,11 @@
+import { DurableObjectState } from "./DurableObjectState.mjs";
+import * as Layer from "effect/Layer";
+import { SqliteClient } from "@effect/sql-sqlite-do";
+import { SqlClient } from "effect/unstable/sql";
+declare namespace DurableObjectSqlite_d_exports {
+  export { SqliteLayerOptions, layer };
+}
+type SqliteLayerOptions = Omit<SqliteClient.SqliteClientConfig, "db" | "storage">;
+declare const layer: (options?: SqliteLayerOptions) => Layer.Layer<SqliteClient.SqliteClient | SqlClient.SqlClient, never, DurableObjectState>;
+//#endregion
+export { DurableObjectSqlite_d_exports, SqliteLayerOptions, layer };

package/dist/DurableObjectSqlite.mjs

@@ -0,0 +1,16 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { DurableObjectState } from "./DurableObjectState.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { SqliteClient } from "@effect/sql-sqlite-do";
+//#region src/DurableObjectSqlite.ts
+var DurableObjectSqlite_exports = /* @__PURE__ */ __exportAll({ layer: () => layer });
+const layer = (options) => Layer.unwrap(Effect.gen(function* () {
+	const state = yield* DurableObjectState;
+	return SqliteClient.layer({
+		...options,
+		storage: state.raw.storage
+	});
+}));
+//#endregion
+export { DurableObjectSqlite_exports, layer };

package/dist/DurableObjectState.d.mts

@@ -0,0 +1,65 @@
+import { DurableObjectStorage } from "./DurableObjectStorage.mjs";
+import { DurableWebSocket } from "./DurableObjectWebSocket.mjs";
+import { WorkerContextWaitUntilOptions } from "./Worker.mjs";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+declare namespace DurableObjectState_d_exports {
+  export { DurableObjectState, DurableObjectStateService, fromDurableObjectState };
+}
+/**
+ * Effect-friendly wrapper around Cloudflare `DurableObjectState`.
+ */
+interface DurableObjectStateService {
+  readonly raw: globalThis.DurableObjectState;
+  readonly id: globalThis.DurableObjectId;
+  readonly storage: DurableObjectStorage;
+  waitUntil(promise: Promise<unknown>): Effect.Effect<void>;
+  /**
+   * Runs a background Effect via Cloudflare's `waitUntil` with the caller's
+   * Effect context, mirroring `WorkerContext.waitUntil` failure modes:
+   * `"observe"` (default) logs or routes failures to `onFailure`, while
+   * `"propagate"` also rejects the native `waitUntil` promise.
+   */
+  waitUntil<A, E, R, R2 = never>(effect: Effect.Effect<A, E, R>, options?: WorkerContextWaitUntilOptions<E, R2>): Effect.Effect<void, never, R | R2>;
+  /**
+   * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate.
+   *
+   * Cloudflare resets a Durable Object if the callback throws/rejects, or if the
+   * callback exceeds the platform timeout (currently documented as 30 seconds).
+   * This safe default resolves the callback with the Effect `Exit` for typed
+   * Effect failures and resumes that `Exit` afterward, so typed failures remain
+   * ordinary Effect failures instead of resetting the Durable Object. Defects
+   * and interruptions still reject the callback.
+   */
+  blockConcurrencyWhile<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
+  /**
+   * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate and lets
+   * Effect failures reject the callback.
+   *
+   * Use this only when Cloudflare's reset-on-throw behavior is intentional. The
+   * platform also resets the Durable Object if the callback exceeds the
+   * documented timeout (currently 30 seconds).
+   */
+  blockConcurrencyWhileOrReset<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
+  acceptWebSocket(ws: DurableWebSocket, tags?: Array<string>): Effect.Effect<void>;
+  getWebSockets(tag?: string): Effect.Effect<Array<DurableWebSocket>>;
+  setWebSocketAutoResponse(pair?: WebSocketRequestResponsePair): Effect.Effect<void>;
+  getWebSocketAutoResponse: Effect.Effect<WebSocketRequestResponsePair | null>;
+  getWebSocketAutoResponseTimestamp(ws: DurableWebSocket): Effect.Effect<Date | null>;
+  setHibernatableWebSocketEventTimeout(timeoutMs?: number): Effect.Effect<void>;
+  getHibernatableWebSocketEventTimeout: Effect.Effect<number | null>;
+  getTags(ws: DurableWebSocket): Effect.Effect<Array<string>>;
+  /**
+   * Forcibly resets the Durable Object. Cloudflare logs an uncaught Error using
+   * the optional reason, and the method is not available in `wrangler dev` local
+   * development according to the Durable Object State docs. Set
+   * `retryAlarm: false` to prevent the current alarm invocation from retrying;
+   * this option has no effect outside an alarm handler.
+   */
+  abort(reason?: string, options?: globalThis.DurableObjectAbortOptions): Effect.Effect<void>;
+}
+declare const DurableObjectState_base: Context.ServiceClass<DurableObjectState, "effect-cf/DurableObjectState", DurableObjectStateService>;
+declare class DurableObjectState extends DurableObjectState_base {}
+declare const fromDurableObjectState: (state: globalThis.DurableObjectState) => DurableObjectStateService;
+//#endregion
+export { DurableObjectState, DurableObjectStateService, DurableObjectState_d_exports, fromDurableObjectState };