@camera.ui/transport 0.0.30 → 0.1.1

package/dist/transports/socketio.js

@@ -1,8 +1,10 @@
+import { 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 { Manager, io } from "socket.io-client";
+import { Manager } from "socket.io-client";
 //#region src/transports/socketio.ts
 var RESOLVE_RETRY_MIN_MS = 3e3;
+var PROBE_TIMEOUT_MS = 3e3;
+var RELEASE_GRACE_MS = 1e4;
 var SOCKETIO_SPEC = {
 	id: "socketio",
 	kind: "persistent",
@@ -22,17 +24,23 @@ function createSocketioTransport(options = {}) {
 	const logger = options.logger;
 	const resolveQuery = options.resolveQuery;
 	const resolveRefreshMs = options.resolveRefreshMs ?? 0;
+	const releaseGraceMs = options.releaseGraceMs ?? RELEASE_GRACE_MS;
 	const emitter = new TransportEmitter();
 	const sockets = /* @__PURE__ */ new Map();
+	const reopen = /* @__PURE__ */ new Set();
+	const rebuildListeners = /* @__PURE__ */ new Set();
+	const holds = /* @__PURE__ */ new Map();
+	const unheld = /* @__PURE__ */ new Set();
+	const releaseTimers = /* @__PURE__ */ new Map();
 	let manager = null;
 	let currentTarget = null;
-	let currentQuery = {};
 	let refreshTimer = null;
 	let queryRefreshAt = 0;
 	let queryRefreshing = false;
 	let status = { up: false };
 	let disposed = false;
 	let applyEpoch = 0;
+	let ensureInflight = null;
 	const staleAfterMs = options.staleAfterMs ?? 6e4;
 	let lastActivityAt = 0;
 	function touchActivity() {
@@ -41,18 +49,16 @@ function createSocketioTransport(options = {}) {
 	function isStaleNow() {
 		return lastActivityAt > 0 && Date.now() - lastActivityAt > staleAfterMs;
 	}
-	function buildAuth(target) {
-		const auth = { token: `Bearer ${target.tokens.access}` };
-		if (target.tokens.proxySession) auth.session = target.tokens.proxySession;
-		return auth;
+	function isDeadNow() {
+		const deadline = (manager?.engine)?._pingTimeoutTime;
+		if (typeof deadline === "number") return Date.now() > deadline;
+		return isStaleNow();
 	}
-	function buildQuery(target) {
-		const q = {};
-		if (target.tokens.proxySession) q.session = target.tokens.proxySession;
-		return q;
+	function buildAuth(target) {
+		return { token: `Bearer ${target.tokens.access}` };
 	}
 	async function queryFor(target) {
-		const base = buildQuery(target);
+		const base = {};
 		if (!resolveQuery) return base;
 		return resolveQuery({
 			target,
@@ -68,8 +74,7 @@ function createSocketioTransport(options = {}) {
 		try {
 			const query = await queryFor(target);
 			if (currentTarget !== target || disposed) return;
-			currentQuery = query;
-			for (const sock of sockets.values()) sock.io.opts.query = query;
+			if (manager) manager.opts.query = query;
 		} catch (err) {
 			logger?.warn(`query refresh failed: ${err instanceof Error ? err.message : String(err)}`);
 		} finally {
@@ -77,6 +82,14 @@ function createSocketioTransport(options = {}) {
 			queryRefreshAt = Date.now();
 		}
 	}
+	async function refreshQueryWithin(ms) {
+		let timer;
+		try {
+			await Promise.race([refreshQuery(), new Promise((resolve) => timer = setTimeout(resolve, ms))]);
+		} finally {
+			clearTimeout(timer);
+		}
+	}
 	function stopRefresh() {
 		if (refreshTimer) {
 			clearInterval(refreshTimer);
@@ -103,12 +116,20 @@ function createSocketioTransport(options = {}) {
 		logger?.debug(`markDown (${reason})`);
 		emitter.emit("down", { reason });
 	}
-	function isAuthError(msg) {
-		return classifyClose(msg) === "auth-expired";
+	function isAuthError(err) {
+		return classifyClose({
+			message: err?.message,
+			data: err?.data
+		}) === "auth-expired";
+	}
+	function dialedAccess(socket) {
+		const token = socket.auth?.token;
+		return typeof token === "string" && token.startsWith("Bearer ") ? token.slice(7) : void 0;
 	}
 	function bindMainSocketEvents(socket) {
 		socket.on("connect", () => markUp());
 		socket.on("disconnect", (reason) => {
+			if (sockets.get(mainNs) !== socket) return;
 			markDown(reason);
 			if (resolveQuery) refreshQuery();
 		});
@@ -116,8 +137,11 @@ function createSocketioTransport(options = {}) {
 			const msg = err?.message ?? "connect_error";
 			logger?.debug(`connect_error (main): ${msg}`);
 			if (resolveQuery) refreshQuery();
-			if (isAuthError(msg)) {
-				emitter.emit("auth-error", { message: msg });
+			if (isAuthError(err)) {
+				emitter.emit("auth-error", {
+					message: msg,
+					access: dialedAccess(socket)
+				});
 				return;
 			}
 			markDown(msg);
@@ -125,8 +149,10 @@ function createSocketioTransport(options = {}) {
 	}
 	function bindSecondarySocketEvents(socket) {
 		socket.on("connect_error", (err) => {
-			const msg = err?.message ?? "connect_error";
-			if (isAuthError(msg)) emitter.emit("auth-error", { message: msg });
+			if (isAuthError(err)) emitter.emit("auth-error", {
+				message: err?.message ?? "connect_error",
+				access: dialedAccess(socket)
+			});
 		});
 	}
 	function socketOrigin(target) {
@@ -135,24 +161,17 @@ function createSocketioTransport(options = {}) {
 	function socketPath(target) {
 		return `${new URL(target.endpoint.url).pathname.replace(/\/$/, "")}${path}`;
 	}
-	function openSocket(namespace, target) {
-		const url = `${socketOrigin(target)}${namespace}`;
-		const sock = io(url, {
-			path: socketPath(target),
-			auth: buildAuth(target),
-			query: currentQuery,
-			reconnection,
-			reconnectionDelay,
-			reconnectionDelayMax,
-			timeout,
-			rejectUnauthorized: false,
-			transports: ["websocket"]
-		});
+	function openSocket(namespace, mgr, target) {
+		const auth = buildAuth(target);
+		const sock = mgr.socket(namespace, { auth });
+		sock.auth = auth;
 		sockets.set(namespace, sock);
+		if (namespace === mainNs) bindMainSocketEvents(sock);
+		else bindSecondarySocketEvents(sock);
+		sock.connect();
 		return sock;
 	}
-	async function rebuildManager(target) {
-		stopRefresh();
+	async function rebuildManager(target, epoch) {
 		let query;
 		try {
 			query = await queryFor(target);
@@ -160,11 +179,10 @@ function createSocketioTransport(options = {}) {
 			markDown(err instanceof Error ? err.message : String(err));
 			throw err;
 		}
-		if (currentTarget !== target || disposed) return;
-		closeAllSockets();
-		currentQuery = query;
-		manager = new Manager(socketOrigin(target), {
+		if (epoch !== applyEpoch || disposed) return;
+		const mgr = new Manager(socketOrigin(target), {
 			path: socketPath(target),
+			query,
 			autoConnect: false,
 			reconnection,
 			reconnectionDelay,
@@ -173,24 +191,31 @@ function createSocketioTransport(options = {}) {
 			rejectUnauthorized: false,
 			transports: ["websocket"]
 		});
-		const main = openSocket(mainNs, target);
-		bindMainSocketEvents(main);
-		startRefresh();
+		manager = mgr;
 		lastActivityAt = Date.now();
-		main.io.on("open", touchActivity);
-		main.io.on("ping", touchActivity);
-		main.io.on("packet", touchActivity);
+		mgr.on("open", touchActivity);
+		mgr.on("ping", touchActivity);
+		mgr.on("packet", touchActivity);
+		openSocket(mainNs, mgr, target);
+		for (const ns of reopen) if (!sockets.has(ns)) openSocket(ns, mgr, target);
+		reopen.clear();
+		startRefresh();
+		for (const handler of [...rebuildListeners]) try {
+			handler();
+		} catch (err) {
+			logger?.warn(`rebuild listener failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
 	}
 	function closeAllSockets() {
-		for (const sock of sockets.values()) {
-			sock.removeAllListeners();
-			sock.disconnect();
-		}
+		const closing = [...sockets.values()];
+		const mgr = manager;
 		sockets.clear();
-		if (manager) {
-			manager._close();
-			manager = null;
+		manager = null;
+		for (const sock of closing) {
+			sock.disconnect();
+			sock.removeAllListeners();
 		}
+		mgr?._close();
 	}
 	function rebindAuth(target) {
 		const auth = buildAuth(target);
@@ -205,7 +230,9 @@ function createSocketioTransport(options = {}) {
 		const endpointChanged = isEndpointChange(currentTarget, target);
 		currentTarget = target;
 		if (!target) {
+			applyEpoch++;
 			closeAllSockets();
+			reopen.clear();
 			stopRefresh();
 			lastActivityAt = 0;
 			markDown("detached");
@@ -213,8 +240,11 @@ function createSocketioTransport(options = {}) {
 		}
 		if (endpointChanged || !manager) {
 			const epoch = ++applyEpoch;
+			for (const ns of sockets.keys()) if (ns !== mainNs) reopen.add(ns);
+			closeAllSockets();
+			stopRefresh();
 			try {
-				await rebuildManager(target);
+				await rebuildManager(target, epoch);
 			} catch (err) {
 				if (epoch === applyEpoch && currentTarget === target) currentTarget = null;
 				throw err;
@@ -224,7 +254,7 @@ function createSocketioTransport(options = {}) {
 		rebindAuth(target);
 	}
 	function health() {
-		if (status.up && isStaleNow()) return {
+		if (status.up && isDeadNow()) return {
 			up: false,
 			lastError: "staleConnection"
 		};
@@ -235,7 +265,14 @@ function createSocketioTransport(options = {}) {
 	}
 	async function dispose() {
 		disposed = true;
+		applyEpoch++;
 		closeAllSockets();
+		reopen.clear();
+		rebuildListeners.clear();
+		for (const timer of releaseTimers.values()) clearTimeout(timer);
+		releaseTimers.clear();
+		holds.clear();
+		unheld.clear();
 		stopRefresh();
 		currentTarget = null;
 		status = { up: false };
@@ -245,20 +282,54 @@ function createSocketioTransport(options = {}) {
 		return sockets.get(namespace) ?? null;
 	}
 	function ensureSocket(namespace) {
-		if (!currentTarget || !manager) return null;
-		let sock = sockets.get(namespace);
-		if (!sock) {
-			sock = openSocket(namespace, currentTarget);
-			bindSecondarySocketEvents(sock);
+		if (!currentTarget) return null;
+		if (!holds.has(namespace)) unheld.add(namespace);
+		if (!manager) {
+			reopen.add(namespace);
+			return null;
 		}
-		return sock;
+		return sockets.get(namespace) ?? openSocket(namespace, manager, currentTarget);
+	}
+	function acquire(namespace) {
+		holds.set(namespace, (holds.get(namespace) ?? 0) + 1);
+		clearTimeout(releaseTimers.get(namespace));
+		releaseTimers.delete(namespace);
+		let held = true;
+		return () => {
+			if (!held || disposed) return;
+			held = false;
+			const left = (holds.get(namespace) ?? 1) - 1;
+			if (left > 0) {
+				holds.set(namespace, left);
+				return;
+			}
+			holds.delete(namespace);
+			if (namespace === mainNs) return;
+			releaseTimers.set(namespace, setTimeout(() => closeReleased(namespace), releaseGraceMs));
+		};
+	}
+	function closeReleased(namespace) {
+		releaseTimers.delete(namespace);
+		if (holds.has(namespace) || unheld.has(namespace)) return;
+		reopen.delete(namespace);
+		const sock = sockets.get(namespace);
+		if (!sock) return;
+		sockets.delete(namespace);
+		sock.disconnect();
+		sock.removeAllListeners();
+	}
+	function onRebuild(handler) {
+		rebuildListeners.add(handler);
+		return () => {
+			rebuildListeners.delete(handler);
+		};
 	}
 	function reviveDeadSockets() {
 		if (!currentTarget) return;
-		if (status.up && isStaleNow()) {
+		if (status.up && isDeadNow()) {
 			logger?.debug("reviveDeadSockets: engine stale — forcing reconnect");
 			lastActivityAt = Date.now();
-			sockets.get(mainNs)?.io.engine?.close();
+			manager?.engine?.close();
 			return;
 		}
 		const auth = buildAuth(currentTarget);
@@ -270,11 +341,39 @@ function createSocketioTransport(options = {}) {
 		}
 		logger?.debug(`reviveDeadSockets: ${revived}/${sockets.size} reconnecting`);
 	}
-	async function ensureAlive() {
-		if (disposed || !currentTarget) return health();
-		if (resolveQuery) await refreshQuery();
-		reviveDeadSockets();
-		return health();
+	function reconnectInactive(target) {
+		const auth = buildAuth(target);
+		for (const sock of sockets.values()) {
+			if (sock.active) continue;
+			sock.auth = auth;
+			sock.connect();
+		}
+	}
+	function ensureAlive() {
+		if (ensureInflight) return ensureInflight;
+		const run = async () => {
+			if (disposed || !currentTarget) return health();
+			const main = sockets.get(mainNs);
+			if (main?.connected && !isDeadNow()) {
+				if (resolveQuery) refreshQuery();
+				const engine = main.io.engine;
+				const answered = await new Promise((resolve) => {
+					main.timeout(PROBE_TIMEOUT_MS).emit("get-status", null, (err) => resolve(!err));
+				});
+				if (!answered && main.connected && main.io.engine === engine) {
+					logger?.debug("ensureAlive: probe unanswered, closing engine");
+					engine.close();
+				} else if (answered && currentTarget) reconnectInactive(currentTarget);
+				return health();
+			}
+			if (resolveQuery) await refreshQueryWithin(PROBE_TIMEOUT_MS);
+			reviveDeadSockets();
+			return health();
+		};
+		ensureInflight = run().finally(() => {
+			ensureInflight = null;
+		});
+		return ensureInflight;
 	}
 	return {
 		get spec() {
@@ -289,6 +388,8 @@ function createSocketioTransport(options = {}) {
 		dispose,
 		socket,
 		ensureSocket,
+		acquire,
+		onRebuild,
 		reviveDeadSockets,
 		ensureAlive
 	};

package/dist/transports/ws.d.ts

@@ -33,7 +33,6 @@ export interface WsTransportOptions {
     readonly spec?: Partial<TransportSpec>;
     readonly webSocketCtor?: typeof WebSocket;
     readonly tokenParam?: string;
-    readonly sessionParam?: string;
     readonly logger?: Logger;
     readonly resolveUrl?: WsUrlResolver;
 }

package/dist/transports/ws.js

@@ -1,5 +1,5 @@
+import { 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";
 //#region src/transports/ws.ts
 var WS_SPEC = {
 	id: "ws",
@@ -10,13 +10,13 @@ var WS_CLOSE_TARGET_CHANGED = 4e3;
 var WS_CLOSE_DETACHED = 4001;
 var WS_CLOSE_DISPOSED = 4002;
 var WS_CLOSE_RESOLVE_FAILED = 4003;
+var RESOLVE_TIMEOUT_MS = 1e4;
 function createWsTransport(options = {}) {
 	const spec = {
 		...WS_SPEC,
 		...options.spec
 	};
 	const tokenParam = options.tokenParam ?? "token";
-	const sessionParam = options.sessionParam ?? "session";
 	const WsCtor = options.webSocketCtor ?? (typeof WebSocket !== "undefined" ? WebSocket : void 0);
 	const resolveUrl = options.resolveUrl;
 	const logger = options.logger;
@@ -38,7 +38,6 @@ function createWsTransport(options = {}) {
 		const params = new URLSearchParams();
 		for (const [k, v] of Object.entries(handleSpec.query ?? {})) if (v !== void 0 && v !== null && v !== "") params.set(k, v);
 		params.set(tokenParam, target.tokens.access);
-		if (target.tokens.proxySession) params.set(sessionParam, target.tokens.proxySession);
 		return `${wsProtocol}//${base.hostname}:${port}${prefix}${handleSpec.path}?${params.toString()}`;
 	}
 	function isAuthCloseEvent(event) {
@@ -67,7 +66,10 @@ function createWsTransport(options = {}) {
 			closeDelivered.add(ws);
 			if (!isCurrent) return;
 			logger?.debug(`close ${handle.spec.path} code=${event.code} clean=${event.wasClean}${event.reason ? ` reason=${event.reason}` : ""}`);
-			if (isAuthCloseEvent(event)) emitter.emit("auth-error", { message: event.reason || `ws close code ${event.code}` });
+			if (isAuthCloseEvent(event)) emitter.emit("auth-error", {
+				message: event.reason || `ws close code ${event.code}`,
+				access: handle.access
+			});
 			const info = {
 				code: event.code,
 				reason: event.reason,
@@ -86,6 +88,7 @@ function createWsTransport(options = {}) {
 	}
 	function closeWs(handle, code, reason) {
 		handle.openSeq++;
+		clearResolveTimer(handle);
 		const ws = handle.ws;
 		if (!ws) return;
 		const Ctor = ensureCtor();
@@ -108,11 +111,12 @@ function createWsTransport(options = {}) {
 		};
 		for (const fn of [...handle.listeners.close]) fn(info);
 	}
-	function connectWs(handle, url) {
+	function connectWs(handle, url, access) {
 		const ws = new (ensureCtor())(url, handle.spec.protocols);
 		if (handle.spec.binaryType) ws.binaryType = handle.spec.binaryType;
 		handle.ws = ws;
 		handle.url = url;
+		handle.access = access;
 		bindWs(handle, ws);
 	}
 	function openWs(handle) {
@@ -121,29 +125,51 @@ function createWsTransport(options = {}) {
 		const target = currentTarget;
 		const defaultUrl = buildUrl(target, handle.spec);
 		if (!resolveUrl) {
-			connectWs(handle, defaultUrl);
+			connectWs(handle, defaultUrl, target.tokens.access);
 			return;
 		}
 		const seq = ++handle.openSeq;
+		clearResolveTimer(handle);
+		handle.resolveTimer = setTimeout(() => {
+			handle.resolveTimer = void 0;
+			if (handle.disposed || seq !== handle.openSeq) return;
+			handle.openSeq++;
+			logger?.warn(`resolveUrl timed out for ${handle.spec.path} after ${RESOLVE_TIMEOUT_MS}ms`);
+			failResolve(handle, "resolve-timeout");
+		}, RESOLVE_TIMEOUT_MS);
 		resolveUrl({
 			target,
 			spec: handle.spec,
 			defaultUrl
 		}).then((url) => {
-			if (handle.disposed || seq !== handle.openSeq || currentTarget !== target) return;
+			if (handle.disposed || seq !== handle.openSeq) return;
+			clearResolveTimer(handle);
+			if (currentTarget !== target) {
+				openWs(handle);
+				return;
+			}
 			connectWs(handle, url);
 		}, (err) => {
 			if (handle.disposed || seq !== handle.openSeq) return;
+			clearResolveTimer(handle);
 			const reason = err instanceof Error ? err.message : String(err);
 			logger?.warn(`resolveUrl failed for ${handle.spec.path}: ${reason}`);
-			const info = {
-				code: WS_CLOSE_RESOLVE_FAILED,
-				reason: "resolve-failed",
-				wasClean: false
-			};
-			for (const fn of [...handle.listeners.close]) fn(info);
+			failResolve(handle, "resolve-failed");
 		});
 	}
+	function failResolve(handle, reason) {
+		const info = {
+			code: WS_CLOSE_RESOLVE_FAILED,
+			reason,
+			wasClean: false
+		};
+		for (const fn of [...handle.listeners.close]) fn(info);
+	}
+	function clearResolveTimer(handle) {
+		if (handle.resolveTimer === void 0) return;
+		clearTimeout(handle.resolveTimer);
+		handle.resolveTimer = void 0;
+	}
 	function recycleAll(code, reason) {
 		const snapshot = [...handles];
 		logger?.debug(`recycleAll (${reason}) handles=${snapshot.length}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camera.ui/transport",
-  "version": "0.0.30",
+  "version": "0.1.1",
   "description": "camera.ui transport layer — framework-agnostic connection kernel, reducer state, pluggable transports (HTTP/WS/Socket.IO/NATS), lifecycle effects and worker bridge",
   "author": "seydx (https://github.com/cameraui/clients)",
   "type": "module",
@@ -39,7 +39,7 @@
       "import": "./dist/worker.js"
     },
     "./testing": {
-      "types": "./dist/testing.d.ts",
+      "types": "./dist/testing/index.d.ts",
       "import": "./dist/testing.js"
     }
   },
@@ -56,26 +56,27 @@
   },
   "dependencies": {
     "@camera.ui/logger": ">=0.0.3",
-    "@camera.ui/rpc": ">=1.0.12",
+    "@camera.ui/rpc": ">=1.1.1",
     "axios": ">=1.20.0",
-    "socket.io-client": ">=4.8.3"
+    "socket.io-client": ">=4.8.4"
   },
   "devDependencies": {
     "@eslint/js": "9.39.4",
     "@stylistic/eslint-plugin": "^5.10.0",
-    "@typescript-eslint/parser": "^8.70.0",
-    "@vue/language-core": "^3.3.11",
+    "@typescript-eslint/parser": "^8.72.0",
+    "@vue/language-core": "^3.3.13",
     "eslint": "9.39.2",
-    "globals": "^17.12.0",
+    "globals": "^17.13.0",
     "jiti": "^2.7.0",
-    "prettier": "^3.9.6",
+    "prettier": "^3.9.10",
     "rimraf": "^6.1.3",
+    "socket.io": "^4.8.4",
     "typescript": "5.9.3",
-    "typescript-eslint": "^8.70.0",
-    "unplugin-dts": "^1.1.0",
-    "updates": "^18.1.0",
-    "vite": "^8.3.0",
-    "vitest": "^5.0.1"
+    "typescript-eslint": "^8.72.0",
+    "unplugin-dts": "^1.1.2",
+    "updates": "^19.3.0",
+    "vite": "^8.3.5",
+    "vitest": "^5.0.5"
   },
   "overrides": {
     "@vue/language-core": "$@vue/language-core"

package/dist/closeCodes-ClWJVOpq.js

@@ -1,14 +0,0 @@
-//#region src/transports/closeCodes.ts
-function classifyClose(input) {
-	const obj = typeof input === "string" ? void 0 : input;
-	const code = obj?.wsCloseCode ?? obj?.code;
-	if (code === 4401 || code === 1008) return "auth-expired";
-	if (code === 4403 || code === 4400) return "forbidden";
-	const text = (typeof input === "string" ? input : obj?.reason ?? obj?.message ?? "").toLowerCase();
-	if (!text) return "other";
-	if (text.includes("forbidden") || text.includes("403")) return "forbidden";
-	if (text.includes("unauthorized") || text.includes("401") || text.includes("auth")) return "auth-expired";
-	return "other";
-}
-//#endregion
-export { classifyClose as t };