@camera.ui/transport 0.0.21 → 0.0.23

package/dist/journal.d.ts

@@ -0,0 +1,19 @@
+export interface JournalEntry {
+    readonly seq: number;
+    readonly t: number;
+    readonly scope: string;
+    readonly msg: string;
+    readonly detail?: string;
+}
+export interface JournalOptions {
+    readonly capacity?: number;
+    readonly now?: () => number;
+}
+export interface ConnectionJournal {
+    record(scope: string, msg: string, detail?: unknown): void;
+    list(): JournalEntry[];
+    clear(): void;
+    subscribe(listener: (entry: JournalEntry) => void): () => void;
+    exportText(): string;
+}
+export declare function createConnectionJournal(options?: JournalOptions): ConnectionJournal;

package/dist/race.d.ts

@@ -9,6 +9,8 @@ export interface RaceFirstOptions {
     readonly timeoutByMode?: TimeoutByModeFn;
     readonly shortCircuit?: (err: unknown) => boolean;
     readonly parentSignal?: AbortSignal;
+    readonly prefer?: (endpoint: Endpoint) => boolean;
+    readonly preferGraceMs?: number;
 }
 export interface RaceFirstResult<T> {
     readonly endpoint: Endpoint;

package/dist/signal.d.ts

@@ -0,0 +1,30 @@
+import { Kernel } from './core/kernel.js';
+import { TransportId } from './core/types.js';
+import { Transport } from './transports/contract.js';
+export type ConnectionSignal = {
+    readonly kind: 'connecting';
+} | {
+    readonly kind: 'online';
+} | {
+    readonly kind: 'degraded';
+    readonly channels: readonly TransportId[];
+} | {
+    readonly kind: 'offline';
+    readonly retryAt?: number;
+} | {
+    readonly kind: 'needs-auth';
+};
+export interface ConnectionSignalOptions {
+    readonly kernel: Kernel;
+    readonly transports: readonly Transport[];
+    readonly debounceMs?: number;
+}
+export interface ConnectionSignalHandle {
+    readonly current: ConnectionSignal;
+    raw(): ConnectionSignal;
+    recompute(): void;
+    subscribe(listener: (signal: ConnectionSignal) => void): () => void;
+    dispose(): void;
+}
+export declare function signalEquals(a: ConnectionSignal, b: ConnectionSignal): boolean;
+export declare function createConnectionSignal(options: ConnectionSignalOptions): ConnectionSignalHandle;

package/dist/testing/fakeTransport.d.ts

@@ -7,6 +7,8 @@ export interface FakeTransportOptions {
 export declare class FakeTransport implements Transport {
     readonly spec: TransportSpec;
     readonly applyCalls: (ConnectionTarget | null)[];
+    failNextApplies: number;
+    ensureAliveCalls: number;
     private readonly emitter;
     private readonly applyDelayMs;
     private currentTarget;
@@ -15,6 +17,7 @@ export declare class FakeTransport implements Transport {
     constructor(options: FakeTransportOptions);
     apply(target: ConnectionTarget | null): Promise<void>;
     health(): TransportStatus;
+    ensureAlive(): Promise<TransportStatus>;
     on<E extends TransportEvent>(event: E, handler: TransportEventHandler<E>): Unsubscribe;
     dispose(): Promise<void>;
     emitDown(reason: string): void;

package/dist/testing.js

@@ -1,8 +1,10 @@
-import { t as TransportEmitter } from "./contract-d-0gfY8v.js";
+import { t as TransportEmitter } from "./contract-dt1m8U-o.js";
 //#region src/testing/fakeTransport.ts
 var FakeTransport = class {
 	spec;
 	applyCalls = [];
+	failNextApplies = 0;
+	ensureAliveCalls = 0;
 	emitter = new TransportEmitter();
 	applyDelayMs;
 	currentTarget = null;
@@ -16,6 +18,14 @@ var FakeTransport = class {
 		if (this.disposed) throw new Error("disposed");
 		this.applyCalls.push(target);
 		if (this.applyDelayMs > 0) await new Promise((resolve) => setTimeout(resolve, this.applyDelayMs));
+		if (this.failNextApplies > 0) {
+			this.failNextApplies--;
+			this.currentStatus = {
+				up: false,
+				lastError: "apply failed"
+			};
+			throw new Error("apply failed");
+		}
 		this.currentTarget = target;
 		this.currentStatus = target ? { up: true } : { up: false };
 		if (target) this.emitter.emit("up", void 0);
@@ -24,6 +34,10 @@ var FakeTransport = class {
 	health() {
 		return this.currentStatus;
 	}
+	async ensureAlive() {
+		this.ensureAliveCalls++;
+		return this.currentStatus;
+	}
 	on(event, handler) {
 		return this.emitter.on(event, handler);
 	}

package/dist/transports/closeCodes.d.ts

@@ -0,0 +1,8 @@
+export type CloseClass = 'auth-expired' | 'forbidden' | 'other';
+export interface CloseLike {
+    readonly code?: number;
+    readonly wsCloseCode?: number;
+    readonly message?: string;
+    readonly reason?: string;
+}
+export declare function classifyClose(input: CloseLike | string): CloseClass;

package/dist/transports/contract.d.ts

@@ -12,6 +12,7 @@ export interface Transport {
     readonly spec: TransportSpec;
     apply(target: ConnectionTarget | null): Promise<void>;
     health(): TransportStatus;
+    ensureAlive?(): Promise<TransportStatus>;
     on<E extends TransportEvent>(event: E, handler: TransportEventHandler<E>): Unsubscribe;
     dispose(): Promise<void>;
 }
@@ -20,7 +21,6 @@ export interface PerResourceTransport<R = unknown, S = unknown> extends Transpor
 }
 export declare function isSameTarget(a: ConnectionTarget | null, b: ConnectionTarget | null): boolean;
 export declare function isEndpointChange(a: ConnectionTarget | null, b: ConnectionTarget | null): boolean;
-export declare function isTokenOnlyChange(a: ConnectionTarget | null, b: ConnectionTarget | null): boolean;
 export declare class TransportEmitter {
     private readonly listeners;
     on<E extends TransportEvent>(event: E, handler: TransportEventHandler<E>): Unsubscribe;

package/dist/transports/http.js

@@ -1,4 +1,4 @@
-import { n as isEndpointChange, r as isSameTarget, t as TransportEmitter } from "../contract-d-0gfY8v.js";
+import { n as isEndpointChange, r as isSameTarget, t as TransportEmitter } from "../contract-dt1m8U-o.js";
 import axios from "axios";
 //#region src/transports/http.ts
 var HTTP_SPEC = {

package/dist/transports/nats.d.ts

@@ -1,6 +1,6 @@
 import { Logger } from '@camera.ui/logger';
 import { RPCClient } from '@camera.ui/rpc';
-import { TransportSpec } from '../core/types.js';
+import { TransportSpec, TransportStatus } from '../core/types.js';
 import { Transport, Unsubscribe } from './contract.js';
 export interface NatsTransportOptions {
     readonly spec?: Partial<TransportSpec>;
@@ -24,5 +24,6 @@ export interface NatsTransport extends Transport {
     subscribeClient(listener: NatsClientListener): Unsubscribe;
     probeAlive(timeoutMs?: number): Promise<void>;
     forceReconnect(): Promise<void>;
+    ensureAlive(): Promise<TransportStatus>;
 }
 export declare function createNatsTransport(options?: NatsTransportOptions): NatsTransport;

package/dist/transports/nats.js

@@ -1,11 +1,11 @@
-import { n as isEndpointChange, r as isSameTarget, t as TransportEmitter } from "../contract-d-0gfY8v.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 = {
 	id: "nats",
 	kind: "persistent",
-	phaseGating: true,
-	graceMs: 4e3
+	phaseGating: true
 };
 function newConnId() {
 	const c = globalThis.crypto;
@@ -112,11 +112,23 @@ function createNatsTransport(options = {}) {
 	}
 	function handleErrorEvent(event) {
 		const message = stringifyError(event.data);
-		const lower = message.toLowerCase();
-		if (lower.includes("auth") || lower.includes("401") || lower.includes("forbidden") || lower.includes("403")) {
+		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,
+			message
+		} : message);
+		if (cls === "auth-expired") {
 			emitter.emit("auth-error", { message });
 			return;
 		}
+		if (cls === "forbidden") {
+			logger?.warn(`forbidden by server: ${message}`);
+			markDown(`forbidden: ${message}`);
+			return;
+		}
 		markDown(message);
 	}
 	async function rebuildClient(target, epoch) {
@@ -163,6 +175,7 @@ function createNatsTransport(options = {}) {
 			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 (classifyClose(err instanceof Error ? err : msg) === "auth-expired") emitter.emit("auth-error", { message: msg });
 			markDown(msg);
 			throw err;
 		} finally {
@@ -268,6 +281,32 @@ function createNatsTransport(options = {}) {
 		await proxy.forceReconnect();
 		logger?.debug(`forceReconnect: returned after ${Date.now() - t0}ms (up=${status.up})`);
 	}
+	let ensureInflight = null;
+	function ensureAlive() {
+		if (ensureInflight) return ensureInflight;
+		const run = async () => {
+			if (disposed || !currentTarget) return health();
+			if (!proxy) {
+				const epoch = ++applyEpoch;
+				try {
+					await rebuildClient(currentTarget, epoch);
+				} catch {}
+				return health();
+			}
+			if (health().up) try {
+				await probeAlive(3e3);
+				return health();
+			} catch {}
+			try {
+				await forceReconnect();
+			} catch {}
+			return health();
+		};
+		ensureInflight = run().finally(() => {
+			ensureInflight = null;
+		});
+		return ensureInflight;
+	}
 	return {
 		spec,
 		apply,
@@ -277,7 +316,8 @@ function createNatsTransport(options = {}) {
 		getClient,
 		subscribeClient,
 		probeAlive,
-		forceReconnect
+		forceReconnect,
+		ensureAlive
 	};
 }
 function stringifyError(value) {

package/dist/transports/socketio.d.ts

@@ -1,6 +1,6 @@
 import { Manager, Socket } from 'socket.io-client';
 import { Logger } from '@camera.ui/logger';
-import { TransportSpec } from '../core/types.js';
+import { TransportSpec, TransportStatus } from '../core/types.js';
 import { Transport } from './contract.js';
 export type { Socket };
 export interface SocketioTransportOptions {
@@ -11,6 +11,7 @@ export interface SocketioTransportOptions {
     readonly reconnectionDelay?: number;
     readonly reconnectionDelayMax?: number;
     readonly timeout?: number;
+    readonly staleAfterMs?: number;
     readonly logger?: Logger;
 }
 export interface SocketioTransport extends Transport {
@@ -18,5 +19,6 @@ export interface SocketioTransport extends Transport {
     socket(namespace?: string): Socket | null;
     ensureSocket(namespace: string): Socket | null;
     reviveDeadSockets(): void;
+    ensureAlive(): Promise<TransportStatus>;
 }
 export declare function createSocketioTransport(options?: SocketioTransportOptions): SocketioTransport;

package/dist/transports/socketio.js

@@ -1,11 +1,11 @@
-import { n as isEndpointChange, r as isSameTarget, t as TransportEmitter } from "../contract-d-0gfY8v.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";
 //#region src/transports/socketio.ts
 var SOCKETIO_SPEC = {
 	id: "socketio",
 	kind: "persistent",
-	phaseGating: true,
-	graceMs: 4e3
+	phaseGating: true
 };
 function createSocketioTransport(options = {}) {
 	const spec = {
@@ -25,6 +25,14 @@ function createSocketioTransport(options = {}) {
 	let currentTarget = null;
 	let status = { up: false };
 	let disposed = false;
+	const staleAfterMs = options.staleAfterMs ?? 6e4;
+	let lastActivityAt = 0;
+	function touchActivity() {
+		lastActivityAt = Date.now();
+	}
+	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;
@@ -51,25 +59,7 @@ function createSocketioTransport(options = {}) {
 		emitter.emit("down", { reason });
 	}
 	function isAuthError(msg) {
-		const m = msg.toLowerCase();
-		return m.includes("auth") || m.includes("unauthorized");
-	}
-	function bindCommonAuthEvents(socket) {
-		let rotatedOut = false;
-		socket.on("unauthenticated", () => {
-			const fresh = currentTarget ? buildAuth(currentTarget) : null;
-			const current = socket.auth?.token;
-			if (fresh && current !== fresh.token) {
-				socket.auth = fresh;
-				rotatedOut = true;
-			} else emitter.emit("auth-error", { message: "unauthenticated" });
-		});
-		socket.on("disconnect", () => {
-			if (rotatedOut) {
-				rotatedOut = false;
-				socket.connect();
-			}
-		});
+		return classifyClose(msg) === "auth-expired";
 	}
 	function bindMainSocketEvents(socket) {
 		socket.on("connect", () => markUp());
@@ -83,14 +73,12 @@ function createSocketioTransport(options = {}) {
 			}
 			markDown(msg);
 		});
-		bindCommonAuthEvents(socket);
 	}
 	function bindSecondarySocketEvents(socket) {
 		socket.on("connect_error", (err) => {
 			const msg = err?.message ?? "connect_error";
 			if (isAuthError(msg)) emitter.emit("auth-error", { message: msg });
 		});
-		bindCommonAuthEvents(socket);
 	}
 	function socketOrigin(target) {
 		return new URL(target.endpoint.url).origin;
@@ -125,7 +113,12 @@ function createSocketioTransport(options = {}) {
 			rejectUnauthorized: false,
 			transports: ["websocket"]
 		});
-		bindMainSocketEvents(openSocket(mainNs, target));
+		const main = openSocket(mainNs, target);
+		bindMainSocketEvents(main);
+		lastActivityAt = Date.now();
+		main.io.on("open", touchActivity);
+		main.io.on("ping", touchActivity);
+		main.io.on("packet", touchActivity);
 	}
 	function closeAllSockets() {
 		for (const sock of sockets.values()) {
@@ -152,6 +145,7 @@ function createSocketioTransport(options = {}) {
 		currentTarget = target;
 		if (!target) {
 			closeAllSockets();
+			lastActivityAt = 0;
 			markDown("detached");
 			return;
 		}
@@ -162,6 +156,10 @@ function createSocketioTransport(options = {}) {
 		rebindAuth(target);
 	}
 	function health() {
+		if (status.up && isStaleNow()) return {
+			up: false,
+			lastError: "staleConnection"
+		};
 		return status;
 	}
 	function on(event, handler) {
@@ -188,6 +186,12 @@ function createSocketioTransport(options = {}) {
 	}
 	function reviveDeadSockets() {
 		if (!currentTarget) return;
+		if (status.up && isStaleNow()) {
+			logger?.debug("reviveDeadSockets: engine stale — forcing reconnect");
+			lastActivityAt = Date.now();
+			sockets.get(mainNs)?.io.engine?.close();
+			return;
+		}
 		const auth = buildAuth(currentTarget);
 		let revived = 0;
 		for (const sock of sockets.values()) if (!sock.connected) {
@@ -197,6 +201,11 @@ function createSocketioTransport(options = {}) {
 		}
 		logger?.debug(`reviveDeadSockets: ${revived}/${sockets.size} reconnecting`);
 	}
+	async function ensureAlive() {
+		if (disposed || !currentTarget) return health();
+		reviveDeadSockets();
+		return health();
+	}
 	return {
 		get spec() {
 			return spec;
@@ -210,7 +219,8 @@ function createSocketioTransport(options = {}) {
 		dispose,
 		socket,
 		ensureSocket,
-		reviveDeadSockets
+		reviveDeadSockets,
+		ensureAlive
 	};
 }
 //#endregion

package/dist/transports/ws.js

@@ -1,4 +1,5 @@
-import { n as isEndpointChange, r as isSameTarget, t as TransportEmitter } from "../contract-d-0gfY8v.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",
@@ -39,10 +40,10 @@ function createWsTransport(options = {}) {
 		return `${wsProtocol}//${base.hostname}:${port}${prefix}${handleSpec.path}?${params.toString()}`;
 	}
 	function isAuthCloseEvent(event) {
-		if (event.code === 1008 || event.code === 4401) return true;
-		if (!event.reason) return false;
-		const lower = event.reason.toLowerCase();
-		return lower.includes("unauthorized") || lower.includes("forbidden") || lower.includes("401") || lower.includes("403");
+		return classifyClose({
+			code: event.code,
+			reason: event.reason
+		}) === "auth-expired";
 	}
 	function bindWs(handle, ws) {
 		ws.onopen = () => {

package/dist/worker.js

@@ -28,7 +28,6 @@ function createWorkerKernelMirror(options) {
 	options.source.addEventListener("message", handler);
 	function targetOf(p) {
 		if (p.kind === "online") return p.target;
-		if (p.kind === "reconnecting") return p.lastTarget;
 		return null;
 	}
 	function phaseEquals(a, b) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camera.ui/transport",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "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",
@@ -56,7 +56,7 @@
   },
   "dependencies": {
     "@camera.ui/logger": ">=0.0.3",
-    "@camera.ui/rpc": ">=1.0.9",
+    "@camera.ui/rpc": ">=1.0.10",
     "axios": ">=1.18.1",
     "socket.io-client": ">=4.8.3"
   },
@@ -64,7 +64,7 @@
     "@eslint/js": "9.39.4",
     "@stylistic/eslint-plugin": "^5.10.0",
     "@typescript-eslint/parser": "^8.65.0",
-    "@vue/language-core": "^3.3.7",
+    "@vue/language-core": "^3.3.8",
     "eslint": "9.39.2",
     "globals": "^17.7.0",
     "jiti": "^2.7.0",

package/dist/core/resolver.d.ts

@@ -1,5 +0,0 @@
-import { Endpoint, EndpointMode } from './types.js';
-export declare function sortByPriority(endpoints: readonly Endpoint[]): Endpoint[];
-export declare function isSameEndpoint(a: Endpoint, b: Endpoint): boolean;
-export declare function endpointKey(ep: Endpoint): string;
-export type { EndpointMode };

package/dist/effects/reconnectWatchdog.d.ts

@@ -1,10 +0,0 @@
-import { Kernel } from '../core/kernel.js';
-export type Detach = () => void;
-export interface ReconnectWatchdogOptions {
-    readonly kernel: Kernel;
-    readonly escalateAfterMs?: number;
-    readonly setTimer?: (cb: () => void, ms: number) => unknown;
-    readonly clearTimer?: (handle: unknown) => void;
-    readonly onEscalate?: (attempt: number) => void;
-}
-export declare function attachReconnectWatchdog(options: ReconnectWatchdogOptions): Detach;

package/dist/effects/transportWatchdog.d.ts

@@ -1,16 +0,0 @@
-import { Kernel } from '../core/kernel.js';
-import { TransportId } from '../core/types.js';
-import { Transport } from '../transports/contract.js';
-export type Detach = () => void;
-export type WatchdogClearReason = 'up' | 'detach' | 'phase-change';
-export interface TransportWatchdogOptions {
-    readonly kernel: Kernel;
-    readonly transports: readonly Transport[];
-    readonly defaultGraceMs?: number;
-    readonly setTimer?: (cb: () => void, ms: number) => unknown;
-    readonly clearTimer?: (handle: unknown) => void;
-    readonly onGraceStarted?: (id: TransportId, graceMs: number) => void;
-    readonly onGraceCleared?: (id: TransportId, reason: WatchdogClearReason) => void;
-    readonly onConfirmed?: (id: TransportId) => void;
-}
-export declare function attachTransportWatchdog(options: TransportWatchdogOptions): Detach;