@camera.ui/transport 0.0.21 → 0.0.23

package/dist/index.js

@@ -1,7 +1,7 @@
-import { i as isTokenOnlyChange, 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 { Logger } from "@camera.ui/logger";
 //#region src/core/reducer.ts
-var EMPTY_TRANSPORTS = /* @__PURE__ */ new Map();
 var DEFAULT_BACKOFF_MS = 5e3;
 function reducer(phase, action, ctx) {
 	switch (action.type) {
@@ -10,124 +10,36 @@ function reducer(phase, action, ctx) {
 			if (phase.kind !== "idle" && phase.kind !== "offline" && phase.kind !== "needs-auth") return phase;
 			return {
 				kind: "discovering",
-				instanceId: action.instanceId,
-				attempt: 1
+				instanceId: action.instanceId
 			};
 		case "USER_RETRY":
-			if (phase.kind === "offline") return {
+			if (phase.kind === "offline" || phase.kind === "needs-auth") return {
 				kind: "discovering",
-				instanceId: phase.instanceId ?? "",
-				attempt: 1
-			};
-			if (phase.kind === "reconnecting") return {
-				kind: "discovering",
-				instanceId: phase.instanceId,
-				attempt: 1,
-				transports: phase.transports
-			};
-			if (phase.kind === "needs-auth") return {
-				kind: "discovering",
-				instanceId: phase.instanceId ?? "",
-				attempt: 1
-			};
-			if (phase.kind === "online") return {
-				kind: "discovering",
-				instanceId: phase.instanceId,
-				attempt: 1,
-				transports: phase.transports
+				instanceId: phase.instanceId ?? ""
 			};
 			return phase;
 		case "PROBE_SUCCEEDED":
-			if (phase.kind === "discovering") return {
-				kind: "online",
-				instanceId: phase.instanceId,
-				target: {
-					endpoint: action.endpoint,
-					tokens: action.tokens
-				},
-				transports: phase.transports ?? EMPTY_TRANSPORTS
-			};
-			if (phase.kind === "reconnecting") return {
+			if (phase.kind !== "discovering") return phase;
+			return {
 				kind: "online",
 				instanceId: phase.instanceId,
 				target: {
 					endpoint: action.endpoint,
 					tokens: action.tokens
-				},
-				transports: phase.transports
+				}
 			};
-			return phase;
-		case "PROBE_FAILED_ALL": {
-			if (phase.kind !== "discovering" && phase.kind !== "reconnecting") return phase;
+		case "PROBE_FAILED_ALL":
+			if (phase.kind !== "discovering" && phase.kind !== "online") return phase;
 			if (action.error === "needs-auth") return {
 				kind: "needs-auth",
 				instanceId: phase.instanceId,
 				reason: action.error
 			};
-			const attempt = phase.kind === "discovering" ? phase.attempt : 1;
-			const backoff = ctx.retryBackoffMs?.(attempt) ?? DEFAULT_BACKOFF_MS;
 			return {
 				kind: "offline",
 				instanceId: phase.instanceId,
 				lastError: action.error,
-				nextRetryAt: ctx.now() + backoff
-			};
-		}
-		case "TRANSPORT_UP":
-			if (phase.kind === "online") return {
-				...phase,
-				transports: setStatus(phase.transports, action.id, { up: true })
-			};
-			if (phase.kind === "reconnecting") {
-				const next = setStatus(phase.transports, action.id, { up: true });
-				if (phase.lastTarget && allPhaseGatingUp(next, ctx)) return {
-					kind: "online",
-					instanceId: phase.instanceId,
-					target: phase.lastTarget,
-					transports: next
-				};
-				return {
-					...phase,
-					transports: next
-				};
-			}
-			if (phase.kind === "discovering") return {
-				...phase,
-				transports: setStatus(phase.transports ?? EMPTY_TRANSPORTS, action.id, { up: true })
-			};
-			return phase;
-		case "TRANSPORT_DOWN":
-			if (phase.kind === "online" || phase.kind === "reconnecting") return {
-				...phase,
-				transports: setStatus(phase.transports, action.id, {
-					up: false,
-					lastError: action.reason,
-					downSince: ctx.now()
-				})
-			};
-			if (phase.kind === "discovering") return {
-				...phase,
-				transports: setStatus(phase.transports ?? EMPTY_TRANSPORTS, action.id, {
-					up: false,
-					lastError: action.reason,
-					downSince: ctx.now()
-				})
-			};
-			return phase;
-		case "TRANSPORT_DOWN_CONFIRMED":
-			if (phase.kind !== "online") return phase;
-			if (!ctx.specs.get(action.id)?.phaseGating) return phase;
-			return {
-				kind: "reconnecting",
-				instanceId: phase.instanceId,
-				lastTarget: phase.target,
-				cause: "transport-down",
-				since: ctx.now(),
-				transports: setStatus(phase.transports, action.id, {
-					up: false,
-					lastError: "down-confirmed",
-					downSince: ctx.now()
-				})
+				nextRetryAt: ctx.now() + DEFAULT_BACKOFF_MS
 			};
 		case "TOKENS_REFRESHED":
 			if (phase.kind === "online") {
@@ -140,33 +52,46 @@ function reducer(phase, action, ctx) {
 					}
 				};
 			}
-			if (phase.kind === "reconnecting" && phase.lastTarget) {
-				if (tokensEqual(phase.lastTarget.tokens, action.tokens)) return phase;
+			if (phase.kind === "discovering") {
+				if (phase.pendingTokens && tokensEqual(phase.pendingTokens, action.tokens)) return phase;
 				return {
 					...phase,
-					lastTarget: {
-						...phase.lastTarget,
-						tokens: action.tokens
-					}
+					pendingTokens: action.tokens
 				};
 			}
 			return phase;
 		case "TOKENS_INVALID":
-			if (phase.kind !== "online" && phase.kind !== "reconnecting") return phase;
-			if (action.transient === true) {
-				const backoff = ctx.retryBackoffMs?.(1) ?? DEFAULT_BACKOFF_MS;
-				return {
-					kind: "offline",
-					instanceId: phase.instanceId,
-					lastError: `tokens invalid: ${action.reason}`,
-					nextRetryAt: ctx.now() + backoff
-				};
-			}
+			if (phase.kind !== "online") return phase;
+			if (action.transient === true) return {
+				kind: "offline",
+				instanceId: phase.instanceId,
+				lastError: `tokens invalid: ${action.reason}`,
+				nextRetryAt: ctx.now() + DEFAULT_BACKOFF_MS
+			};
 			return {
 				kind: "needs-auth",
 				instanceId: phase.instanceId,
 				reason: `tokens invalid: ${action.reason}`
 			};
+		case "ENDPOINT_SWAP":
+			if (phase.kind !== "online") return phase;
+			if (phase.target.endpoint.url === action.endpoint.url && phase.target.endpoint.mode === action.endpoint.mode) {
+				if (tokensEqual(phase.target.tokens, action.tokens)) return phase;
+				return {
+					...phase,
+					target: {
+						...phase.target,
+						tokens: action.tokens
+					}
+				};
+			}
+			return {
+				...phase,
+				target: {
+					endpoint: action.endpoint,
+					tokens: action.tokens
+				}
+			};
 		case "BACKOFF_HINT": {
 			if (phase.kind !== "offline") return phase;
 			const now = ctx.now();
@@ -184,18 +109,6 @@ function reducer(phase, action, ctx) {
 		}
 	}
 }
-function setStatus(map, id, status) {
-	const next = new Map(map);
-	next.set(id, status);
-	return next;
-}
-function allPhaseGatingUp(map, ctx) {
-	for (const [id, spec] of ctx.specs) {
-		if (!spec.phaseGating) continue;
-		if (!map.get(id)?.up) return false;
-	}
-	return true;
-}
 function tokensEqual(a, b) {
 	return a.access === b.access && a.refresh === b.refresh && a.accessExpiresAt === b.accessExpiresAt && a.refreshExpiresAt === b.refreshExpiresAt && a.proxySession === b.proxySession && a.proxySessionExpiresAt === b.proxySessionExpiresAt && a.proxyRefresh === b.proxyRefresh;
 }
@@ -220,6 +133,11 @@ function createKernel(options) {
 			while (next) {
 				const prev = current;
 				const after = reducer(prev, next, options.context);
+				if (options.onAction) try {
+					options.onAction(next, prev, after);
+				} catch (err) {
+					log$1.warn("onAction threw on", next.type, err);
+				}
 				if (after !== prev) {
 					current = after;
 					for (const listener of [...listeners]) try {
@@ -255,15 +173,190 @@ function createKernel(options) {
 	};
 }
 //#endregion
-//#region src/core/resolver.ts
-function sortByPriority(endpoints) {
-	return [...endpoints].sort((a, b) => (a.priority ?? 99) - (b.priority ?? 99));
-}
-function isSameEndpoint(a, b) {
-	return a.mode === b.mode && a.url === b.url;
+//#region src/race.ts
+var DEFAULT_RACE_TIMEOUT_BY_MODE = {
+	"direct-lan": 2e3,
+	"direct-wan": 5e3
+};
+var DEFAULT_PREFER_GRACE_MS = 400;
+var RaceFirstError = class extends Error {
+	endpoint;
+	cause;
+	kind;
+	constructor(message, endpoint, cause, kind) {
+		super(message);
+		this.name = "RaceFirstError";
+		this.endpoint = endpoint;
+		this.cause = cause;
+		this.kind = kind;
+	}
+};
+function raceFirst(candidates, options = {}) {
+	const { timeoutByMode = (mode) => DEFAULT_RACE_TIMEOUT_BY_MODE[mode] ?? 5e3, shortCircuit, parentSignal, prefer } = options;
+	const preferGraceMs = options.preferGraceMs ?? DEFAULT_PREFER_GRACE_MS;
+	return new Promise((resolve, reject) => {
+		if (candidates.length === 0) {
+			reject(new RaceFirstError("raceFirst: no candidates", {
+				url: "",
+				mode: "direct-lan"
+			}, void 0, "all-failed"));
+			return;
+		}
+		if (parentSignal?.aborted) {
+			reject(new RaceFirstError("raceFirst: parent aborted", candidates[0].endpoint, void 0, "aborted"));
+			return;
+		}
+		let settled = false;
+		let remaining = candidates.length;
+		let pendingPreferred = prefer ? candidates.filter((c) => prefer(c.endpoint)).length : 0;
+		let held = null;
+		const lastErrors = /* @__PURE__ */ new Map();
+		const abortControllers = [];
+		const timers = [];
+		function cleanupAllExcept(except) {
+			for (const t of timers) clearTimeout(t);
+			for (const a of abortControllers) if (a !== except) a.abort();
+		}
+		function finishSuccess(endpoint, value, except) {
+			if (settled) return;
+			settled = true;
+			cleanupAllExcept(except);
+			if (onParentAbort) parentSignal?.removeEventListener("abort", onParentAbort);
+			resolve({
+				endpoint,
+				value
+			});
+		}
+		function settleHeld() {
+			if (!held) return;
+			finishSuccess(held.endpoint, held.value, held.ctrl);
+		}
+		function handleSuccess(endpoint, value, ctrl) {
+			if (settled) return;
+			if (!prefer || prefer(endpoint) || pendingPreferred <= 0) {
+				finishSuccess(endpoint, value, ctrl);
+				return;
+			}
+			if (held) return;
+			held = {
+				endpoint,
+				value,
+				ctrl
+			};
+			const holdTimer = setTimeout(settleHeld, preferGraceMs);
+			timers.push(holdTimer);
+		}
+		function finishFail(error) {
+			if (settled) return;
+			settled = true;
+			cleanupAllExcept(null);
+			if (onParentAbort) parentSignal?.removeEventListener("abort", onParentAbort);
+			reject(error);
+		}
+		const onParentAbort = parentSignal ? () => finishFail(new RaceFirstError("raceFirst: parent aborted", candidates[0].endpoint, void 0, "aborted")) : null;
+		if (onParentAbort) parentSignal.addEventListener("abort", onParentAbort);
+		candidates.forEach((cand) => {
+			const ctrl = new AbortController();
+			abortControllers.push(ctrl);
+			const delay = timeoutByMode(cand.endpoint.mode);
+			const timer = setTimeout(() => ctrl.abort(), delay);
+			timers.push(timer);
+			cand.run(ctrl.signal).then((value) => handleSuccess(cand.endpoint, value, ctrl), (err) => {
+				if (settled) {
+					lastErrors.set(cand.endpoint, err);
+					return;
+				}
+				if (prefer?.(cand.endpoint)) {
+					pendingPreferred--;
+					if (held && pendingPreferred <= 0) {
+						lastErrors.set(cand.endpoint, err);
+						settleHeld();
+						return;
+					}
+				}
+				const finalErr = ctrl.signal.aborted && !parentSignal?.aborted ? new RaceFirstError(`timeout (${delay}ms)`, cand.endpoint, err, "all-failed") : err;
+				lastErrors.set(cand.endpoint, finalErr);
+				if (shortCircuit?.(finalErr)) {
+					finishFail(new RaceFirstError("raceFirst: short-circuit", cand.endpoint, finalErr, "short-circuit"));
+					return;
+				}
+				remaining--;
+				if (remaining <= 0) {
+					const [endpoint, cause] = [...lastErrors.entries()].find(([, e]) => {
+						if (e instanceof RaceFirstError) return e.kind !== "all-failed" || !(e.cause instanceof Error && e.cause.message === "aborted");
+						return true;
+					}) ?? [cand.endpoint, finalErr];
+					finishFail(new RaceFirstError("raceFirst: all candidates failed", endpoint, cause, "all-failed"));
+				}
+			});
+		});
+	});
 }
-function endpointKey(ep) {
-	return `${ep.mode}|${ep.url}`;
+//#endregion
+//#region src/effects/backgroundProbe.ts
+function createBackgroundProbe(options) {
+	let inflight = null;
+	let disposed = false;
+	async function round() {
+		if (options.kernel.phase.kind !== "online") {
+			options.onResult?.("skipped", `phase=${options.kernel.phase.kind}`);
+			return "skipped";
+		}
+		const ctrl = new AbortController();
+		try {
+			const pool = await options.discover(ctrl.signal);
+			if (disposed || options.kernel.phase.kind !== "online") return "skipped";
+			if (pool.length === 0) {
+				options.onResult?.("failed", "empty pool");
+				return "failed";
+			}
+			const lastTokens = options.lastTarget?.()?.tokens;
+			const { endpoint, value: tokens } = await raceFirst(pool.map((endpoint) => ({
+				endpoint,
+				run: (signal) => options.probe({
+					endpoint,
+					lastTokens,
+					signal
+				})
+			})), {
+				timeoutByMode: options.timeoutByMode,
+				parentSignal: ctrl.signal,
+				prefer: options.prefer,
+				preferGraceMs: options.preferGraceMs
+			});
+			if (disposed) return "skipped";
+			const phase = options.kernel.phase;
+			if (phase.kind !== "online") {
+				options.onResult?.("skipped", `phase=${phase.kind}`);
+				return "skipped";
+			}
+			const same = phase.target.endpoint.url === endpoint.url && phase.target.endpoint.mode === endpoint.mode;
+			options.kernel.dispatch({
+				type: "ENDPOINT_SWAP",
+				endpoint,
+				tokens
+			});
+			const outcome = same ? "same" : "swap";
+			options.onResult?.(outcome, endpoint.url);
+			return outcome;
+		} catch (err) {
+			options.onResult?.("failed", err instanceof Error ? err.message : String(err));
+			return "failed";
+		}
+	}
+	return {
+		run() {
+			if (disposed) return Promise.resolve("skipped");
+			if (inflight) return inflight;
+			inflight = round().finally(() => {
+				inflight = null;
+			});
+			return inflight;
+		},
+		dispose() {
+			disposed = true;
+		}
+	};
 }
 //#endregion
 //#region src/effects/backoff.ts
@@ -338,8 +431,7 @@ function attachCrossTab(options) {
 		if (e.key !== key) return;
 		if (e.newValue === null) {
 			options.absorb?.(null);
-			const k = options.kernel.phase.kind;
-			if (k !== "online" && k !== "reconnecting") return;
+			if (options.kernel.phase.kind !== "online") return;
 			options.kernel.dispatch({ type: "RESET" });
 			options.onResetReceived?.();
 			return;
@@ -352,8 +444,7 @@ function attachCrossTab(options) {
 			return;
 		}
 		if (!parsed?.tokens?.access) return;
-		const k = options.kernel.phase.kind;
-		if (k !== "online" && k !== "reconnecting") {
+		if (options.kernel.phase.kind !== "online") {
 			if (parsed.endpoint?.url) {
 				options.absorb?.({
 					endpoint: parsed.endpoint,
@@ -375,16 +466,85 @@ function attachCrossTab(options) {
 	};
 }
 //#endregion
+//#region src/effects/degradedRecovery.ts
+var DEFAULT_GRACE_MS$1 = 1e4;
+function attachDegradedRecovery(options) {
+	const graceMs = options.graceMs ?? DEFAULT_GRACE_MS$1;
+	let timer = null;
+	let round = 0;
+	let detached = false;
+	function disarm() {
+		if (timer !== null) {
+			clearTimeout(timer);
+			timer = null;
+		}
+		round = 0;
+	}
+	function arm() {
+		if (detached || timer !== null) return;
+		timer = setTimeout(() => {
+			timer = null;
+			escalate();
+		}, graceMs);
+	}
+	async function escalate() {
+		if (detached || options.signal.current.kind !== "degraded") return;
+		round++;
+		options.onEscalate?.(round);
+		options.ensureAll();
+		const outcome = await options.probe();
+		if (detached || options.signal.current.kind !== "degraded") return;
+		if (outcome === "failed") {
+			if (options.isReachable?.()) {
+				options.onHold?.("probe failed but a channel is up — holding");
+				arm();
+				return;
+			}
+			options.onOffline?.("degraded: endpoint unreachable");
+			options.kernel.dispatch({
+				type: "PROBE_FAILED_ALL",
+				error: "degraded: endpoint unreachable"
+			});
+			return;
+		}
+		arm();
+	}
+	const unsub = options.signal.subscribe((next) => {
+		if (next.kind === "degraded") arm();
+		else disarm();
+	});
+	if (options.signal.current.kind === "degraded") arm();
+	return () => {
+		detached = true;
+		disarm();
+		unsub();
+	};
+}
+//#endregion
 //#region src/effects/networkChange.ts
 function attachNetworkChange(options) {
+	const debounceMs = options.debounceMs ?? 0;
 	let detached = false;
+	let timer = null;
 	const handler = (event) => {
 		if (detached) return;
-		options.onChange(options.kernel, event);
+		if (debounceMs <= 0) {
+			options.onChange(options.kernel, event);
+			return;
+		}
+		if (timer !== null) clearTimeout(timer);
+		timer = setTimeout(() => {
+			timer = null;
+			if (!detached) options.onChange(options.kernel, event);
+		}, debounceMs);
 	};
 	options.source.addEventListener("change", handler);
 	return () => {
 		detached = true;
+		if (timer !== null) {
+			clearTimeout(timer);
+			timer = null;
+		}
 		options.source.removeEventListener("change", handler);
 	};
 }
@@ -459,8 +619,15 @@ function attachPersistence(options) {
 	}
 	const unsub = options.kernel.subscribe((next, prev) => {
 		if (detached) return;
-		const nextTarget = next.kind === "online" ? next.target : next.kind === "reconnecting" ? next.lastTarget : null;
-		const prevTarget = prev.kind === "online" ? prev.target : prev.kind === "reconnecting" ? prev.lastTarget : null;
+		if (next.kind === "discovering" && next.pendingTokens && (prev.kind !== "discovering" || prev.pendingTokens !== next.pendingTokens)) {
+			if (cached) persist({
+				endpoint: cached.endpoint,
+				tokens: next.pendingTokens
+			});
+			return;
+		}
+		const nextTarget = next.kind === "online" ? next.target : null;
+		const prevTarget = prev.kind === "online" ? prev.target : null;
 		if (nextTarget && nextTarget !== prevTarget) {
 			persist(nextTarget);
 			return;
@@ -548,95 +715,6 @@ function attachPresence(options) {
 	};
 }
 //#endregion
-//#region src/race.ts
-var DEFAULT_RACE_TIMEOUT_BY_MODE = {
-	"direct-lan": 2e3,
-	"direct-wan": 5e3
-};
-var RaceFirstError = class extends Error {
-	endpoint;
-	cause;
-	kind;
-	constructor(message, endpoint, cause, kind) {
-		super(message);
-		this.name = "RaceFirstError";
-		this.endpoint = endpoint;
-		this.cause = cause;
-		this.kind = kind;
-	}
-};
-function raceFirst(candidates, options = {}) {
-	const { timeoutByMode = (mode) => DEFAULT_RACE_TIMEOUT_BY_MODE[mode] ?? 5e3, shortCircuit, parentSignal } = options;
-	return new Promise((resolve, reject) => {
-		if (candidates.length === 0) {
-			reject(new RaceFirstError("raceFirst: no candidates", {
-				url: "",
-				mode: "direct-lan"
-			}, void 0, "all-failed"));
-			return;
-		}
-		if (parentSignal?.aborted) {
-			reject(new RaceFirstError("raceFirst: parent aborted", candidates[0].endpoint, void 0, "aborted"));
-			return;
-		}
-		let settled = false;
-		let remaining = candidates.length;
-		const lastErrors = /* @__PURE__ */ new Map();
-		const abortControllers = [];
-		const timers = [];
-		function cleanupAllExcept(except) {
-			for (const t of timers) clearTimeout(t);
-			for (const a of abortControllers) if (a !== except) a.abort();
-		}
-		function finishSuccess(endpoint, value, except) {
-			if (settled) return;
-			settled = true;
-			cleanupAllExcept(except);
-			if (onParentAbort) parentSignal?.removeEventListener("abort", onParentAbort);
-			resolve({
-				endpoint,
-				value
-			});
-		}
-		function finishFail(error) {
-			if (settled) return;
-			settled = true;
-			cleanupAllExcept(null);
-			if (onParentAbort) parentSignal?.removeEventListener("abort", onParentAbort);
-			reject(error);
-		}
-		const onParentAbort = parentSignal ? () => finishFail(new RaceFirstError("raceFirst: parent aborted", candidates[0].endpoint, void 0, "aborted")) : null;
-		if (onParentAbort) parentSignal.addEventListener("abort", onParentAbort);
-		candidates.forEach((cand) => {
-			const ctrl = new AbortController();
-			abortControllers.push(ctrl);
-			const delay = timeoutByMode(cand.endpoint.mode);
-			const timer = setTimeout(() => ctrl.abort(), delay);
-			timers.push(timer);
-			cand.run(ctrl.signal).then((value) => finishSuccess(cand.endpoint, value, ctrl), (err) => {
-				if (settled) {
-					lastErrors.set(cand.endpoint, err);
-					return;
-				}
-				const finalErr = ctrl.signal.aborted && !parentSignal?.aborted ? new RaceFirstError(`timeout (${delay}ms)`, cand.endpoint, err, "all-failed") : err;
-				lastErrors.set(cand.endpoint, finalErr);
-				if (shortCircuit?.(finalErr)) {
-					finishFail(new RaceFirstError("raceFirst: short-circuit", cand.endpoint, finalErr, "short-circuit"));
-					return;
-				}
-				remaining--;
-				if (remaining <= 0) {
-					const [endpoint, cause] = [...lastErrors.entries()].find(([, e]) => {
-						if (e instanceof RaceFirstError) return e.kind !== "all-failed" || !(e.cause instanceof Error && e.cause.message === "aborted");
-						return true;
-					}) ?? [cand.endpoint, finalErr];
-					finishFail(new RaceFirstError("raceFirst: all candidates failed", endpoint, cause, "all-failed"));
-				}
-			});
-		});
-	});
-}
-//#endregion
 //#region src/effects/probeLoop.ts
 function makeProbeFailure(kind, message) {
 	const err = new Error(message);
@@ -712,6 +790,8 @@ function attachProbeLoop(options) {
 			const { endpoint, value: tokens } = await raceFirst(candidates, {
 				timeoutByMode: options.timeoutByMode,
 				parentSignal: ctrl.signal,
+				prefer: options.prefer,
+				preferGraceMs: options.preferGraceMs,
 				shortCircuit: (err) => isProbeFailure(err) && (err.kind === "needs-auth" || err.kind === "fatal" || err.kind === "aborted")
 			});
 			if (ctrl.signal.aborted) return;
@@ -749,52 +829,13 @@ function attachProbeLoop(options) {
 	};
 }
 //#endregion
-//#region src/effects/reconnectWatchdog.ts
-var DEFAULT_ESCALATE_AFTER_MS = 12e3;
-function attachReconnectWatchdog(options) {
-	const escalateAfterMs = options.escalateAfterMs ?? DEFAULT_ESCALATE_AFTER_MS;
-	const setTimer = options.setTimer ?? ((cb, ms) => setTimeout(cb, ms));
-	const clearTimer = options.clearTimer ?? ((h) => clearTimeout(h));
-	let timer;
-	let attempt = 0;
-	let detached = false;
-	function cancelTimer() {
-		if (timer !== void 0) {
-			clearTimer(timer);
-			timer = void 0;
-		}
-	}
-	function arm() {
-		cancelTimer();
-		timer = setTimer(() => {
-			timer = void 0;
-			if (detached) return;
-			if (options.kernel.phase.kind !== "reconnecting") return;
-			attempt += 1;
-			options.onEscalate?.(attempt);
-			options.kernel.dispatch({ type: "USER_RETRY" });
-		}, escalateAfterMs);
-	}
-	const unsubKernel = options.kernel.subscribe((next, prev) => {
-		if (next.kind === "reconnecting" && prev.kind !== "reconnecting") arm();
-		else if (next.kind !== "reconnecting" && prev.kind === "reconnecting") cancelTimer();
-		if (next.kind === "online" || next.kind === "idle") attempt = 0;
-	});
-	if (options.kernel.phase.kind === "reconnecting") arm();
-	return () => {
-		detached = true;
-		cancelTimer();
-		unsubKernel();
-	};
-}
-//#endregion
 //#region src/effects/tokenLifecycle.ts
-var DEFAULT_GRACE_MS$1 = 5e3;
+var DEFAULT_GRACE_MS = 5e3;
 var DEFAULT_MAX_TRANSIENT_RETRIES = 3;
 var DEFAULT_TRANSIENT_RETRY_DELAY_MS = 2e3;
 var MAX_TIMER_DELAY_MS = 2 ** 31 - 1;
 function attachTokenLifecycle(options) {
-	const graceMs = options.graceMs ?? DEFAULT_GRACE_MS$1;
+	const graceMs = options.graceMs ?? DEFAULT_GRACE_MS;
 	const isTransient = options.isTransientError ?? (() => false);
 	const maxTransientRetries = options.maxTransientRetries ?? DEFAULT_MAX_TRANSIENT_RETRIES;
 	const transientRetryDelayMs = options.transientRetryDelayMs ?? DEFAULT_TRANSIENT_RETRY_DELAY_MS;
@@ -835,7 +876,7 @@ function attachTokenLifecycle(options) {
 			return;
 		}
 		const phase = options.kernel.phase;
-		const target = phase.kind === "online" ? phase.target : phase.kind === "reconnecting" ? phase.lastTarget : null;
+		const target = phase.kind === "online" ? phase.target : null;
 		if (!target) {
 			options.onTriggerSkipped?.(reason, "no-target", phase.kind);
 			return;
@@ -856,7 +897,7 @@ function attachTokenLifecycle(options) {
 					};
 				}
 				const livePhase = options.kernel.phase;
-				const base = (livePhase.kind === "online" ? livePhase.target : livePhase.kind === "reconnecting" ? livePhase.lastTarget : null) ?? target;
+				const base = (livePhase.kind === "online" ? livePhase.target : null) ?? target;
 				const refreshTarget = fresh ? {
 					...base,
 					tokens: fresh
@@ -925,7 +966,7 @@ function attachTokenLifecycle(options) {
 				transientRetries = 0;
 				schedule(next.target);
 			}
-		} else if (next.kind === "reconnecting") {} else {
+		} else {
 			cancelTimer();
 			transientRetries = 0;
 		}
@@ -946,7 +987,7 @@ function attachTokenLifecycle(options) {
 	function wake() {
 		if (detached) return;
 		const phase = options.kernel.phase;
-		const target = phase.kind === "online" ? phase.target : phase.kind === "reconnecting" ? phase.lastTarget : null;
+		const target = phase.kind === "online" ? phase.target : null;
 		if (!target) {
 			options.onWakeChecked?.({
 				decision: "no-target",
@@ -989,29 +1030,58 @@ function stringifyError(err) {
 //#endregion
 //#region src/effects/transportSync.ts
 var SKIP = Symbol("transport-sync-skip");
+var DEFAULT_RETRY_MS = 2e3;
 function syncTargetFor(phase) {
 	switch (phase.kind) {
 		case "idle":
 		case "offline":
 		case "needs-auth": return null;
 		case "online": return phase.target;
-		case "reconnecting": return phase.lastTarget;
 		case "discovering": return SKIP;
 	}
 }
 function attachTransportSync(options) {
 	let detached = false;
-	let initialized = false;
-	let lastApplied = null;
-	function applyAll(target) {
-		if (detached) return;
-		if (initialized && isSameTarget(lastApplied, target)) return;
-		initialized = true;
-		lastApplied = target;
-		for (const transport of options.transports) transport.apply(target).catch((err) => {
+	const retryMs = options.retryMs ?? DEFAULT_RETRY_MS;
+	const applied = /* @__PURE__ */ new Map();
+	const retryTimers = /* @__PURE__ */ new Map();
+	let lastNotified;
+	function applyOne(transport, target) {
+		applied.set(transport, target);
+		transport.apply(target).catch((err) => {
 			options.onError?.(transport, target, err);
+			if (applied.get(transport) === target) {
+				applied.delete(transport);
+				scheduleRetry(transport);
+			}
 		});
-		options.onApplied?.(target);
+	}
+	function scheduleRetry(transport) {
+		if (detached || retryTimers.has(transport)) return;
+		const timer = setTimeout(() => {
+			retryTimers.delete(transport);
+			if (detached) return;
+			const decision = syncTargetFor(options.kernel.phase);
+			if (decision === SKIP) {
+				scheduleRetry(transport);
+				return;
+			}
+			if (applied.has(transport) && isSameTarget(applied.get(transport), decision)) return;
+			options.onRetry?.(transport, decision);
+			applyOne(transport, decision);
+		}, retryMs);
+		retryTimers.set(transport, timer);
+	}
+	function applyAll(target) {
+		if (detached) return;
+		for (const transport of options.transports) {
+			if (applied.has(transport) && isSameTarget(applied.get(transport), target)) continue;
+			applyOne(transport, target);
+		}
+		if (lastNotified === void 0 || !isSameTarget(lastNotified, target)) {
+			lastNotified = target;
+			options.onApplied?.(target);
+		}
 	}
 	function syncFromPhase(phase) {
 		const decision = syncTargetFor(phase);
@@ -1024,76 +1094,12 @@ function attachTransportSync(options) {
 	});
 	return () => {
 		detached = true;
+		for (const timer of retryTimers.values()) clearTimeout(timer);
+		retryTimers.clear();
 		unsub();
 	};
 }
 //#endregion
-//#region src/effects/transportWatchdog.ts
-var DEFAULT_GRACE_MS = 4e3;
-function attachTransportWatchdog(options) {
-	const defaultGraceMs = options.defaultGraceMs ?? DEFAULT_GRACE_MS;
-	const setTimer = options.setTimer ?? ((cb, ms) => setTimeout(cb, ms));
-	const clearTimer = options.clearTimer ?? ((h) => clearTimeout(h));
-	const timers = /* @__PURE__ */ new Map();
-	const cleanups = [];
-	let detached = false;
-	function cancelTimer(id, reason) {
-		const handle = timers.get(id);
-		if (handle !== void 0) {
-			clearTimer(handle);
-			timers.delete(id);
-			options.onGraceCleared?.(id, reason);
-		}
-	}
-	function cancelAll(reason) {
-		for (const id of [...timers.keys()]) cancelTimer(id, reason);
-	}
-	for (const transport of options.transports) {
-		const spec = transport.spec;
-		const offUp = transport.on("up", () => {
-			if (detached) return;
-			cancelTimer(spec.id, "up");
-			options.kernel.dispatch({
-				type: "TRANSPORT_UP",
-				id: spec.id
-			});
-		});
-		const offDown = transport.on("down", (payload) => {
-			if (detached) return;
-			options.kernel.dispatch({
-				type: "TRANSPORT_DOWN",
-				id: spec.id,
-				reason: payload.reason
-			});
-			if (!spec.phaseGating) return;
-			if (options.kernel.phase.kind !== "online") return;
-			if (timers.has(spec.id)) return;
-			const graceMs = spec.graceMs ?? defaultGraceMs;
-			options.onGraceStarted?.(spec.id, graceMs);
-			const handle = setTimer(() => {
-				timers.delete(spec.id);
-				if (detached) return;
-				options.onConfirmed?.(spec.id);
-				options.kernel.dispatch({
-					type: "TRANSPORT_DOWN_CONFIRMED",
-					id: spec.id
-				});
-			}, graceMs);
-			timers.set(spec.id, handle);
-		});
-		cleanups.push(offUp, offDown);
-	}
-	const unsubKernel = options.kernel.subscribe((next, prev) => {
-		if (prev.kind === "online" && next.kind !== "online") cancelAll("phase-change");
-	});
-	cleanups.push(unsubKernel);
-	return () => {
-		detached = true;
-		cancelAll("detach");
-		for (const fn of cleanups) fn();
-	};
-}
-//#endregion
 //#region src/effects/workerBridge.ts
 var log = new Logger("workerBridge");
 function attachWorkerBridge(options) {
@@ -1180,4 +1186,187 @@ function attachWorkerBridge(options) {
 	};
 }
 //#endregion
-export { DEFAULT_RACE_TIMEOUT_BY_MODE, RaceFirstError, TransportEmitter, attachBackoff, attachCrossTab, attachNetworkChange, attachPersistence, attachPresence, attachProbeLoop, attachReconnectWatchdog, attachTokenLifecycle, attachTransportSync, attachTransportWatchdog, attachWorkerBridge, createKernel, defaultOnNetworkOnline, endpointKey, isEndpointChange, isProbeFailure, isSameEndpoint, isSameTarget, isTokenOnlyChange, localStorageAdapter, makeProbeFailure, memoryStorageAdapter, raceFirst, reducer, sortByPriority };
+//#region src/journal.ts
+var DEFAULT_CAPACITY = 1e3;
+var MAX_DETAIL_LENGTH = 300;
+function stringifyDetail(detail) {
+	if (detail === void 0 || detail === null) return void 0;
+	let text;
+	if (typeof detail === "string") text = detail;
+	else if (detail instanceof Error) text = detail.message;
+	else try {
+		text = JSON.stringify(detail);
+	} catch {
+		text = String(detail);
+	}
+	return text.length > MAX_DETAIL_LENGTH ? `${text.slice(0, MAX_DETAIL_LENGTH)}…` : text;
+}
+function formatTime(t) {
+	const d = new Date(t);
+	return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}.${String(d.getMilliseconds()).padStart(3, "0")}`;
+}
+function createConnectionJournal(options = {}) {
+	const capacity = options.capacity ?? DEFAULT_CAPACITY;
+	const now = options.now ?? (() => Date.now());
+	const buffer = [];
+	const listeners = /* @__PURE__ */ new Set();
+	let head = 0;
+	let seq = 0;
+	function record(scope, msg, detail) {
+		const entry = {
+			seq: seq++,
+			t: now(),
+			scope,
+			msg,
+			detail: stringifyDetail(detail)
+		};
+		if (buffer.length < capacity) buffer.push(entry);
+		else {
+			buffer[head] = entry;
+			head = (head + 1) % capacity;
+		}
+		for (const listener of [...listeners]) try {
+			listener(entry);
+		} catch {}
+	}
+	function list() {
+		return [...buffer.slice(head), ...buffer.slice(0, head)];
+	}
+	function clear() {
+		buffer.length = 0;
+		head = 0;
+	}
+	function subscribe(listener) {
+		listeners.add(listener);
+		return () => {
+			listeners.delete(listener);
+		};
+	}
+	function exportText() {
+		const entries = list();
+		return [`connection journal — exported ${new Date(now()).toISOString()} (${entries.length} entries)`, ...entries.map((e) => {
+			const detail = e.detail ? ` — ${e.detail}` : "";
+			return `${formatTime(e.t)} [${e.scope}] ${e.msg}${detail}`;
+		})].join("\n");
+	}
+	return {
+		record,
+		list,
+		clear,
+		subscribe,
+		exportText
+	};
+}
+//#endregion
+//#region src/signal.ts
+var DEFAULT_DEBOUNCE_MS = 1500;
+function signalEquals(a, b) {
+	if (a.kind !== b.kind) return false;
+	if (a.kind === "degraded" && b.kind === "degraded") return a.channels.join(",") === b.channels.join(",");
+	if (a.kind === "offline" && b.kind === "offline") return a.retryAt === b.retryAt;
+	return true;
+}
+function createConnectionSignal(options) {
+	const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+	const listeners = /* @__PURE__ */ new Set();
+	const cleanups = [];
+	let hasBeenOnline = false;
+	let anyChannelEverUp = false;
+	let pendingTimer = null;
+	let pendingSignal = null;
+	let disposed = false;
+	function compute() {
+		const phase = options.kernel.phase;
+		switch (phase.kind) {
+			case "idle": return { kind: "connecting" };
+			case "needs-auth": return { kind: "needs-auth" };
+			case "offline": return {
+				kind: "offline",
+				retryAt: phase.nextRetryAt
+			};
+			case "discovering": return hasBeenOnline ? { kind: "offline" } : { kind: "connecting" };
+			case "online": {
+				const channels = options.transports.filter((t) => t.spec.phaseGating && !t.health().up).map((t) => t.spec.id);
+				if (channels.length === 0) return { kind: "online" };
+				return anyChannelEverUp ? {
+					kind: "degraded",
+					channels
+				} : { kind: "connecting" };
+			}
+		}
+	}
+	let current = compute();
+	function clearPending() {
+		if (pendingTimer !== null) {
+			clearTimeout(pendingTimer);
+			pendingTimer = null;
+			pendingSignal = null;
+		}
+	}
+	function apply(next) {
+		clearPending();
+		if (signalEquals(current, next)) return;
+		current = next;
+		for (const listener of [...listeners]) try {
+			listener(next);
+		} catch {}
+	}
+	function recompute() {
+		if (disposed) return;
+		const raw = compute();
+		if (signalEquals(current, raw)) {
+			clearPending();
+			return;
+		}
+		if (raw.kind === "online" || raw.kind === "connecting" || raw.kind === "needs-auth") {
+			apply(raw);
+			return;
+		}
+		if (pendingSignal && pendingSignal.kind === raw.kind) {
+			pendingSignal = raw;
+			return;
+		}
+		clearPending();
+		pendingSignal = raw;
+		pendingTimer = setTimeout(() => {
+			pendingTimer = null;
+			const held = pendingSignal;
+			pendingSignal = null;
+			if (held) apply(compute().kind === held.kind ? compute() : held);
+		}, debounceMs);
+	}
+	cleanups.push(options.kernel.subscribe((next) => {
+		if (next.kind === "online") hasBeenOnline = true;
+		else if (next.kind === "idle") {
+			hasBeenOnline = false;
+			anyChannelEverUp = false;
+		}
+		recompute();
+	}));
+	for (const transport of options.transports) {
+		cleanups.push(transport.on("up", () => {
+			anyChannelEverUp = true;
+			recompute();
+		}));
+		cleanups.push(transport.on("down", () => recompute()));
+	}
+	return {
+		get current() {
+			return current;
+		},
+		raw: () => compute(),
+		recompute,
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		dispose() {
+			disposed = true;
+			clearPending();
+			for (const fn of cleanups) fn();
+			listeners.clear();
+		}
+	};
+}
+//#endregion
+export { TransportEmitter, attachBackoff, attachCrossTab, attachDegradedRecovery, attachNetworkChange, attachPersistence, attachPresence, attachProbeLoop, attachTokenLifecycle, attachTransportSync, attachWorkerBridge, classifyClose, createBackgroundProbe, createConnectionJournal, createConnectionSignal, createKernel, isEndpointChange, isProbeFailure, isSameTarget, localStorageAdapter, makeProbeFailure, memoryStorageAdapter, raceFirst, reducer };