@camera.ui/transport 0.0.30 → 0.1.1

package/dist/transports/nats.js

@@ -1,5 +1,5 @@
+import { n as refusedByServer, t as classifyClose } from "../closeCodes-CltSRjdJ.js";
 import { n as isEndpointChange, r as isSameTarget, t as TransportEmitter } from "../contract-dt1m8U-o.js";
-import { t as classifyClose } from "../closeCodes-ClWJVOpq.js";
 import { createRPCClient } from "@camera.ui/rpc";
 //#region src/transports/nats.ts
 var NATS_SPEC = {
@@ -8,6 +8,8 @@ var NATS_SPEC = {
 	phaseGating: true
 };
 var RESOLVE_RETRY_MIN_MS = 3e3;
+var DIAL_GRACE_MS = 2e3;
+var CLIENT_DEFAULT_PING_INTERVAL_MS = 12e4;
 function newConnId() {
 	const c = globalThis.crypto;
 	if (c?.randomUUID) return c.randomUUID();
@@ -35,6 +37,8 @@ function createNatsTransport(options = {}) {
 	const pingInterval = options.pingInterval ?? 25e3;
 	const pingTimeout = options.pingTimeout ?? 2e4;
 	const maxPingOut = options.maxPingOut ?? 1;
+	const heartbeatInterval = pingInterval || CLIENT_DEFAULT_PING_INTERVAL_MS;
+	const heartbeatWindow = heartbeatInterval + (pingTimeout > 0 ? pingTimeout : heartbeatInterval);
 	const logger = options.logger;
 	const resolveServers = options.resolveServers;
 	const resolveRefreshMs = options.resolveRefreshMs ?? 0;
@@ -48,16 +52,19 @@ function createNatsTransport(options = {}) {
 	let disposed = false;
 	let connId = null;
 	let applyEpoch = 0;
-	let pendingConnectAbort = null;
+	let dialAbort = null;
+	let dialAttempt = null;
+	let parked = false;
 	let poolRefreshAt = 0;
 	let poolRefreshing = false;
+	let dialAccess;
+	let probedUntil = 0;
 	function buildServers(target) {
 		const url = new URL(target.endpoint.url);
 		const wsProtocol = url.protocol === "https:" ? "wss:" : "ws:";
 		const port = url.port || (url.protocol === "https:" ? "443" : "80");
 		const prefix = url.pathname.replace(/\/$/, "");
 		const params = new URLSearchParams({ token: target.tokens.access });
-		if (target.tokens.proxySession) params.set("session", target.tokens.proxySession);
 		if (connId) params.set("connId", connId);
 		return [`${wsProtocol}//${url.hostname}:${port}${prefix}${proxyPath}?${params.toString()}`];
 	}
@@ -171,13 +178,14 @@ function createNatsTransport(options = {}) {
 		})().catch(() => {});
 	}
 	function handleErrorEvent(event) {
-		const message = stringifyError(event.data);
+		const payload = event.error ?? event.data;
+		const message = stringifyError(payload ?? "server error");
 		if (message.toLowerCase().includes("permissions violation")) {
 			logger?.warn(`permission violation (connection stays up): ${message}`);
 			return;
 		}
-		const cls = classifyClose(typeof event.data === "object" && event.data !== null ? {
-			...event.data,
+		const cls = classifyClose(typeof payload === "object" && payload !== null ? {
+			...payload,
 			message
 		} : message);
 		if (cls === "auth-expired") {
@@ -185,102 +193,172 @@ function createNatsTransport(options = {}) {
 				resign(message);
 				return;
 			}
-			emitter.emit("auth-error", { message });
+			emitter.emit("auth-error", {
+				message,
+				access: dialAccess
+			});
 			return;
 		}
 		if (cls === "forbidden") {
+			if (refusedByServer(payload)) {
+				park(message);
+				return;
+			}
 			logger?.warn(`forbidden by server: ${message}`);
-			markDown(`forbidden: ${message}`);
+			markDown(forbiddenError(message));
 			return;
 		}
 		markDown(message);
 	}
+	function park(message) {
+		parked = true;
+		const dropped = proxy;
+		if (dropped) {
+			stopStatusMonitor();
+			stopRefresh();
+			proxy = null;
+			try {
+				dropped.abortClose();
+			} catch {}
+		}
+		logger?.warn(`forbidden by server: ${message}`);
+		markDown(forbiddenError(message));
+		if (dropped) notifyClient();
+	}
 	async function rebuildClient(target, epoch) {
 		logger?.debug(`rebuildClient start (epoch=${epoch})`);
-		const t0 = Date.now();
 		stopStatusMonitor();
 		stopRefresh();
-		pendingConnectAbort?.abort();
+		dialAbort?.abort();
+		parked = false;
 		if (proxy) {
 			try {
 				proxy.abortClose();
 			} catch {}
 			proxy = null;
+			markDown("endpoint-changed");
 			notifyClient();
 		}
-		connId = newConnId();
-		let servers;
+		const abort = new AbortController();
+		dialAbort = abort;
 		try {
-			servers = await serversFor(target);
-		} catch (err) {
-			if (disposed || epoch !== applyEpoch) return;
-			const msg = stringifyError(err);
-			logger?.debug(`rebuildClient resolve FAILED: ${msg}`);
-			markDown(msg);
-			throw err;
+			for (let retry = 0;; retry++) {
+				if (retry > 0) {
+					const wait = retryDelay(retry - 1);
+					logger?.debug(`rebuildClient retry in ${wait}ms`);
+					await sleep(wait, abort.signal);
+					if (disposed || epoch !== applyEpoch) return;
+				}
+				if (await dialOnce(target, epoch, abort.signal)) return;
+			}
+		} finally {
+			if (dialAbort === abort) dialAbort = null;
 		}
-		if (disposed || epoch !== applyEpoch) return;
-		const next = createRPCClient({
-			servers,
-			name: clientName,
-			connId,
-			auth: {
-				user: natsUser,
-				password: natsPassword
-			},
-			reconnect: true,
-			maxReconnectAttempts: -1,
-			reconnectTimeWait,
-			reconnectionDelayMax,
-			reconnectionRandomizationFactor,
-			timeout,
-			connectTimeout,
-			pingInterval,
-			pingTimeout,
-			maxPingOut,
-			ignoreAuthErrorAbort: true
-		});
-		const connectAbort = new AbortController();
-		pendingConnectAbort = connectAbort;
+	}
+	async function dialOnce(target, epoch, signal) {
+		const t0 = Date.now();
+		let settle;
+		const attempt = {
+			startedAt: t0,
+			settled: new Promise((resolve) => settle = resolve)
+		};
+		dialAttempt = attempt;
 		try {
-			await next.connect({ signal: connectAbort.signal });
-		} catch (err) {
+			connId = newConnId();
+			let servers;
 			try {
-				next.abortClose();
-			} catch {}
-			if (disposed || epoch !== applyEpoch) return;
-			const msg = err instanceof Error ? err.message : String(err);
-			logger?.debug(`rebuildClient connect FAILED after ${Date.now() - t0}ms: ${msg}`);
-			if (!resolveServers && classifyClose(err instanceof Error ? err : msg) === "auth-expired") emitter.emit("auth-error", { message: msg });
-			markDown(msg);
-			throw err;
-		} finally {
-			if (pendingConnectAbort === connectAbort) pendingConnectAbort = null;
-		}
-		if (disposed || epoch !== applyEpoch) {
+				servers = await serversFor(target);
+			} catch (err) {
+				if (disposed || epoch !== applyEpoch) return true;
+				const msg = stringifyError(err);
+				logger?.debug(`rebuildClient resolve FAILED: ${msg}`);
+				markDown(msg);
+				return false;
+			}
+			if (disposed || epoch !== applyEpoch) return true;
+			dialAccess = target.tokens.access;
+			const next = createRPCClient({
+				servers,
+				name: clientName,
+				connId,
+				auth: {
+					user: natsUser,
+					password: natsPassword
+				},
+				reconnect: true,
+				maxReconnectAttempts: -1,
+				reconnectTimeWait,
+				reconnectionDelayMax,
+				reconnectionRandomizationFactor,
+				timeout,
+				connectTimeout,
+				pingInterval,
+				pingTimeout,
+				maxPingOut,
+				ignoreAuthErrorAbort: true,
+				waitOnFirstConnect: false
+			});
 			try {
-				next.abortClose();
-			} catch {}
-			return;
+				await next.connect({ signal });
+			} catch (err) {
+				try {
+					next.abortClose();
+				} catch {}
+				if (disposed || epoch !== applyEpoch) return true;
+				const msg = err instanceof Error ? err.message : String(err);
+				logger?.debug(`rebuildClient connect FAILED after ${Date.now() - t0}ms: ${msg}`);
+				const cls = classifyClose(err instanceof Error ? err : msg);
+				if (cls === "forbidden") {
+					park(msg);
+					throw err;
+				}
+				if (cls === "auth-expired" && !resolveServers) {
+					parked = true;
+					emitter.emit("auth-error", {
+						message: msg,
+						access: target.tokens.access
+					});
+					markDown(msg);
+					throw err;
+				}
+				markDown(msg);
+				return false;
+			}
+			if (disposed || epoch !== applyEpoch) {
+				try {
+					next.abortClose();
+				} catch {}
+				return true;
+			}
+			proxy = next;
+			logger?.debug(`rebuildClient connected in ${Date.now() - t0}ms`);
+			markUp();
+			notifyClient();
+			startStatusMonitor(next);
+			startRefresh(next);
+			return true;
+		} finally {
+			settle();
+			if (dialAttempt === attempt) dialAttempt = null;
 		}
-		proxy = next;
-		logger?.debug(`rebuildClient connected in ${Date.now() - t0}ms`);
-		markUp();
-		notifyClient();
-		startStatusMonitor(next);
-		startRefresh(next);
+	}
+	function retryDelay(retry) {
+		const base = reconnectionDelayMax > 0 ? Math.min(reconnectTimeWait * 2 ** retry, reconnectionDelayMax) : reconnectTimeWait;
+		const spread = base * reconnectionRandomizationFactor;
+		return Math.round(base - spread + Math.random() * 2 * spread);
 	}
 	async function apply(target) {
 		if (disposed) throw new Error("nats-transport disposed");
-		if (isSameTarget(currentTarget, target)) return;
+		if (isSameTarget(currentTarget, target) && (!target || proxy || dialAbort || parked)) return;
 		const epoch = ++applyEpoch;
 		const endpointChanged = isEndpointChange(currentTarget, target);
 		currentTarget = target;
 		if (!target) {
 			stopStatusMonitor();
 			stopRefresh();
-			pendingConnectAbort?.abort();
-			pendingConnectAbort = null;
+			dialAbort?.abort();
+			dialAbort = null;
+			parked = false;
 			if (proxy) {
 				try {
 					proxy.abortClose();
@@ -292,20 +370,19 @@ function createNatsTransport(options = {}) {
 			return;
 		}
 		if (endpointChanged || !proxy) {
-			try {
-				await rebuildClient(target, epoch);
-			} catch (err) {
-				if (epoch === applyEpoch && currentTarget === target) currentTarget = null;
-				throw err;
-			}
+			await rebuildClient(target, epoch);
 			return;
 		}
 		const p = proxy;
 		const newServers = await serversFor(target);
-		if (proxy === p && epoch === applyEpoch) p.setServers(newServers);
+		if (epoch !== applyEpoch) return;
+		if (proxy === p) {
+			p.setServers(newServers);
+			dialAccess = target.tokens.access;
+		} else if (parked) await rebuildClient(target, epoch);
 	}
 	function health() {
-		if (status.up && proxy?.isStale) return {
+		if (status.up && proxy?.isStale && Date.now() > probedUntil) return {
 			up: false,
 			lastError: "staleConnection"
 		};
@@ -319,8 +396,8 @@ function createNatsTransport(options = {}) {
 		applyEpoch++;
 		stopStatusMonitor();
 		stopRefresh();
-		pendingConnectAbort?.abort();
-		pendingConnectAbort = null;
+		dialAbort?.abort();
+		dialAbort = null;
 		if (proxy) {
 			try {
 				proxy.abortClose();
@@ -345,6 +422,7 @@ function createNatsTransport(options = {}) {
 		const t0 = Date.now();
 		try {
 			await proxy.flush(timeoutMs);
+			probedUntil = Date.now() + heartbeatWindow;
 			logger?.debug(`probeAlive OK in ${Date.now() - t0}ms`);
 		} catch (err) {
 			logger?.debug(`probeAlive FAILED after ${Date.now() - t0}ms: ${err instanceof Error ? err.message : String(err)}`);
@@ -365,17 +443,20 @@ function createNatsTransport(options = {}) {
 	function ensureAlive() {
 		if (ensureInflight) return ensureInflight;
 		const run = async () => {
-			if (disposed || !currentTarget) return health();
+			if (disposed || !currentTarget || parked) return health();
 			if (!proxy) {
-				const epoch = ++applyEpoch;
-				try {
-					await rebuildClient(currentTarget, epoch);
-				} catch {}
+				const attempt = dialAttempt;
+				if (attempt && Date.now() - attempt.startedAt < DIAL_GRACE_MS) {
+					await attempt.settled;
+					return health();
+				}
+				rebuildClient(currentTarget, ++applyEpoch).catch(() => {});
+				await dialAttempt?.settled;
 				return health();
 			}
-			if (health().up) try {
+			if (status.up) try {
 				await probeAlive(3e3);
-				return health();
+				return status;
 			} catch {}
 			try {
 				await forceReconnect();
@@ -400,11 +481,29 @@ function createNatsTransport(options = {}) {
 		ensureAlive
 	};
 }
+function sleep(ms, signal) {
+	return new Promise((resolve) => {
+		if (signal.aborted) {
+			resolve();
+			return;
+		}
+		const timer = setTimeout(done, ms);
+		signal.addEventListener("abort", done, { once: true });
+		function done() {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", done);
+			resolve();
+		}
+	});
+}
+function forbiddenError(message) {
+	return /^forbidden\b/.test(message) ? message : `forbidden: ${message}`;
+}
 function stringifyError(value) {
 	if (value instanceof Error) return value.message;
 	if (typeof value === "string") return value;
 	try {
-		return JSON.stringify(value);
+		return JSON.stringify(value) ?? String(value);
 	} catch {
 		return String(value);
 	}

package/dist/transports/socketio.d.ts

@@ -1,7 +1,7 @@
 import { Manager, Socket } from 'socket.io-client';
 import { Logger } from '@camera.ui/logger';
 import { ConnectionTarget, TransportSpec, TransportStatus } from '../core/types.js';
-import { Transport } from './contract.js';
+import { Transport, Unsubscribe } from './contract.js';
 export type { Socket };
 export interface ResolveSocketQueryContext {
     readonly target: ConnectionTarget;
@@ -20,12 +20,15 @@ export interface SocketioTransportOptions {
     readonly reconnectionDelayMax?: number;
     readonly timeout?: number;
     readonly staleAfterMs?: number;
+    readonly releaseGraceMs?: number;
     readonly logger?: Logger;
 }
 export interface SocketioTransport extends Transport {
     readonly manager: Manager | null;
     socket(namespace?: string): Socket | null;
     ensureSocket(namespace: string): Socket | null;
+    acquire(namespace: string): Unsubscribe;
+    onRebuild(handler: () => void): Unsubscribe;
     reviveDeadSockets(): void;
     ensureAlive(): Promise<TransportStatus>;
 }