@camera.ui/transport 0.0.1

package/dist/index.js

@@ -0,0 +1,1101 @@
+import { i as isTokenOnlyChange, n as isEndpointChange, r as isSameTarget, t as TransportEmitter } from "./contract-d-0gfY8v.js";
+//#region src/core/reducer.ts
+var EMPTY_TRANSPORTS = /* @__PURE__ */ new Map();
+var DEFAULT_BACKOFF_MS = 5e3;
+function reducer(phase, action, ctx) {
+	switch (action.type) {
+		case "RESET": return phase.kind === "idle" ? phase : { kind: "idle" };
+		case "BOOT":
+			if (phase.kind !== "idle" && phase.kind !== "offline" && phase.kind !== "needs-auth") return phase;
+			return {
+				kind: "discovering",
+				instanceId: action.instanceId,
+				attempt: 1
+			};
+		case "USER_RETRY":
+			if (phase.kind === "offline") return {
+				kind: "discovering",
+				instanceId: phase.instanceId ?? "",
+				attempt: 1
+			};
+			if (phase.kind === "reconnecting") return {
+				kind: "discovering",
+				instanceId: phase.instanceId,
+				attempt: 1
+			};
+			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
+			};
+			return phase;
+		case "PROBE_SUCCEEDED":
+			if (phase.kind === "discovering") return {
+				kind: "online",
+				instanceId: phase.instanceId,
+				target: {
+					endpoint: action.endpoint,
+					tokens: action.tokens
+				},
+				transports: EMPTY_TRANSPORTS
+			};
+			if (phase.kind === "reconnecting") 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;
+			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
+				};
+			}
+			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()
+				})
+			};
+			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()
+				})
+			};
+		case "TOKENS_REFRESHED":
+			if (phase.kind === "online") {
+				if (tokensEqual(phase.target.tokens, action.tokens)) return phase;
+				return {
+					...phase,
+					target: {
+						...phase.target,
+						tokens: action.tokens
+					}
+				};
+			}
+			if (phase.kind === "reconnecting" && phase.lastTarget) {
+				if (tokensEqual(phase.lastTarget.tokens, action.tokens)) return phase;
+				return {
+					...phase,
+					lastTarget: {
+						...phase.lastTarget,
+						tokens: 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
+				};
+			}
+			return {
+				kind: "needs-auth",
+				instanceId: phase.instanceId,
+				reason: `tokens invalid: ${action.reason}`
+			};
+		case "BACKOFF_HINT": {
+			if (phase.kind !== "offline") return phase;
+			const now = ctx.now();
+			const candidate = now + action.retryAfterMs;
+			if (candidate <= phase.nextRetryAt) return phase;
+			return {
+				...phase,
+				nextRetryAt: candidate,
+				backoffHint: {
+					retryAfterMs: action.retryAfterMs,
+					setAt: now,
+					source: action.source
+				}
+			};
+		}
+	}
+}
+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;
+}
+//#endregion
+//#region src/core/kernel.ts
+function createKernel(options) {
+	let current = options.initial ?? { kind: "idle" };
+	const listeners = /* @__PURE__ */ new Set();
+	const queue = [];
+	let dispatching = false;
+	let disposed = false;
+	function dispatch(action) {
+		if (disposed) return;
+		if (dispatching) {
+			queue.push(action);
+			return;
+		}
+		dispatching = true;
+		try {
+			let next = action;
+			while (next) {
+				const prev = current;
+				const after = reducer(prev, next, options.context);
+				if (after !== prev) {
+					current = after;
+					for (const listener of [...listeners]) try {
+						listener(after, prev, next);
+					} catch (err) {
+						console.warn("[kernel] listener threw on", next.type, err);
+					}
+				}
+				next = queue.shift();
+			}
+		} finally {
+			dispatching = false;
+		}
+	}
+	function subscribe(listener) {
+		listeners.add(listener);
+		return () => {
+			listeners.delete(listener);
+		};
+	}
+	function dispose() {
+		disposed = true;
+		listeners.clear();
+		queue.length = 0;
+	}
+	return {
+		get phase() {
+			return current;
+		},
+		dispatch,
+		subscribe,
+		dispose
+	};
+}
+//#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;
+}
+function endpointKey(ep) {
+	return `${ep.mode}|${ep.url}`;
+}
+//#endregion
+//#region src/effects/backoff.ts
+var DEFAULT_SCHEDULE = [
+	5e3,
+	1e4,
+	3e4,
+	6e4
+];
+function attachBackoff(options) {
+	const schedule = options.schedule ?? DEFAULT_SCHEDULE;
+	if (schedule.length === 0) throw new Error("backoff: schedule must have at least one entry");
+	const now = options.now ?? (() => Date.now());
+	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(reason) {
+		if (timer !== void 0) {
+			clearTimer(timer);
+			timer = void 0;
+			if (reason) options.onCancelled?.(reason);
+		}
+	}
+	function scheduleFromPhase(phase, isReschedule) {
+		cancelTimer(isReschedule ? "rescheduled" : void 0);
+		const scheduleDelay = schedule[Math.min(attempt, schedule.length - 1)];
+		const phaseDelay = Math.max(0, phase.nextRetryAt - now());
+		const delay = Math.max(scheduleDelay, phaseDelay);
+		options.onScheduled?.(attempt + 1, delay);
+		if (phase.backoffHint && phaseDelay > scheduleDelay) options.onHintApplied?.(delay, phase.backoffHint.source);
+		timer = setTimer(() => {
+			timer = void 0;
+			if (detached) return;
+			if (options.kernel.phase.kind !== "offline") return;
+			attempt += 1;
+			options.onFire?.(attempt);
+			options.kernel.dispatch({ type: "USER_RETRY" });
+		}, delay);
+	}
+	const unsubKernel = options.kernel.subscribe((next, prev) => {
+		if (next.kind === "offline" && prev.kind !== "offline") {
+			scheduleFromPhase(next, false);
+			return;
+		}
+		if (next.kind === "offline" && prev.kind === "offline" && next.nextRetryAt !== prev.nextRetryAt) {
+			scheduleFromPhase(next, true);
+			return;
+		}
+		if (prev.kind === "offline" && next.kind !== "offline") cancelTimer("phase-left-offline");
+		if (next.kind === "online" || next.kind === "idle") attempt = 0;
+	});
+	if (options.kernel.phase.kind === "offline") scheduleFromPhase(options.kernel.phase, false);
+	return () => {
+		detached = true;
+		cancelTimer("detach");
+		unsubKernel();
+	};
+}
+//#endregion
+//#region src/effects/crossTab.ts
+var DEFAULT_KEY$1 = "camera.ui:transport:target";
+function attachCrossTab(options) {
+	const key = options.key ?? DEFAULT_KEY$1;
+	const source = options.source ?? (typeof window !== "undefined" ? window : void 0);
+	if (!source) throw new Error("attachCrossTab: no `source` provided and no global `window` available");
+	function handle(event) {
+		const e = event;
+		if (e.key !== key) return;
+		if (e.newValue === null) {
+			const k = options.kernel.phase.kind;
+			if (k !== "online" && k !== "reconnecting") return;
+			options.kernel.dispatch({ type: "RESET" });
+			options.onResetReceived?.();
+			return;
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(e.newValue);
+		} catch (err) {
+			options.onError?.("parse", err);
+			return;
+		}
+		if (!parsed?.tokens?.access) return;
+		const k = options.kernel.phase.kind;
+		if (k !== "online" && k !== "reconnecting") return;
+		options.kernel.dispatch({
+			type: "TOKENS_REFRESHED",
+			tokens: parsed.tokens
+		});
+		options.onTokensReceived?.(parsed.tokens);
+	}
+	source.addEventListener("storage", handle);
+	return () => {
+		source.removeEventListener("storage", handle);
+	};
+}
+//#endregion
+//#region src/effects/networkChange.ts
+function attachNetworkChange(options) {
+	let detached = false;
+	const handler = (event) => {
+		if (detached) return;
+		options.onChange(options.kernel, event);
+	};
+	options.source.addEventListener("change", handler);
+	return () => {
+		detached = true;
+		options.source.removeEventListener("change", handler);
+	};
+}
+//#endregion
+//#region src/effects/persistence.ts
+var DEFAULT_KEY = "camera.ui:transport:target";
+function attachPersistence(options) {
+	const key = options.key ?? DEFAULT_KEY;
+	const onError = options.onError ?? (() => {});
+	let detached = false;
+	let cached = null;
+	restore();
+	async function restore() {
+		let raw;
+		try {
+			raw = await options.storage.get(key);
+		} catch (err) {
+			onError("get", err);
+			raw = null;
+		}
+		if (detached) return;
+		if (cached !== null) {
+			options.onRestore?.(cached);
+			return;
+		}
+		if (!raw) {
+			options.onRestore?.(null);
+			return;
+		}
+		try {
+			const parsed = JSON.parse(raw);
+			if (!parsed?.endpoint?.url || !parsed?.tokens?.access) {
+				options.onRestore?.(null);
+				return;
+			}
+			cached = {
+				endpoint: parsed.endpoint,
+				tokens: parsed.tokens
+			};
+			options.onRestore?.(cached);
+		} catch (err) {
+			onError("parse", err);
+			options.onRestore?.(null);
+		}
+	}
+	async function persist(target) {
+		const payload = {
+			endpoint: target.endpoint,
+			tokens: target.tokens,
+			savedAt: Date.now(),
+			version: 1
+		};
+		cached = {
+			endpoint: target.endpoint,
+			tokens: target.tokens
+		};
+		try {
+			await options.storage.set(key, JSON.stringify(payload));
+			options.onPersist?.(target);
+		} catch (err) {
+			onError("set", err);
+		}
+	}
+	async function clear() {
+		cached = null;
+		try {
+			await options.storage.del(key);
+			options.onClear?.();
+		} catch (err) {
+			onError("del", err);
+		}
+	}
+	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 (nextTarget && nextTarget !== prevTarget) {
+			persist(nextTarget);
+			return;
+		}
+		if (next.kind === "idle" && prev.kind !== "idle") clear();
+	});
+	return {
+		detach: () => {
+			detached = true;
+			unsub();
+		},
+		peek: () => cached,
+		seed: async (target) => {
+			if (detached) return;
+			await persist(target);
+		}
+	};
+}
+function localStorageAdapter(scope = globalThis.localStorage) {
+	if (!scope) throw new Error("localStorageAdapter: localStorage is not available in this environment");
+	return {
+		get(k) {
+			return scope.getItem(k);
+		},
+		set(k, v) {
+			scope.setItem(k, v);
+		},
+		del(k) {
+			scope.removeItem(k);
+		}
+	};
+}
+function memoryStorageAdapter(initial = {}) {
+	const store = new Map(Object.entries(initial));
+	return {
+		get(k) {
+			return store.get(k) ?? null;
+		},
+		set(k, v) {
+			store.set(k, v);
+		},
+		del(k) {
+			store.delete(k);
+		}
+	};
+}
+//#endregion
+//#region src/effects/presence.ts
+var defaultOnNetworkOnline = (kernel) => {
+	if (kernel.phase.kind === "offline") kernel.dispatch({ type: "USER_RETRY" });
+};
+function attachPresence(options) {
+	const networkSource = options.networkSource !== void 0 ? options.networkSource : typeof globalThis !== "undefined" && "window" in globalThis ? globalThis.window : null;
+	const visibilitySource = options.visibilitySource !== void 0 ? options.visibilitySource : typeof globalThis !== "undefined" && "document" in globalThis ? globalThis.document : null;
+	const onOnline = options.onOnline ?? defaultOnNetworkOnline;
+	const onOffline = options.onOffline;
+	const cleanups = [];
+	if (networkSource) {
+		const handleOnline = () => onOnline(options.kernel);
+		const handleOffline = () => onOffline?.(options.kernel);
+		networkSource.addEventListener("online", handleOnline);
+		networkSource.addEventListener("offline", handleOffline);
+		cleanups.push(() => {
+			networkSource.removeEventListener("online", handleOnline);
+			networkSource.removeEventListener("offline", handleOffline);
+		});
+	}
+	if (visibilitySource && (options.onVisibilityVisible || options.onVisibilityHidden)) {
+		const handleVisibility = () => {
+			if (visibilitySource.visibilityState !== "hidden") options.onVisibilityVisible?.(options.kernel);
+			else options.onVisibilityHidden?.(options.kernel);
+		};
+		visibilitySource.addEventListener("visibilitychange", handleVisibility);
+		cleanups.push(() => {
+			visibilitySource.removeEventListener("visibilitychange", handleVisibility);
+		});
+	}
+	return () => {
+		for (const fn of cleanups) fn();
+		cleanups.length = 0;
+	};
+}
+//#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);
+	err.kind = kind;
+	return err;
+}
+function isProbeFailure(err) {
+	return err instanceof Error && typeof err.kind === "string";
+}
+function attachProbeLoop(options) {
+	let masterAbort;
+	let detached = false;
+	function cancel() {
+		if (masterAbort) {
+			masterAbort.abort();
+			masterAbort = void 0;
+		}
+	}
+	async function runRound() {
+		if (detached) return;
+		cancel();
+		const ctrl = new AbortController();
+		masterAbort = ctrl;
+		let pool;
+		try {
+			options.onDiscoverStart?.();
+			pool = await options.discover(ctrl.signal);
+			if (ctrl.signal.aborted) return;
+			options.onDiscoverSuccess?.(pool);
+		} catch (err) {
+			if (ctrl.signal.aborted) return;
+			options.onDiscoverError?.(err);
+			const reason = err instanceof Error ? `discover: ${err.message}` : "discover failed";
+			options.onAllFailed?.(reason);
+			options.kernel.dispatch({
+				type: "PROBE_FAILED_ALL",
+				error: reason
+			});
+			return;
+		}
+		if (pool.length === 0) {
+			const reason = "discover returned empty pool";
+			options.onAllFailed?.(reason);
+			options.kernel.dispatch({
+				type: "PROBE_FAILED_ALL",
+				error: reason
+			});
+			return;
+		}
+		const lastTokens = options.lastTarget?.()?.tokens;
+		const candidates = pool.map((endpoint) => ({
+			endpoint,
+			run: async (signal) => {
+				options.onProbeStart?.(endpoint);
+				try {
+					const tokens = await options.probe({
+						endpoint,
+						lastTokens,
+						signal
+					});
+					options.onProbeSuccess?.(endpoint, tokens);
+					return tokens;
+				} catch (err) {
+					const isLocalTimeout = signal.aborted && !ctrl.signal.aborted && !isProbeFailure(err);
+					const timeout = (options.timeoutByMode ?? ((m) => DEFAULT_RACE_TIMEOUT_BY_MODE[m] ?? 5e3))(endpoint.mode);
+					const finalErr = isLocalTimeout ? makeProbeFailure("transient", `timeout (${timeout}ms)`) : err;
+					options.onProbeError?.(endpoint, finalErr);
+					throw finalErr;
+				}
+			}
+		}));
+		try {
+			const { endpoint, value: tokens } = await raceFirst(candidates, {
+				timeoutByMode: options.timeoutByMode,
+				parentSignal: ctrl.signal,
+				shortCircuit: (err) => isProbeFailure(err) && (err.kind === "needs-auth" || err.kind === "fatal" || err.kind === "aborted")
+			});
+			if (ctrl.signal.aborted) return;
+			options.kernel.dispatch({
+				type: "PROBE_SUCCEEDED",
+				endpoint,
+				tokens
+			});
+		} catch (err) {
+			if (ctrl.signal.aborted) return;
+			const underlying = err instanceof RaceFirstError ? err.cause : err;
+			if (isProbeFailure(underlying) && underlying.kind === "aborted") {
+				setTimeout(() => {
+					if (!detached) runRound();
+				}, 200);
+				return;
+			}
+			const reason = isProbeFailure(underlying) && underlying.kind === "needs-auth" ? "needs-auth" : underlying instanceof Error ? underlying.message : "all endpoints failed";
+			options.onAllFailed?.(reason);
+			options.kernel.dispatch({
+				type: "PROBE_FAILED_ALL",
+				error: reason
+			});
+		}
+	}
+	const unsub = options.kernel.subscribe((next, prev) => {
+		if (next.kind === "discovering" && prev.kind !== "discovering") runRound();
+		else if (next.kind !== "discovering" && prev.kind === "discovering") cancel();
+	});
+	if (options.kernel.phase.kind === "discovering") runRound();
+	return () => {
+		detached = true;
+		cancel();
+		unsub();
+	};
+}
+//#endregion
+//#region src/effects/tokenLifecycle.ts
+var DEFAULT_GRACE_MS$1 = 5e3;
+var DEFAULT_MAX_TRANSIENT_RETRIES = 3;
+var DEFAULT_TRANSIENT_RETRY_DELAY_MS = 2e3;
+function attachTokenLifecycle(options) {
+	const graceMs = options.graceMs ?? DEFAULT_GRACE_MS$1;
+	const isTransient = options.isTransientError ?? (() => false);
+	const maxTransientRetries = options.maxTransientRetries ?? DEFAULT_MAX_TRANSIENT_RETRIES;
+	const transientRetryDelayMs = options.transientRetryDelayMs ?? DEFAULT_TRANSIENT_RETRY_DELAY_MS;
+	const now = options.now ?? (() => Date.now());
+	const setTimer = options.setTimer ?? ((cb, ms) => setTimeout(cb, ms));
+	const clearTimer = options.clearTimer ?? ((h) => clearTimeout(h));
+	let timer;
+	let inflight = false;
+	let detached = false;
+	let transientRetries = 0;
+	let pendingAuthError = false;
+	const cleanups = [];
+	function cancelTimer() {
+		if (timer !== void 0) {
+			clearTimer(timer);
+			timer = void 0;
+		}
+	}
+	function schedule(target) {
+		cancelTimer();
+		const exp = target.tokens.accessExpiresAt;
+		if (!exp) return;
+		const delayMs = Math.max(0, exp - now() - graceMs);
+		options.onScheduled?.(delayMs, exp);
+		timer = setTimer(() => {
+			timer = void 0;
+			triggerRefresh("proactive");
+		}, delayMs);
+	}
+	async function triggerRefresh(reason) {
+		if (detached) {
+			options.onTriggerSkipped?.(reason, "detached", options.kernel.phase.kind);
+			return;
+		}
+		if (inflight) {
+			if (reason === "auth-error") pendingAuthError = true;
+			options.onTriggerSkipped?.(reason, "already-inflight", options.kernel.phase.kind);
+			return;
+		}
+		const phase = options.kernel.phase;
+		const target = phase.kind === "online" ? phase.target : phase.kind === "reconnecting" ? phase.lastTarget : null;
+		if (!target) {
+			options.onTriggerSkipped?.(reason, "no-target", phase.kind);
+			return;
+		}
+		inflight = true;
+		options.onRefreshStart?.(reason);
+		try {
+			const result = await (options.acquireRefreshLock ?? ((fn) => fn()))(async () => {
+				const fresh = options.getLatestTokens?.();
+				if (fresh?.accessExpiresAt && fresh.accessExpiresAt > now() + graceMs) {
+					options.kernel.dispatch({
+						type: "TOKENS_REFRESHED",
+						tokens: fresh
+					});
+					return {
+						tokens: fresh,
+						skipped: true
+					};
+				}
+				const tokens = await options.refresh(target, reason);
+				if (detached) return {
+					tokens,
+					skipped: false
+				};
+				options.kernel.dispatch({
+					type: "TOKENS_REFRESHED",
+					tokens
+				});
+				return {
+					tokens,
+					skipped: false
+				};
+			});
+			if (detached) return;
+			transientRetries = 0;
+			if (result.skipped) options.onRefreshSkipped?.(reason, result.tokens);
+			else options.onRefreshSuccess?.(reason, result.tokens);
+		} catch (err) {
+			if (detached) return;
+			const transient = isTransient(err);
+			if (transient && transientRetries < maxTransientRetries) {
+				transientRetries++;
+				const retriesLeft = maxTransientRetries - transientRetries;
+				options.onRefreshError?.(reason, err, {
+					transient: true,
+					retriesLeft,
+					willRetry: true
+				});
+				cancelTimer();
+				timer = setTimer(() => {
+					timer = void 0;
+					triggerRefresh(reason);
+				}, transientRetryDelayMs);
+			} else {
+				transientRetries = 0;
+				options.onRefreshError?.(reason, err, {
+					transient,
+					retriesLeft: 0,
+					willRetry: false
+				});
+				options.kernel.dispatch({
+					type: "TOKENS_INVALID",
+					reason: stringifyError(err),
+					transient
+				});
+			}
+		} finally {
+			inflight = false;
+			if (!detached && pendingAuthError) {
+				pendingAuthError = false;
+				triggerRefresh("auth-error");
+			}
+		}
+	}
+	const unsubKernel = options.kernel.subscribe((next, prev) => {
+		if (next.kind === "online") {
+			if (prev.kind !== "online" || prev.target.tokens.access !== next.target.tokens.access) {
+				transientRetries = 0;
+				schedule(next.target);
+			}
+		} else if (next.kind === "reconnecting") {} else {
+			cancelTimer();
+			transientRetries = 0;
+		}
+	});
+	cleanups.push(unsubKernel);
+	for (const transport of options.transports) {
+		const off = transport.on("auth-error", () => {
+			triggerRefresh("auth-error");
+		});
+		cleanups.push(off);
+	}
+	if (options.kernel.phase.kind === "online") schedule(options.kernel.phase.target);
+	function detach() {
+		detached = true;
+		cancelTimer();
+		for (const fn of cleanups) fn();
+	}
+	function wake() {
+		if (detached) return;
+		const phase = options.kernel.phase;
+		const target = phase.kind === "online" ? phase.target : phase.kind === "reconnecting" ? phase.lastTarget : null;
+		if (!target) {
+			options.onWakeChecked?.({
+				decision: "no-target",
+				phase: phase.kind
+			});
+			return;
+		}
+		const exp = target.tokens.accessExpiresAt;
+		if (!exp) {
+			options.onWakeChecked?.({
+				decision: "no-expiry",
+				phase: phase.kind
+			});
+			return;
+		}
+		const remaining = exp - now();
+		if (remaining < graceMs) {
+			options.onWakeChecked?.({
+				decision: "refresh-now",
+				remainingMs: remaining,
+				phase: phase.kind
+			});
+			triggerRefresh("proactive");
+		} else options.onWakeChecked?.({
+			decision: "still-fresh",
+			remainingMs: remaining,
+			phase: phase.kind
+		});
+	}
+	return {
+		detach,
+		wake
+	};
+}
+function stringifyError(err) {
+	if (err instanceof Error) return err.message;
+	if (typeof err === "string") return err;
+	return "refresh-failed";
+}
+//#endregion
+//#region src/effects/transportSync.ts
+var SKIP = Symbol("transport-sync-skip");
+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) => {
+			options.onError?.(transport, target, err);
+		});
+		options.onApplied?.(target);
+	}
+	function syncFromPhase(phase) {
+		const decision = syncTargetFor(phase);
+		if (decision === SKIP) return;
+		applyAll(decision);
+	}
+	syncFromPhase(options.kernel.phase);
+	const unsub = options.kernel.subscribe((next) => {
+		syncFromPhase(next);
+	});
+	return () => {
+		detached = true;
+		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
+function attachWorkerBridge(options) {
+	let generation = 0;
+	let detached = false;
+	const hostListenerCleanups = /* @__PURE__ */ new Map();
+	function makeSync(phase) {
+		generation++;
+		return {
+			type: "kernel-sync",
+			generation,
+			phase
+		};
+	}
+	function broadcast(phase) {
+		if (detached) return;
+		const msg = makeSync(phase);
+		let count = 0;
+		for (const host of options.hosts()) try {
+			host.postMessage(msg);
+			count++;
+			maybeAttachHostListener(host);
+		} catch (err) {
+			console.warn("[workerBridge] broadcast postMessage failed", {
+				gen: msg.generation,
+				phase: phase.kind,
+				err
+			});
+		}
+		options.onBroadcast?.(generation, count);
+	}
+	function syncOne(host) {
+		if (detached) return;
+		const msg = makeSync(options.kernel.phase);
+		try {
+			host.postMessage(msg);
+			maybeAttachHostListener(host);
+			options.onSyncHost?.(generation);
+		} catch (err) {
+			console.warn("[workerBridge] syncOne postMessage failed", {
+				gen: msg.generation,
+				err
+			});
+		}
+	}
+	function maybeAttachHostListener(host) {
+		if (!options.listenForResyncRequests) return;
+		if (!host.addEventListener) return;
+		if (hostListenerCleanups.has(host)) return;
+		const listener = (event) => {
+			if (detached) return;
+			if (event.data?.type === "kernel-sync-request") syncOne(host);
+		};
+		host.addEventListener("message", listener);
+		hostListenerCleanups.set(host, () => {
+			host.removeEventListener?.("message", listener);
+		});
+	}
+	const unsubKernel = options.kernel.subscribe((next) => {
+		broadcast(next);
+	});
+	return {
+		detach() {
+			detached = true;
+			unsubKernel();
+			for (const cleanup of hostListenerCleanups.values()) cleanup();
+			hostListenerCleanups.clear();
+		},
+		syncHost(host) {
+			syncOne(host);
+		},
+		syncAll() {
+			broadcast(options.kernel.phase);
+		},
+		revalidateWorkers() {
+			if (detached) return;
+			for (const host of options.hosts()) try {
+				host.postMessage({ type: "kernel-revalidate" });
+				maybeAttachHostListener(host);
+			} catch (err) {
+				console.warn("[workerBridge] revalidate postMessage failed", err);
+			}
+		}
+	};
+}
+//#endregion
+export { DEFAULT_RACE_TIMEOUT_BY_MODE, RaceFirstError, TransportEmitter, attachBackoff, attachCrossTab, attachNetworkChange, attachPersistence, attachPresence, attachProbeLoop, attachTokenLifecycle, attachTransportSync, attachTransportWatchdog, attachWorkerBridge, createKernel, defaultOnNetworkOnline, endpointKey, isEndpointChange, isProbeFailure, isSameEndpoint, isSameTarget, isTokenOnlyChange, localStorageAdapter, makeProbeFailure, memoryStorageAdapter, raceFirst, reducer, sortByPriority };