@cntryl/fitz 0.0.2 → 0.0.4

package/dist/index.cjs

@@ -528,11 +528,18 @@ function retryableKey(error) {
 	if (error.domainCode === void 0) return null;
 	return `${prefix}_${error.domainCode}`;
 }
+function isTransientQueueCommitFailure(error) {
+	if (!error.code.startsWith("QUEUE_")) return false;
+	const message = error.message.toLowerCase();
+	if (!message.includes("failed to commit transaction:")) return false;
+	return message.includes("writestall(") || message.includes("memory budget exceeded") || message.includes("lease heartbeat reports unhealthy") || message.includes("refusing writes");
+}
 function isRetryable(error) {
 	if (!(error instanceof FitzError)) return false;
 	if (error instanceof TimeoutError || error instanceof TransportError) return true;
 	const key = retryableKey(error);
-	return key !== null && retryableErrorCodes.has(key);
+	if (key !== null && retryableErrorCodes.has(key)) return true;
+	return isTransientQueueCommitFailure(error);
 }
 /**
 * Error types for Fitz client
@@ -971,7 +978,7 @@ function createMultiplexer(observability = {}) {
 		const span = tracer?.startSpan("fitz.request", attributes);
 		let spanEnded = false;
 		if (signal?.aborted) {
-			const error = abortError$1();
+			const error = abortError$3();
 			span?.recordException(error);
 			span?.end();
 			meter?.counter("fitz.request.failed", 1, {
@@ -1045,7 +1052,7 @@ function createMultiplexer(observability = {}) {
 		heapifyUp(requestEntry.timeoutIndex);
 		if (signal) {
 			onAbort = () => {
-				failRequest(abortError$1());
+				failRequest(abortError$3());
 			};
 			signal.addEventListener("abort", onAbort, { once: true });
 		}
@@ -1065,7 +1072,7 @@ function createMultiplexer(observability = {}) {
 			return deferred.promise;
 		}, (err) => {
 			if (!finalize()) {
-				if (signal?.aborted) throw abortError$1();
+				if (signal?.aborted) throw abortError$3();
 				throw err;
 			}
 			unregisterRequest(messageType, requestEntry);
@@ -1078,7 +1085,7 @@ function createMultiplexer(observability = {}) {
 				span?.end();
 				spanEnded = true;
 			}
-			if (signal?.aborted) throw abortError$1();
+			if (signal?.aborted) throw abortError$3();
 			throw err;
 		});
 	};
@@ -1190,7 +1197,7 @@ function createMultiplexer(observability = {}) {
 const Multiplexer = function(observability = {}) {
 	return createMultiplexer(observability);
 };
-function abortError$1() {
+function abortError$3() {
 	const error = /* @__PURE__ */ new Error("The operation was aborted");
 	error.name = "AbortError";
 	return error;
@@ -1234,8 +1241,64 @@ function readU32BE(payload, offset) {
 	return (payload[offset] << 24 | payload[offset + 1] << 16 | payload[offset + 2] << 8 | payload[offset + 3]) >>> 0;
 }
 //#endregion
+//#region src/client/resilience.ts
+const resilienceMetaSymbol = Symbol("fitz.resilience.meta");
+function attachResilienceMeta(error, meta) {
+	if (error && (typeof error === "object" || typeof error === "function")) Object.defineProperty(error, resilienceMetaSymbol, {
+		value: meta,
+		configurable: true,
+		enumerable: false,
+		writable: true
+	});
+	return error;
+}
+function getResilienceMeta(error) {
+	if (!error || typeof error !== "object" && typeof error !== "function") return;
+	return error[resilienceMetaSymbol];
+}
+function classifyFailureKind(error) {
+	if (error instanceof TimeoutError) return "timeout";
+	if (error instanceof TransportError) return "transport";
+	if (error instanceof ConnectionError) return "connection";
+	if (error instanceof FitzError) return "domain";
+	return "other";
+}
+function isTransientRetryError(error) {
+	return error instanceof TimeoutError || error instanceof TransportError || error instanceof ConnectionError || isRetryable(error);
+}
+function shouldRetryOperation(retryClass, error) {
+	switch (retryClass) {
+		case "wait_only": return false;
+		case "replayable_read": return isTransientRetryError(error);
+		case "confirmed_negative_retry": {
+			const meta = getResilienceMeta(error);
+			return meta?.explicitNegative === true && meta.boundary === "post-send" && isRetryable(error);
+		}
+		default: return false;
+	}
+}
+//#endregion
 //#region src/client/connection.ts
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const sleepWithAbort = async (ms, signal) => {
+	if (signal?.aborted) throw abortError$2();
+	if (ms <= 0) return;
+	await new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			cleanup();
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			cleanup();
+			reject(abortError$2());
+		};
+		const cleanup = () => {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", onAbort);
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+};
 function createAsyncHandlerDispatcher(maxConcurrency, timeoutMs, onError) {
 	let activeCount = 0;
 	let closed = false;
@@ -1303,7 +1366,7 @@ function createRequestGate(maxConcurrency, maxQueueSize) {
 	let closed = false;
 	const queue = [];
 	const acquire = async (signal) => {
-		if (signal?.aborted) throw abortError();
+		if (signal?.aborted) throw abortError$2();
 		if (closed) throw connectionClosedError();
 		return await new Promise((resolve, reject) => {
 			const grant = () => {
@@ -1326,7 +1389,7 @@ function createRequestGate(maxConcurrency, maxQueueSize) {
 			waiter.onAbort = () => {
 				removeWaiter(waiter);
 				cleanup();
-				reject(abortError());
+				reject(abortError$2());
 			};
 			if (signal) signal.addEventListener("abort", waiter.onAbort, { once: true });
 			if (activeCount < maxConcurrency) {
@@ -1375,7 +1438,7 @@ function createRequestGate(maxConcurrency, maxQueueSize) {
 		close
 	};
 }
-function abortError() {
+function abortError$2() {
 	const error = /* @__PURE__ */ new Error("The operation was aborted");
 	error.name = "AbortError";
 	return error;
@@ -1383,12 +1446,37 @@ function abortError() {
 function connectionClosedError() {
 	return new ConnectionError("Connection closed", { state: "CLOSED" });
 }
-function throwIfAborted(signal) {
-	if (signal?.aborted) throw abortError();
+function throwIfAborted$1(signal) {
+	if (signal?.aborted) throw abortError$2();
 }
 function isAbortError$1(error) {
 	return error instanceof Error && error.name === "AbortError";
 }
+const waitForSharedPromise$1 = async (promise, signal) => {
+	if (!signal) return promise;
+	if (signal.aborted) throw abortError$2();
+	return await new Promise((resolve, reject) => {
+		let settled = false;
+		const cleanup = () => {
+			signal.removeEventListener("abort", onAbort);
+		};
+		const settle = (callback) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			callback();
+		};
+		const onAbort = () => {
+			settle(() => reject(abortError$2()));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then((value) => {
+			settle(() => resolve(value));
+		}, (error) => {
+			settle(() => reject(error));
+		});
+	});
+};
 function createConnection(transportFactory, tokenProvider, options = {}) {
 	const timeout = options.timeout ?? 3e4;
 	const authSettleDelayMs = options.authSettleDelayMs ?? 100;
@@ -1396,6 +1484,13 @@ function createConnection(transportFactory, tokenProvider, options = {}) {
 	const reconnectMaxAttempts = options.reconnect?.maxAttempts ?? Infinity;
 	const reconnectBackoffMs = options.reconnect?.backoffMs ?? 250;
 	const reconnectMaxBackoffMs = options.reconnect?.maxBackoffMs ?? 5e3;
+	const retryEnabled = options.retry?.enabled ?? true;
+	const retryMaxAttempts = options.retry?.maxAttempts ?? 3;
+	const retryBackoffMs = options.retry?.backoffMs ?? 100;
+	const retryMaxBackoffMs = options.retry?.maxBackoffMs ?? 1e3;
+	const heartbeatEnabled = options.heartbeat?.enabled ?? true;
+	const heartbeatIntervalMs = options.heartbeat?.intervalMs ?? 1e4;
+	const heartbeatTimeoutMs = options.heartbeat?.timeoutMs ?? 3e4;
 	const maxInFlightRequests = options.maxInFlightRequests ?? 256;
 	const maxRequestQueueSize = options.maxRequestQueueSize ?? 1024;
 	const observability = options.observability;
@@ -1409,10 +1504,23 @@ function createConnection(transportFactory, tokenProvider, options = {}) {
 	let receiveLoop = null;
 	let receiveLoopAbort = false;
 	let closeRequested = false;
+	let permanentlyClosed = false;
+	let connectPromise = null;
 	let reconnectPromise = null;
+	let connectionLossPromise = null;
+	let reconnectRestoreActive = false;
 	let authOutcome = null;
 	let authRejected = false;
+	let hasEstablishedSession = false;
+	let reconnectExhausted = false;
+	let readyWaiterCount = 0;
+	const closeAbortController = new AbortController();
 	const connectionScope = createScope("connection");
+	const readyListeners = /* @__PURE__ */ new Set();
+	let heartbeatTimer = null;
+	let heartbeatTransport = null;
+	let heartbeatPending = false;
+	let lastActivityAt = Date.now();
 	const log = (level, event, fields) => {
 		observability?.logger?.log(level, event, fields);
 	};
@@ -1443,6 +1551,8 @@ function createConnection(transportFactory, tokenProvider, options = {}) {
 	};
 	const handlePossibleTransportFailure = (error) => {
 		if (closeRequested) return;
+		if (state !== "AUTHENTICATED") return;
+		if (getResilienceMeta(error)?.boundary === "pre-send") return;
 		if (error instanceof TransportError || error instanceof ConnectionError || error instanceof AuthenticationError) handleConnectionLoss(error);
 	};
 	const multiplexer = new Multiplexer({
@@ -1453,17 +1563,35 @@ function createConnection(transportFactory, tokenProvider, options = {}) {
 		log("warn", "fitz.connection.handler_failed", { error: describeError(error) });
 	});
 	const connect = async (options = {}) => {
-		closeRequested = false;
+		if (permanentlyClosed || closeRequested) throw connectionClosedError();
+		throwIfAborted$1(options.signal);
+		if (state === "AUTHENTICATED") return;
+		if (connectPromise) {
+			await waitForSharedPromise$1(connectPromise, options.signal);
+			return;
+		}
+		if (reconnectPromise || state === "CONNECTING" || state === "CONNECTED" || state === "AUTHENTICATING" || state === "RECONNECTING" || state === "DISCONNECTED" && canWaitForReconnect()) {
+			await waitForReady(options.signal, timeout);
+			return;
+		}
 		authRejected = false;
-		await openAndAuthenticate(false, options.signal);
+		reconnectExhausted = false;
+		const sharedConnectPromise = openAndAuthenticate(false, options.signal).finally(() => {
+			if (connectPromise === sharedConnectPromise) connectPromise = null;
+		});
+		connectPromise = sharedConnectPromise;
+		await sharedConnectPromise;
 	};
 	const close = async () => {
 		if (state === "CLOSED" && !transport) {
 			await connectionScope.dispose();
 			return;
 		}
+		permanentlyClosed = true;
 		closeRequested = true;
 		receiveLoopAbort = true;
+		stopHeartbeat();
+		closeAbortController.abort();
 		asyncHandlerDispatcher.close();
 		const scopeDisposePromise = connectionScope.dispose();
 		setState("CLOSED");
@@ -1484,15 +1612,34 @@ function createConnection(transportFactory, tokenProvider, options = {}) {
 		await asyncHandlerDispatcher.drain();
 		await scopeDisposePromise;
 	};
-	const request = async (messageType, requestPayload, signal) => {
+	const waitForRequestReady = async (signal, allowReconnectRestore = false) => {
+		if (allowReconnectRestore && reconnectRestoreActive && state === "AUTHENTICATING" && !closeRequested && !authRejected && transport) return;
+		const releaseReadyWaitSlot = acquireReadyWaitSlot();
+		try {
+			await waitForReady(signal, timeout);
+		} finally {
+			releaseReadyWaitSlot?.();
+		}
 		ensureAuthenticated();
+	};
+	const requestInternal = async (messageType, requestPayload, signal, allowReconnectRestore = false) => {
+		let sendStarted = false;
+		await waitForRequestReady(signal, allowReconnectRestore);
 		const releaseRequestSlot = await requestGate.acquire(signal);
 		const startedAt = Date.now();
 		try {
 			const activeTransport = ensureTransport();
 			const frame = FrameCodec.encodeFrame(messageType, requestPayload);
-			return await multiplexer.request(messageType, frame, (data) => sendSerialized(activeTransport, data), timeout, signal);
+			return await multiplexer.request(messageType, frame, (data) => {
+				sendStarted = true;
+				return sendSerialized(activeTransport, data);
+			}, timeout, signal);
 		} catch (error) {
+			attachResilienceMeta(error, {
+				boundary: sendStarted ? "post-send" : "pre-send",
+				failureKind: classifyFailureKind(error),
+				explicitNegative: false
+			});
 			log("error", "fitz.connection.request_failed", {
 				operation: "request",
 				state,
@@ -1507,13 +1654,34 @@ function createConnection(transportFactory, tokenProvider, options = {}) {
 			releaseRequestSlot();
 		}
 	};
-	const send = async (messageType, requestPayload) => {
+	const request = async (messageType, requestPayload, signal) => {
+		return await requestInternal(messageType, requestPayload, signal);
+	};
+	const requestDuringReconnectRestore = async (messageType, requestPayload, signal) => {
+		return await requestInternal(messageType, requestPayload, signal, true);
+	};
+	const send = async (messageType, requestPayload, signal) => {
+		let sendStarted = false;
+		const releaseReadyWaitSlot = acquireReadyWaitSlot();
+		try {
+			await waitForReady(signal, timeout);
+		} finally {
+			releaseReadyWaitSlot?.();
+		}
 		ensureAuthenticated();
-		const releaseRequestSlot = await requestGate.acquire();
+		const releaseRequestSlot = await requestGate.acquire(signal);
 		const startedAt = Date.now();
 		try {
-			await sendSerialized(ensureTransport(), FrameCodec.encodeFrame(messageType, requestPayload));
+			const activeTransport = ensureTransport();
+			const frame = FrameCodec.encodeFrame(messageType, requestPayload);
+			sendStarted = true;
+			await sendSerialized(activeTransport, frame);
 		} catch (error) {
+			attachResilienceMeta(error, {
+				boundary: sendStarted ? "post-send" : "pre-send",
+				failureKind: classifyFailureKind(error),
+				explicitNegative: false
+			});
 			log("error", "fitz.connection.send_failed", {
 				operation: "send",
 				state,
@@ -1528,8 +1696,8 @@ function createConnection(transportFactory, tokenProvider, options = {}) {
 			releaseRequestSlot();
 		}
 	};
-	const sendFireAndForget = async (messageType, requestPayload) => {
-		await send(messageType, requestPayload);
+	const sendFireAndForget = async (messageType, requestPayload, signal) => {
+		await send(messageType, requestPayload, signal);
 	};
 	const registerNotificationHandler = (messageType, handler) => {
 		multiplexer.registerNotificationHandler(messageType, handler);
@@ -1557,22 +1725,224 @@ function createConnection(transportFactory, tokenProvider, options = {}) {
 	const getState = () => state;
 	const isConnected = () => state === "AUTHENTICATED";
 	const getUrl = () => ensureTransport().getUrl();
+	const canWaitForReconnect = () => {
+		return reconnectEnabled && hasEstablishedSession && !reconnectExhausted && !authRejected;
+	};
+	const readyFailure = () => {
+		if (state === "AUTHENTICATED") return null;
+		if (closeRequested || state === "CLOSED") return connectionClosedError();
+		if (authRejected) return new AuthenticationError("Authentication rejected", { state });
+		if (state === "CONNECTING" || state === "CONNECTED" || state === "AUTHENTICATING" || state === "RECONNECTING") return null;
+		if (state === "DISCONNECTED" && canWaitForReconnect()) return null;
+		return new ConnectionError(`Cannot use connection while state is ${state}`, { state });
+	};
+	const notifyReadyListeners = () => {
+		for (const listener of readyListeners) listener();
+	};
+	const acquireReadyWaitSlot = () => {
+		const failure = readyFailure();
+		if (state === "AUTHENTICATED" || failure) return null;
+		if (readyWaiterCount >= maxRequestQueueSize) throw new RequestQueueFullError();
+		readyWaiterCount += 1;
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			readyWaiterCount = Math.max(readyWaiterCount - 1, 0);
+		};
+	};
+	const waitForReady = async (signal, waitTimeoutMs = timeout) => {
+		throwIfAborted$1(signal);
+		const immediateFailure = readyFailure();
+		if (!immediateFailure) {
+			if (state === "AUTHENTICATED") return;
+		} else throw immediateFailure;
+		await new Promise((resolve, reject) => {
+			let settled = false;
+			let timeoutId = null;
+			const cleanup = () => {
+				readyListeners.delete(onStateChange);
+				if (timeoutId) clearTimeout(timeoutId);
+				signal?.removeEventListener("abort", onAbort);
+			};
+			const settle = (cb) => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				cb();
+			};
+			const onAbort = () => {
+				settle(() => reject(abortError$2()));
+			};
+			const onStateChange = () => {
+				const failure = readyFailure();
+				if (state === "AUTHENTICATED") {
+					settle(resolve);
+					return;
+				}
+				if (failure) settle(() => reject(failure));
+			};
+			readyListeners.add(onStateChange);
+			signal?.addEventListener("abort", onAbort, { once: true });
+			timeoutId = setTimeout(() => {
+				settle(() => reject(new ConnectionError("Timed out waiting for connection to become ready", { state })));
+			}, waitTimeoutMs);
+			onStateChange();
+		});
+	};
+	const waitUntilReady = async (signal, waitTimeoutMs = timeout) => {
+		await waitForReady(signal, waitTimeoutMs);
+	};
+	const shouldWaitForReconnect = () => {
+		return reconnectPromise !== null || state === "RECONNECTING" || state === "DISCONNECTED" && canWaitForReconnect();
+	};
+	const getRetryDelayMs = (baseDelayMs) => {
+		const jitter = Math.floor(Math.random() * baseDelayMs * .5);
+		return Math.min(Math.max(baseDelayMs + jitter, 1), retryMaxBackoffMs);
+	};
+	const recordRetry = (operation, attempt, delayMs, error) => {
+		const meta = getResilienceMeta(error);
+		log("warn", "fitz.request.retry", {
+			domain: operation.domain,
+			operation: operation.operation,
+			attempt,
+			delayMs,
+			boundary: meta?.boundary ?? "unknown",
+			error: describeError(error),
+			...describeErrorFields(error)
+		});
+		observability?.meter?.counter("fitz.request.retry", 1, {
+			domain: operation.domain,
+			operation: operation.operation,
+			boundary: meta?.boundary ?? "unknown"
+		});
+	};
+	const recordRetryExhausted = (operation, attempt, error) => {
+		const meta = getResilienceMeta(error);
+		log("warn", "fitz.request.retry_exhausted", {
+			domain: operation.domain,
+			operation: operation.operation,
+			attempt,
+			boundary: meta?.boundary ?? "unknown",
+			error: describeError(error),
+			...describeErrorFields(error)
+		});
+		observability?.meter?.counter("fitz.request.retry_exhausted", 1, {
+			domain: operation.domain,
+			operation: operation.operation,
+			boundary: meta?.boundary ?? "unknown"
+		});
+	};
+	const executeWithRetry = async (operation, task) => {
+		if (!retryEnabled || operation.retryClass === "wait_only") return task();
+		let attempt = 0;
+		let delayMs = retryBackoffMs;
+		while (true) {
+			attempt += 1;
+			try {
+				return await task();
+			} catch (error) {
+				if (isAbortError$1(error)) throw error;
+				if (!shouldRetryOperation(operation.retryClass, error)) throw error;
+				if (attempt >= retryMaxAttempts) {
+					recordRetryExhausted(operation, attempt, error);
+					throw error;
+				}
+				const actualDelayMs = getRetryDelayMs(delayMs);
+				recordRetry(operation, attempt, actualDelayMs, error);
+				await sleepWithAbort(actualDelayMs, operation.signal);
+				delayMs = Math.min(delayMs * 2, retryMaxBackoffMs);
+			}
+		}
+	};
+	const withWriteLock = async (operation) => {
+		const prior = writeChain;
+		let release;
+		writeChain = new Promise((resolve) => {
+			release = resolve;
+		});
+		await prior;
+		try {
+			return await operation();
+		} finally {
+			release();
+		}
+	};
+	const markOutboundActivity = () => {
+		lastActivityAt = Date.now();
+	};
+	const markRemoteActivity = () => {
+		lastActivityAt = Date.now();
+	};
+	const stopHeartbeat = () => {
+		if (heartbeatTimer) {
+			clearTimeout(heartbeatTimer);
+			heartbeatTimer = null;
+		}
+		heartbeatTransport = null;
+		heartbeatPending = false;
+	};
+	const startHeartbeat = (activeTransport) => {
+		if (!heartbeatEnabled) return;
+		stopHeartbeat();
+		activeTransport.enableKeepAlive?.(heartbeatIntervalMs);
+		heartbeatTransport = activeTransport;
+		markRemoteActivity();
+		const scheduleNext = () => {
+			if (closeRequested || receiveLoopAbort || heartbeatTransport !== activeTransport) return;
+			heartbeatTimer = setTimeout(tick, heartbeatIntervalMs);
+		};
+		const tick = () => {
+			heartbeatTimer = null;
+			if (closeRequested || receiveLoopAbort || heartbeatTransport !== activeTransport) return;
+			const now = Date.now();
+			if (now - lastActivityAt < heartbeatIntervalMs) {
+				scheduleNext();
+				return;
+			}
+			const supportsHeartbeat = activeTransport.supportsHeartbeat?.() ?? true;
+			if (!heartbeatPending && supportsHeartbeat && activeTransport.sendHeartbeat) {
+				heartbeatPending = true;
+				const heartbeatSentAt = now;
+				const dispatchHeartbeat = (heartbeat) => activeTransport.sendHeartbeat(heartbeat);
+				withWriteLock(async () => {
+					await dispatchHeartbeat({ timeoutMs: heartbeatTimeoutMs });
+				}).then(() => {
+					if (heartbeatTransport !== activeTransport) return;
+					heartbeatPending = false;
+					markRemoteActivity();
+				}).catch((error) => {
+					if (heartbeatTransport !== activeTransport) return;
+					heartbeatPending = false;
+					if (lastActivityAt > heartbeatSentAt) return;
+					const heartbeatError = new TransportError(`Heartbeat failed: ${describeError(error)}`);
+					activeTransport.close().catch(() => void 0);
+					handleConnectionLoss(heartbeatError);
+				});
+			}
+			scheduleNext();
+		};
+		scheduleNext();
+	};
 	const openAndAuthenticate = async (isReconnect, signal) => {
-		throwIfAborted(signal);
+		throwIfAborted$1(signal);
 		receiveLoopAbort = false;
 		frameParser.parseFrames(new Uint8Array(0));
 		requestGate = createRequestGate(maxInFlightRequests, maxRequestQueueSize);
 		const activeTransport = transportFactory();
 		transport = activeTransport;
+		stopHeartbeat();
 		setState(isReconnect ? "RECONNECTING" : "CONNECTING");
 		emitLifecycleEvent(isReconnect ? "reconnect_start" : "connect_start");
 		await activeTransport.connect();
+		markRemoteActivity();
 		if (closeRequested) {
+			stopHeartbeat();
 			await activeTransport.close().catch(() => void 0);
 			if (transport === activeTransport) transport = null;
 			throw connectionClosedError();
 		}
-		throwIfAborted(signal);
+		throwIfAborted$1(signal);
 		receiveLoop = startReceiveLoop();
 		setState("CONNECTED");
 		setState("AUTHENTICATING");
@@ -1581,23 +1951,34 @@ function createConnection(transportFactory, tokenProvider, options = {}) {
 		try {
 			await sendConnect();
 			if (closeRequested) throw connectionClosedError();
-			throwIfAborted(signal);
+			throwIfAborted$1(signal);
 			await Promise.race([authOutcome.promise, sleep(authSettleDelayMs)]);
 			if (closeRequested) throw connectionClosedError();
-			throwIfAborted(signal);
+			throwIfAborted$1(signal);
 			authOutcome?.resolve();
 			authOutcome = null;
 			if (isReconnect) {
-				await restoreReconnectState();
-				if (closeRequested) throw connectionClosedError();
+				multiplexer.setConnected();
+				reconnectRestoreActive = true;
+				try {
+					await restoreReconnectState();
+					if (closeRequested) throw connectionClosedError();
+				} finally {
+					reconnectRestoreActive = false;
+				}
 			}
+			hasEstablishedSession = true;
+			reconnectExhausted = false;
 			setState("AUTHENTICATED");
-			multiplexer.setConnected();
+			startHeartbeat(activeTransport);
+			if (!isReconnect) multiplexer.setConnected();
 			emitLifecycleEvent(isReconnect ? "reconnect_succeeded" : "connect_succeeded");
 		} catch (error) {
 			authOutcome = null;
+			reconnectRestoreActive = false;
 			multiplexer.setDisconnected();
 			emitDisconnect();
+			stopHeartbeat();
 			if (activeTransport) await activeTransport.close().catch(() => void 0);
 			if (transport === activeTransport) transport = null;
 			const rejectedAuth = error instanceof AuthenticationError;
@@ -1605,7 +1986,7 @@ function createConnection(transportFactory, tokenProvider, options = {}) {
 			if (closeRequested) setState("CLOSED");
 			else setState(rejectedAuth ? "CLOSED" : "DISCONNECTED");
 			emitLifecycleEvent(isReconnect ? "reconnect_failed" : "connect_failed", error);
-			if (isAbortError$1(error)) throw abortError();
+			if (isAbortError$1(error)) throw abortError$2();
 			throw error;
 		}
 	};
@@ -1613,10 +1994,12 @@ function createConnection(transportFactory, tokenProvider, options = {}) {
 		const token = await tokenProvider();
 		const frame = FrameCodec.encodeFrame(1, utf8Encoder.encode(token));
 		await ensureTransport().send(frame);
+		markOutboundActivity();
 	};
 	const startReceiveLoop = async () => {
 		while (!receiveLoopAbort && !closeRequested) try {
 			const data = await ensureTransport().receive();
+			markRemoteActivity();
 			const frames = frameParser.parseFrames(data);
 			for (const frame of frames) multiplexer.dispatch(frame.messageType, frame.payload);
 		} catch (error) {
@@ -1626,6 +2009,17 @@ function createConnection(transportFactory, tokenProvider, options = {}) {
 		}
 	};
 	const handleConnectionLoss = async (error) => {
+		if (connectionLossPromise) {
+			await connectionLossPromise;
+			return;
+		}
+		connectionLossPromise = handleConnectionLossOnce(error).finally(() => {
+			connectionLossPromise = null;
+		});
+		await connectionLossPromise;
+	};
+	const handleConnectionLossOnce = async (error) => {
+		stopHeartbeat();
 		multiplexer.setDisconnected();
 		requestGate.close();
 		emitDisconnect();
@@ -1646,6 +2040,7 @@ function createConnection(transportFactory, tokenProvider, options = {}) {
 			emitLifecycleEvent("auth_rejected", error);
 			return;
 		}
+		reconnectExhausted = false;
 		setState("DISCONNECTED");
 		emitLifecycleEvent("connection_lost", error);
 		if (!reconnectEnabled) return;
@@ -1667,12 +2062,13 @@ function createConnection(transportFactory, tokenProvider, options = {}) {
 			emitLifecycleEvent("reconnect_scheduled", void 0, attempts);
 			const actualDelayMs = getReconnectDelayMs(delayMs);
 			try {
-				await sleep(actualDelayMs);
+				await sleepWithAbort(actualDelayMs, closeAbortController.signal);
 				if (closeRequested) return;
 				await openAndAuthenticate(true);
 				return;
 			} catch (error) {
 				if (closeRequested) return;
+				if (isAbortError$1(error)) return;
 				log("warn", "fitz.connection.reconnect_retry", {
 					attempts,
 					delayMs: actualDelayMs,
@@ -1686,6 +2082,7 @@ function createConnection(transportFactory, tokenProvider, options = {}) {
 			setState("CLOSED");
 			return;
 		}
+		reconnectExhausted = true;
 		setState("DISCONNECTED");
 		emitLifecycleEvent("reconnect_exhausted", void 0, attempts);
 	};
@@ -1706,19 +2103,13 @@ function createConnection(transportFactory, tokenProvider, options = {}) {
 	};
 	const setState = (newState) => {
 		state = newState;
+		notifyReadyListeners();
 	};
 	const sendSerialized = async (transport, data) => {
-		const prior = writeChain;
-		let release;
-		writeChain = new Promise((resolve) => {
-			release = resolve;
-		});
-		await prior;
-		try {
+		await withWriteLock(async () => {
 			await transport.send(data);
-		} finally {
-			release();
-		}
+			markOutboundActivity();
+		});
 	};
 	const emitLifecycleEvent = (event, error, attempt) => {
 		const payload = {
@@ -1745,6 +2136,7 @@ function createConnection(transportFactory, tokenProvider, options = {}) {
 		connect,
 		close,
 		request,
+		requestDuringReconnectRestore,
 		send,
 		sendFireAndForget,
 		registerNotificationHandler,
@@ -1753,6 +2145,9 @@ function createConnection(transportFactory, tokenProvider, options = {}) {
 		onDisconnect,
 		getMultiplexer,
 		dispatchAsyncHandler,
+		executeWithRetry,
+		waitUntilReady,
+		shouldWaitForReconnect,
 		getScope,
 		getState,
 		isConnected,
@@ -1790,6 +2185,7 @@ function createWebSocketTransport(url, options = {}) {
 	let receiverResolve = null;
 	const timeout = options.timeout ?? 3e4;
 	const maxFrameSize = options.maxFrameSize ?? 65535;
+	const receiveTimeoutEnabled = options.receiveTimeout ?? true;
 	const enqueueMessage = (data) => {
 		if (receiverResolve) {
 			receiverResolve(data);
@@ -1863,6 +2259,56 @@ function createWebSocketTransport(url, options = {}) {
 			}
 		});
 	};
+	const sendHeartbeat = async (heartbeatOptions) => {
+		if (!connected || !ws) throw new TransportError("WebSocket is not connected");
+		const activeWs = ws;
+		if (typeof activeWs.ping !== "function" || typeof activeWs.once !== "function" || typeof activeWs.removeListener !== "function") throw new TransportError("WebSocket heartbeat is not supported");
+		const socket = activeWs;
+		return new Promise((resolve, reject) => {
+			let settled = false;
+			let timeoutId = null;
+			const cleanup = () => {
+				if (timeoutId) clearTimeout(timeoutId);
+				socket.removeListener("pong", onPong);
+				socket.removeListener("close", onClose);
+				socket.removeListener("error", onError);
+			};
+			const settle = (callback) => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				callback();
+			};
+			const onPong = () => {
+				settle(resolve);
+			};
+			const onClose = () => {
+				settle(() => reject(new TransportError("WebSocket closed during heartbeat")));
+			};
+			const onError = (...args) => {
+				const event = args[0];
+				const message = event instanceof Error ? event.message : event?.message || "unknown error";
+				settle(() => reject(new TransportError(`WebSocket heartbeat failed: ${message}`)));
+			};
+			timeoutId = setTimeout(() => {
+				settle(() => reject(new TimeoutError(`WebSocket heartbeat timeout after ${heartbeatOptions.timeoutMs}ms`)));
+			}, heartbeatOptions.timeoutMs);
+			socket.once("pong", onPong);
+			socket.once("close", onClose);
+			socket.once("error", onError);
+			try {
+				socket.ping(new Uint8Array(), void 0, (err) => {
+					if (err) settle(() => reject(new TransportError(`WebSocket ping failed: ${err.message}`)));
+				});
+			} catch (err) {
+				settle(() => reject(new TransportError(`WebSocket heartbeat error: ${err instanceof Error ? err.message : String(err)}`)));
+			}
+		});
+	};
+	const supportsHeartbeat = () => {
+		return typeof ws?.ping === "function" && typeof ws?.once === "function" && typeof ws?.removeListener === "function";
+	};
+	const enableKeepAlive = () => void 0;
 	const receive = async () => {
 		if (receiveQueue.length > 0) {
 			const message = receiveQueue.shift();
@@ -1871,12 +2317,12 @@ function createWebSocketTransport(url, options = {}) {
 		}
 		if (!connected) throw new TransportError("Connection closed");
 		return new Promise((resolve, reject) => {
-			const timeoutId = setTimeout(() => {
+			const timeoutId = receiveTimeoutEnabled ? setTimeout(() => {
 				receiverResolve = null;
 				reject(new TimeoutError(`WebSocket receive timeout after ${timeout}ms`));
-			}, timeout);
+			}, timeout) : null;
 			receiverResolve = (data) => {
-				clearTimeout(timeoutId);
+				if (timeoutId) clearTimeout(timeoutId);
 				receiverResolve = null;
 				if (data === null) {
 					reject(new TransportError("Connection closed"));
@@ -1911,6 +2357,9 @@ function createWebSocketTransport(url, options = {}) {
 		connect,
 		send,
 		receive,
+		sendHeartbeat,
+		supportsHeartbeat,
+		enableKeepAlive,
 		close,
 		getUrl,
 		isConnected
@@ -1936,6 +2385,7 @@ function createTcpTransport(url, options = {}) {
 	let receiverResolve = null;
 	const timeout = options.timeout ?? 3e4;
 	const maxFrameSize = options.maxFrameSize ?? 65535;
+	const receiveTimeoutEnabled = options.receiveTimeout ?? true;
 	let lengthBuffer = new Uint8Array(4);
 	let lengthOffset = 0;
 	let currentMessageLength = null;
@@ -2010,7 +2460,7 @@ function createTcpTransport(url, options = {}) {
 					clearTimeout(connectTimeout);
 					connected = true;
 					activeSocket.setNoDelay(true);
-					activeSocket.setTimeout(timeout);
+					activeSocket.setTimeout(receiveTimeoutEnabled ? timeout : 0);
 					resolve();
 				});
 				activeSocket.on("data", (chunk) => {
@@ -2028,8 +2478,10 @@ function createTcpTransport(url, options = {}) {
 					if (receiverResolve) receiverResolve(new Uint8Array(0));
 				});
 				activeSocket.on("timeout", () => {
-					activeSocket.destroy();
-					connected = false;
+					if (receiveTimeoutEnabled) {
+						activeSocket.destroy();
+						connected = false;
+					}
 				});
 			} catch (err) {
 				reject(new TransportError(`Failed to create TCP socket: ${err instanceof Error ? err.message : String(err)}`));
@@ -2054,6 +2506,10 @@ function createTcpTransport(url, options = {}) {
 			});
 		});
 	};
+	const enableKeepAlive = (intervalMs) => {
+		socket?.setKeepAlive(true, intervalMs);
+	};
+	const supportsHeartbeat = () => false;
 	const receive = async () => {
 		if (receiveQueue.length > 0) {
 			const message = receiveQueue.shift();
@@ -2061,12 +2517,12 @@ function createTcpTransport(url, options = {}) {
 			return message;
 		}
 		return new Promise((resolve, reject) => {
-			const timeoutId = setTimeout(() => {
+			const timeoutId = receiveTimeoutEnabled ? setTimeout(() => {
 				receiverResolve = null;
 				reject(new TimeoutError(`TCP receive timeout after ${timeout}ms`));
-			}, timeout);
+			}, timeout) : null;
 			receiverResolve = (data) => {
-				clearTimeout(timeoutId);
+				if (timeoutId) clearTimeout(timeoutId);
 				receiverResolve = null;
 				if (data.length === 0) reject(new TransportError("Connection closed"));
 				else resolve(data);
@@ -2098,6 +2554,8 @@ function createTcpTransport(url, options = {}) {
 		connect,
 		send,
 		receive,
+		supportsHeartbeat,
+		enableKeepAlive,
 		close,
 		getUrl,
 		isConnected
@@ -2136,11 +2594,23 @@ function createTransport(url, transportType = "auto", options = {}) {
 //#region src/domains/base.ts
 function createDomainClient(connection) {
 	const requestFrame = async (messageType, payload, signal) => connection.request(messageType, payload, signal);
+	const requestReconnectFrame = async (messageType, payload, signal) => {
+		const resilientConnection = connection;
+		if (typeof resilientConnection.requestDuringReconnectRestore === "function") return await resilientConnection.requestDuringReconnectRestore(messageType, payload, signal);
+		return await connection.request(messageType, payload, signal);
+	};
 	const sendFrame = async (messageType, payload) => connection.send(messageType, payload);
+	const runWithRetry = async (operation, task) => {
+		const resilientConnection = connection;
+		if (typeof resilientConnection.executeWithRetry === "function") return resilientConnection.executeWithRetry(operation, task);
+		return task();
+	};
 	return {
 		connection,
 		requestFrame,
-		sendFrame
+		requestReconnectFrame,
+		sendFrame,
+		runWithRetry
 	};
 }
 //#endregion
@@ -2318,8 +2788,11 @@ function createAsyncIterableIterator(iterator) {
 //#region src/domains/kv/transaction.ts
 function createKvTransaction(connection, route, txId) {
 	let closed = false;
-	const unsubscribeDisconnect = connection.onDisconnect(() => {
+	const resilientConnection = connection;
+	let unsubscribeDisconnect = () => void 0;
+	unsubscribeDisconnect = connection.onDisconnect(() => {
 		closed = true;
+		unsubscribeDisconnect();
 	});
 	const ensureOpen = () => {
 		if (closed) throw new KvError("Transaction already closed", "TX_CLOSED");
@@ -2334,6 +2807,10 @@ function createKvTransaction(connection, route, txId) {
 			[5]: "OperationNotAllowed"
 		}[status] ?? `Unknown(${status})`}`, operation, status);
 	};
+	const runWithRetry = async (operation, task) => {
+		if (typeof resilientConnection.executeWithRetry === "function") return resilientConnection.executeWithRetry(operation, task);
+		return task();
+	};
 	const put = async (key, value, signal) => {
 		ensureOpen();
 		const payload = KvCodec.encodePut(txId, route, key, value);
@@ -2348,15 +2825,22 @@ function createKvTransaction(connection, route, txId) {
 	};
 	const get = async (key, signal) => {
 		ensureOpen();
-		const payload = KvCodec.encodeGet(txId, route, key);
-		const response = await connection.request(103, payload, signal);
-		const decoded = KvCodec.decodeGetResponse(response);
-		checkStatus(decoded.status, "GET");
-		if (!decoded.found || !decoded.value) return { type: "not-found" };
-		return {
-			type: "found",
-			value: decoded.value
-		};
+		return runWithRetry({
+			domain: "kv",
+			operation: "get",
+			retryClass: "replayable_read",
+			signal
+		}, async () => {
+			const payload = KvCodec.encodeGet(txId, route, key);
+			const response = await connection.request(103, payload, signal);
+			const decoded = KvCodec.decodeGetResponse(response);
+			checkStatus(decoded.status, "GET");
+			if (!decoded.found || !decoded.value) return { type: "not-found" };
+			return {
+				type: "found",
+				value: decoded.value
+			};
+		});
 	};
 	const deleteItem = async (key, signal) => {
 		ensureOpen();
@@ -2372,11 +2856,18 @@ function createKvTransaction(connection, route, txId) {
 	};
 	const scan = async (options = {}, signal) => {
 		ensureOpen();
-		const payload = KvCodec.encodeScan(txId, route, options);
-		const response = await connection.request(108, payload, signal);
-		const decoded = KvCodec.decodeScanResponse(response);
-		checkStatus(decoded.status, "SCAN");
-		return createAsyncIterableIterator(createSliceIterator(decoded.keys));
+		return runWithRetry({
+			domain: "kv",
+			operation: "scan",
+			retryClass: "replayable_read",
+			signal
+		}, async () => {
+			const payload = KvCodec.encodeScan(txId, route, options);
+			const response = await connection.request(108, payload, signal);
+			const decoded = KvCodec.decodeScanResponse(response);
+			checkStatus(decoded.status, "SCAN");
+			return createAsyncIterableIterator(createSliceIterator(decoded.keys));
+		});
 	};
 	const commit = async (signal) => {
 		ensureOpen();
@@ -2443,6 +2934,64 @@ const KvClient = function(connection) {
 	return createKvClient(connection);
 };
 //#endregion
+//#region src/core/wake-gate.ts
+function abortError$1() {
+	const error = /* @__PURE__ */ new Error("The operation was aborted");
+	error.name = "AbortError";
+	return error;
+}
+function createWakeGate() {
+	let currentVersion = 0;
+	const waiters = /* @__PURE__ */ new Set();
+	const cleanup = (waiter) => {
+		waiters.delete(waiter);
+		if (waiter.signal && waiter.onAbort) waiter.signal.removeEventListener("abort", waiter.onAbort);
+	};
+	const wake = () => {
+		currentVersion += 1;
+		const version = currentVersion;
+		for (const waiter of Array.from(waiters)) {
+			cleanup(waiter);
+			waiter.resolve(version);
+		}
+		return version;
+	};
+	const waitAfter = async (observedVersion, options = {}) => {
+		if (currentVersion > observedVersion) return currentVersion;
+		if (options.signal?.aborted) throw abortError$1();
+		return await new Promise((resolve, reject) => {
+			const waiter = {
+				observedVersion,
+				resolve,
+				reject,
+				signal: options.signal
+			};
+			waiter.onAbort = () => {
+				cleanup(waiter);
+				reject(abortError$1());
+			};
+			if (options.signal) options.signal.addEventListener("abort", waiter.onAbort, { once: true });
+			if (currentVersion > observedVersion) {
+				cleanup(waiter);
+				resolve(currentVersion);
+				return;
+			}
+			waiters.add(waiter);
+		});
+	};
+	const wait = async (options) => {
+		return await waitAfter(currentVersion, options);
+	};
+	return {
+		get version() {
+			return currentVersion;
+		},
+		wake,
+		waitAfter,
+		wait
+	};
+}
+//#endregion
 //#region src/domains/queue/codec.ts
 /**
 * Queue domain codec for encoding and decoding protocol messages.
@@ -2656,7 +3205,17 @@ const QueueCodec = {
 //#endregion
 //#region src/domains/queue/types.ts
 function createQueueItem(id, token, body, route, connection) {
+	let closed = false;
+	let unsubscribeDisconnect = () => void 0;
+	unsubscribeDisconnect = connection.onDisconnect(() => {
+		closed = true;
+		unsubscribeDisconnect();
+	});
+	const ensureOpen = () => {
+		if (closed) throw new QueueError("Queue item is no longer valid after disconnect", "ITEM_CLOSED");
+	};
 	const extend = async (leaseSecs, signal) => {
+		ensureOpen();
 		const payload = QueueCodec.encodeExtend(route, id, token, leaseSecs);
 		const response = await connection.request(203, payload, signal);
 		const decoded = QueueCodec.decodeExtendResponse(response);
@@ -2667,6 +3226,7 @@ function createQueueItem(id, token, body, route, connection) {
 		}
 	};
 	const complete = async (signal) => {
+		ensureOpen();
 		const requestPayload = QueueCodec.encodeComplete(route, id, token);
 		const response = await connection.request(204, requestPayload, signal);
 		const decoded = QueueCodec.decodeCompleteResponse(response);
@@ -2675,9 +3235,12 @@ function createQueueItem(id, token, body, route, connection) {
 			const statusName = QueueStatus[errorCode] || `Unknown(${errorCode})`;
 			throw new QueueError(`COMPLETE failed: ${decoded.errorMessage ?? statusName}`, statusName, errorCode);
 		}
+		closed = true;
+		unsubscribeDisconnect();
 	};
 	const testOnlyInvalidToken = () => id + 1n;
 	const testOnlyCompleteWithToken = async (tokenToUse, signal) => {
+		ensureOpen();
 		const requestPayload = QueueCodec.encodeComplete(route, id, tokenToUse);
 		const response = await connection.request(204, requestPayload, signal);
 		const decoded = QueueCodec.decodeCompleteResponse(response);
@@ -2686,6 +3249,8 @@ function createQueueItem(id, token, body, route, connection) {
 			const statusName = QueueStatus[errorCode] || `Unknown(${errorCode})`;
 			throw new QueueError(`COMPLETE failed: ${decoded.errorMessage ?? statusName}`, statusName, errorCode);
 		}
+		closed = true;
+		unsubscribeDisconnect();
 	};
 	return {
 		body,
@@ -2723,7 +3288,7 @@ let QueueStatus = /* @__PURE__ */ function(QueueStatus) {
 * Queue domain client.
 */
 function createQueueClient(connection) {
-	const { requestFrame } = createDomainClient(connection);
+	const { requestFrame, requestReconnectFrame, runWithRetry } = createDomainClient(connection);
 	const subscriptionsByPattern = /* @__PURE__ */ new Map();
 	const patternsBySubId = /* @__PURE__ */ new Map();
 	let notificationHandlerRegistered = false;
@@ -2737,7 +3302,7 @@ function createQueueClient(connection) {
 		subscriptionsByPattern.clear();
 		patternsBySubId.clear();
 		for (const subscription of subscriptions) {
-			const subId = await subscribeWire(subscription.pattern);
+			const subId = await subscribeWire(subscription.pattern, requestReconnectFrame);
 			subscriptionsByPattern.set(subscription.pattern, {
 				subId,
 				handlers: new Map(subscription.handlers)
@@ -2747,11 +3312,17 @@ function createQueueClient(connection) {
 	});
 	const enqueue = async (route, body, options) => {
 		assertQueueRoute(route);
-		const response = await requestFrame(200, QueueCodec.encodeEnqueue(route, body, options));
-		const decoded = QueueCodec.decodeEnqueueResponse(response);
-		checkStatus(decoded, "ENQUEUE");
-		if (decoded.messageId === void 0) throw new QueueError("ENQUEUE response missing messageId", "MISSING_MESSAGE_ID");
-		return decoded.messageId;
+		return runWithRetry({
+			domain: "queue",
+			operation: "enqueue",
+			retryClass: "confirmed_negative_retry"
+		}, async () => {
+			const response = await requestFrame(200, QueueCodec.encodeEnqueue(route, body, options));
+			const decoded = QueueCodec.decodeEnqueueResponse(response);
+			checkStatus(decoded, "ENQUEUE");
+			if (decoded.messageId === void 0) throw new QueueError("ENQUEUE response missing messageId", "MISSING_MESSAGE_ID");
+			return decoded.messageId;
+		});
 	};
 	const reserve = async (route, leaseSeconds, batchSize = 1, waitSeconds = 0) => {
 		assertQueueReserveRoute(route);
@@ -2759,43 +3330,55 @@ function createQueueClient(connection) {
 		let items = await reserveOnce(route, leaseSeconds, batchSize);
 		if (items.length > 0) return items;
 		const deadline = Date.now() + waitSeconds * 1e3;
-		let pendingNotifications = 0;
-		let waiter;
-		const subscription = await subscribe(route, async () => {
-			pendingNotifications += 1;
-			if (!waiter) return;
-			const resolve = waiter;
-			waiter = void 0;
-			pendingNotifications = 0;
-			resolve();
+		const wakeGate = createWakeGate();
+		const subscription = await subscribe(route, () => {
+			wakeGate.wake();
 		});
 		try {
 			while (true) {
+				const observed = wakeGate.version;
 				items = await reserveOnce(route, leaseSeconds, batchSize);
 				if (items.length > 0) return items;
 				const remainingMs = deadline - Date.now();
 				if (remainingMs <= 0) return items;
-				await new Promise((resolve) => {
-					if (pendingNotifications > 0) {
-						pendingNotifications = 0;
-						resolve();
-						return;
-					}
-					const release = () => {
-						clearTimeout(timeoutId);
-						if (waiter === release) waiter = void 0;
-						resolve();
-					};
-					const timeoutId = setTimeout(release, remainingMs);
-					waiter = release;
+				const waitPromise = wakeGate.waitAfter(observed);
+				let timeoutId = null;
+				const timeoutPromise = new Promise((resolve) => {
+					timeoutId = setTimeout(() => {
+						resolve("timeout");
+					}, remainingMs);
 				});
+				if (await Promise.race([waitPromise.then(() => {
+					if (timeoutId) clearTimeout(timeoutId);
+					return "wake";
+				}), timeoutPromise]) === "timeout") return items;
 			}
 		} finally {
-			await subscription.unsubscribe();
+			await subscription.unsubscribe().catch(() => void 0);
 		}
 	};
-	const reserveOnce = async (route, leaseSeconds, batchSize) => {
-		const response = await requestFrame(202, QueueCodec.encodeReserve(route, leaseSeconds, batchSize));
+	const reserveWhenAvailable = async function* (route, options) {
+		assertQueueReserveRoute(route);
+		const wakeGate = createWakeGate();
+		const subscription = await subscribe(route, () => {
+			wakeGate.wake();
+		});
+		try {
+			while (true) {
+				const observed = wakeGate.version;
+				const items = await reserveOnce(route, options.leaseSeconds, options.batchSize ?? 1, options.signal);
+				if (items.length > 0) {
+					yield items;
+					continue;
+				}
+				await wakeGate.waitAfter(observed, { signal: options.signal });
+			}
+		} finally {
+			await subscription.unsubscribe().catch(() => void 0);
+		}
+	};
+	const reserveOnce = async (route, leaseSeconds, batchSize, signal) => {
+		const response = await requestFrame(202, QueueCodec.encodeReserve(route, leaseSeconds, batchSize), signal);
 		const decoded = QueueCodec.decodeReserveResponse(response);
 		checkStatus(decoded, "RESERVE");
 		return (decoded.items ?? []).map((item) => createQueueItem(item.id, item.token, item.body, route, connection));
@@ -2807,8 +3390,8 @@ function createQueueClient(connection) {
 		if (existing) return addLocalSubscription(pattern, existing.subId, handler);
 		return addLocalSubscription(pattern, await subscribeWire(pattern), handler);
 	};
-	const subscribeWire = async (pattern) => {
-		const response = await requestFrame(207, QueueCodec.encodeSubscribe(wireWatchPattern(pattern)));
+	const subscribeWire = async (pattern, request = requestFrame) => {
+		const response = await request(207, QueueCodec.encodeSubscribe(wireWatchPattern(pattern)));
 		const decoded = QueueCodec.decodeSubscribeResponse(response);
 		checkStatus(decoded, "SUBSCRIBE");
 		if (decoded.subId === void 0) throw new QueueError("SUBSCRIBE response missing subId", "MISSING_SUB_ID");
@@ -2875,11 +3458,16 @@ function createQueueClient(connection) {
 			[4]: "QueueFull",
 			[5]: "InvalidDelay"
 		}[errorCode] ?? `Unknown(${errorCode})`;
-		throw new QueueError(`${operation} failed: ${response.errorMessage ?? statusName}`, statusName, errorCode);
+		throw attachResilienceMeta(new QueueError(`${operation} failed: ${response.errorMessage ?? statusName}`, statusName, errorCode), {
+			boundary: "post-send",
+			failureKind: "domain",
+			explicitNegative: true
+		});
 	};
 	return {
 		enqueue,
 		reserve,
+		reserveWhenAvailable,
 		subscribe
 	};
 }
@@ -3190,16 +3778,35 @@ function createRpcSubscription(route, unsubscribeFn) {
 */
 function createRpcResponseWriter(connection, correlationId) {
 	let sequence = 0n;
+	let stale = false;
+	let unsubscribeDisconnect = () => void 0;
+	const dispose = () => {
+		if (stale) return;
+		stale = true;
+		unsubscribeDisconnect();
+		unsubscribeDisconnect = () => void 0;
+	};
+	unsubscribeDisconnect = connection.onDisconnect(() => {
+		dispose();
+	});
 	const send = async (body, isEnd) => {
+		if (stale) throw new ConnectionError("RPC response writer is no longer valid");
 		const payload = RpcCodec.encodeResponse(correlationId, sequence++, body, isEnd);
 		try {
 			await connection.send(303, payload);
+			if (isEnd) dispose();
 		} catch (error) {
-			if (isBenignShutdownError(error, connection)) return;
+			if (isBenignShutdownError(error, connection)) {
+				dispose();
+				return;
+			}
 			throw error;
 		}
 	};
-	return { send };
+	return {
+		send,
+		dispose
+	};
 }
 function isBenignShutdownError(error, connection) {
 	if (connection.getState() !== "AUTHENTICATED") return true;
@@ -3347,7 +3954,7 @@ const RpcClient = function(connection) {
 	return createRpcClient(connection);
 };
 function createRpcClient(connection) {
-	const { requestFrame } = createDomainClient(connection);
+	const { requestFrame, requestReconnectFrame } = createDomainClient(connection);
 	const pendingRpcs = /* @__PURE__ */ new Map();
 	const workers = /* @__PURE__ */ new Map();
 	let initialized = false;
@@ -3365,7 +3972,7 @@ function createRpcClient(connection) {
 		if (workers.size === 0) return;
 		const registeredWorkers = Array.from(workers.entries());
 		workers.clear();
-		for (const [route, handler] of registeredWorkers) await registerWorker(route, handler);
+		for (const [route, handler] of registeredWorkers) await registerWorkerInternal(route, handler, requestReconnectFrame);
 	});
 	const call = async (route, body, options) => {
 		assertRpcRoute(route);
@@ -3391,13 +3998,16 @@ function createRpcClient(connection) {
 			throw error;
 		}
 	};
-	const registerWorker = async (route, handler) => {
-		assertRpcRoute(route);
-		initRpcHandler();
-		const response = await requestFrame(300, RpcCodec.encodeSubscribeWorker(route));
+	const registerWorkerInternal = async (route, handler, request = requestFrame) => {
+		const response = await request(300, RpcCodec.encodeSubscribeWorker(route));
 		const decoded = RpcCodec.decodeSubscribeWorkerResponse(response);
 		if (decoded.status !== 0) throw new RpcError(`RPC SUBSCRIBE_WORKER failed: status ${decoded.status}`, "SUBSCRIBE_FAILED", decoded.status);
 		workers.set(route, handler);
+	};
+	const registerWorker = async (route, handler) => {
+		assertRpcRoute(route);
+		initRpcHandler();
+		await registerWorkerInternal(route, handler);
 		const unsubscribeFn = async (registeredRoute) => {
 			await unregisterWorker(registeredRoute);
 		};
@@ -3466,6 +4076,8 @@ function createRpcClient(connection) {
 				try {
 					await writer.send(utf8Encoder.encode(`Handler error: ${message}`), true);
 				} catch {}
+			} finally {
+				writer.dispose();
 			}
 		});
 	};
@@ -3701,7 +4313,17 @@ function createLeaseSubscription(subId, pattern, unsubscribeFn) {
 function createLease(token, expiresAt, route, connection) {
 	let currentToken = token;
 	let currentExpiry = expiresAt;
+	let closed = false;
+	let unsubscribeDisconnect = () => void 0;
+	unsubscribeDisconnect = connection.onDisconnect(() => {
+		closed = true;
+		unsubscribeDisconnect();
+	});
+	const ensureOpen = () => {
+		if (closed) throw new LeaseError("Lease handle is no longer valid after disconnect", "CLOSED");
+	};
 	const extend = async (ttlSecs, signal) => {
+		ensureOpen();
 		const requestPayload = LeaseCodec.encodeExtend(route, currentToken, ttlSecs);
 		const data = assertSuccess(await connection.request(401, requestPayload, signal), "EXTEND");
 		if (data && data.length >= 8) currentToken = new BufferReader(data).readU64BE();
@@ -3709,12 +4331,16 @@ function createLease(token, expiresAt, route, connection) {
 		return currentExpiry;
 	};
 	const release = async (signal) => {
+		ensureOpen();
 		const payload = LeaseCodec.encodeRelease(route, currentToken);
 		assertSuccess(await connection.request(402, payload, signal), "RELEASE");
+		closed = true;
+		unsubscribeDisconnect();
 	};
 	const getExpiry = () => currentExpiry;
 	const testOnlyInvalidToken = () => currentToken + 1n;
 	const testOnlyExtendWithToken = async (tokenToUse, ttlSecs, signal) => {
+		ensureOpen();
 		const requestPayload = LeaseCodec.encodeExtend(route, tokenToUse, ttlSecs);
 		const data = assertSuccess(await connection.request(401, requestPayload, signal), "EXTEND");
 		if (data && data.length >= 8) currentToken = new BufferReader(data).readU64BE();
@@ -3722,8 +4348,11 @@ function createLease(token, expiresAt, route, connection) {
 		return currentExpiry;
 	};
 	const testOnlyReleaseWithToken = async (tokenToUse, signal) => {
+		ensureOpen();
 		const payload = LeaseCodec.encodeRelease(route, tokenToUse);
 		assertSuccess(await connection.request(402, payload, signal), "RELEASE");
+		closed = true;
+		unsubscribeDisconnect();
 	};
 	return {
 		extend,
@@ -3740,7 +4369,7 @@ function createLease(token, expiresAt, route, connection) {
 * Lease domain client.
 */
 function createLeaseClient(connection) {
-	const { requestFrame } = createDomainClient(connection);
+	const { requestFrame, requestReconnectFrame, runWithRetry } = createDomainClient(connection);
 	const subscriptionsByPattern = /* @__PURE__ */ new Map();
 	let initialized = false;
 	let nextHandlerId = 1;
@@ -3752,7 +4381,7 @@ function createLeaseClient(connection) {
 		}));
 		subscriptionsByPattern.clear();
 		for (const subscription of subscriptions) {
-			const subId = await subscribeWire(subscription.pattern);
+			const subId = await subscribeWire(subscription.pattern, requestReconnectFrame);
 			subscriptionsByPattern.set(subscription.pattern, {
 				subId,
 				handlers: new Map(subscription.handlers)
@@ -3769,16 +4398,22 @@ function createLeaseClient(connection) {
 	};
 	const query = async (route) => {
 		assertExactLeaseRoute(route);
-		const response = await requestFrame(403, LeaseCodec.encodeQuery(route));
-		const decoded = LeaseCodec.decodeQueryResponse(response);
-		if (decoded.status !== 0) throw new LeaseError("QUERY failed", "QUERY_FAILED", decoded.status);
-		return {
-			isHeld: decoded.isHeld ?? false,
-			owner: decoded.owner,
-			token: decoded.token,
-			ttlRemainingSecs: decoded.ttlRemainingSecs,
-			expiresAt: decoded.expiresAt
-		};
+		return runWithRetry({
+			domain: "lease",
+			operation: "query",
+			retryClass: "replayable_read"
+		}, async () => {
+			const response = await requestFrame(403, LeaseCodec.encodeQuery(route));
+			const decoded = LeaseCodec.decodeQueryResponse(response);
+			if (decoded.status !== 0) throw new LeaseError("QUERY failed", "QUERY_FAILED", decoded.status);
+			return {
+				isHeld: decoded.isHeld ?? false,
+				owner: decoded.owner,
+				token: decoded.token,
+				ttlRemainingSecs: decoded.ttlRemainingSecs,
+				expiresAt: decoded.expiresAt
+			};
+		});
 	};
 	const subscribe = async (pattern, handler) => {
 		assertExactLeaseRoute(pattern);
@@ -3787,8 +4422,8 @@ function createLeaseClient(connection) {
 		if (existing) return addLocalSubscription(pattern, existing.subId, handler);
 		return addLocalSubscription(pattern, await subscribeWire(pattern), handler);
 	};
-	const subscribeWire = async (pattern) => {
-		const response = await requestFrame(407, LeaseCodec.encodeSubscribe(pattern));
+	const subscribeWire = async (pattern, request = requestFrame) => {
+		const response = await request(407, LeaseCodec.encodeSubscribe(pattern));
 		const decoded = LeaseCodec.decodeSubscribeResponse(response);
 		if (decoded.subId === void 0) throw new LeaseError("SUBSCRIBE failed", "SUBSCRIBE_FAILED");
 		return decoded.subId;
@@ -3935,7 +4570,7 @@ function createNoticeSubscription(subId, pattern, unsubscribeFn) {
 * Notice domain client.
 */
 function createNoticeClient(connection) {
-	const { requestFrame } = createDomainClient(connection);
+	const { requestFrame, requestReconnectFrame } = createDomainClient(connection);
 	const subscriptionsByPattern = /* @__PURE__ */ new Map();
 	const patternsBySubId = /* @__PURE__ */ new Map();
 	let initialized = false;
@@ -3949,7 +4584,7 @@ function createNoticeClient(connection) {
 		subscriptionsByPattern.clear();
 		patternsBySubId.clear();
 		for (const subscription of subscriptions) {
-			const subId = await subscribeWire(subscription.pattern);
+			const subId = await subscribeWire(subscription.pattern, requestReconnectFrame);
 			subscriptionsByPattern.set(subscription.pattern, {
 				subId,
 				handlers: new Map(subscription.handlers)
@@ -3975,8 +4610,8 @@ function createNoticeClient(connection) {
 		if (existing) return addLocalSubscription(pattern, existing.subId, handler);
 		return addLocalSubscription(pattern, await subscribeWire(pattern), handler);
 	};
-	const subscribeWire = async (pattern) => {
-		const response = await requestFrame(501, NoticeCodec.encodeSubscribe(pattern));
+	const subscribeWire = async (pattern, request = requestFrame) => {
+		const response = await request(501, NoticeCodec.encodeSubscribe(pattern));
 		const decoded = NoticeCodec.decodeSubscribeResponse(response);
 		if (decoded.subId === void 0) throw new NoticeError("SUBSCRIBE response missing subId", "MISSING_SUB_ID");
 		return decoded.subId;
@@ -4418,8 +5053,10 @@ function createStreamSubscription(subId, pattern, unsubscribeFn) {
 //#region src/domains/stream/session.ts
 function createStreamSession(connection, _route, sessionId) {
 	let closed = false;
-	const unsubscribeDisconnect = connection.onDisconnect(() => {
+	let unsubscribeDisconnect = () => void 0;
+	unsubscribeDisconnect = connection.onDisconnect(() => {
 		closed = true;
+		unsubscribeDisconnect();
 	});
 	const ensureOpen = () => {
 		if (closed) throw new StreamError("Stream session already closed", "SESSION_CLOSED");
@@ -4493,7 +5130,7 @@ function isAbortSignal(value) {
 * 3. `commit()` or `rollback()` finalizes the session
 */
 function createStreamClient(connection) {
-	const { requestFrame } = createDomainClient(connection);
+	const { requestFrame, requestReconnectFrame, runWithRetry } = createDomainClient(connection);
 	const subscriptionsByPattern = /* @__PURE__ */ new Map();
 	const patternsBySubId = /* @__PURE__ */ new Map();
 	let initialized = false;
@@ -4507,7 +5144,7 @@ function createStreamClient(connection) {
 		subscriptionsByPattern.clear();
 		patternsBySubId.clear();
 		for (const subscription of snapshot) {
-			const subId = await subscribeWire(subscription.pattern);
+			const subId = await subscribeWire(subscription.pattern, requestReconnectFrame);
 			subscriptionsByPattern.set(subscription.pattern, {
 				subId,
 				handlers: new Map(subscription.handlers)
@@ -4525,43 +5162,89 @@ function createStreamClient(connection) {
 	};
 	const readPage = async (route, startOffset, limit = 100, options) => {
 		assertStreamPattern(route);
-		const response = await requestFrame(604, StreamCodec.encodeRead(route, startOffset, limit, options), options?.signal);
-		const decoded = StreamCodec.decodeReadResponse(response);
-		checkStatus(decoded.status, "READ");
-		return {
-			items: decoded.items,
-			cursor: decoded.cursor ?? {
-				lastResourceOffset: startOffset,
-				lastAreaOffset: void 0,
-				lastRealmOffset: void 0,
-				hasMore: false
-			}
-		};
+		return runWithRetry({
+			domain: "stream",
+			operation: "read",
+			retryClass: "replayable_read",
+			signal: options?.signal
+		}, async () => {
+			const response = await requestFrame(604, StreamCodec.encodeRead(route, startOffset, limit, options), options?.signal);
+			const decoded = StreamCodec.decodeReadResponse(response);
+			checkStatus(decoded.status, "READ");
+			return {
+				items: decoded.items,
+				cursor: decoded.cursor ?? {
+					lastResourceOffset: startOffset,
+					lastAreaOffset: void 0,
+					lastRealmOffset: void 0,
+					hasMore: false
+				}
+			};
+		});
 	};
 	const read = async (route, startOffset, limit = 100, options) => {
 		const page = await readPage(route, startOffset, limit, options);
 		return StreamCodec.flattenStreamReadItems(page.items);
 	};
+	const readWhenCommitted = async function* (route, options) {
+		assertStreamPattern(route);
+		const wakeGate = createWakeGate();
+		const subscription = await subscribe(route, () => {
+			wakeGate.wake();
+		});
+		try {
+			let offset = options.offset;
+			while (true) {
+				const observed = wakeGate.version;
+				const page = await readPage(route, offset, options.batchSize ?? 100, {
+					maxBytes: options.maxBytes,
+					filter: options.filter,
+					signal: options.signal
+				});
+				if (page.items.length > 0) {
+					offset = page.cursor.lastResourceOffset + 1n;
+					const records = StreamCodec.flattenStreamReadItems(page.items);
+					if (records.length > 0) yield records;
+				}
+				if (page.cursor.hasMore) continue;
+				await wakeGate.waitAfter(observed, { signal: options.signal });
+			}
+		} finally {
+			await subscription.unsubscribe().catch(() => void 0);
+		}
+	};
 	const consume = async (route, startOffset, limit = 100, options) => {
 		return createAsyncIterableIterator(createSliceIterator(await read(route, startOffset, limit, options)));
 	};
 	const peek = async (route) => {
 		assertStreamRoute(route);
-		const response = await requestFrame(605, StreamCodec.encodeLast(route));
-		const decoded = StreamCodec.decodeLastResponse(response);
-		checkStatus(decoded.status, "LAST");
-		return decoded.record ?? null;
+		return runWithRetry({
+			domain: "stream",
+			operation: "last",
+			retryClass: "replayable_read"
+		}, async () => {
+			const response = await requestFrame(605, StreamCodec.encodeLast(route));
+			const decoded = StreamCodec.decodeLastResponse(response);
+			checkStatus(decoded.status, "LAST");
+			return decoded.record ?? null;
+		});
 	};
 	const metadata = async (route) => {
 		assertStreamRoute(route);
-		const response = await requestFrame(606, StreamCodec.encodeMetadata(route));
-		const decoded = StreamCodec.decodeMetadataResponse(response);
-		checkStatus(decoded.status, "GET_METADATA");
-		return decoded.metadata ?? {
-			firstOffset: 0n,
-			lastOffset: 0n,
-			recordCount: 0n
-		};
+		return runWithRetry({
+			domain: "stream",
+			operation: "metadata",
+			retryClass: "replayable_read"
+		}, async () => {
+			const response = await requestFrame(606, StreamCodec.encodeMetadata(route));
+			const decoded = StreamCodec.decodeMetadataResponse(response);
+			checkStatus(decoded.status, "GET_METADATA");
+			return decoded.metadata ?? {
+				firstOffset: 0n,
+				lastOffset: 0n,
+				recordCount: 0n
+			};
+		});
 	};
 	const subscribe = async (pattern, handler) => {
 		assertStreamPattern(pattern);
@@ -4570,8 +5253,8 @@ function createStreamClient(connection) {
 		if (existing) return addLocalSubscription(pattern, existing.subId, handler);
 		return addLocalSubscription(pattern, await subscribeWire(pattern), handler);
 	};
-	const subscribeWire = async (pattern) => {
-		const response = await requestFrame(607, StreamCodec.encodeSubscribe(pattern));
+	const subscribeWire = async (pattern, request = requestFrame) => {
+		const response = await request(607, StreamCodec.encodeSubscribe(pattern));
 		const decoded = StreamCodec.decodeSubscribeResponse(response);
 		checkStatus(decoded.status, "SUBSCRIBE");
 		if (decoded.subId === void 0) throw new StreamError("SUBSCRIBE response missing subId", "MISSING_SESSION_ID");
@@ -4649,6 +5332,7 @@ function createStreamClient(connection) {
 		begin,
 		readPage,
 		read,
+		readWhenCommitted,
 		consume,
 		peek,
 		metadata,
@@ -4826,9 +5510,10 @@ var ScheduleError$1 = class extends Error {
 * Schedule domain client.
 */
 function createScheduleClient(connection) {
-	const { requestFrame } = createDomainClient(connection);
+	const { requestFrame, requestReconnectFrame } = createDomainClient(connection);
 	const subscriptionsByPattern = /* @__PURE__ */ new Map();
 	const patternsBySubId = /* @__PURE__ */ new Map();
+	const pendingNotificationsBySubId = /* @__PURE__ */ new Map();
 	let notifyHandlerInitialized = false;
 	let nextHandlerId = 1;
 	connection.onReconnect(async () => {
@@ -4839,8 +5524,9 @@ function createScheduleClient(connection) {
 		}));
 		subscriptionsByPattern.clear();
 		patternsBySubId.clear();
+		pendingNotificationsBySubId.clear();
 		for (const subscription of subscriptions) {
-			const subId = await subscribeWire(subscription.pattern);
+			const subId = await subscribeWire(subscription.pattern, requestReconnectFrame);
 			subscriptionsByPattern.set(subscription.pattern, {
 				subId,
 				handlers: new Map(subscription.handlers)
@@ -4863,6 +5549,29 @@ function createScheduleClient(connection) {
 		const decoded = ScheduleCodec.decodeListResponse(assertSuccess(response, "LIST"));
 		return [decoded.entries, decoded.totalCount];
 	};
+	const waitForNotifications = async function* (route, options = {}) {
+		assertConcreteScheduleRoute(route);
+		const wakeGate = createWakeGate();
+		const pendingNotifications = [];
+		const subscription = await subscribe(route, (notification) => {
+			pendingNotifications.push(notification);
+			wakeGate.wake();
+		});
+		try {
+			while (true) {
+				const notification = pendingNotifications.shift();
+				if (notification) {
+					yield notification;
+					continue;
+				}
+				const observed = wakeGate.version;
+				if (pendingNotifications.length > 0) continue;
+				await wakeGate.waitAfter(observed, { signal: options.signal });
+			}
+		} finally {
+			await subscription.unsubscribe().catch(() => void 0);
+		}
+	};
 	const subscribe = async (pattern, handler) => {
 		assertConcreteScheduleRoute(pattern);
 		initNotifyHandler();
@@ -4870,8 +5579,8 @@ function createScheduleClient(connection) {
 		if (existing) return addLocalSubscription(pattern, existing.subId, handler);
 		return addLocalSubscription(pattern, await subscribeWire(pattern), handler);
 	};
-	const subscribeWire = async (pattern) => {
-		const response = await requestFrame(703, ScheduleCodec.encodeSubscribe(pattern));
+	const subscribeWire = async (pattern, request = requestFrame) => {
+		const response = await request(703, ScheduleCodec.encodeSubscribe(pattern));
 		return ScheduleCodec.decodeSubscribeResponse(assertSuccess(response, "SUBSCRIBE")).subId;
 	};
 	const addLocalSubscription = (pattern, subId, handler) => {
@@ -4886,6 +5595,7 @@ function createScheduleClient(connection) {
 			patternsBySubId.set(subId, pattern);
 		}
 		subscription.handlers.set(handlerId, handler);
+		flushPendingNotifications(subId);
 		return createScheduleSubscription(subId, pattern, async () => {
 			await unsubscribe(pattern, handlerId);
 		});
@@ -4897,6 +5607,7 @@ function createScheduleClient(connection) {
 		if (subscription.handlers.size > 0) return;
 		subscriptionsByPattern.delete(pattern);
 		patternsBySubId.delete(subscription.subId);
+		pendingNotificationsBySubId.delete(subscription.subId);
 		const response = await requestFrame(704, ScheduleCodec.encodeUnsubscribe(pattern));
 		ScheduleCodec.decodeUnsubscribeResponse(assertSuccess(response, "UNSUBSCRIBE"));
 	};
@@ -4907,16 +5618,40 @@ function createScheduleClient(connection) {
 			try {
 				const decoded = ScheduleCodec.decodeNotification(payload);
 				const pattern = patternsBySubId.get(decoded.subId);
-				if (!pattern) return;
+				if (!pattern) {
+					queuePendingNotification(decoded.subId, { payload: decoded.payload });
+					return;
+				}
 				const subscription = subscriptionsByPattern.get(pattern);
-				if (!subscription) return;
-				const notification = { payload: decoded.payload };
-				for (const handler of subscription.handlers.values()) connection.dispatchAsyncHandler(async () => {
-					await handler(notification);
-				});
+				if (!subscription) {
+					queuePendingNotification(decoded.subId, { payload: decoded.payload });
+					return;
+				}
+				dispatchNotification(subscription, { payload: decoded.payload });
 			} catch {}
 		});
 	};
+	const queuePendingNotification = (subId, notification) => {
+		const existing = pendingNotificationsBySubId.get(subId);
+		if (existing) {
+			existing.push(notification);
+			return;
+		}
+		pendingNotificationsBySubId.set(subId, [notification]);
+	};
+	const flushPendingNotifications = (subId) => {
+		const pending = pendingNotificationsBySubId.get(subId);
+		if (!pending || pending.length === 0) return;
+		pendingNotificationsBySubId.delete(subId);
+		const subscription = Array.from(subscriptionsByPattern.values()).find((entry) => entry.subId === subId);
+		if (!subscription) return;
+		for (const notification of pending) dispatchNotification(subscription, notification);
+	};
+	const dispatchNotification = (subscription, notification) => {
+		for (const handler of subscription.handlers.values()) connection.dispatchAsyncHandler(async () => {
+			await handler(notification);
+		});
+	};
 	const assertSuccess = (payload, operation) => {
 		const result = parseStandardResponse(payload);
 		if (result.success) return result.data;
@@ -4933,7 +5668,8 @@ function createScheduleClient(connection) {
 		create,
 		cancel,
 		list,
-		subscribe
+		subscribe,
+		waitForNotifications
 	};
 }
 const ScheduleClient = function(connection) {
@@ -4944,6 +5680,39 @@ function assertConcreteScheduleRoute(route) {
 }
 //#endregion
 //#region src/client/client.ts
+const abortError = () => {
+	const error = /* @__PURE__ */ new Error("The operation was aborted");
+	error.name = "AbortError";
+	return error;
+};
+const throwIfAborted = (signal) => {
+	if (signal?.aborted) throw abortError();
+};
+const waitForSharedPromise = async (promise, signal) => {
+	if (!signal) return promise;
+	if (signal.aborted) throw abortError();
+	return await new Promise((resolve, reject) => {
+		let settled = false;
+		const cleanup = () => {
+			signal.removeEventListener("abort", onAbort);
+		};
+		const settle = (callback) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			callback();
+		};
+		const onAbort = () => {
+			settle(() => reject(abortError()));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then((value) => {
+			settle(() => resolve(value));
+		}, (error) => {
+			settle(() => reject(error));
+		});
+	});
+};
 function createClient(config) {
 	const observability = config.observability;
 	const resolvedConfig = {
@@ -4955,12 +5724,25 @@ function createClient(config) {
 		maxRequestQueueSize: 1024,
 		observability: config.observability ?? {},
 		reconnect: {
-			enabled: false,
+			enabled: true,
 			maxAttempts: Infinity,
 			backoffMs: 250,
 			maxBackoffMs: 5e3,
 			...config.reconnect
 		},
+		retry: {
+			enabled: true,
+			maxAttempts: 3,
+			backoffMs: 100,
+			maxBackoffMs: 1e3,
+			...config.retry
+		},
+		heartbeat: {
+			enabled: true,
+			intervalMs: 1e4,
+			timeoutMs: 3e4,
+			...config.heartbeat
+		},
 		asyncHandlers: {
 			maxConcurrency: Infinity,
 			timeoutMs: 3e4,
@@ -4977,34 +5759,72 @@ function createClient(config) {
 	let noticeClient = null;
 	let streamClient = null;
 	let scheduleClient = null;
+	let clientClosed = false;
+	let pendingConnectPromise = null;
 	const resolveTokenProvider = () => {
 		if (resolvedConfig.tokenProvider) return resolvedConfig.tokenProvider;
 		return () => "";
 	};
 	const ensureConnection = () => {
+		if (clientClosed) throw new ConnectionError("Client is closed", { state: "CLOSED" });
 		if (!connection) throw new ConnectionError("Not connected to Fitz server. Call connect() first.", { state: getState() });
 		return connection;
 	};
-	const connect = async (options = {}) => {
-		if (connection?.isConnected()) return;
+	const createOwnedConnection = () => {
+		if (connection) return connection;
 		connection = createConnection(() => createTransport(resolvedConfig.url, resolvedConfig.transport, {
 			timeout: resolvedConfig.timeout,
-			maxFrameSize: resolvedConfig.maxFrameSize
+			maxFrameSize: resolvedConfig.maxFrameSize,
+			receiveTimeout: resolvedConfig.heartbeat?.enabled === false
 		}), resolveTokenProvider(), {
 			timeout: resolvedConfig.timeout,
 			authSettleDelayMs: resolvedConfig.authSettleDelayMs,
 			maxInFlightRequests: resolvedConfig.maxInFlightRequests,
 			maxRequestQueueSize: resolvedConfig.maxRequestQueueSize,
 			reconnect: resolvedConfig.reconnect,
+			retry: resolvedConfig.retry,
+			heartbeat: resolvedConfig.heartbeat,
 			observability,
 			asyncHandlers: resolvedConfig.asyncHandlers
 		});
-		await connection.connect(options);
+		return connection;
+	};
+	const connect = async (options = {}) => {
+		if (clientClosed) throw new ConnectionError("Client is closed", { state: "CLOSED" });
+		throwIfAborted(options.signal);
+		const activeConnection = createOwnedConnection();
+		if (activeConnection.isConnected()) return;
+		if (pendingConnectPromise) {
+			await waitForSharedPromise(pendingConnectPromise, options.signal);
+			return;
+		}
+		const state = activeConnection.getState();
+		const trackedConnectPromise = (state === "CONNECTING" || state === "CONNECTED" || state === "AUTHENTICATING" || state === "RECONNECTING" || state === "DISCONNECTED" && typeof activeConnection.shouldWaitForReconnect === "function" && activeConnection.shouldWaitForReconnect() ? typeof activeConnection.waitUntilReady === "function" ? activeConnection.waitUntilReady(void 0, resolvedConfig.timeout) : activeConnection.connect() : activeConnection.connect(options)).finally(() => {
+			if (pendingConnectPromise === trackedConnectPromise) pendingConnectPromise = null;
+		});
+		pendingConnectPromise = trackedConnectPromise;
+		await waitForSharedPromise(trackedConnectPromise, options.signal);
 	};
 	const close = async () => {
+		if (clientClosed && !connection) {
+			kvClient = null;
+			queueClient = null;
+			rpcClient = null;
+			leaseClient = null;
+			noticeClient = null;
+			streamClient = null;
+			scheduleClient = null;
+			return;
+		}
+		clientClosed = true;
+		pendingConnectPromise = null;
 		if (connection) {
-			await connection.close();
-			connection = null;
+			const activeConnection = connection;
+			try {
+				await activeConnection.close();
+			} finally {
+				if (connection === activeConnection) connection = null;
+			}
 		}
 		kvClient = null;
 		queueClient = null;
@@ -5015,7 +5835,7 @@ function createClient(config) {
 		scheduleClient = null;
 	};
 	const isConnected = () => {
-		return connection?.isConnected() ?? false;
+		return !clientClosed && (connection?.isConnected() ?? false);
 	};
 	const kv = () => {
 		const activeConnection = ensureConnection();
@@ -5056,7 +5876,10 @@ function createClient(config) {
 		return ensureConnection().getUrl();
 	};
 	const getState = () => {
-		return connection?.getState() ?? "DISCONNECTED";
+		if (clientClosed) return "CLOSED";
+		if (!connection) return "DISCONNECTED";
+		const state = connection.getState();
+		return state === "CLOSED" ? "DISCONNECTED" : state;
 	};
 	return {
 		config: resolvedConfig,
@@ -5282,6 +6105,7 @@ exports.TimeoutError = TimeoutError;
 exports.TransportError = TransportError;
 exports.createClient = createClient;
 exports.createTaskGroup = createTaskGroup;
+exports.createWakeGate = createWakeGate;
 exports.isRetryable = isRetryable;
 
 //# sourceMappingURL=index.cjs.map