effect-cf 0.31.0 → 0.32.1

package/dist/index.mjs

@@ -2,7 +2,7 @@ import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { a as WorkerEnvironment, i as WorkerConfig, n as violationsMessage, r as Environment_exports, t as causeMessage } from "./ErrorMessage-BM0K-Nik.mjs";
 import { n as Service$2, r as layer$19, t as Binding_exports } from "./Binding-pfilNJmP.mjs";
 import { n as Artifacts_exports } from "./Artifacts-CSIk1Oml.mjs";
-import { a as DurableObjectWebSocket_exports, i as fromExecutionContext, n as DurableObjectState_exports, o as fromWebSocket, r as fromDurableObjectState, s as DurableObjectStorage_exports, t as DurableObjectState } from "./DurableObjectState-CxS5Y2hf.mjs";
+import { a as DurableObjectWebSocket_exports, c as DurableObjectStorage_exports, i as fromExecutionContext, n as DurableObjectState_exports, o as DurableWebSocketAttachmentError, r as fromDurableObjectState, s as fromWebSocket, t as DurableObjectState } from "./DurableObjectState-D1Ibr6k0.mjs";
 import { Cause, Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Function as Function$1, Layer, ManagedRuntime, Option, Predicate, Queue, Result, Schema } from "effect";
 import { FetchHttpClient, HttpClient, HttpClientRequest, HttpEffect, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import { OtlpExporter, OtlpLogger, OtlpMetrics, OtlpSerialization, OtlpTracer } from "effect/unstable/observability";
@@ -2457,68 +2457,378 @@ var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("eff
 //#region src/DurableObjectRpcWebSocket.ts
 var DurableObjectRpcWebSocket_exports = /* @__PURE__ */ __exportAll({
 	DurableObjectRpcWebSocket: () => DurableObjectRpcWebSocket,
-	layer: () => layer$8
+	layer: () => layer$8,
+	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);
 /**
 * Context tag for the Durable Object RPC websocket service.
 */
 var DurableObjectRpcWebSocket = class extends Context.Service()("effect-cf/DurableObjectRpcWebSocket") {};
 /**
-* Builds a layer that bridges Durable Object websocket events to `RpcServer.Protocol`.
+* 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$8 = (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 disconnects = yield* Queue.make();
 	const connectionsBySocket = /* @__PURE__ */ new Map();
 	const connectionsById = /* @__PURE__ */ new Map();
 	const clientIds = /* @__PURE__ */ new Set();
+	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 attachment = readAttachment(socket.raw, attachmentKey);
-		if (attachment !== void 0) {
-			nextClientId = Math.max(nextClientId, attachment + 1);
-			return attachment;
+		if (attachment._tag === "Invalid") throw new Error("Invalid Durable Object RPC websocket attachment metadata");
+		if (attachment._tag === "Valid") {
+			const metadata = attachment.metadata;
+			nextClientId = Math.max(nextClientId, metadata.clientId + 1);
+			writeAttachment(socket.raw, attachmentKey, metadata);
+			return metadata;
 		}
 		const id = nextClientId++;
-		writeAttachment(socket.raw, attachmentKey, id);
-		return id;
+		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) => {
+	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: reserveClientId(socket),
+			id: metadata.clientId,
 			socket,
-			parser: serialization.makeUnsafe()
+			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);
 		clientIds.add(connection.id);
+		nextClientId = Math.max(nextClientId, connection.id + 1);
 		return connection;
 	};
-	const unregister = (socket) => Effect.sync(() => {
+	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);
 		clientIds.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);
-	});
-	for (const socket of yield* durableObjectState.getWebSockets(tag)) register(socket);
-	const send = (connection, response) => Effect.sync(() => {
-		try {
-			const encoded = connection.parser.encode(response);
-			if (encoded !== void 0) connection.socket.raw.send(encoded);
-		} catch (cause) {
-			const encoded = connection.parser.encode(RpcMessage.ResponseDefectEncoded(cause));
-			if (encoded !== void 0) connection.socket.raw.send(encoded);
+		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(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_;
@@ -2538,12 +2848,64 @@ const layer$8 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 			supportsSpanPropagation: true
 		});
 	});
+	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) => Effect.gen(function* () {
+		accept: (socket, tags = []) => Effect.gen(function* () {
 			register(socket);
-			yield* durableObjectState.acceptWebSocket(socket, [tag]);
+			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)),
@@ -2554,32 +2916,91 @@ const layer$8 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 				yield* send(connection, RpcMessage.ResponseDefectEncoded("RPC server is not ready"));
 				return;
 			}
-			for (const current of decoded) yield* run(connection.id, current);
+			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(cause));
 		})),
 		close: unregister,
-		error: (socket, cause) => Effect.gen(function* () {
-			yield* Effect.logDebug("Durable Object RPC websocket error", cause);
-			yield* unregister(socket);
-		})
+		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 (Predicate.isObjectOrArray(value) && Predicate.hasProperty(value, key) && Predicate.isNumber(value[key])) return value[key];
+	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 writeAttachment = (socket, key, clientId) => {
+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 : {};
+	const currentMetadata = Predicate.hasProperty(attachment, key) && Predicate.isObject(attachment[key]) ? attachment[key] : {};
 	socket.serializeAttachment({
 		...attachment,
-		[key]: clientId
+		[key]: {
+			...currentMetadata,
+			...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
 //#region src/DurableObjectSqlite.ts
 var DurableObjectSqlite_exports = /* @__PURE__ */ __exportAll({ layer: () => layer$7 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.31.0",
+  "version": "0.32.1",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {