@hype-stack/cli 0.0.1 → 0.2.0

package/dist/cli-CPOgUkiJ.js

@@ -0,0 +1,4056 @@
+import { Command as e } from "commander";
+import * as t from "@clack/prompts";
+import n from "node:fs/promises";
+import r from "picocolors";
+import i from "node:os";
+import a from "node:path";
+import { exec as o, spawn as s } from "node:child_process";
+import { downloadTemplate as c } from "giget";
+//#region \0rolldown/runtime.js
+var l = Object.create, u = Object.defineProperty, d = Object.getOwnPropertyDescriptor, f = Object.getOwnPropertyNames, p = Object.getPrototypeOf, m = Object.prototype.hasOwnProperty, h = (e, t) => () => (t || (e((t = { exports: {} }).exports, t), e = null), t.exports), g = (e, t, n, r) => {
+	if (t && typeof t == "object" || typeof t == "function") for (var i = f(t), a = 0, o = i.length, s; a < o; a++) s = i[a], !m.call(e, s) && s !== n && u(e, s, {
+		get: ((e) => t[e]).bind(null, s),
+		enumerable: !(r = d(t, s)) || r.enumerable
+	});
+	return e;
+}, _ = (e, t, n) => (n = e == null ? {} : l(p(e)), g(t || !e || !e.__esModule ? u(n, "default", {
+	value: e,
+	enumerable: !0
+}) : n, e)), v = "0.0.1", y = "gh:BetterTyped/hype-stack", b = "stack.json", x = "/schema/stack.json", S = "https://hypestack.dev", C = "HYPE_STACK_API_URL", w = /^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/, T = [
+	{
+		value: "cursor",
+		label: "Cursor",
+		hint: "default"
+	},
+	{
+		value: "claude",
+		label: "Claude Code"
+	},
+	{
+		value: "windsurf",
+		label: "Windsurf"
+	},
+	{
+		value: "copilot",
+		label: "GitHub Copilot"
+	}
+], E = T.map((e) => e.value), D = ".cursor/rules", O = ".cursor", ee = ".agents";
+function k() {
+	let e = process.env.HYPE_STACK_API_URL;
+	return e ? (ne(e), e.replace(/\/+$/, "")) : S;
+}
+function te() {
+	let e = process.env.HYPE_STACK_WEB_URL;
+	return e ? (ne(e), e.replace(/\/+$/, "")) : k();
+}
+function ne(e) {
+	try {
+		let t = new URL(e);
+		if (!t.protocol.startsWith("http")) throw Error(`${C} must use http or https protocol, got "${t.protocol}"`);
+	} catch (t) {
+		throw t instanceof TypeError ? Error(`${C} is not a valid URL: "${e}"`, { cause: t }) : t;
+	}
+}
+function re() {
+	return `${k()}${x}`;
+}
+//#endregion
+//#region src/ui/theme.ts
+var A = (e) => `\x1b[38;5;208m${e}\x1b[39m`, j = (e) => `\x1b[38;5;214m${e}\x1b[39m`, M = (e) => `\x1b[38;5;220m${e}\x1b[39m`, ie = (e) => `\x1b[38;5;33m${e}\x1b[39m`, N = (e) => `\x1b[38;5;39m${e}\x1b[39m`, P = (e) => `\x1b[38;5;81m${e}\x1b[39m`, F = {
+	orange: A,
+	orangeBright: j,
+	amber: M,
+	deepBlue: ie,
+	skyBlue: N,
+	lightBlue: P
+}, I = {
+	brand: (e) => A(e),
+	brandBold: (e) => r.bold(A(e)),
+	accent: (e) => N(e),
+	accentBold: (e) => r.bold(N(e)),
+	success: (e) => r.green(e),
+	error: (e) => r.red(e),
+	warning: (e) => r.yellow(e),
+	muted: (e) => r.dim(e),
+	bold: (e) => r.bold(e),
+	highlight: (e) => r.bold(r.white(e)),
+	path: (e) => r.underline(N(e)),
+	command: (e) => r.bold(M(e)),
+	label: (e) => r.dim(r.bold(e))
+}, L = {
+	arrow: A("›"),
+	bullet: I.muted("·"),
+	dash: I.muted("─"),
+	corner: I.muted("╰"),
+	pipe: I.muted("│"),
+	dot: I.muted("•"),
+	spark: M("✦"),
+	sparkSmall: j("✧"),
+	bolt: M("⚡")
+}, ae = [
+	A,
+	A,
+	j,
+	M,
+	ie,
+	N,
+	P,
+	P
+];
+function oe(e) {
+	let t = [...e], n = t.length;
+	return t.map((e, t) => {
+		if (e === " " || e === "\n") return e;
+		let r = t / Math.max(n - 1, 1);
+		return ae[Math.min(Math.floor(r * ae.length), ae.length - 1)](e);
+	}).join("");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@hyper-fetch+core@8.1.1/node_modules/@hyper-fetch/core/dist/index.mjs
+var se = Object.create, ce = Object.defineProperty, le = Object.getOwnPropertyDescriptor, ue = Object.getOwnPropertyNames, de = Object.getPrototypeOf, fe = Object.prototype.hasOwnProperty, pe = (e, t) => () => (t || e((t = { exports: {} }).exports, t), t.exports), me = (e, t, n, r) => {
+	if (t && typeof t == "object" || typeof t == "function") for (var i = ue(t), a = 0, o = i.length, s; a < o; a++) s = i[a], !fe.call(e, s) && s !== n && ce(e, s, {
+		get: ((e) => t[e]).bind(null, s),
+		enumerable: !(r = le(t, s)) || r.enumerable
+	});
+	return e;
+}, he = (e, t, n) => (n = e == null ? {} : se(de(e)), me(t || !e || !e.__esModule ? ce(n, "default", {
+	value: e,
+	enumerable: !0
+}) : n, e)), ge = (e) => `${e.queryKey}_${Date.now().toString(36)}_${Math.random().toString(36).substring(2)}`, _e = /* @__PURE__ */ he((/* @__PURE__ */ pe(((e, t) => {
+	var n = typeof Reflect == "object" ? Reflect : null, r = n && typeof n.apply == "function" ? n.apply : function(e, t, n) {
+		return Function.prototype.apply.call(e, t, n);
+	}, i = n && typeof n.ownKeys == "function" ? n.ownKeys : Object.getOwnPropertySymbols ? function(e) {
+		return Object.getOwnPropertyNames(e).concat(Object.getOwnPropertySymbols(e));
+	} : function(e) {
+		return Object.getOwnPropertyNames(e);
+	};
+	function a(e) {
+		console && console.warn && console.warn(e);
+	}
+	var o = Number.isNaN || function(e) {
+		return e !== e;
+	};
+	function s() {
+		s.init.call(this);
+	}
+	t.exports = s, t.exports.once = y, s.EventEmitter = s, s.prototype._events = void 0, s.prototype._eventsCount = 0, s.prototype._maxListeners = void 0;
+	var c = 10;
+	function l(e) {
+		if (typeof e != "function") throw TypeError("The \"listener\" argument must be of type Function. Received type " + typeof e);
+	}
+	Object.defineProperty(s, "defaultMaxListeners", {
+		enumerable: !0,
+		get: function() {
+			return c;
+		},
+		set: function(e) {
+			if (typeof e != "number" || e < 0 || o(e)) throw RangeError("The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received " + e + ".");
+			c = e;
+		}
+	}), s.init = function() {
+		(this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) && (this._events = Object.create(null), this._eventsCount = 0), this._maxListeners = this._maxListeners || void 0;
+	}, s.prototype.setMaxListeners = function(e) {
+		if (typeof e != "number" || e < 0 || o(e)) throw RangeError("The value of \"n\" is out of range. It must be a non-negative number. Received " + e + ".");
+		return this._maxListeners = e, this;
+	};
+	function u(e) {
+		return e._maxListeners === void 0 ? s.defaultMaxListeners : e._maxListeners;
+	}
+	s.prototype.getMaxListeners = function() {
+		return u(this);
+	}, s.prototype.emit = function(e) {
+		for (var t = [], n = 1; n < arguments.length; n++) t.push(arguments[n]);
+		var i = e === "error", a = this._events;
+		if (a !== void 0) i &&= a.error === void 0;
+		else if (!i) return !1;
+		if (i) {
+			var o;
+			if (t.length > 0 && (o = t[0]), o instanceof Error) throw o;
+			var s = /* @__PURE__ */ Error("Unhandled error." + (o ? " (" + o.message + ")" : ""));
+			throw s.context = o, s;
+		}
+		var c = a[e];
+		if (c === void 0) return !1;
+		if (typeof c == "function") r(c, this, t);
+		else for (var l = c.length, u = g(c, l), n = 0; n < l; ++n) r(u[n], this, t);
+		return !0;
+	};
+	function d(e, t, n, r) {
+		var i, o, s;
+		if (l(n), o = e._events, o === void 0 ? (o = e._events = Object.create(null), e._eventsCount = 0) : (o.newListener !== void 0 && (e.emit("newListener", t, n.listener ? n.listener : n), o = e._events), s = o[t]), s === void 0) s = o[t] = n, ++e._eventsCount;
+		else if (typeof s == "function" ? s = o[t] = r ? [n, s] : [s, n] : r ? s.unshift(n) : s.push(n), i = u(e), i > 0 && s.length > i && !s.warned) {
+			s.warned = !0;
+			var c = /* @__PURE__ */ Error("Possible EventEmitter memory leak detected. " + s.length + " " + String(t) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+			c.name = "MaxListenersExceededWarning", c.emitter = e, c.type = t, c.count = s.length, a(c);
+		}
+		return e;
+	}
+	s.prototype.addListener = function(e, t) {
+		return d(this, e, t, !1);
+	}, s.prototype.on = s.prototype.addListener, s.prototype.prependListener = function(e, t) {
+		return d(this, e, t, !0);
+	};
+	function f() {
+		if (!this.fired) return this.target.removeListener(this.type, this.wrapFn), this.fired = !0, arguments.length === 0 ? this.listener.call(this.target) : this.listener.apply(this.target, arguments);
+	}
+	function p(e, t, n) {
+		var r = {
+			fired: !1,
+			wrapFn: void 0,
+			target: e,
+			type: t,
+			listener: n
+		}, i = f.bind(r);
+		return i.listener = n, r.wrapFn = i, i;
+	}
+	s.prototype.once = function(e, t) {
+		return l(t), this.on(e, p(this, e, t)), this;
+	}, s.prototype.prependOnceListener = function(e, t) {
+		return l(t), this.prependListener(e, p(this, e, t)), this;
+	}, s.prototype.removeListener = function(e, t) {
+		var n, r, i, a, o;
+		if (l(t), r = this._events, r === void 0 || (n = r[e], n === void 0)) return this;
+		if (n === t || n.listener === t) --this._eventsCount === 0 ? this._events = Object.create(null) : (delete r[e], r.removeListener && this.emit("removeListener", e, n.listener || t));
+		else if (typeof n != "function") {
+			for (i = -1, a = n.length - 1; a >= 0; a--) if (n[a] === t || n[a].listener === t) {
+				o = n[a].listener, i = a;
+				break;
+			}
+			if (i < 0) return this;
+			i === 0 ? n.shift() : _(n, i), n.length === 1 && (r[e] = n[0]), r.removeListener !== void 0 && this.emit("removeListener", e, o || t);
+		}
+		return this;
+	}, s.prototype.off = s.prototype.removeListener, s.prototype.removeAllListeners = function(e) {
+		var t, n = this._events, r;
+		if (n === void 0) return this;
+		if (n.removeListener === void 0) return arguments.length === 0 ? (this._events = Object.create(null), this._eventsCount = 0) : n[e] !== void 0 && (--this._eventsCount === 0 ? this._events = Object.create(null) : delete n[e]), this;
+		if (arguments.length === 0) {
+			var i = Object.keys(n), a;
+			for (r = 0; r < i.length; ++r) a = i[r], a !== "removeListener" && this.removeAllListeners(a);
+			return this.removeAllListeners("removeListener"), this._events = Object.create(null), this._eventsCount = 0, this;
+		}
+		if (t = n[e], typeof t == "function") this.removeListener(e, t);
+		else if (t !== void 0) for (r = t.length - 1; r >= 0; r--) this.removeListener(e, t[r]);
+		return this;
+	};
+	function m(e, t, n) {
+		var r = e._events;
+		if (r === void 0) return [];
+		var i = r[t];
+		return i === void 0 ? [] : typeof i == "function" ? n ? [i.listener || i] : [i] : n ? v(i) : g(i, i.length);
+	}
+	s.prototype.listeners = function(e) {
+		return m(this, e, !0);
+	}, s.prototype.rawListeners = function(e) {
+		return m(this, e, !1);
+	}, s.listenerCount = function(e, t) {
+		return typeof e.listenerCount == "function" ? e.listenerCount(t) : h.call(e, t);
+	}, s.prototype.listenerCount = h;
+	function h(e) {
+		var t = this._events;
+		if (t !== void 0) {
+			var n = t[e];
+			if (typeof n == "function") return 1;
+			if (n !== void 0) return n.length;
+		}
+		return 0;
+	}
+	s.prototype.eventNames = function() {
+		return this._eventsCount > 0 ? i(this._events) : [];
+	};
+	function g(e, t) {
+		for (var n = Array(t), r = 0; r < t; ++r) n[r] = e[r];
+		return n;
+	}
+	function _(e, t) {
+		for (; t + 1 < e.length; t++) e[t] = e[t + 1];
+		e.pop();
+	}
+	function v(e) {
+		for (var t = Array(e.length), n = 0; n < t.length; ++n) t[n] = e[n].listener || e[n];
+		return t;
+	}
+	function y(e, t) {
+		return new Promise(function(n, r) {
+			function i(n) {
+				e.removeListener(t, a), r(n);
+			}
+			function a() {
+				typeof e.removeListener == "function" && e.removeListener("error", i), n([].slice.call(arguments));
+			}
+			x(e, t, a, { once: !0 }), t !== "error" && b(e, i, { once: !0 });
+		});
+	}
+	function b(e, t, n) {
+		typeof e.on == "function" && x(e, "error", t, n);
+	}
+	function x(e, t, n, r) {
+		if (typeof e.on == "function") r.once ? e.once(t, n) : e.on(t, n);
+		else if (typeof e.addEventListener == "function") e.addEventListener(t, function i(a) {
+			r.once && e.removeEventListener(t, i), n(a);
+		});
+		else throw TypeError("The \"emitter\" argument must be of type EventEmitter. Received type " + typeof e);
+	}
+})))()), ve = (e) => `listen_${String(e)}`, ye = class extends _e.default {
+	emitCallbacks = [];
+	constructor(e) {
+		super(e);
+	}
+	emit(e, t, n) {
+		let r = [e, t];
+		return n && r.push(n), this.emitCallbacks?.forEach((e) => e(...r)), super.emit(...r);
+	}
+	onEmit = (e) => (this.emitCallbacks?.push(e), () => {
+		this.emitCallbacks = this.emitCallbacks?.filter((t) => t !== e);
+	});
+	onListener = (e, t) => (super.on(ve(e), t), () => {
+		super.off(ve(e), t);
+	});
+	on = (e, t) => (super.on(e, t), super.emit(ve(e), super.listeners(e).length), this);
+	off = (e, t) => (super.off(e, t), super.emit(ve(e), super.listeners(e).length), this);
+	addListener = this.on;
+	removeListener = this.off;
+}, be = class {
+	emitter = new ye();
+	events = Te(this.emitter);
+	isBrowser;
+	isOnline;
+	isFocused;
+	constructor(e) {
+		this.options = e, this.emitter?.setMaxListeners(1e3);
+		let { initiallyFocused: t = z.initiallyFocused, initiallyOnline: n = z.initiallyOnline } = this.options || z;
+		this.setInitialFocus(t), this.setInitialOnline(n), this.isBrowser = Se();
+	}
+	initialize = () => {
+		let { focusEvent: e = z.focusEvent, onlineEvent: t = z.onlineEvent } = this.options || z;
+		e(this.setFocused), t(this.setOnline);
+	};
+	setInitialFocus = async (e) => {
+		typeof e == "function" ? (this.isFocused = !1, this.isFocused = await e()) : this.isFocused = e;
+	};
+	setInitialOnline = async (e) => {
+		typeof e == "function" ? (this.isOnline = !1, this.isOnline = await e()) : this.isOnline = e;
+	};
+	setFocused = (e) => {
+		this.isFocused = e, e ? this.events.emitFocus() : this.events.emitBlur();
+	};
+	setOnline = (e) => {
+		this.isOnline = e, e ? this.events.emitOnline() : this.events.emitOffline();
+	};
+}, xe = () => {
+	try {
+		return !!(window && window.addEventListener);
+	} catch {
+		/* istanbul ignore next */
+		return !1;
+	}
+}, Se = () => {
+	try {
+		return !!(xe() && window.document && window.document.addEventListener);
+	} catch {
+		/* istanbul ignore next */
+		return !1;
+	}
+}, Ce = (e, t, n) => xe() ? (window.addEventListener(e, t, n), () => window.removeEventListener(e, t, n)) : () => null, we = (e, t, n) => Se() ? (window.document.addEventListener(e, t, n), () => window.document.removeEventListener(e, t, n)) : () => null, Te = (e) => ({
+	emitFocus: () => {
+		e.emit(R.FOCUS);
+	},
+	emitBlur: () => {
+		e.emit(R.BLUR);
+	},
+	emitOnline: () => {
+		e.emit(R.ONLINE);
+	},
+	emitOffline: () => {
+		e.emit(R.OFFLINE);
+	},
+	onFocus: (t) => (e.on(R.FOCUS, t), () => e.removeListener(R.FOCUS, t)),
+	onBlur: (t) => (e.on(R.BLUR, t), () => e.removeListener(R.BLUR, t)),
+	onOnline: (t) => (e.on(R.ONLINE, t), () => e.removeListener(R.ONLINE, t)),
+	onOffline: (t) => (e.on(R.OFFLINE, t), () => e.removeListener(R.OFFLINE, t))
+}), R = /* @__PURE__ */ function(e) {
+	return e.FOCUS = "focus", e.BLUR = "blur", e.ONLINE = "online", e.OFFLINE = "offline", e;
+}({}), z = {
+	initiallyFocused: !0,
+	initiallyOnline: !0,
+	focusEvent: (e) => {
+		we("visibilitychange", () => e(!0)), Ce("focus", () => e(!0)), Ce("blur", () => e(!1));
+	},
+	onlineEvent: (e) => {
+		Ce("online", () => e(!0)), Ce("offline", () => e(!1));
+	}
+}, Ee = class {
+	emitter = new ye();
+	events = nt(this.emitter);
+	constructor() {
+		this.emitter?.setMaxListeners(1e3);
+	}
+	abortControllers = /* @__PURE__ */ new Map();
+	addAbortController = (e, t) => {
+		let n = this.abortControllers.get(e);
+		if (!n) {
+			let t = /* @__PURE__ */ new Map();
+			n = t, this.abortControllers.set(e, t);
+		}
+		let r = n.get(t);
+		(!r || r.signal.aborted) && n.set(t, new AbortController());
+	};
+	getAbortController = (e, t) => this.abortControllers.get(e)?.get(t);
+	removeAbortController = (e, t) => {
+		this.abortControllers.get(e)?.delete(t);
+	};
+	useAbortController = (e, t) => {
+		(this.abortControllers.get(e)?.get(t))?.abort();
+	};
+	abortByKey = (e) => {
+		let t = this.abortControllers.get(e);
+		t && Array.from(t.entries()).forEach(([t]) => {
+			this.useAbortController(e, t);
+		});
+	};
+	abortByRequestId = (e, t) => {
+		this.useAbortController(e, t);
+	};
+	abortAll = () => {
+		Array.from(this.abortControllers.entries()).forEach(([e, t]) => {
+			Array.from(t.entries()).forEach(([t]) => {
+				this.useAbortController(e, t);
+			});
+		});
+	};
+}, De = () => "loading-event-any", Oe = (e) => `${e}-loading-event`, ke = (e) => `${e}-loading-cache-event`, Ae = (e) => `${e}-loading-event-by-id`, je = () => "remove-event-any", Me = (e) => `${e}-remove-event`, Ne = (e) => `${e}-remove-event-by-id`, Pe = () => "request-abort-any", Fe = (e) => `${e}-request-abort`, Ie = (e) => `${e}-request-abort-by-id`, Le = () => "response-any", Re = (e) => `${e}-response`, ze = (e) => `${e}-response-by-id`, Be = () => "request-start-any", Ve = (e) => `${e}-request-start`, He = (e) => `${e}-request-start-by-id`, Ue = () => "response-start-any", We = (e) => `${e}-response-start`, Ge = (e) => `${e}-response-start-by-id`, Ke = () => "request-progress-any", qe = (e) => `${e}-request-progress`, Je = (e) => `${e}-request-progress-by-id`, Ye = () => "response-progress-any", Xe = (e) => `${e}-response-progress`, Ze = (e) => `${e}-response-progress-by-id`, Qe = () => "request-deduplicated-any", $e = (e) => `${e}-query-request-deduplicated`, et = (e) => `${e}-cache-request-deduplicated`, tt = (e) => `${e}-request-deduplicated-by-id`, nt = (e) => ({
+	emitDeduplicated: (t, n = !1) => {
+		e.emit(Qe(), t, n), e.emit(tt(t.requestId), t, n), e.emit(et(t.request.cacheKey), t, n), e.emit($e(t.request.queryKey), t, n);
+	},
+	emitLoading: (t, n = !1) => {
+		e.emit(De(), t, n), e.emit(Ae(t.requestId), t, n), e.emit(ke(t.request.cacheKey), t, n), e.emit(Oe(t.request.queryKey), t, n);
+	},
+	emitRequestStart: (t, n = !1) => {
+		e.emit(Be(), t, n), e.emit(He(t.requestId), t, n), e.emit(Ve(t.request.queryKey), t, n);
+	},
+	emitResponseStart: (t, n = !1) => {
+		e.emit(Ue(), t, n), e.emit(Ge(t.requestId), t, n), e.emit(We(t.request.queryKey), t, n);
+	},
+	emitUploadProgress: (t, n = !1) => {
+		e.emit(Ke(), t, n), e.emit(Je(t.requestId), t, n), e.emit(qe(t.request.queryKey), t, n);
+	},
+	emitDownloadProgress: (t, n = !1) => {
+		e.emit(Ye(), t, n), e.emit(Ze(t.requestId), t, n), e.emit(Xe(t.request.queryKey), t, n);
+	},
+	emitResponse: (t, n = !1) => {
+		e.emit(Le(), t, n), e.emit(ze(t.requestId), t, n), e.emit(Re(t.request.cacheKey), t, n);
+	},
+	emitAbort: (t, n = !1) => {
+		e.emit(Pe(), t, n), e.emit(Ie(t.requestId), t, n), e.emit(Fe(t.request.abortKey), t, n);
+	},
+	emitRemove: (t, n = !1) => {
+		e.emit(je(), t, n), e.emit(Ne(t.requestId), t, n), e.emit(Me(t.request.queryKey), t, n);
+	},
+	onDeduplicated: (t) => (e.on(Qe(), t), () => e.removeListener(Qe(), t)),
+	onDeduplicatedByQueue: (t, n) => (e.on($e(t), n), () => e.removeListener($e(t), n)),
+	onDeduplicatedByCache: (t, n) => (e.on(et(t), n), () => e.removeListener(et(t), n)),
+	onDeduplicatedById: (t, n) => (e.on(tt(t), n), () => e.removeListener(tt(t), n)),
+	onLoading: (t) => (e.on(De(), t), () => e.removeListener(De(), t)),
+	onLoadingByQueue: (t, n) => (e.on(Oe(t), n), () => e.removeListener(Oe(t), n)),
+	onLoadingByCache: (t, n) => (e.on(ke(t), n), () => e.removeListener(ke(t), n)),
+	onLoadingById: (t, n) => (e.on(Ae(t), n), () => e.removeListener(Ae(t), n)),
+	onRequestStart: (t) => (e.on(Be(), t), () => e.removeListener(Be(), t)),
+	onRequestStartByQueue: (t, n) => (e.on(Ve(t), n), () => e.removeListener(Ve(t), n)),
+	onRequestStartById: (t, n) => (e.on(He(t), n), () => e.removeListener(He(t), n)),
+	onResponseStart: (t) => (e.on(Ue(), t), () => e.removeListener(Ue(), t)),
+	onResponseStartByQueue: (t, n) => (e.on(We(t), n), () => e.removeListener(We(t), n)),
+	onResponseStartById: (t, n) => (e.on(Ge(t), n), () => e.removeListener(Ge(t), n)),
+	onUploadProgress: (t) => (e.on(Ke(), t), () => e.removeListener(Ke(), t)),
+	onUploadProgressByQueue: (t, n) => (e.on(qe(t), n), () => e.removeListener(qe(t), n)),
+	onUploadProgressById: (t, n) => (e.on(Je(t), n), () => e.removeListener(Je(t), n)),
+	onDownloadProgress: (t) => (e.on(Ye(), t), () => e.removeListener(Ye(), t)),
+	onDownloadProgressByQueue: (t, n) => (e.on(Xe(t), n), () => e.removeListener(Xe(t), n)),
+	onDownloadProgressById: (t, n) => (e.on(Ze(t), n), () => e.removeListener(Ze(t), n)),
+	onResponse: (t) => (e.on(Le(), t), () => e.removeListener(Le(), t)),
+	onResponseByCache: (t, n) => (e.on(Re(t), n), () => e.removeListener(Re(t), n)),
+	onResponseById: (t, n) => (e.on(ze(t), n), () => e.removeListener(ze(t), n)),
+	onAbort: (t) => (e.on(Pe(), t), () => e.removeListener(Pe(), t)),
+	onAbortByKey: (t, n) => (e.on(Fe(t), n), () => e.removeListener(Fe(t), n)),
+	onAbortById: (t, n) => (e.on(Ie(t), n), () => e.removeListener(Ie(t), n)),
+	onRemove: (t) => (e.on(je(), t), () => e.removeListener(je(), t)),
+	onRemoveByQueue: (t, n) => (e.on(Me(t), n), () => e.removeListener(Me(t), n)),
+	onRemoveById: (t, n) => (e.on(Ne(t), n), () => e.removeListener(Ne(t), n))
+}), rt = class {
+	logger;
+	level;
+	modules;
+	emitter = new _e.default();
+	client;
+	constructor(e) {
+		this.options = e, this.emitter?.setMaxListeners(1e3), this.logger = this.options?.logger || ot, this.level = this.options?.level || "warning", this.modules = this.options?.modules;
+	}
+	setSeverity = (e) => {
+		this.level = e;
+	};
+	setModules = (e) => {
+		this.modules = e;
+	};
+	initialize = (e, t) => (this.client = e, {
+		error: (e) => this.log({
+			...e,
+			level: "error",
+			module: t
+		}),
+		warning: (e) => this.log({
+			...e,
+			level: "warning",
+			module: t
+		}),
+		info: (e) => this.log({
+			...e,
+			level: "info",
+			module: t
+		}),
+		debug: (e) => this.log({
+			...e,
+			level: "debug",
+			module: t
+		})
+	});
+	log = (e) => {
+		this.client.debug && (st.indexOf(this.level) <= st.indexOf(e.level) || this.modules && !this.modules.includes(e.module) || this.logger(e));
+	};
+}, it = () => `${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`, at = (e) => e.type === "request" || e.type === "response" ? `${e.extra.request.endpoint}` : `[${e.module}]`, ot = (e) => {
+	let t = ct[e.level], n = lt[e.level], r = `%c[${it()}]%c${e.title}%c${at(e)}`, i = `${t}${n}font-weight:600;border-radius: 4px 0 0 4px;`, a = `${t}${n}font-weight:600;`, o = `${t}font-weight:normal;border-radius: 0 4px 4px 0;`;
+	e.extra && Object.keys(e.extra)?.length ? (console.groupCollapsed(r, i, a, o), console.log(e.extra), console.groupEnd()) : console.log(r, t);
+}, st = [
+	"error",
+	"warning",
+	"info",
+	"debug"
+], B = "padding:2px 5px;", ct = {
+	error: `${B};background:#db252520;`,
+	warning: `${B};background:#e1941e20;`,
+	info: `${B};background:#1e74e120;`,
+	debug: `${B};background:#00000020;`
+}, lt = {
+	error: "color:#ff3737;",
+	warning: "color:#ffc107;",
+	info: "color:#34a8ff;",
+	debug: "color:#cccccc;"
+}, ut = class extends Error {
+	constructor() {
+		super("Request timeout"), this.name = "TimeoutError";
+	}
+}, dt = class extends Error {
+	constructor() {
+		super("Request aborted"), this.name = "AbortError";
+	}
+}, ft = class extends Error {
+	constructor() {
+		super("Request deleted"), this.name = "DeletedError";
+	}
+}, V = class extends Error {
+	description;
+	constructor(e) {
+		super("Request processing error"), this.description = e, this.name = "RequestProcessingError";
+	}
+}, pt = class extends Error {
+	description;
+	constructor(e) {
+		super("Unexpected error"), this.description = e, this.name = "UnexpectedError";
+	}
+}, H = (e) => e === "timeout" ? new ut() : e === "abort" ? new dt() : e === "deleted" ? new ft() : e === "processing" ? new V() : new pt(), mt = (e) => {
+	try {
+		return JSON.stringify(e);
+	} catch {
+		return "";
+	}
+}, ht = (e) => {
+	let t = xe() && e.payload instanceof FormData, n = typeof e.payload == "object" && e.payload !== null, r = {};
+	return !t && n && (r["Content-Type"] = "application/json"), Object.assign(r, e.headers), r;
+}, gt = (e) => xe() && e instanceof FormData ? e : mt(e), _t = [
+	"onBeforeSent",
+	"onRequestStart",
+	"onResponseStart",
+	"onUploadProgress",
+	"onDownloadProgress",
+	"onResponse",
+	"onRemove"
+];
+function vt(e) {
+	let t = {
+		onBeforeSent: [],
+		onRequestStart: [],
+		onResponseStart: [],
+		onUploadProgress: [],
+		onDownloadProgress: [],
+		onResponse: [],
+		onRemove: []
+	};
+	e && _t.forEach((n) => {
+		t[n] = [...e[n]];
+	});
+	let n = (e) => (n) => (t[e].push(n), () => {
+		let r = t[e].indexOf(n);
+		r !== -1 && t[e].splice(r, 1);
+	});
+	return {
+		onBeforeSent: n("onBeforeSent"),
+		onRequestStart: n("onRequestStart"),
+		onResponseStart: n("onResponseStart"),
+		onUploadProgress: n("onUploadProgress"),
+		onDownloadProgress: n("onDownloadProgress"),
+		onResponse: n("onResponse"),
+		onRemove: n("onRemove"),
+		__emit(e, n) {
+			t[e].forEach((e) => {
+				e(n);
+			});
+		},
+		__snapshot() {
+			let e = {};
+			return _t.forEach((n) => {
+				e[n] = [...t[n]];
+			}), e;
+		}
+	};
+}
+var yt = /* @__PURE__ */ function(e) {
+	return e.GET = "GET", e.POST = "POST", e.PUT = "PUT", e.PATCH = "PATCH", e.DELETE = "DELETE", e;
+}({}), U = (e, t) => t ? `${t}__${e}` : e, bt = (e) => {
+	try {
+		if (typeof e == "string") return e;
+		if (e == null) return "";
+		let t = JSON.stringify(e);
+		if (typeof t != "string") throw Error();
+		return t;
+	} catch {
+		return "";
+	}
+}, xt = ({ loaded: e, total: t }) => !e || !t ? 0 : Number((e * 100 / t).toFixed(0)), St = (e, t, { total: n, loaded: r }) => {
+	let i = r / (t - +e || 1), a = Math.max(n, r), o = a - r, s = i ? o / i : null;
+	return {
+		timeLeft: a === r ? 0 : s,
+		sizeLeft: o
+	};
+}, Ct = (e, t, n) => {
+	let { total: r, loaded: i } = n;
+	if (Number.isNaN(r) || Number.isNaN(i)) return {
+		progress: 0,
+		timeLeft: 0,
+		sizeLeft: 0,
+		total: 0,
+		loaded: 0,
+		startTimestamp: +e
+	};
+	let { timeLeft: a, sizeLeft: o } = St(e, t, n);
+	return {
+		progress: xt(n),
+		timeLeft: a,
+		sizeLeft: o,
+		total: r,
+		loaded: i,
+		startTimestamp: +e
+	};
+}, wt = (e) => `${e.method}_${e.requestOptions.endpoint}_${e.cancelable}`, Tt = (e, t) => `${bt(e.method)}_${t ? e.requestOptions.endpoint : bt(e.endpoint)}_${t ? "" : bt(e.queryParams)}`, Et = (e, t = "auto") => {
+	let { fetchDispatcher: n, submitDispatcher: r } = e.client, i = e.method === yt.GET, a = t === "auto" && i || t === "fetch";
+	return [a ? n : r, a];
+}, Dt = async (e, t) => {
+	let n = e.unstable_responseMapper?.(t);
+	return n instanceof Promise ? await n : n || t;
+}, Ot = async (e, t) => {
+	let { client: n } = e, { requestManager: r } = n, [i] = Et(e, t?.dispatcherType), a;
+	if (e.optimistic) try {
+		a = await e.optimistic({
+			request: e,
+			client: e.client,
+			payload: e.payload
+		});
+	} catch (e) {
+		return {
+			data: null,
+			error: /* @__PURE__ */ Error(`Optimistic callback failed: ${e instanceof Error ? e.message : e}`),
+			status: null,
+			success: !1,
+			extra: n.adapter.defaultExtra,
+			requestTimestamp: +/* @__PURE__ */ new Date(),
+			responseTimestamp: +/* @__PURE__ */ new Date()
+		};
+	}
+	return new Promise((n) => {
+		let o = !1, s = i.add(e), { $hooks: c } = e, l = {
+			requestId: s,
+			request: e,
+			mutationContext: a
+		};
+		t?.onBeforeSent?.(l), c.__emit("onBeforeSent", l);
+		let u = r.events.onRequestStartById(s, (e) => {
+			let n = {
+				...e,
+				mutationContext: a
+			};
+			t?.onRequestStart?.(n), c.__emit("onRequestStart", n);
+		}), d = r.events.onResponseStartById(s, (e) => {
+			let n = {
+				...e,
+				mutationContext: a
+			};
+			t?.onResponseStart?.(n), c.__emit("onResponseStart", n);
+		}), f = r.events.onUploadProgressById(s, (e) => {
+			let n = {
+				...e,
+				mutationContext: a
+			};
+			t?.onUploadProgress?.(n), c.__emit("onUploadProgress", n);
+		}), p = r.events.onDownloadProgressById(s, (e) => {
+			let n = {
+				...e,
+				mutationContext: a
+			};
+			t?.onDownloadProgress?.(n), c.__emit("onDownloadProgress", n);
+		}), m = r.events.onResponseById(s, (r) => {
+			let { details: i, response: s } = r;
+			o = !0;
+			let l = {
+				...r,
+				mutationContext: a
+			}, u = e.unstable_responseMapper?.(s), d = e.offline && i.isOffline, { willRetry: f } = i, p = (e, r) => {
+				!e && d || !e && f || (t?.onResponse?.(l), c.__emit("onResponse", l), n(r), g());
+			};
+			if (u instanceof Promise) (async () => {
+				let e = await u, { success: t } = e;
+				p(t, e);
+			})();
+			else {
+				let e = u || s, { success: t } = e;
+				p(t, e);
+			}
+		}), h = r.events.onRemoveById(s, (r) => {
+			if (!o) {
+				let i = {
+					...r,
+					mutationContext: a
+				};
+				t?.onRemove?.(i), c.__emit("onRemove", i), n({
+					data: null,
+					status: null,
+					success: !1,
+					error: H("deleted"),
+					extra: e.client.adapter.defaultExtra,
+					requestTimestamp: +/* @__PURE__ */ new Date(),
+					responseTimestamp: +/* @__PURE__ */ new Date()
+				}), g();
+			}
+		});
+		function g() {
+			u(), d(), f(), p(), m(), h();
+		}
+	});
+}, kt = /* @__PURE__ */ function(e) {
+	return e[e.SEC = 1e3] = "SEC", e[e.MIN = 6e4] = "MIN", e[e.HOUR = 36e5] = "HOUR", e[e.DAY = 864e5] = "DAY", e[e.WEEK = 6048e5] = "WEEK", e[e.MONTH_30 = 2592e6] = "MONTH_30", e[e.MONTH_31 = 26784e5] = "MONTH_31", e[e.YEAR = 31536e6] = "YEAR", e[e.YEAR_LEAP = 316224e5] = "YEAR_LEAP", e;
+}({}), At = class e {
+	endpoint;
+	headers;
+	auth;
+	method;
+	params;
+	payload;
+	queryParams;
+	options;
+	cancelable;
+	retry;
+	retryTime;
+	cacheTime;
+	cache;
+	staleTime;
+	queued;
+	offline;
+	abortKey;
+	cacheKey;
+	queryKey;
+	used;
+	deduplicate;
+	deduplicateTime;
+	scope;
+	$hooks = vt();
+	isMockerEnabled = !1;
+	unstable_mock;
+	unstable_payloadMapper;
+	unstable_requestMapper;
+	unstable_responseMapper;
+	retryOnError;
+	optimistic;
+	unstable_hasParams = !1;
+	unstable_hasPayload = !1;
+	unstable_hasQuery = !1;
+	unstable_hasMutationContext = void 0;
+	updatedAbortKey;
+	updatedCacheKey;
+	updatedQueryKey;
+	constructor(e, t, n) {
+		this.client = e, this.requestOptions = t, this.initialRequestConfiguration = n;
+		let { endpoint: r, headers: i, auth: a = !0, method: o = e.adapter.defaultMethod, options: s, cancelable: c = !1, retry: l = 0, retryTime: u = 500, cacheTime: d = kt.MIN * 5, cache: f = !0, staleTime: p = kt.MIN * 5, queued: m = !1, offline: h = !0, abortKey: g, cacheKey: _, queryKey: v, deduplicate: y = !1, deduplicateTime: b = null } = {
+			...this.client.adapter.unstable_getRequestDefaults?.(t),
+			...t
+		};
+		this.endpoint = n?.endpoint ?? r, this.headers = n?.headers ?? i, this.auth = n?.auth ?? a, this.method = o, this.params = n?.params, this.payload = n?.payload, this.queryParams = n?.queryParams, this.options = n?.options ?? s, this.cancelable = n?.cancelable ?? c, this.retry = n?.retry ?? l, this.retryTime = n?.retryTime ?? u, this.cacheTime = n?.cacheTime ?? d, this.cache = n?.cache ?? f, this.staleTime = n?.staleTime ?? p, this.queued = n?.queued ?? m, this.offline = n?.offline ?? h, this.abortKey = n?.abortKey ?? g ?? this.client.unstable_abortKeyMapper(this), this.cacheKey = n?.cacheKey ?? _ ?? this.client.unstable_cacheKeyMapper(this), this.queryKey = n?.queryKey ?? v ?? this.client.unstable_queryKeyMapper(this), this.used = n?.used ?? !1, this.deduplicate = n?.deduplicate ?? y, this.deduplicateTime = n?.deduplicateTime ?? b, this.scope = n?.scope ?? null, this.updatedAbortKey = n?.updatedAbortKey ?? !1, this.updatedCacheKey = n?.updatedCacheKey ?? !1, this.updatedQueryKey = n?.updatedQueryKey ?? !1;
+	}
+	setHeaders = (e) => this.clone({ headers: e });
+	setAuth = (e) => this.clone({ auth: e });
+	setParams = (e) => this.clone({ params: e });
+	setPayload = (e) => this.clone({ payload: e });
+	setQueryParams = (e) => this.clone({ queryParams: e });
+	setOptions = (e) => this.clone({ options: e });
+	setScope = (e) => {
+		let t = this.clone();
+		return t.scope = e, t;
+	};
+	setCancelable = (e) => this.clone({ cancelable: e });
+	setRetry = (e) => this.clone({ retry: e });
+	setRetryTime = (e) => this.clone({ retryTime: e });
+	setRetryOnError = (e) => {
+		let t = this.clone();
+		return t.retryOnError = e, t;
+	};
+	setOptimistic = (e) => {
+		let t = this.clone();
+		return t.optimistic = e, t;
+	};
+	setCacheTime = (e) => this.clone({ cacheTime: e });
+	setCache = (e) => this.clone({ cache: e });
+	setStaleTime = (e) => this.clone({ staleTime: e });
+	setQueued = (e) => this.clone({ queued: e });
+	setAbortKey = (e) => (this.updatedAbortKey = !0, this.clone({ abortKey: e }));
+	setCacheKey = (e) => (this.updatedCacheKey = !0, this.clone({ cacheKey: e }));
+	setQueryKey = (e) => (this.updatedQueryKey = !0, this.clone({ queryKey: e }));
+	setDeduplicate = (e) => this.clone({ deduplicate: e });
+	setDeduplicateTime = (e) => this.clone({ deduplicateTime: e });
+	setUsed = (e) => this.clone({ used: e });
+	setOffline = (e) => this.clone({ offline: e });
+	setMock = (e, t = {}) => (this.unstable_mock = {
+		fn: e,
+		config: t
+	}, this.isMockerEnabled = !0, this);
+	clearMock = () => (this.unstable_mock = void 0, this.isMockerEnabled = !1, this);
+	setMockingEnabled = (e) => (this.isMockerEnabled = e, this);
+	setPayloadMapper = (e) => {
+		let t = this.clone(void 0);
+		return t.unstable_payloadMapper = e, t;
+	};
+	setRequestMapper = (e) => {
+		let t = this.clone(void 0);
+		return t.unstable_requestMapper = e, t;
+	};
+	setResponseMapper = (e) => {
+		let t = this.clone();
+		return t.unstable_responseMapper = e, t;
+	};
+	paramsMapper = (e) => {
+		let { endpoint: t } = this.requestOptions, n = String(t);
+		return e && Object.entries(e).forEach(([e, t]) => {
+			n = n.replace(RegExp(`:${e}`, "g"), String(t));
+		}), n;
+	};
+	toJSON() {
+		return {
+			requestOptions: this.requestOptions,
+			endpoint: this.endpoint,
+			headers: this.headers,
+			auth: this.auth,
+			method: this.method,
+			params: this.params,
+			payload: this.payload,
+			queryParams: this.queryParams,
+			options: this.options,
+			cancelable: this.cancelable,
+			retry: this.retry,
+			retryTime: this.retryTime,
+			cacheTime: this.cacheTime,
+			cache: this.cache,
+			staleTime: this.staleTime,
+			queued: this.queued,
+			offline: this.offline,
+			abortKey: this.abortKey,
+			cacheKey: this.cacheKey,
+			queryKey: this.queryKey,
+			used: this.used,
+			disableResponseInterceptors: this.requestOptions.disableResponseInterceptors,
+			disableRequestInterceptors: this.requestOptions.disableRequestInterceptors,
+			updatedAbortKey: this.updatedAbortKey,
+			updatedCacheKey: this.updatedCacheKey,
+			updatedQueryKey: this.updatedQueryKey,
+			deduplicate: this.deduplicate,
+			deduplicateTime: this.deduplicateTime,
+			scope: this.scope,
+			isMockerEnabled: this.isMockerEnabled,
+			hasMock: !!this.unstable_mock
+		};
+	}
+	clone(t) {
+		let n = {
+			...this.toJSON(),
+			...t,
+			options: t?.options || this.options,
+			abortKey: this.updatedAbortKey ? t?.abortKey || this.abortKey : void 0,
+			cacheKey: this.updatedCacheKey ? t?.cacheKey || this.cacheKey : void 0,
+			queryKey: this.updatedQueryKey ? t?.queryKey || this.queryKey : void 0,
+			endpoint: this.paramsMapper(t?.params || this.params),
+			queryParams: t?.queryParams || this.queryParams,
+			payload: t?.payload || this.payload,
+			params: t?.params || this.params
+		}, r = new e(this.client, this.requestOptions, n);
+		return r.unstable_payloadMapper = this.unstable_payloadMapper, r.unstable_responseMapper = this.unstable_responseMapper, r.unstable_requestMapper = this.unstable_requestMapper, r.retryOnError = this.retryOnError, r.unstable_mock = this.unstable_mock, r.isMockerEnabled = this.isMockerEnabled, r.optimistic = this.optimistic, r.$hooks = vt(this.$hooks.__snapshot()), r;
+	}
+	abort = () => {
+		let { requestManager: e } = this.client;
+		return e.abortByKey(U(this.abortKey, this.scope)), this.clone();
+	};
+	dehydrate = (e) => {
+		let { response: t, override: n = !0 } = e || {};
+		if (t) return {
+			override: n,
+			cacheTime: this.cacheTime,
+			staleTime: this.staleTime,
+			cacheKey: this.cacheKey,
+			scope: this.scope,
+			timestamp: +/* @__PURE__ */ new Date(),
+			hydrated: !0,
+			cache: !0,
+			response: t
+		};
+		let r = this.client.cache.get(U(this.cacheKey, this.scope));
+		if (r) return {
+			override: n,
+			cacheTime: this.cacheTime,
+			staleTime: this.staleTime,
+			cacheKey: this.cacheKey,
+			scope: this.scope,
+			timestamp: +/* @__PURE__ */ new Date(),
+			hydrated: !0,
+			cache: !0,
+			response: {
+				data: r.data,
+				error: r.error,
+				status: r.status,
+				success: r.success,
+				extra: r.extra,
+				requestTimestamp: r.requestTimestamp,
+				responseTimestamp: r.responseTimestamp
+			}
+		};
+	};
+	read() {
+		let e = this.client.cache.get(U(this.cacheKey, this.scope));
+		if (e) return {
+			data: e.data,
+			error: e.error,
+			status: e.status,
+			success: e.success,
+			extra: e.extra,
+			requestTimestamp: e.requestTimestamp,
+			responseTimestamp: e.responseTimestamp
+		};
+	}
+	exec = async (e) => {
+		let { adapter: t, requestManager: n } = this.client, r = this.clone(e), i = this.client.unstable_requestIdMapper(this), a = U(this.abortKey, this.scope);
+		n.addAbortController(a, i);
+		let o = await t.fetch(r, i);
+		return n.removeAbortController(a, i), r.unstable_responseMapper ? r.unstable_responseMapper(o) : o;
+	};
+	send = async (e) => {
+		let { dispatcherType: t, cachePolicy: n = "network-only", ...r } = e || {}, i = this.clone(r), a = e === void 0 ? void 0 : {
+			...e,
+			cachePolicy: void 0
+		};
+		if (n === "network-only") return Ot(i, a);
+		let o = i.read();
+		if (n === "cache-first") return o ? Dt(i, o) : Ot(i, a);
+		if (o) {
+			let e = await Dt(i, o);
+			return Ot(i, a), e;
+		}
+		return Ot(i, a);
+	};
+	static fromJSON = (t, n) => new e(t, n.requestOptions, n);
+}, jt = async ({ request: e, requestId: t, resolve: n, onStartTime: r, internalErrorMapping: i }) => {
+	let { requestManager: a, loggerManager: o } = e.client, { unstable_payloadMapper: s } = e.client.adapter, c = o.initialize(e.client, "Adapter"), l = null, u = null, d = e, f = 1, p = 1, m = 0, h = 0;
+	c.debug({
+		title: "Running middleware callbacks",
+		type: "request",
+		extra: {
+			request: d,
+			requestId: t
+		}
+	}), d = await d.client.unstable_modifyRequest(d), d.auth && (d = await d.client.unstable_modifyAuth(d)), d.unstable_requestMapper && (d = await d.unstable_requestMapper(d, t));
+	let { client: g, abortKey: _ } = d, v = U(_, d.scope), y = d.payload;
+	d.unstable_payloadMapper ? y = await d.unstable_payloadMapper(d.payload) : s && (y = await s(y));
+	let b = d.options, x = +/* @__PURE__ */ new Date();
+	r(x);
+	let S = () => l, C = () => u, w = (e, t) => {
+		if (!t) return e;
+		let n = Number(t.total || 0), r = Number(t.loaded || 0);
+		return Math.max(n, r, e);
+	}, T = (e, n, r) => {
+		let i = Ct(new Date(e), new Date(n), r);
+		m !== 100 && (m = i.total, a.events.emitUploadProgress({
+			...i,
+			requestId: t,
+			request: d
+		}));
+	}, E = (e, n, r) => {
+		let i = Ct(new Date(e), new Date(n), r);
+		h !== 100 && (h = i.total, a.events.emitDownloadProgress({
+			...i,
+			requestId: t,
+			request: d
+		}));
+	}, D = () => {
+		c.debug({
+			title: "Request about to be sent",
+			type: "request",
+			extra: {
+				request: d,
+				requestId: t
+			}
+		}), g.triggerPlugins("onRequestTrigger", { request: d });
+	}, O = (e) => {
+		c.info({
+			title: "Request start",
+			type: "request",
+			extra: {
+				request: d,
+				requestId: t
+			}
+		}), g.triggerPlugins("onRequestStart", { request: d }), e?.total && (f = w(f, e));
+		let n = {
+			total: f,
+			loaded: e?.loaded || 0
+		};
+		return l = +/* @__PURE__ */ new Date(), T(l, l, n), a.events.emitRequestStart({
+			requestId: t,
+			request: d
+		}), l;
+	}, ee = (e) => {
+		l ||= +/* @__PURE__ */ new Date(), f = w(f, e);
+		let t = +/* @__PURE__ */ new Date();
+		return T(l, t, {
+			total: f,
+			loaded: e.loaded || 0
+		}), t;
+	}, k = () => {
+		l ||= +/* @__PURE__ */ new Date();
+		let e = +/* @__PURE__ */ new Date();
+		return T(l, e, {
+			total: f,
+			loaded: f
+		}), e;
+	}, te = (e) => {
+		u = +/* @__PURE__ */ new Date(), p = w(p, e);
+		let n = {
+			total: p,
+			loaded: e?.loaded || 0
+		};
+		return E(u, u, n), a.events.emitResponseStart({
+			requestId: t,
+			request: d
+		}), u;
+	}, ne = (e) => {
+		u ||= +/* @__PURE__ */ new Date();
+		let t = +/* @__PURE__ */ new Date();
+		return p = w(p, e), E(u, t, {
+			total: e.total || p,
+			loaded: e.loaded || 0
+		}), t;
+	}, re = () => {
+		u ||= +/* @__PURE__ */ new Date();
+		let e = +/* @__PURE__ */ new Date();
+		return E(u, e, {
+			total: p,
+			loaded: p
+		}), e;
+	}, A = async ({ data: e, error: r, status: i, extra: a }) => {
+		let o = {
+			data: e,
+			error: r ?? null,
+			success: !0,
+			status: i,
+			extra: a,
+			requestTimestamp: x,
+			responseTimestamp: +/* @__PURE__ */ new Date()
+		};
+		return o = await d.client.unstable_modifyResponse?.(o, d), o = await d.client.unstable_modifySuccessResponse?.(o, d), g.triggerPlugins("onRequestSuccess", {
+			response: o,
+			request: d
+		}), g.triggerPlugins("onRequestFinished", {
+			response: o,
+			request: d
+		}), n(o), c.info({
+			title: "Response success",
+			type: "response",
+			extra: {
+				request: d,
+				requestId: t,
+				response: o
+			}
+		}), o;
+	}, j = Mt({
+		request: d,
+		requestId: t,
+		startTime: x,
+		logger: c,
+		resolve: n
+	}), M = ({ status: e, extra: n }) => (c.error({
+		title: "Abort error",
+		type: "request",
+		extra: {
+			request: d,
+			requestId: t
+		}
+	}), j({
+		error: i(H("abort")),
+		status: e,
+		extra: n
+	})), ie = ({ status: e, extra: n }) => (c.error({
+		title: "Timeout error",
+		type: "request",
+		extra: {
+			request: d,
+			requestId: t
+		}
+	}), j({
+		error: H("timeout"),
+		status: e,
+		extra: n
+	})), N = ({ status: e, extra: n }) => (c.error({
+		title: "Unexpected error",
+		type: "request",
+		extra: {
+			request: d,
+			requestId: t
+		}
+	}), j({
+		error: H(),
+		status: e,
+		extra: n
+	})), P = () => a.getAbortController(v, t), F = ({ status: e, extra: n, onAbort: r = () => {} }) => {
+		let i = P();
+		if (!i) throw new V("Controller is not found");
+		let o = () => {
+			M({
+				status: e,
+				extra: n
+			}), r(), a.events.emitAbort({
+				requestId: t,
+				request: d
+			});
+		};
+		return i.signal.aborted && o(), i.signal.addEventListener("abort", o), () => i.signal.removeEventListener("abort", o);
+	};
+	c.debug({
+		title: "Mounted adapter bindings",
+		type: "request",
+		extra: {
+			request: d,
+			requestId: t,
+			payload: y,
+			adapterOptions: b
+		}
+	});
+	let I = e.client.adapter.unstable_queryParamsMapper(d.queryParams), L = e.client.adapter.unstable_endpointMapper(d.endpoint), ae = e.client.adapter.unstable_headerMapper(d), { url: oe } = e.client;
+	return {
+		request: d,
+		requestId: t,
+		url: oe,
+		endpoint: L,
+		queryParams: I,
+		payload: y,
+		headers: ae,
+		adapter: e.client.adapter,
+		adapterOptions: b,
+		getAbortController: P,
+		getRequestStartTimestamp: S,
+		getResponseStartTimestamp: C,
+		createAbortListener: F,
+		onBeforeRequest: D,
+		onRequestStart: O,
+		onRequestProgress: ee,
+		onRequestEnd: k,
+		onResponseStart: te,
+		onResponseProgress: ne,
+		onResponseEnd: re,
+		onSuccess: A,
+		onAbortError: M,
+		onTimeoutError: ie,
+		onUnexpectedError: N,
+		onError: j
+	};
+};
+function Mt({ request: e, requestId: t, startTime: n, resolve: r, logger: i }) {
+	let { client: a } = e;
+	return async ({ error: o, status: s, extra: c }) => {
+		let l = {
+			data: null,
+			status: s,
+			error: o,
+			success: !1,
+			extra: c,
+			requestTimestamp: n,
+			responseTimestamp: +/* @__PURE__ */ new Date()
+		};
+		return l = await a.unstable_modifyResponse(l, e), l = await a.unstable_modifyErrorResponse(l, e), a.triggerPlugins("onRequestError", {
+			response: l,
+			request: e
+		}), a.triggerPlugins("onRequestFinished", {
+			response: l,
+			request: e
+		}), r(l), i.error({
+			title: "Request error",
+			type: "request",
+			extra: {
+				request: e,
+				requestId: t,
+				response: l
+			}
+		}), l;
+	};
+}
+var Nt = async ({ request: e, requestId: t, onError: n, onResponseEnd: r, onTimeoutError: i, onRequestEnd: a, createAbortListener: o, onResponseProgress: s, onRequestProgress: c, onResponseStart: l, onBeforeRequest: u, onRequestStart: d, onSuccess: f, onAbortError: p, adapter: m }) => {
+	if (!e.unstable_mock) throw new V("Mock should be defined when calling mocker");
+	let h = !1, { requestTime: g = 20, responseTime: _ = 20, totalUploaded: v = 1e3, totalDownloaded: y = 1e3, timeout: b } = e.unstable_mock.config, { data: x, error: S, status: C, success: w = !0, extra: T = e.client.adapter.defaultExtra } = await e.unstable_mock.fn({
+		request: e,
+		requestId: t
+	});
+	o({
+		status: m.systemErrorStatus,
+		extra: m.systemErrorExtra,
+		onAbort: () => {
+			h = !0;
+		}
+	}), u(), d();
+	let E = (e, t, n) => new Promise((r) => {
+		if (h) {
+			r(!0);
+			return;
+		}
+		let i = +/* @__PURE__ */ new Date(), a = Math.ceil(e / 20), o = Math.ceil(t / a), s = 0, c = setInterval(function() {
+			h && (r(!0), clearInterval(c));
+			let a = Math.min(e, +/* @__PURE__ */ new Date() - i);
+			s += s + o >= t ? t - s : o, n({
+				total: t,
+				loaded: a >= e ? t : s
+			}), a >= e && (r(!0), clearInterval(c));
+		}, 20);
+	});
+	typeof b == "number" && setTimeout(() => {
+		h = !0, i({
+			status: 0,
+			extra: T
+		});
+	}, b), h || await E(g, v, c), h || (a(), l()), h || await E(_, y, s), h ? p({
+		status: m.systemErrorStatus,
+		extra: m.systemErrorExtra
+	}) : w || S && x ? f({
+		data: x,
+		error: S,
+		status: C,
+		extra: T
+	}) : n({
+		error: S,
+		status: C,
+		extra: T
+	}), h || r();
+}, Pt = (e) => e, Ft = class {
+	unstable_fetcher;
+	name;
+	defaultMethod;
+	defaultExtra;
+	systemErrorStatus;
+	systemErrorExtra;
+	defaultRequestOptions;
+	logger;
+	initialized = !1;
+	client;
+	unstable_onInitializeCallback;
+	unstable_queryParamsMapperConfig;
+	unstable_headerMapperConfig;
+	unstable_payloadMapperConfig;
+	unstable_endpointMapperConfig;
+	constructor(e) {
+		this.options = e, this.name = e.name, this.defaultMethod = e.defaultMethod, this.defaultExtra = e.defaultExtra, this.systemErrorStatus = e.systemErrorStatus, this.systemErrorExtra = e.systemErrorExtra, this.defaultRequestOptions = e.defaultRequestOptions;
+	}
+	initialize = (e) => (this.logger = e.loggerManager.initialize(e, "Adapter"), this.initialized = !0, this.client = e, this.unstable_onInitializeCallback?.({ client: e }), this);
+	onInitialize = (e) => (this.unstable_onInitializeCallback = e, this);
+	unstable_internalErrorMapping = (e) => e;
+	unstable_headerMapper = ht;
+	unstable_payloadMapper = gt;
+	unstable_endpointMapper = Pt;
+	unstable_queryParamsMapper = Pt;
+	unstable_getAdapterDefaults;
+	unstable_getRequestDefaults;
+	unstable_devtoolsEndpointGetter = (e) => e;
+	setDefaultMethod = (e) => (this.defaultMethod = e, this);
+	setDefaultExtra = (e) => (this.defaultExtra = e, this);
+	setDevtoolsEndpointGetter = (e) => (this.unstable_devtoolsEndpointGetter = e, this);
+	setRequestDefaults = (e) => (this.unstable_getRequestDefaults = e, this);
+	setAdapterDefaults = (e) => (this.unstable_getAdapterDefaults = e, this);
+	setInternalErrorMapping = (e) => (this.unstable_internalErrorMapping = e, this);
+	setHeaderMapper = (e) => (this.unstable_headerMapper = ((t) => e(t, this.unstable_headerMapperConfig)), this);
+	setPayloadMapper = (e) => (this.unstable_payloadMapper = ((t) => e(t, this.unstable_payloadMapperConfig)), this);
+	setEndpointMapper = (e) => (this.unstable_endpointMapper = ((t) => e(t, this.unstable_endpointMapperConfig)), this);
+	setQueryParamsMapper = (e) => (this.unstable_queryParamsMapper = ((t) => e(t, this.unstable_queryParamsMapperConfig)), this);
+	setQueryParamsMapperConfig = (e) => (this.unstable_queryParamsMapperConfig = e, this);
+	setHeaderMapperConfig = (e) => (this.unstable_headerMapperConfig = e, this);
+	setEndpointMapperConfig = (e) => (this.unstable_endpointMapperConfig = e, this);
+	setPayloadMapperConfig = (e) => (this.unstable_payloadMapperConfig = e, this);
+	setFetcher(e) {
+		return this.unstable_fetcher = e.bind(this), this;
+	}
+	async fetch(e, t) {
+		let n, r = async (r) => {
+			try {
+				if (!this.initialized) throw new V(`Adapter ${this.options.name} is not initialized`);
+				if (!this.unstable_fetcher) throw new V(`Fetcher for ${this.options.name} adapter is not set`);
+				this.client.triggerPlugins("onAdapterFetch", {
+					adapter: this,
+					request: e,
+					requestId: t
+				});
+				let i = await jt({
+					request: e,
+					requestId: t,
+					resolve: r,
+					internalErrorMapping: this.unstable_internalErrorMapping,
+					onStartTime: (e) => {
+						n = e;
+					}
+				});
+				return e.unstable_mock && e.isMockerEnabled && e.client.isMockerEnabled ? await Nt(i) : this.unstable_fetcher(i);
+			} catch (i) {
+				return Mt({
+					request: e,
+					requestId: t,
+					startTime: n || Date.now(),
+					logger: this.logger,
+					resolve: r
+				})({
+					error: this.unstable_internalErrorMapping(i),
+					status: this.options.systemErrorStatus,
+					extra: this.options.systemErrorExtra
+				});
+			}
+		};
+		return new Promise((e) => {
+			r(e);
+		});
+	}
+}, It = (e) => {
+	try {
+		return JSON.parse(e);
+	} catch {
+		return e;
+	}
+}, Lt = (e) => e ? It(e) : H(), Rt = (e) => (t) => {
+	let { skipNull: n, skipEmptyString: r } = e;
+	return !(r && t === void 0 || r && t === "" || n && t === null);
+}, W = (e, { encode: t, strict: n }) => t && n ? encodeURIComponent(e).replace(/[!'()*]/g, (e) => `%${e.charCodeAt(0).toString(16).toUpperCase()}`) : t ? encodeURIComponent(e) : e, zt = (e, t, n) => {
+	let r = !Rt(n)(t);
+	return !e || r ? "" : `${W(e, n)}=${W(t instanceof Date ? n.dateParser?.(t) || t.toISOString() : typeof t == "object" && !Array.isArray(t) ? n.objectParser?.(t) || JSON.stringify(t) : String(t), n)}`;
+}, Bt = (e, t, n) => {
+	let { arrayFormat: r, arraySeparator: i } = n;
+	return t.filter(Rt(n)).reduce((t, a, o) => {
+		switch (r) {
+			case "index": {
+				let r = `${W(e, n)}[${W(String(o), n)}]=`;
+				t.push(`${r}${W(String(a), n)}`);
+				break;
+			}
+			case "bracket": {
+				let r = `${W(e, n)}[]=`;
+				t.push(`${r}${W(String(a), n)}`);
+				break;
+			}
+			case "comma": {
+				let r = !t.length && `${W(e, n)}=` || "";
+				return [[...t, `${r}${W(String(a), n)}`].join(",")];
+			}
+			case "separator": {
+				let r = !t.length && `${W(e, n)}=` || "";
+				return [[...t, `${r}${W(String(a), n)}`].join(i || "|")];
+			}
+			case "bracket-separator": {
+				let r = !t.length && `${W(e, n)}[]=` || "";
+				return [[...t, `${r}${W(String(a), n)}`].join(i || "|")];
+			}
+			default: {
+				let r = `${W(e, n)}=`;
+				t.push(`${r}${W(String(a), n)}`);
+			}
+		}
+		return t;
+	}, []).join("&");
+}, Vt = (e, t = gn) => {
+	if (!e || !Object.keys(e).length) return "";
+	if (typeof e == "string") return e[0] === "?" ? e : `?${e}`;
+	let n = Object.entries(e).map(([e, n]) => Array.isArray(n) ? Bt(e, n, t) : zt(e, n, t)).filter(Boolean).join("&");
+	return n ? `?${n}` : "";
+}, Ht = kt.SEC * 5, G = { headers: {} }, Ut = () => new Ft({
+	name: "http",
+	defaultMethod: yt.GET,
+	defaultExtra: G,
+	systemErrorStatus: 0,
+	systemErrorExtra: G
+}).setQueryParamsMapper(Vt).setFetcher(async ({ request: e, adapterOptions: t, headers: n, payload: r, onError: i, onResponseEnd: a, onTimeoutError: o, onRequestEnd: s, createAbortListener: c, getAbortController: l, onResponseProgress: u, onResponseStart: d, onBeforeRequest: f, onRequestStart: p, onRequestProgress: m, onSuccess: h }) => {
+	let { method: g, client: _, endpoint: v, queryParams: y } = e, b = y ? Vt(y) : "", x = `${_.url}${v}${b}`, S = l(), { timeout: C = Ht, streaming: w = !1, ...T } = t || {}, E = !1, D, O = c({
+		status: 0,
+		extra: G
+	});
+	C > 0 && S && (D = setTimeout(() => {
+		E = !0, O(), S.abort();
+	}, C)), f(), p();
+	try {
+		let e = {
+			method: g,
+			headers: n,
+			signal: S?.signal,
+			...T
+		};
+		if (r && g !== "GET" && g !== "HEAD" && (e.body = r, typeof r == "string")) {
+			let e = new Blob([r]).size;
+			m({
+				total: e,
+				loaded: e
+			});
+		}
+		s();
+		let t = await fetch(x, e);
+		D && clearTimeout(D), d();
+		let o = {};
+		t.headers.forEach((e, t) => {
+			o[t] = e;
+		});
+		let c = { headers: o }, { status: l } = t;
+		if (w && t.body) a(), O(), t.ok ? h({
+			data: t.body,
+			status: l,
+			extra: c
+		}) : i({
+			error: Lt(await t.text()),
+			status: l,
+			extra: c
+		});
+		else {
+			let e;
+			if (t.body && typeof t.body.getReader == "function") {
+				let n = t.body.getReader(), r = parseInt(t.headers.get("content-length") || "0", 10), i = 0, a = [];
+				for (;;) {
+					let { done: e, value: t } = await n.read();
+					if (e) break;
+					a.push(t), i += t.length, u({
+						total: r || i,
+						loaded: i
+					});
+				}
+				let o = new Uint8Array(i), s = 0;
+				for (let e of a) o.set(e, s), s += e.length;
+				e = new TextDecoder().decode(o);
+			} else e = await t.text();
+			a(), O(), t.ok ? h({
+				data: It(e),
+				status: l,
+				extra: c
+			}) : i({
+				error: Lt(e),
+				status: l,
+				extra: c
+			});
+		}
+	} catch (e) {
+		if (D && clearTimeout(D), O(), S?.signal?.aborted) {
+			E && o({
+				status: 0,
+				extra: G
+			});
+			return;
+		}
+		i({
+			error: e,
+			status: 0,
+			extra: G
+		});
+	}
+}), Wt = () => Ut(), Gt = class {
+	emitter = new ye();
+	events;
+	storage;
+	lazyStorage;
+	version;
+	garbageCollectors = /* @__PURE__ */ new Map();
+	logger;
+	client;
+	constructor(e) {
+		this.options = e;
+		let { storage: t = /* @__PURE__ */ new Map(), lazyStorage: n, version: r = "0.0.1" } = e ?? {};
+		this.emitter?.setMaxListeners(1e3), this.events = $t(this.emitter), this.storage = t, this.version = r, this.lazyStorage = n;
+	}
+	initialize = (e) => (this.client = e, this.logger = e.loggerManager.initialize(e, "Cache"), e.appManager.events.onOnline(() => {
+		[...this.storage.keys()].forEach(this.scheduleGarbageCollector);
+	}), [...this.storage.keys()].forEach(this.scheduleGarbageCollector), this);
+	set = (e, t) => {
+		this.logger.debug({
+			title: "Processing cache response",
+			type: "system",
+			extra: {
+				request: e,
+				response: t
+			}
+		});
+		let { cacheKey: n, cache: r, staleTime: i, cacheTime: a, scope: o } = e, s = U(n, o), c = this.storage.get(s), l = typeof t == "function" ? t(c || null) : t, u = Kt(c, l), d = {
+			...u,
+			scope: o,
+			staleTime: i,
+			version: this.version,
+			cacheKey: n,
+			cacheTime: a,
+			cached: !!e.cache
+		}, f = this.client.mode === "server", p = r && (!f || !!e.scope);
+		l.success && p ? (this.logger.debug({
+			title: "Saving response to cache storage",
+			type: "system",
+			extra: {
+				request: e,
+				data: u
+			}
+		}), this.storage.set(s, d), this.lazyStorage?.set(s, d), this.client.triggerPlugins("onCacheItemChange", {
+			cache: this,
+			cacheKey: n,
+			prevData: c || null,
+			newData: d
+		}), this.scheduleGarbageCollector(s)) : this.logger.debug({
+			title: "Prevented saving response to cache",
+			type: "system",
+			extra: {
+				request: e,
+				data: u
+			}
+		}), this.logger.debug({
+			title: "Emitting cache response",
+			type: "system",
+			extra: {
+				request: e,
+				data: u
+			}
+		}), this.events.emitCacheData(d);
+	};
+	update = (e, t) => {
+		this.logger.debug({
+			title: "Processing cache update",
+			type: "system",
+			extra: {
+				request: e,
+				partialResponse: t
+			}
+		});
+		let { cacheKey: n, scope: r } = e, i = U(n, r), a = this.storage.get(i), o = typeof t == "function" ? t(a || null) : t;
+		a && this.set(e, {
+			...a,
+			...o
+		});
+	};
+	get = (e) => (this.getLazyResource(e), this.storage.get(e));
+	keys = () => {
+		let e = this.storage.keys();
+		return Array.from(e);
+	};
+	delete = (e) => {
+		this.logger.debug({
+			title: "Deleting cache element",
+			type: "system",
+			extra: { cacheKey: e }
+		}), this.storage.delete(e), this.lazyStorage?.delete(e), this.client.triggerPlugins("onCacheItemDelete", {
+			cache: this,
+			cacheKey: e
+		}), this.events.emitDelete(e);
+	};
+	invalidate = (e) => {
+		this.logger.debug({
+			title: "Revalidating cache element",
+			type: "system",
+			extra: { cacheKeys: e }
+		});
+		let t = (e) => {
+			let t = Array.from(this.storage.keys()), n = (e, t = e) => {
+				let n = this.storage.get(e);
+				n && this.storage.set(e, {
+					...n,
+					staleTime: 0
+				}), this.client.triggerPlugins("onCacheItemInvalidate", {
+					cache: this,
+					cacheKey: t
+				}), this.events.emitInvalidation(t);
+			};
+			e instanceof At ? n(U(e.cacheKey, e.scope), e.cacheKey) : typeof e == "string" ? n(e) : t.length && t.forEach((t) => {
+				e.test(t) && n(t);
+			});
+		};
+		Array.isArray(e) ? e.forEach(t.bind(this)) : t.bind(this)(e);
+	};
+	getLazyResource = async (e) => {
+		let t = await this.lazyStorage?.get(e), n = this.storage.get(e);
+		if (this.lazyStorage && t) {
+			let r = +/* @__PURE__ */ new Date(), i = n ? n.responseTimestamp < t.responseTimestamp : !0, a = t.staleTime <= r - t.responseTimestamp, o = t.version === this.version;
+			if (o || this.lazyStorage?.delete(e), i && !a && o) return this.storage.set(e, t), this.events.emitCacheData({
+				...t,
+				cacheKey: e,
+				cached: !0
+			}), t;
+		}
+		let r = n?.version === this.version;
+		return n && !r && this.delete(e), n;
+	};
+	getLazyKeys = async () => {
+		let e = await this.lazyStorage?.keys() || [];
+		return [...new Set(e)];
+	};
+	getAllKeys = async () => {
+		let e = await this.lazyStorage?.keys(), t = Array.from(e || []), n = Array.from(this.storage.keys());
+		return [...new Set([...t, ...n])];
+	};
+	scheduleGarbageCollector = (e) => {
+		let t = this.storage.get(e);
+		if (clearTimeout(this.garbageCollectors.get(e)), t) {
+			let n = t.cacheTime + t.responseTimestamp - +/* @__PURE__ */ new Date();
+			t.cacheTime === null ? this.logger.debug({
+				title: "Cache time is null",
+				type: "system",
+				extra: { cacheKey: e }
+			}) : t.cacheTime !== null && JSON.stringify(t.cacheTime) === "null" || t.cacheTime === Infinity ? this.logger.debug({
+				title: "Cache time is Infinite",
+				type: "system",
+				extra: { cacheKey: e }
+			}) : n >= 0 ? this.garbageCollectors.set(e, setTimeout(() => {
+				this.client.appManager.isOnline && (this.logger.info({
+					title: "Garbage collecting cache data",
+					type: "system",
+					extra: { cacheKey: e }
+				}), this.delete(e));
+			}, n)) : this.client.appManager.isOnline && (this.logger.info({
+				title: "Garbage collecting cache data",
+				type: "system",
+				extra: { cacheKey: e }
+			}), this.delete(e));
+		}
+	};
+	clear = async () => {
+		this.garbageCollectors.forEach((e) => clearTimeout(e)), this.storage.clear();
+	};
+}, Kt = (e, t) => {
+	let { data: n, success: r } = t, i = !r && e ? e.data : null, a = n || i;
+	return {
+		...t,
+		data: a
+	};
+}, qt = () => "invalidate", Jt = (e) => `${e}_invalidate`, Yt = () => "delete", Xt = (e) => `${e}_delete`, Zt = (e) => `${e}_cache`, Qt = () => "cache", $t = (e) => ({
+	emitCacheData: (t, n = !1) => {
+		e.emit(Qt(), t, n), e.emit(Zt(t.cacheKey), t, n);
+	},
+	emitInvalidation: (t, n = !1) => {
+		e.emit(qt(), t, n), e.emit(Jt(t), n);
+	},
+	emitDelete: (t, n = !1) => {
+		e.emit(Yt(), t, n), e.emit(Xt(t), n);
+	},
+	onData: (t) => (e.on(Qt(), t), () => e.removeListener(Qt(), t)),
+	onDataByKey: (t, n) => (e.on(Zt(t), n), () => e.removeListener(Zt(t), n)),
+	onInvalidate: (t) => (e.on(qt(), t), () => e.removeListener(qt(), t)),
+	onInvalidateByKey: (t, n) => (e.on(Jt(t), n), () => e.removeListener(Jt(t), n)),
+	onDelete: (t) => (e.on(Yt(), t), () => e.removeListener(Yt(), t)),
+	onDeleteByKey: (t, n) => (e.on(Xt(t), n), () => e.removeListener(Xt(t), n))
+}), K = /* @__PURE__ */ function(e) {
+	return e.ONE_BY_ONE = "one-by-one", e.ALL_AT_ONCE = "all-at-once", e.PREVIOUS_CANCELED = "previous-canceled", e.DEDUPLICATED = "deduplicated", e;
+}({}), en = (e) => ({
+	emitDrained: (t, n) => {
+		e.emit(nn(), t, n), e.emit(rn(t.queryKey), t, n);
+	},
+	emitQueueStatusChanged: (t, n) => {
+		e.emit(an(), t, n), e.emit(on(t.queryKey), t, n);
+	},
+	emitQueueChanged: (t, n) => {
+		e.emit(sn(), t, n), e.emit(cn(t.queryKey), t, n);
+	},
+	onDrained: (t) => (e.on(nn(), t), () => e.removeListener(nn(), t)),
+	onDrainedByKey: (t, n) => (e.on(rn(t), n), () => e.removeListener(rn(t), n)),
+	onQueueStatusChange: (t) => (e.on(an(), t), () => e.removeListener(an(), t)),
+	onQueueStatusChangeByKey: (t, n) => (e.on(on(t), n), () => e.removeListener(on(t), n)),
+	onQueueChange: (t) => (e.on(sn(), t), () => e.removeListener(sn(), t)),
+	onQueueChangeByKey: (t, n) => (e.on(cn(t), n), () => e.removeListener(cn(t), n))
+}), tn = class {
+	emitter = new ye();
+	events = en(this.emitter);
+	storage = /* @__PURE__ */ new Map();
+	requestCount = /* @__PURE__ */ new Map();
+	runningRequests = /* @__PURE__ */ new Map();
+	logger;
+	client;
+	constructor(e) {
+		this.options = e, this.emitter?.setMaxListeners(1e3), this.options?.storage && (this.storage = this.options.storage);
+	}
+	isRequestJSON = (e) => !(e instanceof At);
+	initialize = (e) => (this.client = e, this.logger = e.loggerManager.initialize(e, "Dispatcher"), this.client.appManager.events.onOnline(() => {
+		this.flush();
+	}), this);
+	start = (e) => {
+		let t = this.getQueue(e);
+		t.stopped = !1, this.setQueue(e, t), this.flushQueue(e), this.client.triggerPlugins("onDispatcherQueueRunning", {
+			dispatcher: this,
+			queue: t,
+			status: "running"
+		}), this.events.emitQueueStatusChanged(t);
+	};
+	pause = (e) => {
+		let t = this.getQueue(e);
+		t.stopped = !0, this.setQueue(e, t), this.client.triggerPlugins("onDispatcherQueueRunning", {
+			dispatcher: this,
+			queue: t,
+			status: "paused"
+		}), this.events.emitQueueStatusChanged(t);
+	};
+	stop = (e) => {
+		let t = this.getQueue(e);
+		t.stopped = !0, this.setQueue(e, t), this.cancelRunningRequests(e), this.client.triggerPlugins("onDispatcherQueueRunning", {
+			dispatcher: this,
+			queue: t,
+			status: "stopped"
+		}), this.events.emitQueueStatusChanged(t);
+	};
+	getQueuesKeys = () => Array.from(this.storage.keys());
+	getQueue = (e) => {
+		let t = {
+			queryKey: e,
+			requests: [],
+			stopped: !1
+		}, n = this.storage.get(e);
+		if (!n) return t;
+		let r = n.requests.map((e) => this.isRequestJSON(e.request) ? {
+			...e,
+			request: this.client.fromJSON(e.request)
+		} : e);
+		return {
+			...n,
+			requests: r
+		};
+	};
+	getRequest = (e, t) => {
+		let n = {
+			queryKey: e,
+			requests: [],
+			stopped: !1
+		};
+		return (this.storage.get(e) || n).requests.find((e) => e.requestId === t);
+	};
+	getIsActiveQueue = (e) => {
+		let t = this.getQueue(e), n = t.requests.some((e) => !e.stopped), r = !t.stopped;
+		return n && r;
+	};
+	addQueueItem = (e, t) => {
+		let n = this.getQueue(e);
+		n.requests.push(t), this.client.triggerPlugins("onDispatcherItemAdded", {
+			dispatcher: this,
+			queue: n,
+			queueItem: t
+		}), this.setQueue(e, n);
+	};
+	setQueue = (e, t) => (this.storage.set(e, t), this.client.triggerPlugins("onDispatcherQueueCreated", {
+		dispatcher: this,
+		queue: t
+	}), this.events.emitQueueChanged(t), t);
+	clearQueue = (e) => {
+		let t = {
+			queryKey: e,
+			requests: [],
+			stopped: this.getQueue(e).stopped
+		};
+		return this.storage.set(e, t), this.client.triggerPlugins("onDispatcherQueueCleared", {
+			dispatcher: this,
+			queue: t
+		}), this.events.emitQueueChanged(t), this.events.emitDrained(t), t;
+	};
+	flushQueue = async (e) => {
+		let t = this.getQueue(e), n = this.getRunningRequests(e), r = t.requests.find((e) => !e.stopped), i = t && t.stopped, a = !this.client.appManager.isOnline, o = !r?.request.queued, s = !n.length, c = !r;
+		i || a || c ? this.logger.debug({
+			title: "Skipping queue trigger",
+			type: "system",
+			extra: {
+				isStopped: i,
+				isOffline: a,
+				isEmpty: c
+			}
+		}) : o ? t.requests.forEach((t) => {
+			this.hasRunningRequest(e, t.requestId) || this.performRequest(t);
+		}) : s && (await this.performRequest(r), this.flushQueue(e));
+	};
+	flush = async () => {
+		let e = this.getQueuesKeys();
+		for (let t of e) this.getQueue(t) && this.flushQueue(t);
+	};
+	clear = () => {
+		this.getQueuesKeys().forEach((e) => this.cancelRunningRequests(e)), this.runningRequests.clear(), this.storage.clear(), this.client.triggerPlugins("onDispatcherCleared", { dispatcher: this });
+	};
+	startRequest = (e, t) => {
+		let n = this.getQueue(e), r = n.requests.find((e) => e.requestId === t);
+		r && (r.stopped = !1, this.setQueue(e, n), this.flushQueue(e), this.events.emitQueueStatusChanged(n));
+	};
+	stopRequest = (e, t) => {
+		let n = this.getQueue(e), r = n.requests.find((e) => e.requestId === t);
+		r && (r.stopped = !0, this.setQueue(e, n), this.cancelRunningRequest(e, t), this.events.emitQueueStatusChanged(n));
+	};
+	getAllRunningRequests = () => Array.from(this.runningRequests.values()).flat();
+	getRunningRequests = (e) => this.runningRequests.get(e) || [];
+	getRunningRequest = (e, t) => this.getRunningRequests(e).find((e) => e.requestId === t);
+	addRunningRequest = (e, t, n) => {
+		let r = {
+			requestId: t,
+			request: n,
+			timestamp: Date.now()
+		}, i = this.getRunningRequests(e);
+		return i.push(r), this.runningRequests.set(e, i), r;
+	};
+	hasRunningRequests = (e) => !!this.getRunningRequests(e).length;
+	hasRunningRequest = (e, t) => !!this.getRunningRequests(e).find((e) => e.requestId === t);
+	cancelRunningRequests = (e) => {
+		this.runningRequests.get(e)?.forEach((e) => {
+			let t = U(e.request.abortKey, e.request.scope);
+			this.client.requestManager.abortByRequestId(t, e.requestId);
+		}), this.deleteRunningRequests(e);
+	};
+	cancelRunningRequest = (e, t) => {
+		let n = this.getRunningRequests(e).filter((e) => {
+			if (e.requestId === t) {
+				let t = U(e.request.abortKey, e.request.scope);
+				return this.client.requestManager.abortByRequestId(t, e.requestId), !1;
+			}
+			return !0;
+		});
+		this.runningRequests.set(e, n);
+	};
+	deleteRunningRequests = (e) => {
+		this.runningRequests.set(e, []);
+	};
+	deleteRunningRequest = (e, t) => {
+		let n = this.getRunningRequests(e);
+		this.runningRequests.set(e, n.filter((e) => e.requestId !== t));
+	};
+	getQueueRequestCount = (e) => this.requestCount.get(e) || 0;
+	incrementQueueRequestCount = (e) => {
+		let t = this.requestCount.get(e) || 0;
+		this.requestCount.set(e, t + 1);
+	};
+	createStorageItem = (e) => ({
+		requestId: this.client.unstable_requestIdMapper(e),
+		timestamp: +/* @__PURE__ */ new Date(),
+		request: e,
+		retries: 0,
+		stopped: !1,
+		resolved: !1
+	});
+	add = (e) => {
+		let t = U(e.queryKey, e.scope), n = this.createStorageItem(e), { requestId: r } = n, [i] = this.getQueue(t).requests.slice(-1), a = dn(e, i);
+		switch (this.logger.debug({
+			title: "Adding request to queue",
+			type: "system",
+			extra: {
+				requestType: a,
+				request: e,
+				requestId: r
+			}
+		}), a) {
+			case K.ONE_BY_ONE: return this.addQueueItem(t, n), this.flushQueue(t), r;
+			case K.PREVIOUS_CANCELED: return this.cancelRunningRequests(t), this.clearQueue(t), this.addQueueItem(t, n), this.flushQueue(t), r;
+			case K.DEDUPLICATED: return this.client.requestManager.events.emitDeduplicated({
+				request: i.request,
+				requestId: r,
+				deduplicatedRequest: e
+			}), i.requestId;
+			default: return this.addQueueItem(t, n), this.flushQueue(t), r;
+		}
+	};
+	delete = (e, t, n) => {
+		this.logger.debug({
+			title: "Deleting request",
+			type: "system",
+			extra: {
+				queryKey: e,
+				requestId: t,
+				abortKey: n
+			}
+		});
+		let r = this.getQueue(e), i = r.requests.find((e) => e.requestId === t);
+		if (i) return r.requests = r.requests.filter((e) => e.requestId !== t), this.storage.set(e, r), this.hasRunningRequest(e, t) && (this.deleteRunningRequest(e, t), this.client.requestManager.abortByRequestId(n, t)), this.client.triggerPlugins("onDispatcherItemDeleted", {
+			queue: r,
+			dispatcher: this,
+			queueItem: i
+		}), this.events.emitQueueChanged(r), this.client.requestManager.events.emitRemove({
+			requestId: t,
+			request: i.request,
+			resolved: i.resolved
+		}), r.requests.length || (this.client.triggerPlugins("onDispatcherQueueDrained", {
+			queue: r,
+			dispatcher: this
+		}), this.events.emitDrained(r)), r;
+	};
+	performRequest = async (e) => {
+		let { request: t, requestId: n } = e;
+		this.logger.debug({
+			title: "Performing request",
+			type: "system",
+			extra: {
+				request: t,
+				requestId: n
+			}
+		});
+		let { retry: r, retryTime: i, queryKey: a, abortKey: o, offline: s, scope: c } = t, l = U(a, c), u = U(o, c), { adapter: d, requestManager: f, cache: p, appManager: m } = this.client, h = ln(e.retries, r), g = !m.isOnline && s, _ = this.hasRunningRequest(l, n), v = e.stopped;
+		if (g || _ || v) return this.logger.warning({
+			title: "Unable to perform request",
+			type: "system",
+			extra: {
+				isOffline: g,
+				isAlreadyRunning: _,
+				isStopped: v
+			}
+		});
+		let y = this.addRunningRequest(l, n, t);
+		f.events.emitLoading({
+			request: t,
+			requestId: n,
+			loading: !0,
+			isRetry: !!e.retries,
+			isOffline: g
+		}), this.incrementQueueRequestCount(l), f.addAbortController(u, n);
+		let b = await d.fetch(t, n);
+		e.resolved = !0, f.removeAbortController(u, n);
+		let x = !m.isOnline, S = H("abort").message === b.error?.message, C = !this.hasRunningRequest(l, n) || S;
+		this.deleteRunningRequest(l, n);
+		let w = b.success || !h || !t.retryOnError || t.retryOnError(b), T = !b.success && h && w && !C && !x, E = {
+			isCanceled: C,
+			isOffline: x,
+			retries: e.retries,
+			willRetry: T,
+			addedTimestamp: e.timestamp,
+			triggerTimestamp: y.timestamp,
+			requestTimestamp: b.requestTimestamp,
+			responseTimestamp: b.responseTimestamp
+		};
+		if (f.events.emitResponse({
+			request: t,
+			requestId: n,
+			response: b,
+			details: E
+		}), f.events.emitLoading({
+			request: t,
+			requestId: n,
+			loading: !1,
+			isRetry: !!e.retries,
+			isOffline: g
+		}), p.set(t, {
+			...b,
+			...E
+		}), this.logger.debug({
+			title: "Dispatcher processing response",
+			type: "system",
+			extra: {
+				requestId: n,
+				request: t,
+				response: b,
+				details: E
+			}
+		}), C) {
+			let e = this.getQueue(l), r = e.requests.find((e) => e.requestId === n);
+			return !e.stopped && !r?.stopped ? (this.logger.debug({
+				title: "Request paused",
+				type: "system",
+				extra: {
+					response: b,
+					requestDetails: E,
+					request: t
+				}
+			}), this.delete(l, n, u)) : this.logger.debug({
+				title: "Request canceled",
+				type: "system",
+				extra: {
+					response: b,
+					requestDetails: E,
+					request: t
+				}
+			});
+		}
+		if (!b.success && x) return s ? this.logger.debug({
+			title: "Awaiting for network restoration",
+			type: "system",
+			extra: {
+				response: b,
+				requestDetails: E,
+				request: t
+			}
+		}) : (this.logger.warning({
+			title: "Removing non-offline request",
+			type: "system",
+			extra: {
+				response: b,
+				requestDetails: E,
+				request: t
+			}
+		}), this.delete(l, n, u));
+		if (b.success) return this.delete(l, n, u), this.logger.debug({
+			title: "Successful response, removing request from queue.",
+			type: "system",
+			extra: {
+				response: b,
+				requestDetails: E,
+				request: t
+			}
+		});
+		T ? (this.logger.debug({
+			title: "Waiting for retry",
+			type: "system",
+			extra: {
+				response: b,
+				requestDetails: E,
+				request: t
+			}
+		}), setTimeout(() => {
+			this.logger.warning({
+				title: "Error response, performing retry",
+				type: "request",
+				extra: {
+					response: b,
+					requestDetails: E,
+					request: t,
+					requestId: n
+				}
+			}), this.performRequest({
+				...e,
+				retries: e.retries + 1
+			});
+		}, i || 0)) : (t.retry && this.logger.error({
+			title: "All retries have been used. Removing request from queue.",
+			type: "request",
+			extra: {
+				response: b,
+				requestDetails: E,
+				request: t,
+				requestId: n
+			}
+		}), this.delete(l, n, u));
+	};
+}, nn = () => "drained-event", rn = (e) => `${e}-drained-event`, an = () => "status-event", on = (e) => `${e}-status-event`, sn = () => "change-event", cn = (e) => `${e}-change-event`, ln = (e, t) => !!(t && e < t), un = (e, t) => e.deduplicateTime ? +/* @__PURE__ */ new Date() - t.timestamp <= e.deduplicateTime : !0, dn = (e, t) => {
+	let { queued: n, cancelable: r, deduplicate: i } = e, a = t ? un(e, t) : !1;
+	return n ? K.ONE_BY_ONE : r ? K.PREVIOUS_CANCELED : a && i ? K.DEDUPLICATED : K.ALL_AT_ONCE;
+};
+function fn(e) {
+	return e === "client" || e === "server" ? e : typeof window < "u" && typeof document < "u" ? "client" : "server";
+}
+var pn = async (e, t) => {
+	let n = t;
+	if (!t.requestOptions.disableRequestInterceptors) {
+		for (let r of e) if (n = await r(t), !n) throw Error("Request modifier must return request");
+	}
+	return n;
+}, mn = async (e, t, n) => {
+	let r = t;
+	if (!n.requestOptions.disableResponseInterceptors) {
+		for (let i of e) if (r = await i(t, n), !r) throw Error("Response modifier must return data");
+	}
+	return r;
+}, hn = class {
+	url;
+	mode;
+	debug;
+	unstable_onErrorCallbacks = [];
+	unstable_onSuccessCallbacks = [];
+	unstable_onResponseCallbacks = [];
+	unstable_onAuthCallbacks = [];
+	unstable_onRequestCallbacks = [];
+	loggerManager = new rt();
+	requestManager = new Ee();
+	appManager;
+	adapter;
+	cache;
+	fetchDispatcher;
+	submitDispatcher;
+	isMockerEnabled = !0;
+	plugins = [];
+	unstable_abortKeyMapper = wt;
+	unstable_cacheKeyMapper = Tt;
+	unstable_queryKeyMapper = Tt;
+	unstable_requestIdMapper = ge;
+	logger = this.loggerManager.initialize(this, "Client");
+	constructor(e) {
+		this.options = e;
+		let { url: t, appManager: n, cache: r, fetchDispatcher: i, submitDispatcher: a, mode: o } = this.options;
+		this.url = t, this.mode = fn(o), this.adapter = Wt(), this.appManager = n?.() || new be(), this.cache = r?.() || new Gt(), this.fetchDispatcher = i?.() || new tn(), this.submitDispatcher = a?.() || new tn(), this.adapter.initialize(this), this.appManager.initialize(), this.cache.initialize(this), this.fetchDispatcher.initialize(this), this.submitDispatcher.initialize(this);
+	}
+	setDebug = (e) => (this.debug = e, this);
+	setLogLevel = (e) => (this.loggerManager.setSeverity(e), this);
+	setLogger = (e) => (this.loggerManager = e(this), this.loggerManager.initialize(this, "Client"), this);
+	setEnableGlobalMocking = (e) => (this.isMockerEnabled = e, this);
+	setAdapter = (e) => (this.adapter = e, this.adapter.initialize(this), this);
+	onAuth = (e) => (this.unstable_onAuthCallbacks.push(e), this);
+	removeOnAuthInterceptors = (e) => (this.unstable_onAuthCallbacks = this.unstable_onAuthCallbacks.filter((t) => !e.includes(t)), this);
+	onError = (e) => (this.unstable_onErrorCallbacks.push(e), this);
+	removeOnErrorInterceptors = (e) => (this.unstable_onErrorCallbacks = this.unstable_onErrorCallbacks.filter((t) => !e.includes(t)), this);
+	onSuccess = (e) => (this.unstable_onSuccessCallbacks.push(e), this);
+	removeOnSuccessInterceptors = (e) => (this.unstable_onSuccessCallbacks = this.unstable_onSuccessCallbacks.filter((t) => !e.includes(t)), this);
+	onRequest = (e) => (this.unstable_onRequestCallbacks.push(e), this);
+	removeOnRequestInterceptors = (e) => (this.unstable_onRequestCallbacks = this.unstable_onRequestCallbacks.filter((t) => !e.includes(t)), this);
+	onResponse = (e) => (this.unstable_onResponseCallbacks.push(e), this);
+	removeOnResponseInterceptors = (e) => (this.unstable_onResponseCallbacks = this.unstable_onResponseCallbacks.filter((t) => !e.includes(t)), this);
+	addPlugin = (e) => (this.plugins.push(e), e.initialize(this), e.trigger("onMount", { client: this }), this);
+	removePlugin = (e) => {
+		let t = this.plugins.length;
+		return this.plugins = this.plugins.filter((t) => t !== e), this.plugins.length !== t && e.trigger("onUnmount", { client: this }), this;
+	};
+	triggerPlugins = (e, t) => (this.plugins.length && this.plugins.forEach((n) => {
+		n.trigger(e, t);
+	}), this);
+	setAbortKeyMapper = (e) => (this.unstable_abortKeyMapper = e, this);
+	setCacheKeyMapper = (e) => (this.unstable_cacheKeyMapper = e, this);
+	setQueryKeyMapper = (e) => (this.unstable_queryKeyMapper = e, this);
+	setRequestIdMapper = (e) => (this.unstable_requestIdMapper = e, this);
+	unstable_modifyAuth = async (e) => pn(this.unstable_onAuthCallbacks, e);
+	unstable_modifyRequest = async (e) => pn(this.unstable_onRequestCallbacks, e);
+	unstable_modifyErrorResponse = async (e, t) => mn(this.unstable_onErrorCallbacks, e, t);
+	unstable_modifySuccessResponse = async (e, t) => mn(this.unstable_onSuccessCallbacks, e, t);
+	unstable_modifyResponse = async (e, t) => mn(this.unstable_onResponseCallbacks, e, t);
+	fromJSON = (e) => At.fromJSON(this, e);
+	clear = () => {
+		let { appManager: e, cache: t, fetchDispatcher: n, submitDispatcher: r } = this.options;
+		this.requestManager.abortControllers.clear(), this.fetchDispatcher.clear(), this.submitDispatcher.clear(), this.cache.clear(), this.requestManager.emitter.removeAllListeners(), this.fetchDispatcher.emitter.removeAllListeners(), this.submitDispatcher.emitter.removeAllListeners(), this.cache.emitter.removeAllListeners(), this.cache = t?.() || new Gt(), this.appManager = e?.() || new be(), this.fetchDispatcher = n?.() || new tn(), this.submitDispatcher = r?.() || new tn(), this.appManager.initialize(), this.cache.initialize(this), this.fetchDispatcher.initialize(this), this.submitDispatcher.initialize(this);
+	};
+	hydrate = (e, t) => {
+		e?.forEach((e) => {
+			if (!e) return;
+			let { cacheKey: n, scope: r, response: i, ...a } = e, o = {
+				cache: !0,
+				override: !0
+			}, s = typeof t == "function" ? {
+				...o,
+				...a,
+				...t(e)
+			} : {
+				...o,
+				...a,
+				...t
+			};
+			if (!s.override && this.cache.get(U(n, r))) return;
+			let c = It(i);
+			this.cache.set({
+				...s,
+				cacheKey: n,
+				scope: r
+			}, c);
+		});
+	};
+	createRequest = (e) => (e) => {
+		let t = this.adapter.unstable_endpointMapper(e.endpoint), n = {
+			...e,
+			endpoint: String(t)
+		}, r = new At(this, n);
+		return this.plugins.forEach((e) => e.trigger("onRequestCreate", { request: r })), r;
+	};
+}, gn = {
+	strict: !0,
+	encode: !0,
+	arrayFormat: "bracket",
+	arraySeparator: "bracket",
+	sort: !1,
+	skipNull: !0,
+	skipEmptyString: !0
+};
+function _n(e) {
+	return new hn(e);
+}
+//#endregion
+//#region src/core/client.ts
+var q = _n({ url: k() });
+//#endregion
+//#region src/core/license.ts
+function vn(e) {
+	return `${q.url}/packs/${e}/checkout`;
+}
+//#endregion
+//#region src/core/auth-api.ts
+var yn = /* @__PURE__ */ _((/* @__PURE__ */ h(((e, t) => {
+	t.exports = {};
+})))(), 1);
+async function bn(e) {
+	let { data: t, success: n } = await q.createRequest()({
+		endpoint: "/auth/cli/whoami",
+		method: "GET"
+	}).setHeaders({ Authorization: `Bearer ${e}` }).send();
+	return !n || !t ? null : t;
+}
+async function xn(e) {
+	await q.createRequest()({
+		endpoint: "/auth/cli/token",
+		method: "DELETE"
+	}).setHeaders({ Authorization: `Bearer ${e}` }).send();
+}
+//#endregion
+//#region src/core/auth-store.ts
+var Sn = 1, Cn = "hype-stack", wn = "auth.json";
+function Tn() {
+	let e = process.env.HYPE_STACK_CONFIG_DIR;
+	if (e) return a.join(e, Cn);
+	let t = i.homedir();
+	if (process.platform === "win32") {
+		let e = process.env.APPDATA ?? a.join(t, "AppData", "Roaming");
+		return a.join(e, Cn);
+	}
+	if (process.platform === "darwin") return a.join(t, "Library", "Application Support", Cn);
+	let n = process.env.XDG_CONFIG_HOME ?? a.join(t, ".config");
+	return a.join(n, Cn);
+}
+function En() {
+	return a.join(Tn(), wn);
+}
+async function Dn() {
+	let e = await n.readFile(En(), "utf-8").catch(() => null);
+	if (!e) return {
+		version: Sn,
+		tokens: {}
+	};
+	let t = JSON.parse(e);
+	return {
+		version: t.version ?? Sn,
+		tokens: t.tokens ?? {}
+	};
+}
+async function On(e) {
+	let t = Tn();
+	await n.mkdir(t, { recursive: !0 }), await n.writeFile(En(), `${JSON.stringify(e, null, 2)}\n`, { mode: 384 });
+}
+async function kn(e) {
+	return (await Dn()).tokens[e] ?? null;
+}
+async function An(e, t) {
+	let n = await Dn();
+	n.tokens[e] = t, await On(n);
+}
+async function jn(e) {
+	let t = await Dn();
+	e in t.tokens && (delete t.tokens[e], await On(t));
+}
+//#endregion
+//#region src/core/device.ts
+function Mn() {
+	let e = i.networkInterfaces();
+	for (let t of Object.values(e)) if (t) {
+		for (let e of t) if (!e.internal && e.mac !== "00:00:00:00:00:00") return e.mac;
+	}
+	return "unknown";
+}
+function Nn() {
+	let e = `${Mn()}:${i.hostname()}:${i.platform()}:${i.arch()}`;
+	return (0, yn.createHash)("sha256").update(e).digest("hex").slice(0, 16);
+}
+function Pn() {
+	return `hype-stack/${v} ${i.platform()} ${i.arch()} node/${process.version.slice(1)}`;
+}
+//#endregion
+//#region src/core/open-browser.ts
+function Fn(e) {
+	o(process.platform === "darwin" ? `open "${e}"` : process.platform === "win32" ? `start "" "${e}"` : `xdg-open "${e}"`);
+}
+//#endregion
+//#region src/core/login.ts
+var In = 300 * 1e3, Ln = (e) => `<!doctype html><html><head><meta charset="utf-8"><title>Hype Stack CLI</title></head><body style="font-family:system-ui,sans-serif;text-align:center;padding-top:4rem;color:#111"><h2>${e}</h2><p>You can close this tab and return to your terminal.</p></body></html>`;
+async function Rn(e = {}) {
+	let t = (0, yn.randomBytes)(16).toString("hex"), n = k(), r = yn.default.createServer(), i = await new Promise((n, i) => {
+		let a = setTimeout(() => {
+			o(), i(/* @__PURE__ */ Error("Login timed out. Run `hype-stack login` again."));
+		}, In);
+		function o() {
+			clearTimeout(a), r.close();
+		}
+		r.on("request", (e, r) => {
+			let a = new URL(e.url ?? "/", "http://127.0.0.1");
+			if (a.pathname !== "/callback") {
+				r.writeHead(404).end();
+				return;
+			}
+			let s = (e) => {
+				r.writeHead(200, { "Content-Type": "text/html" }), r.end(Ln(e));
+			};
+			if (a.searchParams.get("state") !== t) {
+				s("Login failed."), o(), i(/* @__PURE__ */ Error("Login failed: state mismatch. Run `hype-stack login` again."));
+				return;
+			}
+			let c = a.searchParams.get("token");
+			if (a.searchParams.get("error") || !c) {
+				s("Login cancelled."), o(), i(/* @__PURE__ */ Error("Login was cancelled in the browser."));
+				return;
+			}
+			s("Logged in to Hype Stack."), o(), n(c);
+		}), r.on("error", (e) => {
+			o(), i(e);
+		}), r.listen(0, "127.0.0.1", () => {
+			let { port: n } = r.address(), i = encodeURIComponent(Pn()), a = `${te()}/cli/authorize?port=${n}&state=${t}&label=${i}`;
+			e.onUrl?.(a), Fn(a);
+		});
+	}), a = await bn(i).catch(() => null), o = {
+		token: i,
+		email: a?.email,
+		organizationId: a?.organizationId
+	};
+	return await An(n, o), o;
+}
+//#endregion
+//#region src/core/access-prompts.ts
+async function zn() {
+	let e = await t.confirm({ message: "Log in to install packs your organization owns? (opens your browser)" });
+	if (t.isCancel(e) || !e) return null;
+	t.log.step("Opening your browser to sign in...");
+	try {
+		let e = await Rn({ onUrl: (e) => {
+			t.log.info(`If your browser didn't open, visit:\n  ${I.path(e)}`);
+		} });
+		return t.log.success(e.email ? `Logged in as ${e.email}` : "Logged in"), e.token;
+	} catch (e) {
+		return t.log.error(e instanceof Error ? e.message : String(e)), null;
+	}
+}
+async function Bn(e) {
+	if (e.length === 0) return;
+	t.note([
+		"These packs need a purchase before they can be installed:",
+		"",
+		...e.map((e) => `  ${I.brand(e.displayName)}  ${I.highlight(`$${e.price}`)}`)
+	].join("\n"), "Locked Packs");
+	let n = await t.confirm({ message: `Open the purchase ${e.length === 1 ? "page" : "pages"} in your browser?` });
+	if (t.isCancel(n) || !n) {
+		t.log.info(I.muted("Run 'hype-stack login' after purchasing, then 'hype-stack compose' again."));
+		return;
+	}
+	for (let t of e) Fn(vn(t.name));
+	t.log.info([
+		I.muted("After purchasing, run:"),
+		`  ${I.highlight("hype-stack login")}      ${I.muted("Save your access")}`,
+		`  ${I.highlight("hype-stack compose")}    ${I.muted("Install the packs")}`
+	].join("\n"));
+}
+//#endregion
+//#region src/utils/exec.ts
+function J(e, t, n) {
+	return new Promise((r, i) => {
+		let a = s(e, t, {
+			cwd: n.cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		}), o = "", c = "";
+		a.stdout.on("data", (e) => {
+			let t = e.toString();
+			if (o += t, n.onData) {
+				let e = t.split("\n").filter(Boolean);
+				for (let t of e) n.onData(t);
+			}
+		}), a.stderr.on("data", (e) => {
+			let t = e.toString();
+			if (c += t, n.onData) {
+				let e = t.split("\n").filter(Boolean);
+				for (let t of e) n.onData(t);
+			}
+		}), a.on("error", i), a.on("close", (e) => {
+			r({
+				exitCode: e ?? 1,
+				stdout: o,
+				stderr: c
+			});
+		});
+	});
+}
+//#endregion
+//#region src/utils/fs.ts
+async function Y(e) {
+	return (await n.stat(e).catch(() => null))?.isDirectory() ?? !1;
+}
+async function X(e) {
+	return (await n.stat(e).catch(() => null))?.isFile() ?? !1;
+}
+async function Vn(e) {
+	return (await n.readdir(e).catch(() => [])).length === 0;
+}
+async function Hn(e) {
+	let t = await n.readFile(e, "utf-8").catch(() => null);
+	return t ? JSON.parse(t) : null;
+}
+async function Un(e, t) {
+	await n.writeFile(e, JSON.stringify(t, null, 2) + "\n", "utf-8");
+}
+async function Wn(e) {
+	let t = {};
+	if (!await Y(e)) return t;
+	let r = await n.readdir(e, { withFileTypes: !0 });
+	for (let n of r) n.isDirectory() && await X(a.join(e, n.name, "package.json")) && (t[n.name] = a.relative(a.dirname(e), a.join(e, n.name)));
+	return t;
+}
+async function Gn(e) {
+	await n.rm(e, {
+		recursive: !0,
+		force: !0
+	});
+}
+//#endregion
+//#region src/core/codegen.ts
+function Kn(e) {
+	t.log.info(I.muted("Run database setup yourself when ready:")), t.note([
+		`${I.command(`cd ${e}`)}`,
+		`${I.command("pnpm exec prisma generate")} ${I.muted("(regenerate the Prisma client)")}`,
+		`${I.command("pnpm exec prisma migrate dev")} ${I.muted("(create + apply tables for new packs)")}`
+	].join("\n"), "Database Setup");
+}
+async function qn(e) {
+	let { projectRoot: n, paths: r, skipPrompts: i, runCommand: o = J } = e, s = r.backend.root, c = a.join(n, s);
+	if (!await X(a.join(c, "package.json"))) return;
+	if (i) {
+		Kn(s);
+		return;
+	}
+	let l = await t.confirm({
+		message: `Run database setup now? (${I.command("prisma generate")} + ${I.command("prisma migrate")})`,
+		initialValue: !0
+	});
+	if (t.isCancel(l) || !l) {
+		Kn(s);
+		return;
+	}
+	let u = t.spinner();
+	if (u.start("Generating Prisma client..."), (await o("pnpm", [
+		"exec",
+		"prisma",
+		"generate"
+	], { cwd: c })).exitCode !== 0) {
+		u.stop(I.warning("Prisma client generation failed")), Kn(s);
+		return;
+	}
+	u.stop(I.success("Prisma client generated"));
+	let d = t.spinner();
+	if (d.start("Applying database schema..."), (await o("pnpm", [
+		"exec",
+		"prisma",
+		"migrate",
+		"dev",
+		"--name",
+		"add-packs"
+	], { cwd: c })).exitCode !== 0) {
+		d.stop(I.warning("Database migration failed (is your database running?)")), Kn(s);
+		return;
+	}
+	d.stop(I.success("Database schema applied"));
+}
+//#endregion
+//#region src/core/stack-config.ts
+async function Jn(e) {
+	return Hn(a.join(e, b));
+}
+async function Yn(e) {
+	return X(a.join(e, b));
+}
+async function Xn(e, t) {
+	await Un(a.join(e, b), t);
+}
+async function Zn(e) {
+	let t = a.join(e, "apps"), n = a.join(e, "packages"), [r, i] = await Promise.all([Wn(t), Wn(n)]);
+	return {
+		apps: r,
+		packages: i
+	};
+}
+function Qn(e) {
+	let t = e.apps.backend ?? "apps/backend", n = e.apps.frontend ?? "apps/frontend", r = e.packages.enums ?? "packages/enums";
+	return {
+		backend: {
+			root: t,
+			prisma: `${t}/prisma`,
+			features: `${t}/src/features`,
+			middleware: `${t}/src/middleware`,
+			libs: `${t}/src/libs`,
+			utils: `${t}/src/utils`,
+			routes: `${t}/src/routes`
+		},
+		frontend: {
+			root: n,
+			features: `${n}/src/features`,
+			components: `${n}/src/components`,
+			layouts: `${n}/src/components/layouts`,
+			hooks: `${n}/src/hooks`,
+			utils: `${n}/src/lib`
+		},
+		enums: {
+			root: r,
+			src: `${r}/src`
+		}
+	};
+}
+function $n(e, t) {
+	return {
+		$schema: re(),
+		version: 1,
+		name: e,
+		apps: t.apps,
+		packages: t.packages,
+		paths: Qn(t),
+		installedPacks: [],
+		licenseKey: null
+	};
+}
+async function er(e) {
+	let t = a.join(e, "package.json"), n = a.join(e, "apps"), [r, i] = await Promise.all([X(t), Y(n)]);
+	return r && i;
+}
+function Z(e, t) {
+	return e.replace(/\{\{(\w+)\.(\w+)\}\}/g, (n, r, i) => {
+		let a = t[r];
+		if (!a) throw Error(`Unknown app "${r}" in path template "${e}"`);
+		let o = a[i];
+		if (!o) throw Error(`Unknown path key "${i}" for app "${r}" in template "${e}"`);
+		return o;
+	});
+}
+//#endregion
+//#region src/core/registry.ts
+async function tr(e) {
+	let { data: t, error: n, status: r } = await q.createRequest()({
+		endpoint: `/packs/${encodeURIComponent(e)}/manifest`,
+		method: "GET"
+	}).send();
+	if (r === 404) throw Error(`Pack "${e}" not found in registry`);
+	if (n || !t) throw Error(`Failed to load manifest for "${e}": ${String(n)}`);
+	return t;
+}
+async function nr(e, t = {}) {
+	let r = q.createRequest()({
+		endpoint: `/packs/${encodeURIComponent(e)}/download`,
+		method: "POST"
+	}), o = {
+		"X-Device-Id": Nn(),
+		"X-Client-Info": Pn()
+	};
+	t.token && (o.Authorization = `Bearer ${t.token}`);
+	let { data: s, error: c, success: l } = await r.setPayload({ key: t.licenseKey ?? void 0 }).setHeaders(o).send();
+	if (!l || !s) throw Error(`Failed to download pack "${e}": ${String(c)}`);
+	if (!s.ok) return {
+		status: "denied",
+		reason: s.reason,
+		packs: s.packs ?? [],
+		expiresAt: s.expiresAt ?? null
+	};
+	let u = await n.mkdtemp(a.join(i.tmpdir(), `hype-stack-pack-${e}-`));
+	return await Promise.all(s.files.map(async (e) => {
+		let t = a.join(u, ...e.path.split("/"));
+		await n.mkdir(a.dirname(t), { recursive: !0 }), await n.writeFile(t, Buffer.from(e.content, "base64"));
+	})), {
+		status: "ok",
+		packDir: u
+	};
+}
+function rr(e, t, n) {
+	let r = Z(e, t);
+	return a.resolve(n, r);
+}
+function ir(e, t) {
+	return a.join(t, e);
+}
+var ar = q.createRequest()({
+	endpoint: "/packs/list",
+	method: "GET"
+});
+async function or() {
+	let { data: e, error: t } = await ar.send();
+	if (t || !e) throw Error(`Failed to fetch pack list: ${String(t)}`);
+	return e.packs;
+}
+async function sr(e, t = {}) {
+	if (e.length === 0) return {};
+	let n = q.createRequest()({
+		endpoint: "/packs/authorize",
+		method: "POST"
+	}), r = {};
+	t.token && (r.Authorization = `Bearer ${t.token}`);
+	let { data: i, error: a } = await n.setPayload({
+		packs: e,
+		key: t.key ?? void 0
+	}).setHeaders(r).send();
+	if (a || !i) throw Error(`Failed to authorize packs: ${String(a)}`);
+	return i.results;
+}
+//#endregion
+//#region src/core/codemods.ts
+var cr = "@hype-stack/";
+async function lr(e, t, r) {
+	let i = Z("{{backend.root}}", t), o = a.resolve(r, i, "src/config/env/env.config.ts"), s = a.resolve(r, i, ".env.example"), c = a.resolve(r, i, ".env.test");
+	if (await X(o)) {
+		let t = await n.readFile(o, "utf-8");
+		for (let n of e) t.includes(`from "${n.from}"`) || (t = ur(t, n), t = dr(t, n));
+		await n.writeFile(o, t, "utf-8");
+	}
+	if (await X(s)) {
+		let t = await n.readFile(s, "utf-8");
+		for (let n of e) t = fr(t, n);
+		await n.writeFile(s, t, "utf-8");
+	}
+	if (await X(c)) {
+		let t = await n.readFile(c, "utf-8");
+		for (let n of e) t = pr(t, n);
+		await n.writeFile(c, t, "utf-8");
+	}
+}
+function ur(e, t) {
+	let n = `import { ${t.import} } from "${t.from}";`, r = e.lastIndexOf("import ");
+	if (r === -1) return n + "\n" + e;
+	let i = e.indexOf("\n", e.indexOf(";", r));
+	return i === -1 ? e + "\n" + n : e.slice(0, i + 1) + n + "\n" + e.slice(i + 1);
+}
+function dr(e, t) {
+	let n = `    ${t.import}.parse(process.env);`, r = e.match(/(\s*)envSchema\.parse\(process\.env\);/);
+	if (!r) return e;
+	let i = e.indexOf(r[0]), a = e.indexOf("\n", i);
+	return a === -1 ? e + "\n" + n : e.slice(0, a + 1) + n + "\n" + e.slice(a + 1);
+}
+function fr(e, t) {
+	for (let n of Object.keys(t.envExample.vars)) if (e.includes(`${n}=`)) return e;
+	let n = [];
+	n.push(""), n.push(`# ${t.envExample.section}`);
+	for (let [e, r] of Object.entries(t.envExample.vars)) n.push(`${e}=${r}`);
+	return e.trimEnd() + "\n" + n.join("\n") + "\n";
+}
+function pr(e, t) {
+	for (let n of Object.keys(t.envTest)) if (e.includes(`${n}=`)) return e;
+	let n = [""];
+	for (let [e, r] of Object.entries(t.envTest)) n.push(`${e}=${r}`);
+	return e.trimEnd() + "\n" + n.join("\n") + "\n";
+}
+async function mr(e, t, r) {
+	let i = a.resolve(r, Z("{{backend.routes}}", t), "index.ts");
+	if (!await X(i)) return;
+	let o = await n.readFile(i, "utf-8");
+	for (let t of e) o.includes(`from "${t.from}"`) || (o = hr(o, t), o = gr(o, t));
+	await n.writeFile(i, o, "utf-8");
+}
+function hr(e, t) {
+	let n = `import { ${t.import} } from "${t.from}";`, r = e.lastIndexOf("from \"./");
+	if (r !== -1) {
+		let t = e.indexOf("\n", r);
+		return t === -1 ? e : e.slice(0, t + 1) + n + "\n" + e.slice(t + 1);
+	}
+	let i = e.indexOf("export const registerRoutes");
+	return i === -1 ? e : e.slice(0, i) + n + "\n\n" + e.slice(i);
+}
+function gr(e, t) {
+	let n = `.route("${t.prefix}", ${t.import})`, r = e.match(/\.route\([^)]+\);/g);
+	if (r) {
+		let t = r[r.length - 1], i = e.lastIndexOf(t) + t.length - 1;
+		return e.slice(0, i) + "\n    " + n + ";" + e.slice(i + 1);
+	}
+	return e.replace("return app;", `return app\n    ${n};`);
+}
+async function _r(e, t, r) {
+	let i = a.resolve(r, Z("{{backend.root}}", t), "src/context.ts");
+	if (!await X(i)) return;
+	let o = await n.readFile(i, "utf-8");
+	for (let t of e) o.includes(`export let ${t.export}`) || (o = vr(o, t), o = yr(o, t), o = br(o, t), o = xr(o, t));
+	await n.writeFile(i, o, "utf-8");
+}
+function vr(e, t) {
+	let n = `import { ${t.typeImport.name} } from "${t.typeImport.from}";`;
+	if (e.includes(`from "${t.typeImport.from}"`)) return e;
+	let r = e.lastIndexOf("import ");
+	if (r === -1) return n + "\n" + e;
+	let i = e.indexOf("\n", e.indexOf(";", r));
+	return i === -1 ? e + "\n" + n : e.slice(0, i + 1) + n + "\n" + e.slice(i + 1);
+}
+function yr(e, t) {
+	let n = `export let ${t.export}: ${t.type};`, r = e.lastIndexOf("export let ");
+	if (r === -1) {
+		let t = e.indexOf("export const setupContext");
+		return t === -1 ? e + "\n" + n + "\n" : e.slice(0, t) + n + "\n\n" + e.slice(t);
+	}
+	let i = e.indexOf("\n", r);
+	return i === -1 ? e + "\n" + n : e.slice(0, i + 1) + n + "\n" + e.slice(i + 1);
+}
+function br(e, t) {
+	let n = `  ${t.export} = ${t.init};`, r = e.match(/export const setupContext\s*=\s*async\s*\([^)]*\)\s*=>\s*\{/);
+	if (!r) return e;
+	let i = e.indexOf("{", e.indexOf(r[0]));
+	return i === -1 ? e : e.slice(0, i + 1) + "\n" + n + e.slice(i + 1);
+}
+function xr(e, t) {
+	let n = `  ${t.export}: ${t.type};`, r = e.indexOf("export type ContextVariables = {");
+	if (r === -1) return e;
+	let i = e.indexOf("};", r);
+	return i === -1 ? e : e.slice(0, i) + n + "\n" + e.slice(i);
+}
+async function Sr(e, t, r) {
+	let i = a.resolve(r, Z("{{enums.src}}", t), "index.ts");
+	if (!await X(i)) return;
+	let o = await n.readFile(i, "utf-8");
+	for (let t of e) o.includes(`from "${t.from}"`) || (o = Cr(o, t));
+	await n.writeFile(i, o, "utf-8");
+}
+function Cr(e, t) {
+	let n = `export * from "${t.from}";`, r = e.lastIndexOf("export * from");
+	if (r !== -1) {
+		let t = e.indexOf("\n", r);
+		return t === -1 ? e + "\n" + n + "\n" : e.slice(0, t + 1) + n + "\n" + e.slice(t + 1);
+	}
+	return e.trim() === "" ? n + "\n" : e.trimEnd() + "\n" + n + "\n";
+}
+async function wr(e, t, r) {
+	let i = Z("{{backend.root}}", t), o = a.resolve(r, i, "src/sockets/index.ts");
+	if (!await X(o)) return;
+	let s = await n.readFile(o, "utf-8");
+	for (let t of e) s.includes(`from "${t.from}"`) || (s = Tr(s, t), s = Er(s, t));
+	await X(a.resolve(r, i, "src/libs/websocket/ws-authenticate.ts")) && (s = Dr(s)), await n.writeFile(o, s, "utf-8");
+}
+function Tr(e, t) {
+	let n = `import { ${t.import} } from "${t.from}";`, r = e.lastIndexOf("from \"./");
+	if (r !== -1) {
+		let t = e.indexOf("\n", r);
+		return t === -1 ? e : e.slice(0, t + 1) + n + "\n" + e.slice(t + 1);
+	}
+	let i = e.indexOf("const sockets");
+	return i === -1 ? e : e.slice(0, i) + n + "\n\n" + e.slice(i);
+}
+function Er(e, t) {
+	let n = `.socket("${t.prefix}", ${t.import})`, r = e.match(/\.socket\([^)]+\);/g);
+	if (r) {
+		let t = r[r.length - 1], i = e.lastIndexOf(t) + t.length - 1;
+		return e.slice(0, i) + "\n  " + n + ";" + e.slice(i + 1);
+	}
+	return e.replace(/new SocketRouter\([^)]*\);/, (e) => `new SocketRouter(${e.slice(17, e.length - 2)})\n  ${n};`);
+}
+function Dr(e) {
+	if (e.includes("wsAuthenticate")) return e;
+	let t = e.indexOf("from \"@backend/libs/websocket/socket-router\""), n = e;
+	if (t !== -1) {
+		let e = n.indexOf("\n", t);
+		n = n.slice(0, e + 1) + "import { wsAuthenticate } from \"@backend/libs/websocket/ws-authenticate\";\n" + n.slice(e + 1);
+	}
+	return n.replace("new SocketRouter()", "new SocketRouter({ authenticate: wsAuthenticate })");
+}
+async function Or(e, t, r) {
+	let i = a.resolve(r, Z("{{backend.utils}}", t), "frontend-url/frontend-url.ts");
+	if (!await X(i)) return;
+	let o = await n.readFile(i, "utf-8");
+	for (let t of e) o.includes(`"${t.path}"`) || (o = kr(o, t));
+	await n.writeFile(i, o, "utf-8");
+}
+function kr(e, t) {
+	let n = `  "${t.path}": ${t.search};`, r = e.indexOf("type RouteDefinitions = {");
+	if (r === -1) return e;
+	let i = e.indexOf("};", r);
+	return i === -1 ? e : e.slice(0, i) + n + "\n" + e.slice(i);
+}
+var Ar = "import { type LucideIcon } from \"lucide-react\";\n\n/* -------------------------------------------------------------------------------------------------\n * Types\n * -----------------------------------------------------------------------------------------------*/\n\nexport type NavItem = {\n  label: string;\n  icon: LucideIcon;\n  to: string;\n  params?: Record<string, string>;\n};\n\nexport type NavSection = {\n  label: string;\n  icon: LucideIcon;\n  items: NavItem[];\n};\n\nexport type NavSectionLink = NavSection & { to: string; params?: Record<string, string> };\n\nexport type NavEntry = NavSection | NavSectionLink;\n\n/* -------------------------------------------------------------------------------------------------\n * Navigation\n * -----------------------------------------------------------------------------------------------*/\n\nexport const primaryNav: NavEntry[] = [];\n\nexport const secondaryNav: NavEntry[] = [];\n\nexport const tertiaryNav: NavEntry[] = [];\n\nexport const settingsNav: NavEntry[] = [];\n", jr = {
+	primary: "primaryNav",
+	secondary: "secondaryNav",
+	tertiary: "tertiaryNav",
+	settings: "settingsNav"
+};
+async function Mr(e, t, r) {
+	let i = Z("{{frontend.root}}", t), o = a.resolve(r, i, "src/constants/nav.constants.ts"), s;
+	await X(o) ? s = await n.readFile(o, "utf-8") : (await n.mkdir(a.dirname(o), { recursive: !0 }), s = Ar);
+	for (let t of e) s.includes(`label: "${t.label}"`) || (s = Pr(s, t), s = Ir(s, t));
+	await n.writeFile(o, s, "utf-8");
+}
+function Nr(e) {
+	let t = [e.icon];
+	if (e.items) for (let n of e.items) t.includes(n.icon) || t.push(n.icon);
+	return t;
+}
+function Pr(e, t) {
+	let n = Nr(t), r = e;
+	for (let e of n) r = Fr(r, e);
+	return r;
+}
+function Fr(e, t) {
+	let n = e.match(/import \{([^}]+)\} from "lucide-react";/);
+	if (!n) return e;
+	let r = n[1].split(",").map((e) => e.trim()).filter(Boolean);
+	if (r.some((e) => e === t)) return e;
+	let i = r.findIndex((e) => e.startsWith("type "));
+	return i === -1 ? r.push(t) : r.splice(i, 0, t), e.replace(n[0], `import { ${r.join(", ")} } from "lucide-react";`);
+}
+function Ir(e, t) {
+	let n = jr[t.group];
+	if (!n) return e;
+	let r = Rr(t), i = RegExp(`export const ${n}: NavEntry\\[\\] = \\[`), a = e.match(i);
+	if (!a) return e;
+	let o = e.indexOf(a[0]) + a[0].length, s = Lr(e, o - 1);
+	return s === -1 ? e : e.slice(o, s).trim() === "" ? e.slice(0, s) + "\n" + r + "\n" + e.slice(s) : e.slice(0, s) + r + "\n" + e.slice(s);
+}
+function Lr(e, t) {
+	let n = 0;
+	for (let r = t; r < e.length; r++) if (e[r] === "[") n++;
+	else if (e[r] === "]" && (n--, n === 0)) return r;
+	return -1;
+}
+function Rr(e) {
+	let t = [];
+	if (t.push("  {"), t.push(`    label: "${e.label}",`), t.push(`    icon: ${e.icon},`), e.to && t.push(`    to: "${e.to}",`), e.params && t.push(`    params: ${e.params},`), e.items && e.items.length > 0) {
+		t.push("    items: [");
+		for (let n of e.items) {
+			let e = [
+				`label: "${n.label}"`,
+				`icon: ${n.icon}`,
+				`to: "${n.to}"`
+			];
+			n.params && e.push(`params: ${n.params}`), t.push(`      { ${e.join(", ")} },`);
+		}
+		t.push("    ],");
+	} else t.push("    items: [],");
+	return t.push("  },"), t.join("\n");
+}
+async function zr(e, t, r) {
+	let i = Z("{{backend.features}}", t), o = a.resolve(r, i, "organizations/modules/setup-organization/steps/index.ts");
+	if (!await X(o)) return;
+	let s = await n.readFile(o, "utf-8");
+	for (let t of e) s.includes(`from "${t.from}"`) || (s = Br(s, t), s = Vr(s, t));
+	await n.writeFile(o, s, "utf-8");
+}
+function Br(e, t) {
+	let n = `import { ${t.import} } from "${t.from}";`, r = e.lastIndexOf("import ");
+	if (r !== -1) {
+		let t = e.indexOf("\n", e.indexOf(";", r));
+		return t === -1 ? e + "\n" + n : e.slice(0, t + 1) + n + "\n" + e.slice(t + 1);
+	}
+	return e.indexOf("type "), n + "\n\n" + e;
+}
+function Vr(e, t) {
+	let n = `  { id: "${t.id}", execute: (ctx) => ${t.import}(ctx) },`, r = e.match(/export const steps:\s*Step\[\]\s*=\s*\[/);
+	if (!r) return e;
+	let i = e.indexOf(r[0]) + r[0].length, a = Hr(e, i - 1);
+	return a === -1 ? e : e.slice(i, a).trim() === "" ? e.slice(0, a) + "\n" + n + "\n" + e.slice(a) : e.slice(0, a) + n + "\n" + e.slice(a);
+}
+function Hr(e, t) {
+	let n = 0;
+	for (let r = t; r < e.length; r++) if (e[r] === "[") n++;
+	else if (e[r] === "]" && (n--, n === 0)) return r;
+	return -1;
+}
+var Ur = "import { type ComponentType } from \"react\";\n\nexport type NavbarAction = {\n  id: string;\n  component: ComponentType;\n};\n\nexport const navbarActions: NavbarAction[] = [];\n";
+async function Wr(e, t, r) {
+	let i = Z("{{frontend.root}}", t), o = a.resolve(r, i, "src/constants/navbar-actions.tsx"), s;
+	await X(o) ? s = await n.readFile(o, "utf-8") : (await n.mkdir(a.dirname(o), { recursive: !0 }), s = Ur);
+	for (let t of e) s.includes(`id: "${t.id}"`) || (s = Gr(s, t), s = Kr(s, t));
+	await n.writeFile(o, s, "utf-8");
+}
+function Gr(e, t) {
+	let n = `import { ${t.import} } from "${t.from}";`;
+	if (e.includes(n)) return e;
+	let r = e.lastIndexOf("import ");
+	if (r === -1) return n + "\n" + e;
+	let i = e.indexOf("\n", r);
+	return i === -1 ? e + "\n" + n : e.slice(0, i + 1) + n + "\n" + e.slice(i + 1);
+}
+function Kr(e, t) {
+	let n = `  { id: "${t.id}", component: ${t.import} },`, r = e.match(/export const navbarActions:\s*NavbarAction\[\]\s*=\s*\[/);
+	if (!r) return e;
+	let i = e.indexOf(r[0]) + r[0].length, a = qr(e, i - 1);
+	return a === -1 ? e : e.slice(i, a).trim() === "" ? e.slice(0, a) + "\n" + n + "\n" + e.slice(a) : e.slice(0, a) + n + "\n" + e.slice(a);
+}
+function qr(e, t) {
+	let n = 0;
+	for (let r = t; r < e.length; r++) if (e[r] === "[") n++;
+	else if (e[r] === "]" && (n--, n === 0)) return r;
+	return -1;
+}
+var Jr = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx"
+]);
+async function Yr(e) {
+	let { files: t, paths: r, projectRoot: i, projectName: o } = e;
+	if (o === "hype-stack") return;
+	let s = `@${o}/`;
+	await Promise.all(t.map(async (e) => {
+		let t = rr(e.target, r, i), o = await n.stat(t).catch(() => null);
+		o?.isDirectory() ? await Xr(t, s) : o?.isFile() && Jr.has(a.extname(t)) && await Zr(t, s);
+	}));
+}
+async function Xr(e, t) {
+	let r = await n.readdir(e, { withFileTypes: !0 });
+	await Promise.all(r.map(async (n) => {
+		let r = a.join(e, n.name);
+		n.isDirectory() ? await Xr(r, t) : n.isFile() && Jr.has(a.extname(n.name)) && await Zr(r, t);
+	}));
+}
+async function Zr(e, t) {
+	let r = await n.readFile(e, "utf-8");
+	if (!r.includes(cr)) return;
+	let i = r.replaceAll(cr, t);
+	await n.writeFile(e, i, "utf-8");
+}
+//#endregion
+//#region src/core/installer.ts
+async function Qr(e, t) {
+	if ((await n.stat(e)).isDirectory()) {
+		await n.mkdir(t, { recursive: !0 });
+		let r = await n.readdir(e, { withFileTypes: !0 });
+		for (let n of r) await Qr(a.join(e, n.name), a.join(t, n.name));
+	} else await n.mkdir(a.dirname(t), { recursive: !0 }), await n.copyFile(e, t);
+}
+async function $r(e) {
+	let { file: t, packDir: n, paths: r, projectRoot: i } = e, a = ir(t.source, n), o = rr(t.target, r, i);
+	return {
+		sourcePath: a,
+		targetPath: o,
+		sourceExists: await X(a) || await Y(a),
+		targetExists: await X(o) || await Y(o)
+	};
+}
+async function ei(e) {
+	let { file: t, packDir: r, paths: i, projectRoot: a } = e, { sourcePath: o, targetPath: s, sourceExists: c, targetExists: l } = await $r({
+		file: t,
+		packDir: r,
+		paths: i,
+		projectRoot: a
+	});
+	if (!c) return `${t.source}: Source not found (${o})`;
+	switch (t.strategy) {
+		case "create":
+		case "skip-if-exists": return null;
+		case "merge": return !l || !t.marker || (await n.readFile(s, "utf-8")).includes(t.marker) ? null : `${t.target}: Marker "${t.marker}" not found`;
+		default: return `${t.target}: Unknown strategy: ${String(t.strategy)}`;
+	}
+}
+async function ti(e) {
+	let { file: t, packDir: r, paths: i, projectRoot: a, force: o } = e, { sourcePath: s, targetPath: c, sourceExists: l, targetExists: u } = await $r({
+		file: t,
+		packDir: r,
+		paths: i,
+		projectRoot: a
+	});
+	if (!l) return {
+		status: "error",
+		path: t.source,
+		reason: "Source not found"
+	};
+	switch (t.strategy) {
+		case "create": return u && !o ? {
+			status: "skipped",
+			path: t.target,
+			reason: "Already exists"
+		} : (await Qr(s, c), {
+			status: "installed",
+			path: t.target
+		});
+		case "skip-if-exists": return u ? {
+			status: "skipped",
+			path: t.target,
+			reason: "Already exists (skip-if-exists)"
+		} : (await Qr(s, c), {
+			status: "installed",
+			path: t.target
+		});
+		case "merge": {
+			if (!u) return await Qr(s, c), {
+				status: "installed",
+				path: t.target
+			};
+			let e = await n.readFile(s, "utf-8"), r = await n.readFile(c, "utf-8");
+			if (t.marker) {
+				let i = r.indexOf(t.marker);
+				if (i === -1) return {
+					status: "error",
+					path: t.target,
+					reason: `Marker "${t.marker}" not found`
+				};
+				let a = r.slice(0, i) + e + r.slice(i);
+				await n.writeFile(c, a);
+			} else {
+				let t = r + "\n" + e;
+				await n.writeFile(c, t);
+			}
+			return {
+				status: "installed",
+				path: t.target
+			};
+		}
+		default: return {
+			status: "error",
+			path: t.target,
+			reason: `Unknown strategy: ${String(t.strategy)}`
+		};
+	}
+}
+async function ni(e) {
+	let { manifest: t, config: n, projectRoot: r, force: i, packDir: a } = e, o = n.paths;
+	if (!o) throw Error("stack.json is missing 'paths' configuration. Run 'hype-stack init' to set it up.");
+	let s = [];
+	for (let e of t.files) {
+		let t = await ei({
+			file: e,
+			packDir: a,
+			paths: o,
+			projectRoot: r,
+			force: i
+		});
+		t && s.push(t);
+	}
+	return s;
+}
+async function ri(e) {
+	let { manifest: t, config: n, projectRoot: r, force: i, packDir: a } = e, o = n.paths;
+	if (!o) throw Error("stack.json is missing 'paths' configuration. Run 'hype-stack init' to set it up.");
+	let s = {
+		installed: [],
+		skipped: [],
+		errors: []
+	};
+	for (let e of t.files) {
+		let t = await ti({
+			file: e,
+			packDir: a,
+			paths: o,
+			projectRoot: r,
+			force: i
+		});
+		switch (t.status) {
+			case "installed":
+				s.installed.push(t.path);
+				break;
+			case "skipped":
+				s.skipped.push(`${t.path} (${t.reason})`);
+				break;
+			case "error":
+				s.errors.push(`${t.path}: ${t.reason}`);
+				break;
+		}
+	}
+	return await Yr({
+		files: t.files,
+		paths: o,
+		projectRoot: r,
+		projectName: n.name
+	}), t.env && t.env.length > 0 && await lr(t.env, o, r), t.routes && t.routes.length > 0 && await mr(t.routes, o, r), t.context && t.context.length > 0 && await _r(t.context, o, r), t.sockets && t.sockets.length > 0 && await wr(t.sockets, o, r), t.enums && t.enums.length > 0 && await Sr(t.enums, o, r), t.frontendRoutes && t.frontendRoutes.length > 0 && await Or(t.frontendRoutes, o, r), t.nav && t.nav.length > 0 && await Mr(t.nav, o, r), t.navbarActions && t.navbarActions.length > 0 && await Wr(t.navbarActions, o, r), t.onboardingSteps && t.onboardingSteps.length > 0 && await zr(t.onboardingSteps, o, r), s;
+}
+async function ii(e) {
+	let { packs: t, config: n, projectRoot: r, force: i } = e, a = [];
+	for (let e of t) {
+		let t = await ni({
+			manifest: e.manifest,
+			config: n,
+			projectRoot: r,
+			force: i,
+			packDir: e.packDir
+		});
+		for (let n of t) a.push(`${e.manifest.name}: ${n}`);
+	}
+	if (a.length > 0) return {
+		installed: [],
+		skipped: [],
+		errors: a,
+		appliedPacks: [],
+		aborted: !0,
+		config: n
+	};
+	let o = [], s = [], c = [], l = [], u = n;
+	for (let e of t) {
+		let t = await ri({
+			manifest: e.manifest,
+			config: u,
+			projectRoot: r,
+			force: i,
+			packDir: e.packDir
+		});
+		o.push(...t.installed), s.push(...t.skipped), c.push(...t.errors), u = await ai(u, e.manifest.name, r), l.push(e.manifest.name);
+	}
+	return {
+		installed: o,
+		skipped: s,
+		errors: c,
+		appliedPacks: l,
+		aborted: !1,
+		config: u
+	};
+}
+async function ai(e, t, n) {
+	let r = {
+		...e,
+		installedPacks: [...e.installedPacks ?? [], t]
+	};
+	return await Xn(n, r), r;
+}
+//#endregion
+//#region src/core/npm-deps.ts
+function oi(e, t) {
+	let n = [], r = [];
+	if (!e) return {
+		errors: n,
+		operations: r
+	};
+	for (let [i, a] of Object.entries(e)) {
+		let e = t[i];
+		if (!e?.root) {
+			n.push(`Unknown stack app "${i}" for dependencies_npm - no paths.${i}.root in stack.json.`);
+			continue;
+		}
+		let o = [];
+		for (let [e, t] of Object.entries(a)) {
+			let r = t.trim();
+			if (!r) {
+				n.push(`Empty version range for npm package "${e}" under dependencies_npm.${i}.`);
+				continue;
+			}
+			o.push(`${e}@${r}`);
+		}
+		o.length > 0 && r.push({
+			relativeDir: e.root,
+			specs: o
+		});
+	}
+	return {
+		errors: n,
+		operations: r
+	};
+}
+function si(e) {
+	let t = {};
+	for (let n of e) if (n) for (let [e, r] of Object.entries(n)) t[e] = {
+		...t[e],
+		...r
+	};
+	return t;
+}
+async function ci(e, t, n = J) {
+	let r = [];
+	for (let i of e) {
+		let e = a.join(t, i.relativeDir);
+		if (!await X(a.join(e, "package.json"))) {
+			r.push(`Cannot install npm dependencies under "${i.relativeDir}": package.json not found.`);
+			continue;
+		}
+		let o = a.normalize(i.relativeDir), s;
+		try {
+			s = await n("pnpm", [
+				"add",
+				...i.specs,
+				"--dir",
+				o
+			], { cwd: t });
+		} catch (e) {
+			let t = e instanceof Error ? e.message : String(e);
+			r.push(`pnpm add failed for "${i.relativeDir}": ${t}`);
+			continue;
+		}
+		if (s.exitCode !== 0) {
+			let e = s.stderr.trim() || s.stdout.trim() || `(exit ${String(s.exitCode)})`;
+			r.push(`pnpm add failed for "${i.relativeDir}": ${e}`);
+		}
+	}
+	return {
+		ok: r.length === 0,
+		errors: r
+	};
+}
+//#endregion
+//#region src/core/resolve.ts
+function li(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) t.set(n.name, {
+		name: n.name,
+		dependencies: n.dependencies
+	});
+	return t;
+}
+function ui(e, t, n = /* @__PURE__ */ new Set()) {
+	let r = /* @__PURE__ */ new Set();
+	function i(e) {
+		if (n.has(e)) return [];
+		if (r.has(e)) throw Error(`Circular dependency detected: ${e}`);
+		r.add(e);
+		let a = t.get(e);
+		if (!a) throw Error(`Pack "${e}" not found in registry`);
+		let o = [];
+		for (let e of a.dependencies) o.push(...i(e));
+		return n.add(e), o.push(e), o;
+	}
+	return i(e);
+}
+function di(e, t, n = []) {
+	let r = new Set(n), i = new Set(n), a = [];
+	for (let n of e) {
+		let e = ui(n, t, new Set(i));
+		for (let t of e) i.has(t) || (i.add(t), a.push(t));
+	}
+	return {
+		order: a,
+		alreadyInstalled: e.filter((e) => r.has(e))
+	};
+}
+function fi(e) {
+	let { order: t, graph: n, isLocked: r, installed: i = [] } = e, a = new Set(i), o = /* @__PURE__ */ new Set();
+	for (let e of t) {
+		let t = n.get(e)?.dependencies.some((e) => !a.has(e) && o.has(e)) ?? !1;
+		(r(e) || t) && o.add(e);
+	}
+	return {
+		installable: t.filter((e) => !o.has(e)),
+		blocked: t.filter((e) => o.has(e))
+	};
+}
+//#endregion
+//#region src/ui/banner.ts
+var pi = [
+	" ██╗  ██╗ ██╗   ██╗ ██████╗  ███████╗",
+	" ██║  ██║ ╚██╗ ██╔╝ ██╔══██╗ ██╔════╝",
+	" ███████║  ╚████╔╝  ██████╔╝ █████╗  ",
+	" ██╔══██║   ╚██╔╝   ██╔═══╝  ██╔══╝  ",
+	" ██║  ██║    ██║    ██║      ███████╗",
+	" ╚═╝  ╚═╝    ╚═╝    ╚═╝      ╚══════╝"
+], mi = [
+	" ███████╗ ████████╗  █████╗   ██████╗ ██╗  ██╗",
+	" ██╔════╝ ╚══██╔══╝ ██╔══██╗ ██╔════╝ ██║ ██╔╝",
+	" ███████╗    ██║    ███████║ ██║      █████╔╝ ",
+	" ╚════██║    ██║    ██╔══██║ ██║      ██╔═██╗ ",
+	" ███████║    ██║    ██║  ██║ ╚██████╗ ██║  ██╗",
+	" ╚══════╝    ╚═╝    ╚═╝  ╚═╝  ╚═════╝ ╚═╝  ╚═╝"
+];
+function hi() {
+	console.log();
+	for (let e of pi) console.log(F.orange(e));
+	for (let e of mi) console.log(F.skyBlue(e));
+	console.log(), console.log(`  ${L.spark} ${r.dim("v" + v)}  ${r.dim("·")}  ${oe("Ship web + desktop apps from one codebase")}`), console.log();
+}
+function gi() {
+	console.log(), console.log(`  ${L.bolt} ${F.orange("Hype")}${F.skyBlue("Stack")}  ${r.dim("v" + v)}`), console.log();
+}
+//#endregion
+//#region src/ui/logger.ts
+function _i(e) {
+	t.note(e.map((e) => `${L.arrow} ${e}`).join("\n"), "Next steps");
+}
+function Q() {
+	t.cancel(I.muted("Operation cancelled.")), process.exit(0);
+}
+//#endregion
+//#region src/commands/init.ts
+async function vi(e) {
+	let n = e.cwd ?? process.cwd(), r = e.silent ?? !1;
+	if (r || (gi(), t.intro(I.brandBold("Initialize Hype Stack configuration"))), !await er(n)) {
+		t.log.error(`This doesn't look like a Hype Stack project. ${I.muted("Expected apps/ directory and package.json")}`), t.outro(I.muted(`Run ${I.command("hype-stack create")} to scaffold a new project.`));
+		return;
+	}
+	if (await Yn(n)) {
+		let e = await Jn(n);
+		if (e && !r) {
+			t.log.info(`Found existing ${I.path("stack.json")} for project ${I.highlight(e.name)}`);
+			let n = await t.confirm({
+				message: "Overwrite existing configuration?",
+				initialValue: !1
+			});
+			if (t.isCancel(n) || !n) {
+				t.outro(I.muted("Keeping existing configuration."));
+				return;
+			}
+		}
+	}
+	let i = await Zn(n);
+	if (!r) {
+		let e = Object.entries(i.apps), n = Object.entries(i.packages);
+		if (e.length > 0) {
+			t.log.info(I.bold("Detected apps:"));
+			for (let [n, r] of e) t.log.message(`  ${L.arrow} ${I.highlight(n)} ${I.muted(`→ ${r}`)}`);
+		}
+		if (n.length > 0) {
+			t.log.info(I.bold("Detected packages:"));
+			for (let [e, r] of n) t.log.message(`  ${L.arrow} ${I.highlight(e)} ${I.muted(`→ ${r}`)}`);
+		}
+		e.length === 0 && n.length === 0 && t.log.warn("No apps or packages detected in the workspace.");
+	}
+	let o = (await Hn(a.join(n, "package.json")))?.name?.replace(/^@/, "").replace(/\/source$/, "") ?? "my-app", s = o;
+	if (!r) {
+		let e = await t.text({
+			message: "Project name for stack.json?",
+			placeholder: o,
+			initialValue: o
+		});
+		t.isCancel(e) && Q(), s = e;
+	}
+	await Xn(n, $n(s, i)), r || (t.log.success(`${I.path("stack.json")} written successfully`), t.outro(I.muted("Your project is mapped and ready for Hype Stack CLI commands.")));
+}
+async function yi(e) {
+	await Yn(e) || (t.log.warn(`No ${I.path("stack.json")} found. Let's set one up first.`), await vi({
+		cwd: e,
+		silent: !1
+	}));
+}
+//#endregion
+//#region src/commands/compose.ts
+async function bi(e = {}) {
+	let r = e.cwd ?? process.cwd();
+	gi(), await yi(r), t.intro(I.brandBold("Compose your stack"));
+	let i = await Jn(r);
+	i || (t.cancel("Could not load stack.json. Run 'hype-stack init' first."), process.exit(1)), i.paths || (t.cancel("stack.json is missing `paths`. Run 'hype-stack init' again to regenerate it."), process.exit(1));
+	let a = t.spinner();
+	a.start("Loading packs...");
+	let o;
+	try {
+		o = await or();
+	} catch (e) {
+		a.stop("Failed to load packs"), t.cancel(`Could not reach Hype Stack. Check your connection and try again.\n${xi(e)}`), process.exit(1);
+	}
+	a.stop("Packs loaded");
+	let s = i.installedPacks ?? [], c = new Set(s), l = new Map(o.map((e) => [e.name, e])), u = e.licenseKey ?? process.env.HYPE_STACK_LICENSE_KEY ?? i.licenseKey ?? null, d = (await kn(k()))?.token ?? null, f = await Si(o, c, {
+		token: d,
+		key: u
+	}), p = (e) => {
+		let t = l.get(e);
+		return !t || t.tier === "free" ? "free" : f[e]?.owned ? "owned" : "locked";
+	}, m = (e) => !c.has(e) && p(e) === "locked", h = await wi({
+		packs: o,
+		installedSet: c,
+		stateOf: p,
+		options: e
+	});
+	if (h === null && (t.cancel("Cancelled."), process.exit(0)), h.length === 0) {
+		t.outro(I.muted("No packs selected. Nothing to do."));
+		return;
+	}
+	let g = li(o), _;
+	try {
+		_ = di(h, g, s);
+	} catch (e) {
+		t.cancel(xi(e)), process.exit(1);
+	}
+	if (_.order.length === 0) {
+		t.note(`${_.alreadyInstalled.join(", ")} already installed.`, "Nothing to do"), t.outro(I.muted("Your selection is already part of the project."));
+		return;
+	}
+	let v = fi({
+		order: _.order,
+		graph: g,
+		isLocked: m,
+		installed: s
+	});
+	if (v.blocked.length > 0 && !d && !u) {
+		let e = await zn();
+		e && (d = e, f = await Si(o, c, {
+			token: d,
+			key: u
+		}), v = fi({
+			order: _.order,
+			graph: g,
+			isLocked: m,
+			installed: s
+		}));
+	}
+	if (v.blocked.length > 0 && await Ti(v.blocked, m, l), v.installable.length === 0) {
+		t.outro(I.muted("Nothing left to install once locked packs are removed."));
+		return;
+	}
+	if (Ei(v.installable, l), !e.yes) {
+		let e = await t.confirm({ message: `Install ${v.installable.length} pack${v.installable.length === 1 ? "" : "s"}?` });
+		(t.isCancel(e) || !e) && (t.cancel("Installation cancelled."), process.exit(0));
+	}
+	a.start("Downloading packs...");
+	let y;
+	try {
+		y = await Di(v.installable, {
+			token: d,
+			key: u
+		});
+	} catch (e) {
+		a.stop("Download failed"), t.cancel(xi(e)), process.exit(1);
+	}
+	a.stop(`Downloaded ${y.length} pack${y.length === 1 ? "" : "s"}`);
+	try {
+		a.start("Installing pack files...");
+		let n = await ii({
+			packs: y,
+			config: i,
+			projectRoot: r,
+			force: e.force ?? !1
+		});
+		if (n.aborted) {
+			a.stop("Installation aborted");
+			for (let e of n.errors) t.log.error(e);
+			t.cancel("No files were written. Fix the errors above (or pass --force for existing files) and try again."), process.exit(1);
+		}
+		a.stop("Files installed"), n.installed.length > 0 && t.log.success(`${I.highlight(String(n.installed.length))} files installed`), n.skipped.length > 0 && t.log.warning(`${n.skipped.length} files skipped (use --force to overwrite)`);
+		for (let e of n.errors) t.log.error(e);
+		await Oi({
+			prepared: y,
+			paths: i.paths,
+			cwd: r,
+			spinner: a
+		}), await qn({
+			projectRoot: r,
+			paths: i.paths,
+			skipPrompts: e.yes ?? !1
+		}), ki(y), t.outro(I.brand(`Installed ${n.appliedPacks.join(", ")}.`));
+	} finally {
+		await Promise.all(y.map((e) => n.rm(e.packDir, {
+			recursive: !0,
+			force: !0
+		})));
+	}
+}
+function xi(e) {
+	return e instanceof Error ? e.message : String(e);
+}
+async function Si(e, t, n) {
+	let r = e.filter((e) => e.tier === "paid" && !t.has(e.name)).map((e) => e.name);
+	return r.length === 0 ? {} : sr(r, n).catch(() => ({}));
+}
+function Ci(e, t) {
+	return e === "free" ? I.success("free") : e === "owned" ? I.accent("owned") : `${I.highlight(`$${t}`)} ${I.muted("locked")}`;
+}
+async function wi(e) {
+	let { packs: n, installedSet: r, stateOf: i, options: a } = e;
+	if (a.packs && a.packs.length > 0) {
+		let e = a.packs.filter((e) => !n.some((t) => t.name === e));
+		return e.length > 0 && (t.cancel(`Unknown pack${e.length === 1 ? "" : "s"}: ${e.join(", ")}`), process.exit(1)), a.packs;
+	}
+	let o = n.filter((e) => r.has(e.name));
+	o.length > 0 && t.note(o.map((e) => `  ${I.muted("✓")} ${e.displayName}`).join("\n"), "Already Installed");
+	let s = n.filter((e) => !r.has(e.name));
+	if (s.length === 0) return t.outro(I.muted("Every available pack is already installed.")), [];
+	let c = await t.multiselect({
+		message: "Select packs to add (free packs install without an account)",
+		options: s.map((e) => {
+			let t = i(e.name);
+			return {
+				value: e.name,
+				label: `${e.displayName}  ${Ci(t, e.price)}`,
+				hint: e.description
+			};
+		}),
+		required: !1
+	});
+	return t.isCancel(c) ? null : c;
+}
+async function Ti(e, n, r) {
+	let i = e.filter((e) => n(e)), a = e.filter((e) => !n(e));
+	a.length > 0 && t.log.warning(`Skipping ${a.join(", ")} because ${a.length === 1 ? "it depends" : "they depend"} on a pack you don't own yet.`), await Bn(i.map((e) => r.get(e)).filter((e) => e !== void 0).map((e) => ({
+		name: e.name,
+		displayName: e.displayName,
+		price: e.price
+	})));
+}
+function Ei(e, n) {
+	let r = e.map((e, t) => {
+		let r = n.get(e), i = r ? r.displayName : e;
+		return `  ${I.muted(`${t + 1}.`)} ${I.brand(i)}`;
+	});
+	t.note([
+		"These packs will be installed, in order:",
+		"",
+		...r
+	].join("\n"), "Install Plan");
+}
+async function Di(e, t) {
+	let n = [];
+	for (let r of e) {
+		let e = await tr(r), i = await nr(r, t);
+		if (i.status === "denied") throw Error(`Access to "${r}" was denied (${i.reason}). Try 'hype-stack login' or check your license.`);
+		n.push({
+			manifest: e,
+			packDir: i.packDir
+		});
+	}
+	return n;
+}
+async function Oi(e) {
+	let { prepared: n, paths: r, cwd: i, spinner: a } = e, o = oi(si(n.map((e) => e.manifest.dependencies_npm)), r);
+	if (o.errors.length > 0) {
+		for (let e of o.errors) t.log.error(e);
+		return;
+	}
+	if (o.operations.length === 0) return;
+	a.start("Installing npm dependencies...");
+	let s = await ci(o.operations, i);
+	if (a.stop(s.ok ? "npm dependencies installed" : "npm dependency installation failed"), !s.ok) for (let e of s.errors) t.log.error(e);
+}
+function ki(e) {
+	let n = e.flatMap((e) => e.manifest.postInstall ?? []), r = [...new Set(n)];
+	r.length !== 0 && t.note(r.map((e) => `  ${I.muted("→")} ${e}`).join("\n"), "Next Steps");
+}
+//#endregion
+//#region src/core/clone.ts
+async function Ai(e) {
+	let t = await c(y, {
+		dir: e,
+		force: !0
+	});
+	return {
+		dir: t.dir,
+		source: t.source
+	};
+}
+//#endregion
+//#region src/core/editor-config.ts
+function ji(e) {
+	let t = {
+		globs: [],
+		alwaysApply: !1
+	};
+	if (!e.startsWith("---")) return {
+		frontmatter: t,
+		content: e
+	};
+	let n = e.indexOf("---", 3);
+	if (n === -1) return {
+		frontmatter: t,
+		content: e
+	};
+	let r = e.slice(3, n).trim(), i = e.slice(n + 3).trimStart(), a = r.split("\n"), o = 0;
+	for (; o < a.length;) {
+		let e = a[o].trim();
+		if (e.startsWith("description:")) t.description = e.slice(12).trim();
+		else if (e.startsWith("alwaysApply:")) t.alwaysApply = e.slice(12).trim() === "true";
+		else if (e.startsWith("globs:")) {
+			let n = e.slice(6).trim();
+			if (n) t.globs = n.split(",").map((e) => e.trim()).filter(Boolean);
+			else {
+				let e = [];
+				for (; o + 1 < a.length && a[o + 1].trim().startsWith("- ");) o++, e.push(a[o].trim().slice(2).trim());
+				t.globs = e;
+			}
+		}
+		o++;
+	}
+	return {
+		frontmatter: t,
+		content: i
+	};
+}
+function Mi(e) {
+	return e.frontmatter.globs.length > 0 ? `---\npaths:\n${e.frontmatter.globs.map((e) => `  - "${e}"`).join("\n")}\n---\n\n${e.content}` : e.content;
+}
+function Ni(e) {
+	let t;
+	t = e.frontmatter.alwaysApply ? "always_on" : e.frontmatter.globs.length > 0 ? "glob" : "model_decision";
+	let n = [`trigger: ${t}`];
+	if (t === "glob") {
+		let t = e.frontmatter.globs.map((e) => `  - "${e}"`).join("\n");
+		n.push(`globs:\n${t}`);
+	}
+	return e.frontmatter.description && n.push(`description: ${e.frontmatter.description}`), `---\n${n.join("\n")}\n---\n\n${e.content}`;
+}
+function Pi(e) {
+	return e.frontmatter.globs.length > 0 ? `---\napplyTo: "${e.frontmatter.globs.join(", ")}"\n---\n\n${e.content}` : e.content;
+}
+var Fi = {
+	claude: {
+		rulesDir: ".claude/rules",
+		extension: ".md",
+		convert: Mi
+	},
+	windsurf: {
+		rulesDir: ".windsurf/rules",
+		extension: ".md",
+		convert: Ni
+	},
+	copilot: {
+		rulesDir: ".github/instructions",
+		extension: ".instructions.md",
+		convert: Pi
+	}
+};
+async function Ii(e) {
+	let t = a.join(e, D), r = (await n.readdir(t, { withFileTypes: !0 }).catch(() => [])).filter((e) => e.isFile() && e.name.endsWith(".mdc"));
+	return await Promise.all(r.map(async (e) => {
+		let r = a.join(t, e.name), { frontmatter: i, content: o } = ji(await n.readFile(r, "utf-8"));
+		return {
+			frontmatter: i,
+			content: o,
+			filename: e.name
+		};
+	}));
+}
+async function Li(e, t) {
+	if (t === "cursor") return;
+	let r = Fi[t], i = await Ii(e), o = a.join(e, r.rulesDir);
+	await n.mkdir(o, { recursive: !0 }), await Promise.all(i.map((e) => {
+		let t = r.convert(e), i = e.filename.replace(/\.mdc$/, r.extension);
+		return n.writeFile(a.join(o, i), t, "utf-8");
+	})), await Gn(a.join(e, O)), await Gn(a.join(e, ee));
+}
+//#endregion
+//#region src/core/env-files.ts
+var Ri = [
+	"apps",
+	"packages",
+	"libs",
+	"shared"
+];
+async function zi(e) {
+	let t = await Bi(e);
+	return (await Promise.all(t.map(async (t) => {
+		let r = a.join(a.dirname(t), ".env");
+		return await X(r) ? null : (await n.copyFile(t, r), a.relative(e, r));
+	}))).filter((e) => e !== null).sort();
+}
+async function Bi(e) {
+	let t = [a.join(e, ".env.example")], r = await Promise.all(Ri.map(async (t) => {
+		let r = a.join(e, t);
+		return (await n.readdir(r, { withFileTypes: !0 }).catch(() => [])).filter((e) => e.isDirectory()).map((e) => a.join(r, e.name, ".env.example"));
+	}));
+	return t.push(...r.flat()), (await Promise.all(t.map(async (e) => await X(e) ? e : null))).filter((e) => e !== null);
+}
+//#endregion
+//#region src/core/post-clone.ts
+var $ = "@hype-stack/", Vi = "hype-stack";
+async function Hi(e) {
+	await Gn(a.join(e, ".git"));
+}
+async function Ui(e) {
+	await J("git", ["init"], { cwd: e }), await J("git", ["add", "."], { cwd: e }), await J("git", [
+		"-c",
+		"user.name=Hype Stack CLI",
+		"-c",
+		"user.email=cli@hypestack.dev",
+		"commit",
+		"-m",
+		"Initial commit from Hype Stack CLI"
+	], { cwd: e });
+}
+async function Wi(e, t) {
+	let r = `@${t}/`, i = await Ji(e);
+	for (let e of i) {
+		let t = await Hn(e);
+		if (!t) continue;
+		let i = !1;
+		t.name?.startsWith($) && (t.name = t.name.replace($, r), i = !0), Gi(t.dependencies, r) && (i = !0), Gi(t.devDependencies, r) && (i = !0), t.nx && Ki(t.nx, r) && (i = !0);
+		let a = await n.readFile(e, "utf-8");
+		if (a.includes($)) {
+			let t = a.replaceAll($, r);
+			await n.writeFile(e, t, "utf-8");
+		} else i && await Un(e, t);
+	}
+	await qi(e, t);
+}
+function Gi(e, t) {
+	if (!e) return !1;
+	let n = !1;
+	for (let r of Object.keys(e)) if (r.startsWith($)) {
+		let i = r.replace($, t);
+		e[i] = e[r], delete e[r], n = !0;
+	}
+	return n;
+}
+function Ki(e, t) {
+	if (!e) return !1;
+	let n = !1;
+	if (e.implicitDependencies &&= e.implicitDependencies.map((e) => e.startsWith($) ? (n = !0, e.replace($, t)) : e), e.targets) {
+		for (let r of Object.values(e.targets)) if (r.buildTarget?.includes($) && (r.buildTarget = r.buildTarget.replaceAll($, t), n = !0), r.dependsOn &&= r.dependsOn.map((e) => e.includes($) ? (n = !0, e.replaceAll($, t)) : e), r.configurations) for (let e of Object.values(r.configurations)) e.buildTarget?.includes($) && (e.buildTarget = e.buildTarget.replaceAll($, t), n = !0);
+	}
+	return n;
+}
+async function qi(e, t) {
+	let r = a.join(e, "packages/enums/src/app/index.ts"), i = await n.readFile(r, "utf-8").catch(() => null);
+	if (!i) return;
+	let o = t.split("-").map((e) => e.charAt(0).toUpperCase() + e.slice(1)).join(" "), s = i.replaceAll(`id: "${Vi}"`, `id: "${t}"`).replaceAll(`name: "${Vi}"`, `name: "${t}"`).replace(/name: "Hype Stack"/, `name: "${o}"`).replace(/description: ".*?"/, `description: "${o} application"`);
+	await n.writeFile(r, s, "utf-8");
+}
+async function Ji(e) {
+	let t = [], r = a.join(e, "package.json");
+	(await n.stat(r).catch(() => null))?.isFile() && t.push(r);
+	for (let r of [
+		"apps",
+		"packages",
+		"libs",
+		"shared"
+	]) {
+		let i = a.join(e, r), o = await n.readdir(i, { withFileTypes: !0 }).catch(() => []);
+		for (let e of o) {
+			if (!e.isDirectory()) continue;
+			let r = a.join(i, e.name, "package.json");
+			(await n.stat(r).catch(() => null))?.isFile() && t.push(r);
+		}
+	}
+	return t;
+}
+//#endregion
+//#region src/core/post-setup.ts
+async function Yi() {
+	return (await J("docker", ["info"], { cwd: process.cwd() })).exitCode === 0;
+}
+async function Xi(e) {
+	return X(`${e}/apps/backend/.env`);
+}
+async function Zi(e, n, r) {
+	let i = r ? `Start services with ${I.command("docker compose up -d")}?` : `Docker is not running. Start services with ${I.command("docker compose up -d")}?`, a = n ? !0 : await t.confirm({
+		message: i,
+		initialValue: !0
+	});
+	if (t.isCancel(a) && Q(), !a) return t.log.info(I.muted("Skipping Docker services and database migrations.")), !1;
+	let o = t.spinner();
+	return o.start("Starting Docker services..."), (await J("docker", [
+		"compose",
+		"up",
+		"-d"
+	], { cwd: `${e}/apps/backend` })).exitCode === 0 ? (o.stop(I.success("Docker services started")), !0) : (o.stop(I.warning("Failed to start Docker services")), t.log.warn(I.muted("Run `docker compose up -d` in apps/backend manually to start services.")), t.log.info(I.muted("Skipping database migrations.")), !1);
+}
+async function Qi(e, t = 15, n = 2e3) {
+	for (let r = 0; r < t; r++) {
+		if ((await J("docker", [
+			"compose",
+			"exec",
+			"-T",
+			"postgres",
+			"pg_isready",
+			"-U",
+			"postgres"
+		], { cwd: `${e}/apps/backend` })).exitCode === 0) return !0;
+		await new Promise((e) => setTimeout(e, n));
+	}
+	return !1;
+}
+async function $i(e, n, r = {}) {
+	if (!await Xi(e)) {
+		t.log.warn(`${I.path(".env")} not found in ${I.path("apps/backend")}. Skipping Docker and migrations - configure it first.`);
+		return;
+	}
+	if (!await Zi(e, n, await Yi())) return;
+	let i = t.spinner();
+	if (i.start("Waiting for Postgres to be ready..."), !await Qi(e, r.postgresMaxAttempts ?? 15, r.postgresCheckIntervalMs ?? 2e3)) {
+		i.stop(I.warning("Postgres health check timed out")), t.log.warn(I.muted("Run migrations manually once Postgres is ready: pnpm --filter @internal/backend migration:latest"));
+		return;
+	}
+	i.stop(I.success("Postgres is ready"));
+	let a = n ? !0 : await t.confirm({
+		message: `Run database migrations with ${I.command("prisma migrate deploy")}?`,
+		initialValue: !0
+	});
+	if (t.isCancel(a) && Q(), !a) {
+		t.log.info(I.muted("Skipping database migrations."));
+		return;
+	}
+	let o = t.spinner();
+	if (o.start("Running database migrations..."), (await J("pnpm", [
+		"--filter",
+		"@internal/backend",
+		"migration:latest"
+	], { cwd: e })).exitCode !== 0) {
+		o.stop(I.warning("Migrations failed")), t.log.warn(I.muted("Run `pnpm --filter @internal/backend migration:latest` manually to apply migrations."));
+		return;
+	}
+	o.stop(I.success("Database migrations applied"));
+	let s = t.spinner();
+	if (s.start("Generating Prisma client..."), (await J("pnpm", [
+		"--filter",
+		"@internal/backend",
+		"generate"
+	], { cwd: e })).exitCode !== 0) {
+		s.stop(I.warning("Prisma client generation failed")), t.log.warn(I.muted("Run `pnpm --filter @internal/backend generate` manually."));
+		return;
+	}
+	s.stop(I.success("Prisma client generated"));
+}
+//#endregion
+//#region src/core/readme.ts
+var ea = {
+	cursor: {
+		label: "Cursor",
+		rulesDir: ".cursor/rules"
+	},
+	claude: {
+		label: "Claude Code",
+		rulesDir: ".claude/rules"
+	},
+	windsurf: {
+		label: "Windsurf",
+		rulesDir: ".windsurf/rules"
+	},
+	copilot: {
+		label: "GitHub Copilot",
+		rulesDir: ".github/instructions"
+	}
+}, ta = {
+	backend: "Hono API server (Postgres, Prisma, Kysely, Valkey cache, WorkOS auth)",
+	frontend: "React + Vite app talking to the backend through the typed HyperFetch SDK"
+}, na = {
+	enums: "Shared enums and app config used across apps",
+	cli: "Project tooling and code generators"
+};
+function ra(e) {
+	return e.split(/[-_]/).filter(Boolean).map((e) => e.charAt(0).toUpperCase() + e.slice(1)).join(" ");
+}
+function ia(e, t) {
+	return Object.entries(e).toSorted(([e], [t]) => e.localeCompare(t)).map(([e, n]) => {
+		let r = t[e];
+		return r ? `- \`${n}\` - ${r}` : `- \`${n}\``;
+	});
+}
+function aa(e) {
+	let { projectName: t, editor: n, workspace: r } = e, i = ra(t), a = ea[n], o = !!r.apps.backend, s = ia(r.apps, ta), c = ia(r.packages, na), l = [];
+	s.length > 0 && l.push(...s), c.length > 0 && l.push(...c), l.push("- `stack.json` - Hype Stack workspace config (apps, paths, installed packs)");
+	let u = [];
+	u.push(`# ${i}`), u.push([
+		`${i} is built on [Hype Stack](https://hypestack.dev), a typed full stack template.`,
+		"The backend runs on Hono with Postgres, Prisma, and Kysely. The frontend is React + Vite and",
+		"talks to the API through a fully typed SDK, so types flow end to end with no manual wiring."
+	].join(" ")), u.push([
+		"## Prerequisites",
+		"",
+		"- [Node.js](https://nodejs.org) 20 or newer",
+		"- [pnpm](https://pnpm.io) (this repo uses pnpm workspaces)",
+		"- [Docker](https://www.docker.com) for local Postgres, Valkey, and object storage"
+	].join("\n"));
+	let d = [];
+	d.push([
+		"Install dependencies",
+		"",
+		"```bash",
+		"pnpm install",
+		"```"
+	]);
+	let f = ["```bash"];
+	o && f.push("cp apps/backend/.env.example apps/backend/.env"), r.apps.frontend && f.push("cp apps/frontend/.env.example apps/frontend/.env"), f.push("```"), d.push([
+		"Configure environment variables",
+		"",
+		"Copy the example env files and fill in any required values.",
+		"",
+		...f
+	]), o && (d.push([
+		"Start local services",
+		"",
+		"Postgres, Valkey (Redis compatible), and object storage run in Docker. Ports and",
+		"credentials are defined in `apps/backend/docker-compose.yml` and `apps/backend/.env.example`.",
+		"",
+		"```bash",
+		"cd apps/backend && docker compose up -d && cd ../..",
+		"```"
+	]), d.push([
+		"Set up the database",
+		"",
+		"Apply migrations and generate the Prisma client.",
+		"",
+		"```bash",
+		"pnpm --filter @internal/backend migration:latest",
+		"pnpm --filter @internal/backend generate",
+		"```"
+	])), d.push([
+		"Run the app",
+		"",
+		"```bash",
+		"pnpm dev",
+		"```",
+		"",
+		"Check the `.env` files for the exact URLs and ports."
+	]);
+	let p = d.flatMap((e, t) => {
+		let [n, ...r] = e;
+		return [
+			`### ${t + 1}. ${n}`,
+			"",
+			...r,
+			""
+		];
+	});
+	u.push([
+		"## Getting started",
+		"",
+		...p
+	].join("\n").trimEnd()), u.push([
+		"## Project structure",
+		"",
+		...l
+	].join("\n"));
+	let m = [
+		"Run these from the repo root unless noted otherwise.",
+		"",
+		"| Command | What it does |",
+		"| --- | --- |",
+		"| `pnpm dev` | Start backend and frontend in watch mode |",
+		"| `pnpm build` | Build all apps and packages |",
+		"| `pnpm test` | Run the test suites |",
+		"| `pnpm typecheck` | Type check the whole workspace |",
+		"| `pnpm lint` | Lint the whole workspace |"
+	];
+	return o && m.push("| `pnpm --filter @internal/backend migration:create` | Create a new migration from schema changes |", "| `pnpm --filter @internal/backend migration:latest` | Apply pending migrations |", "| `pnpm --filter @internal/backend generate` | Regenerate the Prisma client |"), u.push([
+		"## Scripts",
+		"",
+		...m
+	].join("\n")), u.push([
+		"## Adding features",
+		"",
+		"Hype Stack ships features as packs (auth, monetization, notifications, and more).",
+		"Pick the ones you want with the CLI:",
+		"",
+		"```bash",
+		"npx hype-stack compose",
+		"```",
+		"",
+		"Installed packs are tracked in `stack.json`."
+	].join("\n")), u.push([
+		"## Editor and AI rules",
+		"",
+		`This project was set up for **${a.label}**. Coding conventions and AI guidance`,
+		`live in \`${a.rulesDir}\`. Keep them up to date as the project grows so the assistant`,
+		"stays useful."
+	].join("\n")), u.join("\n\n") + "\n";
+}
+async function oa(e, t) {
+	let r = a.join(e, "README.md");
+	await n.writeFile(r, aa(t), "utf-8");
+}
+//#endregion
+//#region src/utils/validate.ts
+function sa(e) {
+	if (!e.trim()) return "Project name cannot be empty";
+	if (!w.test(e)) return "Project name must be lowercase, alphanumeric, and may contain hyphens, dots, or underscores";
+	if (e.length > 214) return "Project name is too long (max 214 characters)";
+}
+//#endregion
+//#region src/commands/create.ts
+async function ca(e) {
+	hi(), t.intro(I.brandBold("Create a new Hype Stack project"));
+	let n = e.yes === !0, r;
+	if (n && e.name) {
+		let n = sa(e.name);
+		n && (t.log.error(n), Q()), r = e.name;
+	} else {
+		let n = await t.text({
+			message: "What is your project named?",
+			placeholder: "my-app",
+			initialValue: e.name ?? "",
+			validate: (e) => sa(e ?? "")
+		});
+		t.isCancel(n) && Q(), r = n;
+	}
+	let i;
+	if (n) i = e.directory ?? `./${r}`;
+	else {
+		let n = await t.text({
+			message: "Where should we create it?",
+			placeholder: `./${r}`,
+			initialValue: e.directory ?? `./${r}`
+		});
+		t.isCancel(n) && Q(), i = n;
+	}
+	let o = e.editor && E.includes(e.editor) ? e.editor : null, s;
+	if (o) s = o;
+	else if (n) s = "cursor";
+	else {
+		let e = await t.select({
+			message: "Which code editor do you use?",
+			options: T.map((e) => ({
+				value: e.value,
+				label: e.label,
+				hint: "hint" in e ? e.hint : void 0
+			})),
+			initialValue: "cursor"
+		});
+		t.isCancel(e) && Q(), s = e;
+	}
+	if (!n) {
+		let e = T.find((e) => e.value === s)?.label ?? s, n = await t.confirm({ message: `Create ${I.highlight(r)} in ${I.path(i)} with ${I.highlight(e)} config?` });
+		(t.isCancel(n) || !n) && Q();
+	}
+	let c = a.resolve(i);
+	if (await Y(c) && !await Vn(c)) {
+		let e = await t.confirm({
+			message: `Directory ${I.path(c)} is not empty. Continue anyway?`,
+			initialValue: !1
+		});
+		(t.isCancel(e) || !e) && Q();
+	}
+	let l = t.spinner();
+	l.start("Cloning Hype Stack template..."), await Ai(c), l.stop(I.success("Template cloned"));
+	let u = t.spinner();
+	u.start("Setting up project..."), await Hi(c), await Wi(c, r), await Li(c, s);
+	let d = await Zn(c);
+	await Xn(c, $n(r, d)), await oa(c, {
+		projectName: r,
+		editor: s,
+		workspace: d
+	}), u.stop(I.success("Project configured"));
+	let f = t.spinner();
+	f.start("Installing dependencies..."), (await J("pnpm", ["install"], { cwd: c })).exitCode === 0 ? f.stop(I.success("Dependencies installed")) : (f.stop(I.warning("Dependencies installed with warnings")), t.log.warn(I.muted("You may need to run `pnpm install` manually to resolve issues.")));
+	let p = t.spinner();
+	p.start("Initializing git repository..."), await Ui(c), p.stop(I.success("Git repository initialized with clean history"));
+	let m = t.spinner();
+	m.start("Creating .env files from examples...");
+	let h = await zi(c);
+	if (h.length > 0) {
+		let e = h.length;
+		m.stop(I.success(`Created ${e} .env file${e === 1 ? "" : "s"} from examples`));
+	} else m.stop(I.muted("No .env.example files to copy"));
+	t.log.success(`${I.brandBold("Hype Stack")} project ${I.highlight(r)} is ready!`);
+	let g = a.relative(process.cwd(), c) || ".", _ = [`${I.command(`cd ${g}`)}`];
+	h.length > 0 ? _.push(`Review your ${I.path(".env")} files and fill in any secrets`) : _.push(`Copy ${I.path(".env.example")} to ${I.path(".env")} and configure`), _i(_);
+	let v = n ? !0 : await t.confirm({
+		message: "Would you like to start Docker services and run database migrations now?",
+		initialValue: !0
+	});
+	t.isCancel(v) && Q(), v ? await $i(c, n) : (t.log.info(I.muted("You can start services later:")), _i([
+		`${I.command("docker compose up -d")} ${I.muted("(in apps/backend - start Postgres, Valkey, RustFS)")}`,
+		`${I.command("pnpm --filter @internal/backend migration:latest")} ${I.muted("(apply migrations)")}`,
+		`${I.command("pnpm --filter @internal/backend generate")} ${I.muted("(generate Prisma client)")}`
+	])), _i([`${I.command("pnpm dev")} ${I.muted("(start frontend + backend)")}`]), t.outro(I.muted("Happy building!"));
+}
+//#endregion
+//#region src/commands/login.ts
+async function la() {
+	gi(), t.intro(I.brandBold("Log in to Hype Stack")), t.log.step("Opening your browser to sign in...");
+	let e;
+	try {
+		e = await Rn({ onUrl: (e) => {
+			t.log.info(`If your browser didn't open, visit:\n  ${I.path(e)}`);
+		} });
+	} catch (e) {
+		t.cancel(e instanceof Error ? e.message : String(e)), process.exit(1);
+	}
+	t.outro(I.brand(e.email ? `Logged in as ${e.email}. You can now install packs your organization owns.` : "Logged in. You can now install packs your organization owns."));
+}
+//#endregion
+//#region src/commands/logout.ts
+async function ua() {
+	gi(), t.intro(I.brandBold("Log out of Hype Stack"));
+	let e = k(), n = await kn(e);
+	if (!n) {
+		t.outro(I.muted("You're not logged in."));
+		return;
+	}
+	await xn(n.token).catch(() => null), await jn(e), t.outro(I.brand("Logged out."));
+}
+//#endregion
+//#region src/cli.ts
+function da(e) {
+	if (!e) return;
+	let t = e.split(",").map((e) => e.trim()).filter((e) => e.length > 0);
+	return t.length > 0 ? t : void 0;
+}
+function fa() {
+	let t = new e();
+	return t.name("hype-stack").description("Build with Hype Stack -- templates, components, modules, and more").version(v, "-v, --version"), t.command("create").description("Create a new Hype Stack project").option("-n, --name <name>", "Project name").option("-d, --directory <path>", "Target directory").option("-e, --editor <editor>", "Code editor (cursor, claude, windsurf, copilot)").option("--no-install", "Skip dependency installation").option("-y, --yes", "Skip confirmation prompts (requires --name)").action(async (e) => {
+		await ca({
+			name: e.name,
+			directory: e.directory,
+			install: e.install,
+			editor: e.editor,
+			yes: e.yes
+		});
+	}), t.command("init").description("Initialize stack.json in the current project").action(async () => {
+		await vi({});
+	}), t.command("compose").description("Choose feature packs to add to your project").option("--packs <list>", "Comma-separated pack names (non-interactive)").option("--force", "Overwrite existing files").option("-y, --yes", "Skip confirmation prompts").option("-k, --key <key>", "License key").option("--license-key <key>", "License key (alias for --key)").option("--cwd <path>", "Working directory").action(async (e) => {
+		await bi({
+			packs: da(e.packs),
+			force: e.force,
+			yes: e.yes,
+			licenseKey: e.key ?? e.licenseKey,
+			cwd: e.cwd
+		});
+	}), t.command("login").description("Log in via your browser to install packs your organization owns").action(async () => {
+		await la();
+	}), t.command("logout").description("Log out and remove the saved CLI token").action(async () => {
+		await ua();
+	}), t.command("auth").description("Alias for `login`").action(async () => {
+		await la();
+	}), t;
+}
+//#endregion
+export { bi as a, ca as i, ua as n, yi as o, la as r, vi as s, fa as t };