@hype-stack/cli 0.1.0 → 0.2.1

package/dist/cli-B_p3GdS8.js

@@ -0,0 +1,4845 @@
+import { DEFAULT_THEME as e, THEME_CHOICES as t, getTheme as n, isThemeName as r } from "./themes.js";
+import { Command as i } from "commander";
+import * as a from "@clack/prompts";
+import o from "node:fs/promises";
+import s from "picocolors";
+import c from "node:os";
+import l from "node:path";
+import { exec as u, spawn as d } from "node:child_process";
+import { downloadTemplate as f } from "giget";
+//#region \0rolldown/runtime.js
+var p = Object.create, m = Object.defineProperty, h = Object.getOwnPropertyDescriptor, g = Object.getOwnPropertyNames, _ = Object.getPrototypeOf, v = Object.prototype.hasOwnProperty, y = (e, t) => () => (t || (e((t = { exports: {} }).exports, t), e = null), t.exports), b = (e, t, n, r) => {
+	if (t && typeof t == "object" || typeof t == "function") for (var i = g(t), a = 0, o = i.length, s; a < o; a++) s = i[a], !v.call(e, s) && s !== n && m(e, s, {
+		get: ((e) => t[e]).bind(null, s),
+		enumerable: !(r = h(t, s)) || r.enumerable
+	});
+	return e;
+}, x = (e, t, n) => (n = e == null ? {} : p(_(e)), b(t || !e || !e.__esModule ? m(n, "default", {
+	value: e,
+	enumerable: !0
+}) : n, e)), S = "0.0.1", C = "gh:BetterTyped/hype-stack", w = "stack.json", T = "/schema/stack.json", E = "https://hype-stack.dev", D = "HYPE_STACK_API_URL", O = /^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/, k = [
+	{
+		value: "cursor",
+		label: "Cursor",
+		hint: "default"
+	},
+	{
+		value: "claude",
+		label: "Claude Code"
+	},
+	{
+		value: "windsurf",
+		label: "Windsurf"
+	},
+	{
+		value: "copilot",
+		label: "GitHub Copilot"
+	}
+], ee = k.map((e) => e.value), A = ".cursor/rules", j = ".cursor", te = ".agents";
+function M() {
+	let e = process.env.HYPE_STACK_API_URL;
+	return e ? (ne(e), e.replace(/\/+$/, "")) : E;
+}
+function N() {
+	let e = process.env.HYPE_STACK_WEB_URL;
+	return e ? (ne(e), e.replace(/\/+$/, "")) : M();
+}
+function ne(e) {
+	try {
+		let t = new URL(e);
+		if (!t.protocol.startsWith("http")) throw Error(`${D} must use http or https protocol, got "${t.protocol}"`);
+	} catch (t) {
+		throw t instanceof TypeError ? Error(`${D} is not a valid URL: "${e}"`, { cause: t }) : t;
+	}
+}
+function re() {
+	return `${M()}${T}`;
+}
+//#endregion
+//#region src/ui/theme.ts
+var P = (e) => `\x1b[38;5;208m${e}\x1b[39m`, ie = (e) => `\x1b[38;5;214m${e}\x1b[39m`, F = (e) => `\x1b[38;5;220m${e}\x1b[39m`, ae = (e) => `\x1b[38;5;33m${e}\x1b[39m`, I = (e) => `\x1b[38;5;39m${e}\x1b[39m`, oe = (e) => `\x1b[38;5;81m${e}\x1b[39m`, se = {
+	orange: P,
+	orangeBright: ie,
+	amber: F,
+	deepBlue: ae,
+	skyBlue: I,
+	lightBlue: oe
+}, L = {
+	brand: (e) => P(e),
+	brandBold: (e) => s.bold(P(e)),
+	accent: (e) => I(e),
+	accentBold: (e) => s.bold(I(e)),
+	success: (e) => s.green(e),
+	error: (e) => s.red(e),
+	warning: (e) => s.yellow(e),
+	muted: (e) => s.dim(e),
+	bold: (e) => s.bold(e),
+	highlight: (e) => s.bold(s.white(e)),
+	path: (e) => s.underline(I(e)),
+	command: (e) => s.bold(F(e)),
+	label: (e) => s.dim(s.bold(e))
+}, R = {
+	arrow: P("›"),
+	bullet: L.muted("·"),
+	dash: L.muted("─"),
+	corner: L.muted("╰"),
+	pipe: L.muted("│"),
+	dot: L.muted("•"),
+	spark: F("✦"),
+	sparkSmall: ie("✧"),
+	bolt: F("⚡")
+}, ce = [
+	F,
+	F,
+	ie,
+	P,
+	ae,
+	I,
+	oe,
+	oe
+];
+function le(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 ce[Math.min(Math.floor(r * ce.length), ce.length - 1)](e);
+	}).join("");
+}
+function ue(e, t, n) {
+	return Math.round(e + (t - e) * n);
+}
+function de(e, t) {
+	let { start: n, end: r, angle: i = 1 } = t, a = Math.max(...e.map((e) => e.length), 1), o = Math.max(e.length - 1, 1);
+	return e.map((e, t) => [...e].map((e, s) => {
+		if (e === " ") return e;
+		let c = s / Math.max(a - 1, 1), l = t / o, u = Math.min((c + l * i) / (1 + i), 1);
+		return `\x1b[38;2;${ue(n[0], r[0], u)};${ue(n[1], r[1], u)};${ue(n[2], r[2], u)}m${e}\x1b[39m`;
+	}).join(""));
+}
+//#endregion
+//#region src/core/license.ts
+function fe(e) {
+	return `${N()}/packs/${e}`;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@hyper-fetch+core@8.1.1/node_modules/@hyper-fetch/core/dist/index.mjs
+var pe = /* @__PURE__ */ x((/* @__PURE__ */ y(((e, t) => {
+	t.exports = {};
+})))(), 1), me = Object.create, he = Object.defineProperty, ge = Object.getOwnPropertyDescriptor, _e = Object.getOwnPropertyNames, ve = Object.getPrototypeOf, ye = Object.prototype.hasOwnProperty, be = (e, t) => () => (t || e((t = { exports: {} }).exports, t), t.exports), xe = (e, t, n, r) => {
+	if (t && typeof t == "object" || typeof t == "function") for (var i = _e(t), a = 0, o = i.length, s; a < o; a++) s = i[a], !ye.call(e, s) && s !== n && he(e, s, {
+		get: ((e) => t[e]).bind(null, s),
+		enumerable: !(r = ge(t, s)) || r.enumerable
+	});
+	return e;
+}, Se = (e, t, n) => (n = e == null ? {} : me(ve(e)), xe(t || !e || !e.__esModule ? he(n, "default", {
+	value: e,
+	enumerable: !0
+}) : n, e)), Ce = (e) => `${e.queryKey}_${Date.now().toString(36)}_${Math.random().toString(36).substring(2)}`, we = /* @__PURE__ */ Se((/* @__PURE__ */ be(((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);
+	}
+})))()), Te = (e) => `listen_${String(e)}`, Ee = class extends we.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(Te(e), t), () => {
+		super.off(Te(e), t);
+	});
+	on = (e, t) => (super.on(e, t), super.emit(Te(e), super.listeners(e).length), this);
+	off = (e, t) => (super.off(e, t), super.emit(Te(e), super.listeners(e).length), this);
+	addListener = this.on;
+	removeListener = this.off;
+}, De = class {
+	emitter = new Ee();
+	events = Me(this.emitter);
+	isBrowser;
+	isOnline;
+	isFocused;
+	constructor(e) {
+		this.options = e, this.emitter?.setMaxListeners(1e3);
+		let { initiallyFocused: t = B.initiallyFocused, initiallyOnline: n = B.initiallyOnline } = this.options || B;
+		this.setInitialFocus(t), this.setInitialOnline(n), this.isBrowser = ke();
+	}
+	initialize = () => {
+		let { focusEvent: e = B.focusEvent, onlineEvent: t = B.onlineEvent } = this.options || B;
+		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();
+	};
+}, Oe = () => {
+	try {
+		return !!(window && window.addEventListener);
+	} catch {
+		/* istanbul ignore next */
+		return !1;
+	}
+}, ke = () => {
+	try {
+		return !!(Oe() && window.document && window.document.addEventListener);
+	} catch {
+		/* istanbul ignore next */
+		return !1;
+	}
+}, Ae = (e, t, n) => Oe() ? (window.addEventListener(e, t, n), () => window.removeEventListener(e, t, n)) : () => null, je = (e, t, n) => ke() ? (window.document.addEventListener(e, t, n), () => window.document.removeEventListener(e, t, n)) : () => null, Me = (e) => ({
+	emitFocus: () => {
+		e.emit(z.FOCUS);
+	},
+	emitBlur: () => {
+		e.emit(z.BLUR);
+	},
+	emitOnline: () => {
+		e.emit(z.ONLINE);
+	},
+	emitOffline: () => {
+		e.emit(z.OFFLINE);
+	},
+	onFocus: (t) => (e.on(z.FOCUS, t), () => e.removeListener(z.FOCUS, t)),
+	onBlur: (t) => (e.on(z.BLUR, t), () => e.removeListener(z.BLUR, t)),
+	onOnline: (t) => (e.on(z.ONLINE, t), () => e.removeListener(z.ONLINE, t)),
+	onOffline: (t) => (e.on(z.OFFLINE, t), () => e.removeListener(z.OFFLINE, t))
+}), z = /* @__PURE__ */ function(e) {
+	return e.FOCUS = "focus", e.BLUR = "blur", e.ONLINE = "online", e.OFFLINE = "offline", e;
+}({}), B = {
+	initiallyFocused: !0,
+	initiallyOnline: !0,
+	focusEvent: (e) => {
+		je("visibilitychange", () => e(!0)), Ae("focus", () => e(!0)), Ae("blur", () => e(!1));
+	},
+	onlineEvent: (e) => {
+		Ae("online", () => e(!0)), Ae("offline", () => e(!1));
+	}
+}, Ne = class {
+	emitter = new Ee();
+	events = lt(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);
+			});
+		});
+	};
+}, Pe = () => "loading-event-any", Fe = (e) => `${e}-loading-event`, Ie = (e) => `${e}-loading-cache-event`, Le = (e) => `${e}-loading-event-by-id`, Re = () => "remove-event-any", ze = (e) => `${e}-remove-event`, Be = (e) => `${e}-remove-event-by-id`, Ve = () => "request-abort-any", He = (e) => `${e}-request-abort`, Ue = (e) => `${e}-request-abort-by-id`, We = () => "response-any", Ge = (e) => `${e}-response`, Ke = (e) => `${e}-response-by-id`, qe = () => "request-start-any", Je = (e) => `${e}-request-start`, Ye = (e) => `${e}-request-start-by-id`, Xe = () => "response-start-any", Ze = (e) => `${e}-response-start`, Qe = (e) => `${e}-response-start-by-id`, $e = () => "request-progress-any", et = (e) => `${e}-request-progress`, tt = (e) => `${e}-request-progress-by-id`, nt = () => "response-progress-any", rt = (e) => `${e}-response-progress`, it = (e) => `${e}-response-progress-by-id`, at = () => "request-deduplicated-any", ot = (e) => `${e}-query-request-deduplicated`, st = (e) => `${e}-cache-request-deduplicated`, ct = (e) => `${e}-request-deduplicated-by-id`, lt = (e) => ({
+	emitDeduplicated: (t, n = !1) => {
+		e.emit(at(), t, n), e.emit(ct(t.requestId), t, n), e.emit(st(t.request.cacheKey), t, n), e.emit(ot(t.request.queryKey), t, n);
+	},
+	emitLoading: (t, n = !1) => {
+		e.emit(Pe(), t, n), e.emit(Le(t.requestId), t, n), e.emit(Ie(t.request.cacheKey), t, n), e.emit(Fe(t.request.queryKey), t, n);
+	},
+	emitRequestStart: (t, n = !1) => {
+		e.emit(qe(), t, n), e.emit(Ye(t.requestId), t, n), e.emit(Je(t.request.queryKey), t, n);
+	},
+	emitResponseStart: (t, n = !1) => {
+		e.emit(Xe(), t, n), e.emit(Qe(t.requestId), t, n), e.emit(Ze(t.request.queryKey), t, n);
+	},
+	emitUploadProgress: (t, n = !1) => {
+		e.emit($e(), t, n), e.emit(tt(t.requestId), t, n), e.emit(et(t.request.queryKey), t, n);
+	},
+	emitDownloadProgress: (t, n = !1) => {
+		e.emit(nt(), t, n), e.emit(it(t.requestId), t, n), e.emit(rt(t.request.queryKey), t, n);
+	},
+	emitResponse: (t, n = !1) => {
+		e.emit(We(), t, n), e.emit(Ke(t.requestId), t, n), e.emit(Ge(t.request.cacheKey), t, n);
+	},
+	emitAbort: (t, n = !1) => {
+		e.emit(Ve(), t, n), e.emit(Ue(t.requestId), t, n), e.emit(He(t.request.abortKey), t, n);
+	},
+	emitRemove: (t, n = !1) => {
+		e.emit(Re(), t, n), e.emit(Be(t.requestId), t, n), e.emit(ze(t.request.queryKey), t, n);
+	},
+	onDeduplicated: (t) => (e.on(at(), t), () => e.removeListener(at(), t)),
+	onDeduplicatedByQueue: (t, n) => (e.on(ot(t), n), () => e.removeListener(ot(t), n)),
+	onDeduplicatedByCache: (t, n) => (e.on(st(t), n), () => e.removeListener(st(t), n)),
+	onDeduplicatedById: (t, n) => (e.on(ct(t), n), () => e.removeListener(ct(t), n)),
+	onLoading: (t) => (e.on(Pe(), t), () => e.removeListener(Pe(), t)),
+	onLoadingByQueue: (t, n) => (e.on(Fe(t), n), () => e.removeListener(Fe(t), n)),
+	onLoadingByCache: (t, n) => (e.on(Ie(t), n), () => e.removeListener(Ie(t), n)),
+	onLoadingById: (t, n) => (e.on(Le(t), n), () => e.removeListener(Le(t), n)),
+	onRequestStart: (t) => (e.on(qe(), t), () => e.removeListener(qe(), t)),
+	onRequestStartByQueue: (t, n) => (e.on(Je(t), n), () => e.removeListener(Je(t), n)),
+	onRequestStartById: (t, n) => (e.on(Ye(t), n), () => e.removeListener(Ye(t), n)),
+	onResponseStart: (t) => (e.on(Xe(), t), () => e.removeListener(Xe(), t)),
+	onResponseStartByQueue: (t, n) => (e.on(Ze(t), n), () => e.removeListener(Ze(t), n)),
+	onResponseStartById: (t, n) => (e.on(Qe(t), n), () => e.removeListener(Qe(t), n)),
+	onUploadProgress: (t) => (e.on($e(), t), () => e.removeListener($e(), t)),
+	onUploadProgressByQueue: (t, n) => (e.on(et(t), n), () => e.removeListener(et(t), n)),
+	onUploadProgressById: (t, n) => (e.on(tt(t), n), () => e.removeListener(tt(t), n)),
+	onDownloadProgress: (t) => (e.on(nt(), t), () => e.removeListener(nt(), t)),
+	onDownloadProgressByQueue: (t, n) => (e.on(rt(t), n), () => e.removeListener(rt(t), n)),
+	onDownloadProgressById: (t, n) => (e.on(it(t), n), () => e.removeListener(it(t), n)),
+	onResponse: (t) => (e.on(We(), t), () => e.removeListener(We(), t)),
+	onResponseByCache: (t, n) => (e.on(Ge(t), n), () => e.removeListener(Ge(t), n)),
+	onResponseById: (t, n) => (e.on(Ke(t), n), () => e.removeListener(Ke(t), n)),
+	onAbort: (t) => (e.on(Ve(), t), () => e.removeListener(Ve(), t)),
+	onAbortByKey: (t, n) => (e.on(He(t), n), () => e.removeListener(He(t), n)),
+	onAbortById: (t, n) => (e.on(Ue(t), n), () => e.removeListener(Ue(t), n)),
+	onRemove: (t) => (e.on(Re(), t), () => e.removeListener(Re(), t)),
+	onRemoveByQueue: (t, n) => (e.on(ze(t), n), () => e.removeListener(ze(t), n)),
+	onRemoveById: (t, n) => (e.on(Be(t), n), () => e.removeListener(Be(t), n))
+}), ut = class {
+	logger;
+	level;
+	modules;
+	emitter = new we.default();
+	client;
+	constructor(e) {
+		this.options = e, this.emitter?.setMaxListeners(1e3), this.logger = this.options?.logger || pt, 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 && (mt.indexOf(this.level) <= mt.indexOf(e.level) || this.modules && !this.modules.includes(e.module) || this.logger(e));
+	};
+}, dt = () => `${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`, ft = (e) => e.type === "request" || e.type === "response" ? `${e.extra.request.endpoint}` : `[${e.module}]`, pt = (e) => {
+	let t = gt[e.level], n = _t[e.level], r = `%c[${dt()}]%c${e.title}%c${ft(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);
+}, mt = [
+	"error",
+	"warning",
+	"info",
+	"debug"
+], ht = "padding:2px 5px;", gt = {
+	error: `${ht};background:#db252520;`,
+	warning: `${ht};background:#e1941e20;`,
+	info: `${ht};background:#1e74e120;`,
+	debug: `${ht};background:#00000020;`
+}, _t = {
+	error: "color:#ff3737;",
+	warning: "color:#ffc107;",
+	info: "color:#34a8ff;",
+	debug: "color:#cccccc;"
+}, vt = class extends Error {
+	constructor() {
+		super("Request timeout"), this.name = "TimeoutError";
+	}
+}, yt = class extends Error {
+	constructor() {
+		super("Request aborted"), this.name = "AbortError";
+	}
+}, bt = class extends Error {
+	constructor() {
+		super("Request deleted"), this.name = "DeletedError";
+	}
+}, xt = class extends Error {
+	description;
+	constructor(e) {
+		super("Request processing error"), this.description = e, this.name = "RequestProcessingError";
+	}
+}, St = class extends Error {
+	description;
+	constructor(e) {
+		super("Unexpected error"), this.description = e, this.name = "UnexpectedError";
+	}
+}, V = (e) => e === "timeout" ? new vt() : e === "abort" ? new yt() : e === "deleted" ? new bt() : e === "processing" ? new xt() : new St(), Ct = (e) => {
+	try {
+		return JSON.stringify(e);
+	} catch {
+		return "";
+	}
+}, wt = (e) => {
+	let t = Oe() && 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;
+}, Tt = (e) => Oe() && e instanceof FormData ? e : Ct(e), Et = [
+	"onBeforeSent",
+	"onRequestStart",
+	"onResponseStart",
+	"onUploadProgress",
+	"onDownloadProgress",
+	"onResponse",
+	"onRemove"
+];
+function Dt(e) {
+	let t = {
+		onBeforeSent: [],
+		onRequestStart: [],
+		onResponseStart: [],
+		onUploadProgress: [],
+		onDownloadProgress: [],
+		onResponse: [],
+		onRemove: []
+	};
+	e && Et.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 Et.forEach((n) => {
+				e[n] = [...t[n]];
+			}), e;
+		}
+	};
+}
+var Ot = /* @__PURE__ */ function(e) {
+	return e.GET = "GET", e.POST = "POST", e.PUT = "PUT", e.PATCH = "PATCH", e.DELETE = "DELETE", e;
+}({}), H = (e, t) => t ? `${t}__${e}` : e, kt = (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 "";
+	}
+}, At = ({ loaded: e, total: t }) => !e || !t ? 0 : Number((e * 100 / t).toFixed(0)), jt = (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
+	};
+}, Mt = (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 } = jt(e, t, n);
+	return {
+		progress: At(n),
+		timeLeft: a,
+		sizeLeft: o,
+		total: r,
+		loaded: i,
+		startTimestamp: +e
+	};
+}, Nt = (e) => `${e.method}_${e.requestOptions.endpoint}_${e.cancelable}`, Pt = (e, t) => `${kt(e.method)}_${t ? e.requestOptions.endpoint : kt(e.endpoint)}_${t ? "" : kt(e.queryParams)}`, Ft = (e, t = "auto") => {
+	let { fetchDispatcher: n, submitDispatcher: r } = e.client, i = e.method === Ot.GET, a = t === "auto" && i || t === "fetch";
+	return [a ? n : r, a];
+}, It = async (e, t) => {
+	let n = e.unstable_responseMapper?.(t);
+	return n instanceof Promise ? await n : n || t;
+}, Lt = async (e, t) => {
+	let { client: n } = e, { requestManager: r } = n, [i] = Ft(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: V("deleted"),
+					extra: e.client.adapter.defaultExtra,
+					requestTimestamp: +/* @__PURE__ */ new Date(),
+					responseTimestamp: +/* @__PURE__ */ new Date()
+				}), g();
+			}
+		});
+		function g() {
+			u(), d(), f(), p(), m(), h();
+		}
+	});
+}, Rt = /* @__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;
+}({}), zt = 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 = Dt();
+	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 = Rt.MIN * 5, cache: f = !0, staleTime: p = Rt.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 = Dt(this.$hooks.__snapshot()), r;
+	}
+	abort = () => {
+		let { requestManager: e } = this.client;
+		return e.abortByKey(H(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(H(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(H(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 = H(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 Lt(i, a);
+		let o = i.read();
+		if (n === "cache-first") return o ? It(i, o) : Lt(i, a);
+		if (o) {
+			let e = await It(i, o);
+			return Lt(i, a), e;
+		}
+		return Lt(i, a);
+	};
+	static fromJSON = (t, n) => new e(t, n.requestOptions, n);
+}, Bt = 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 = H(_, 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 = Mt(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 = Mt(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;
+	}, k = (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;
+	}, ee = () => {
+		l ||= +/* @__PURE__ */ new Date();
+		let e = +/* @__PURE__ */ new Date();
+		return T(l, e, {
+			total: f,
+			loaded: f
+		}), e;
+	}, A = (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;
+	}, j = (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;
+	}, te = () => {
+		u ||= +/* @__PURE__ */ new Date();
+		let e = +/* @__PURE__ */ new Date();
+		return E(u, e, {
+			total: p,
+			loaded: p
+		}), e;
+	}, M = 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;
+	}, N = Vt({
+		request: d,
+		requestId: t,
+		startTime: x,
+		logger: c,
+		resolve: n
+	}), ne = ({ status: e, extra: n }) => (c.error({
+		title: "Abort error",
+		type: "request",
+		extra: {
+			request: d,
+			requestId: t
+		}
+	}), N({
+		error: i(V("abort")),
+		status: e,
+		extra: n
+	})), re = ({ status: e, extra: n }) => (c.error({
+		title: "Timeout error",
+		type: "request",
+		extra: {
+			request: d,
+			requestId: t
+		}
+	}), N({
+		error: V("timeout"),
+		status: e,
+		extra: n
+	})), P = ({ status: e, extra: n }) => (c.error({
+		title: "Unexpected error",
+		type: "request",
+		extra: {
+			request: d,
+			requestId: t
+		}
+	}), N({
+		error: V(),
+		status: e,
+		extra: n
+	})), ie = () => a.getAbortController(v, t), F = ({ status: e, extra: n, onAbort: r = () => {} }) => {
+		let i = ie();
+		if (!i) throw new xt("Controller is not found");
+		let o = () => {
+			ne({
+				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 ae = e.client.adapter.unstable_queryParamsMapper(d.queryParams), I = e.client.adapter.unstable_endpointMapper(d.endpoint), oe = e.client.adapter.unstable_headerMapper(d), { url: se } = e.client;
+	return {
+		request: d,
+		requestId: t,
+		url: se,
+		endpoint: I,
+		queryParams: ae,
+		payload: y,
+		headers: oe,
+		adapter: e.client.adapter,
+		adapterOptions: b,
+		getAbortController: ie,
+		getRequestStartTimestamp: S,
+		getResponseStartTimestamp: C,
+		createAbortListener: F,
+		onBeforeRequest: D,
+		onRequestStart: O,
+		onRequestProgress: k,
+		onRequestEnd: ee,
+		onResponseStart: A,
+		onResponseProgress: j,
+		onResponseEnd: te,
+		onSuccess: M,
+		onAbortError: ne,
+		onTimeoutError: re,
+		onUnexpectedError: P,
+		onError: N
+	};
+};
+function Vt({ 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 Ht = 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 xt("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();
+}, Ut = (e) => e, Wt = 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 = wt;
+	unstable_payloadMapper = Tt;
+	unstable_endpointMapper = Ut;
+	unstable_queryParamsMapper = Ut;
+	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 xt(`Adapter ${this.options.name} is not initialized`);
+				if (!this.unstable_fetcher) throw new xt(`Fetcher for ${this.options.name} adapter is not set`);
+				this.client.triggerPlugins("onAdapterFetch", {
+					adapter: this,
+					request: e,
+					requestId: t
+				});
+				let i = await Bt({
+					request: e,
+					requestId: t,
+					resolve: r,
+					internalErrorMapping: this.unstable_internalErrorMapping,
+					onStartTime: (e) => {
+						n = e;
+					}
+				});
+				return e.unstable_mock && e.isMockerEnabled && e.client.isMockerEnabled ? await Ht(i) : this.unstable_fetcher(i);
+			} catch (i) {
+				return Vt({
+					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);
+		});
+	}
+}, Gt = (e) => {
+	try {
+		return JSON.parse(e);
+	} catch {
+		return e;
+	}
+}, Kt = (e) => e ? Gt(e) : V(), qt = (e) => (t) => {
+	let { skipNull: n, skipEmptyString: r } = e;
+	return !(r && t === void 0 || r && t === "" || n && t === null);
+}, U = (e, { encode: t, strict: n }) => t && n ? encodeURIComponent(e).replace(/[!'()*]/g, (e) => `%${e.charCodeAt(0).toString(16).toUpperCase()}`) : t ? encodeURIComponent(e) : e, Jt = (e, t, n) => {
+	let r = !qt(n)(t);
+	return !e || r ? "" : `${U(e, n)}=${U(t instanceof Date ? n.dateParser?.(t) || t.toISOString() : typeof t == "object" && !Array.isArray(t) ? n.objectParser?.(t) || JSON.stringify(t) : String(t), n)}`;
+}, Yt = (e, t, n) => {
+	let { arrayFormat: r, arraySeparator: i } = n;
+	return t.filter(qt(n)).reduce((t, a, o) => {
+		switch (r) {
+			case "index": {
+				let r = `${U(e, n)}[${U(String(o), n)}]=`;
+				t.push(`${r}${U(String(a), n)}`);
+				break;
+			}
+			case "bracket": {
+				let r = `${U(e, n)}[]=`;
+				t.push(`${r}${U(String(a), n)}`);
+				break;
+			}
+			case "comma": {
+				let r = !t.length && `${U(e, n)}=` || "";
+				return [[...t, `${r}${U(String(a), n)}`].join(",")];
+			}
+			case "separator": {
+				let r = !t.length && `${U(e, n)}=` || "";
+				return [[...t, `${r}${U(String(a), n)}`].join(i || "|")];
+			}
+			case "bracket-separator": {
+				let r = !t.length && `${U(e, n)}[]=` || "";
+				return [[...t, `${r}${U(String(a), n)}`].join(i || "|")];
+			}
+			default: {
+				let r = `${U(e, n)}=`;
+				t.push(`${r}${U(String(a), n)}`);
+			}
+		}
+		return t;
+	}, []).join("&");
+}, Xt = (e, t = Tn) => {
+	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) ? Yt(e, n, t) : Jt(e, n, t)).filter(Boolean).join("&");
+	return n ? `?${n}` : "";
+}, Zt = Rt.SEC * 5, W = { headers: {} }, Qt = () => new Wt({
+	name: "http",
+	defaultMethod: Ot.GET,
+	defaultExtra: W,
+	systemErrorStatus: 0,
+	systemErrorExtra: W
+}).setQueryParamsMapper(Xt).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 ? Xt(y) : "", x = `${_.url}${v}${b}`, S = l(), { timeout: C = Zt, streaming: w = !1, ...T } = t || {}, E = !1, D, O = c({
+		status: 0,
+		extra: W
+	});
+	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: Kt(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: Gt(e),
+				status: l,
+				extra: c
+			}) : i({
+				error: Kt(e),
+				status: l,
+				extra: c
+			});
+		}
+	} catch (e) {
+		if (D && clearTimeout(D), O(), S?.signal?.aborted) {
+			E && o({
+				status: 0,
+				extra: W
+			});
+			return;
+		}
+		i({
+			error: e,
+			status: 0,
+			extra: W
+		});
+	}
+}), $t = () => Qt(), en = class {
+	emitter = new Ee();
+	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 = ln(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 = H(n, o), c = this.storage.get(s), l = typeof t == "function" ? t(c || null) : t, u = tn(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 = H(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 zt ? n(H(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();
+	};
+}, tn = (e, t) => {
+	let { data: n, success: r } = t, i = !r && e ? e.data : null, a = n || i;
+	return {
+		...t,
+		data: a
+	};
+}, nn = () => "invalidate", rn = (e) => `${e}_invalidate`, an = () => "delete", on = (e) => `${e}_delete`, sn = (e) => `${e}_cache`, cn = () => "cache", ln = (e) => ({
+	emitCacheData: (t, n = !1) => {
+		e.emit(cn(), t, n), e.emit(sn(t.cacheKey), t, n);
+	},
+	emitInvalidation: (t, n = !1) => {
+		e.emit(nn(), t, n), e.emit(rn(t), n);
+	},
+	emitDelete: (t, n = !1) => {
+		e.emit(an(), t, n), e.emit(on(t), n);
+	},
+	onData: (t) => (e.on(cn(), t), () => e.removeListener(cn(), t)),
+	onDataByKey: (t, n) => (e.on(sn(t), n), () => e.removeListener(sn(t), n)),
+	onInvalidate: (t) => (e.on(nn(), t), () => e.removeListener(nn(), t)),
+	onInvalidateByKey: (t, n) => (e.on(rn(t), n), () => e.removeListener(rn(t), n)),
+	onDelete: (t) => (e.on(an(), t), () => e.removeListener(an(), t)),
+	onDeleteByKey: (t, n) => (e.on(on(t), n), () => e.removeListener(on(t), n))
+}), G = /* @__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;
+}({}), un = (e) => ({
+	emitDrained: (t, n) => {
+		e.emit(fn(), t, n), e.emit(pn(t.queryKey), t, n);
+	},
+	emitQueueStatusChanged: (t, n) => {
+		e.emit(mn(), t, n), e.emit(hn(t.queryKey), t, n);
+	},
+	emitQueueChanged: (t, n) => {
+		e.emit(gn(), t, n), e.emit(_n(t.queryKey), t, n);
+	},
+	onDrained: (t) => (e.on(fn(), t), () => e.removeListener(fn(), t)),
+	onDrainedByKey: (t, n) => (e.on(pn(t), n), () => e.removeListener(pn(t), n)),
+	onQueueStatusChange: (t) => (e.on(mn(), t), () => e.removeListener(mn(), t)),
+	onQueueStatusChangeByKey: (t, n) => (e.on(hn(t), n), () => e.removeListener(hn(t), n)),
+	onQueueChange: (t) => (e.on(gn(), t), () => e.removeListener(gn(), t)),
+	onQueueChangeByKey: (t, n) => (e.on(_n(t), n), () => e.removeListener(_n(t), n))
+}), dn = class {
+	emitter = new Ee();
+	events = un(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 zt);
+	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 = H(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 = H(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 = H(e.queryKey, e.scope), n = this.createStorageItem(e), { requestId: r } = n, [i] = this.getQueue(t).requests.slice(-1), a = bn(e, i);
+		switch (this.logger.debug({
+			title: "Adding request to queue",
+			type: "system",
+			extra: {
+				requestType: a,
+				request: e,
+				requestId: r
+			}
+		}), a) {
+			case G.ONE_BY_ONE: return this.addQueueItem(t, n), this.flushQueue(t), r;
+			case G.PREVIOUS_CANCELED: return this.cancelRunningRequests(t), this.clearQueue(t), this.addQueueItem(t, n), this.flushQueue(t), r;
+			case G.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 = H(a, c), u = H(o, c), { adapter: d, requestManager: f, cache: p, appManager: m } = this.client, h = vn(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 = V("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));
+	};
+}, fn = () => "drained-event", pn = (e) => `${e}-drained-event`, mn = () => "status-event", hn = (e) => `${e}-status-event`, gn = () => "change-event", _n = (e) => `${e}-change-event`, vn = (e, t) => !!(t && e < t), yn = (e, t) => e.deduplicateTime ? +/* @__PURE__ */ new Date() - t.timestamp <= e.deduplicateTime : !0, bn = (e, t) => {
+	let { queued: n, cancelable: r, deduplicate: i } = e, a = t ? yn(e, t) : !1;
+	return n ? G.ONE_BY_ONE : r ? G.PREVIOUS_CANCELED : a && i ? G.DEDUPLICATED : G.ALL_AT_ONCE;
+};
+function xn(e) {
+	return e === "client" || e === "server" ? e : typeof window < "u" && typeof document < "u" ? "client" : "server";
+}
+var Sn = 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;
+}, Cn = 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;
+}, wn = class {
+	url;
+	mode;
+	debug;
+	unstable_onErrorCallbacks = [];
+	unstable_onSuccessCallbacks = [];
+	unstable_onResponseCallbacks = [];
+	unstable_onAuthCallbacks = [];
+	unstable_onRequestCallbacks = [];
+	loggerManager = new ut();
+	requestManager = new Ne();
+	appManager;
+	adapter;
+	cache;
+	fetchDispatcher;
+	submitDispatcher;
+	isMockerEnabled = !0;
+	plugins = [];
+	unstable_abortKeyMapper = Nt;
+	unstable_cacheKeyMapper = Pt;
+	unstable_queryKeyMapper = Pt;
+	unstable_requestIdMapper = Ce;
+	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 = xn(o), this.adapter = $t(), this.appManager = n?.() || new De(), this.cache = r?.() || new en(), this.fetchDispatcher = i?.() || new dn(), this.submitDispatcher = a?.() || new dn(), 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) => Sn(this.unstable_onAuthCallbacks, e);
+	unstable_modifyRequest = async (e) => Sn(this.unstable_onRequestCallbacks, e);
+	unstable_modifyErrorResponse = async (e, t) => Cn(this.unstable_onErrorCallbacks, e, t);
+	unstable_modifySuccessResponse = async (e, t) => Cn(this.unstable_onSuccessCallbacks, e, t);
+	unstable_modifyResponse = async (e, t) => Cn(this.unstable_onResponseCallbacks, e, t);
+	fromJSON = (e) => zt.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 en(), this.appManager = e?.() || new De(), this.fetchDispatcher = n?.() || new dn(), this.submitDispatcher = r?.() || new dn(), 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(H(n, r))) return;
+			let c = Gt(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 zt(this, n);
+		return this.plugins.forEach((e) => e.trigger("onRequestCreate", { request: r })), r;
+	};
+}, Tn = {
+	strict: !0,
+	encode: !0,
+	arrayFormat: "bracket",
+	arraySeparator: "bracket",
+	sort: !1,
+	skipNull: !0,
+	skipEmptyString: !0
+};
+function En(e) {
+	return new wn(e);
+}
+//#endregion
+//#region src/core/client.ts
+var K = En({ url: M() });
+//#endregion
+//#region src/core/auth-api.ts
+async function Dn(e) {
+	let { data: t, success: n } = await K.createRequest()({
+		endpoint: "/auth/cli/whoami",
+		method: "GET"
+	}).setHeaders({ Authorization: `Bearer ${e}` }).send();
+	return !n || !t ? null : t;
+}
+async function On(e) {
+	await K.createRequest()({
+		endpoint: "/auth/cli/token",
+		method: "DELETE"
+	}).setHeaders({ Authorization: `Bearer ${e}` }).send();
+}
+//#endregion
+//#region src/core/auth-store.ts
+var kn = 1, An = "hype-stack", jn = "auth.json";
+function Mn() {
+	let e = process.env.HYPE_STACK_CONFIG_DIR;
+	if (e) return l.join(e, An);
+	let t = c.homedir();
+	if (process.platform === "win32") {
+		let e = process.env.APPDATA ?? l.join(t, "AppData", "Roaming");
+		return l.join(e, An);
+	}
+	if (process.platform === "darwin") return l.join(t, "Library", "Application Support", An);
+	let n = process.env.XDG_CONFIG_HOME ?? l.join(t, ".config");
+	return l.join(n, An);
+}
+function Nn() {
+	return l.join(Mn(), jn);
+}
+async function Pn() {
+	let e = await o.readFile(Nn(), "utf-8").catch(() => null);
+	if (!e) return {
+		version: kn,
+		tokens: {}
+	};
+	let t = JSON.parse(e);
+	return {
+		version: t.version ?? kn,
+		tokens: t.tokens ?? {}
+	};
+}
+async function Fn(e) {
+	let t = Mn();
+	await o.mkdir(t, { recursive: !0 }), await o.writeFile(Nn(), `${JSON.stringify(e, null, 2)}\n`, { mode: 384 });
+}
+async function In(e) {
+	return (await Pn()).tokens[e] ?? null;
+}
+async function Ln(e, t) {
+	let n = await Pn();
+	n.tokens[e] = t, await Fn(n);
+}
+async function Rn(e) {
+	let t = await Pn();
+	e in t.tokens && (delete t.tokens[e], await Fn(t));
+}
+//#endregion
+//#region src/core/device.ts
+function zn() {
+	let e = c.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 Bn() {
+	let e = `${zn()}:${c.hostname()}:${c.platform()}:${c.arch()}`;
+	return (0, pe.createHash)("sha256").update(e).digest("hex").slice(0, 16);
+}
+function Vn() {
+	return `hype-stack/${S} ${c.platform()} ${c.arch()} node/${process.version.slice(1)}`;
+}
+//#endregion
+//#region src/core/open-browser.ts
+function Hn(e) {
+	u(process.platform === "darwin" ? `open "${e}"` : process.platform === "win32" ? `start "" "${e}"` : `xdg-open "${e}"`);
+}
+//#endregion
+//#region src/core/login.ts
+var Un = 300 * 1e3, Wn = (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 Gn(e = {}) {
+	let t = (0, pe.randomBytes)(16).toString("hex"), n = M(), r = pe.default.createServer(), i = await new Promise((n, i) => {
+		let a = setTimeout(() => {
+			o(), i(/* @__PURE__ */ Error("Login timed out. Run `hype-stack login` again."));
+		}, Un);
+		function o() {
+			clearTimeout(a), r.close(), r.closeAllConnections?.();
+		}
+		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",
+					Connection: "close"
+				}), r.end(Wn(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(Vn()), a = `${N()}/cli/authorize?port=${n}&state=${t}&label=${i}`;
+			e.onUrl?.(a), Hn(a);
+		});
+	}), a = await Dn(i).catch(() => null), o = {
+		token: i,
+		email: a?.email,
+		organizationId: a?.organizationId
+	};
+	return await Ln(n, o), o;
+}
+//#endregion
+//#region src/core/access-prompts.ts
+async function Kn() {
+	let e = await a.confirm({ message: "Log in to install packs your organization owns? (opens your browser)" });
+	if (a.isCancel(e) || !e) return null;
+	a.log.step("Opening your browser to sign in...");
+	try {
+		let e = await Gn({ onUrl: (e) => {
+			a.log.info(`If your browser didn't open, visit:\n  ${L.path(e)}`);
+		} });
+		return a.log.success(e.email ? `Logged in as ${e.email}` : "Logged in"), e.token;
+	} catch (e) {
+		return a.log.error(e instanceof Error ? e.message : String(e)), null;
+	}
+}
+async function qn(e) {
+	if (e.length === 0) return;
+	a.note([
+		"These packs need a purchase before they can be installed:",
+		"",
+		...e.map((e) => `  ${L.brand(e.displayName)}  ${L.highlight(`$${e.price}`)}`)
+	].join("\n"), "Locked Packs");
+	let t = await a.confirm({ message: `Open the purchase ${e.length === 1 ? "page" : "pages"} in your browser?` });
+	if (a.isCancel(t) || !t) {
+		a.log.info(L.muted("Run 'hype-stack login' after purchasing, then 'hype-stack compose' again."));
+		return;
+	}
+	for (let t of e) Hn(fe(t.name));
+	a.log.info([
+		L.muted("After purchasing, run:"),
+		`  ${L.highlight("hype-stack login")}      ${L.muted("Save your access")}`,
+		`  ${L.highlight("hype-stack compose")}    ${L.muted("Install the packs")}`
+	].join("\n"));
+}
+//#endregion
+//#region src/utils/exec.ts
+function q(e, t, n) {
+	return new Promise((r, i) => {
+		let a = d(e, t, {
+			cwd: n.cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		}), o = "", s = "";
+		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 (s += 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: s
+			});
+		});
+	});
+}
+//#endregion
+//#region src/utils/fs.ts
+async function Jn(e) {
+	return (await o.stat(e).catch(() => null))?.isDirectory() ?? !1;
+}
+async function J(e) {
+	return (await o.stat(e).catch(() => null))?.isFile() ?? !1;
+}
+async function Yn(e) {
+	return (await o.readdir(e).catch(() => [])).length === 0;
+}
+async function Xn(e) {
+	let t = await o.readFile(e, "utf-8").catch(() => null);
+	return t ? JSON.parse(t) : null;
+}
+async function Zn(e, t) {
+	await o.writeFile(e, JSON.stringify(t, null, 2) + "\n", "utf-8");
+}
+async function Qn(e) {
+	let t = {};
+	if (!await Jn(e)) return t;
+	let n = await o.readdir(e, { withFileTypes: !0 });
+	for (let r of n) r.isDirectory() && await J(l.join(e, r.name, "package.json")) && (t[r.name] = l.relative(l.dirname(e), l.join(e, r.name)));
+	return t;
+}
+async function $n(e) {
+	await o.rm(e, {
+		recursive: !0,
+		force: !0
+	});
+}
+//#endregion
+//#region src/core/codegen.ts
+function er(e) {
+	a.log.info(L.muted("Run database setup yourself when ready:")), a.note([
+		`${L.command(`cd ${e}`)}`,
+		`${L.command("pnpm exec prisma generate")} ${L.muted("(regenerate the Prisma client)")}`,
+		`${L.command("pnpm exec prisma migrate dev")} ${L.muted("(create + apply tables for new packs)")}`
+	].join("\n"), "Database Setup");
+}
+async function tr(e) {
+	let { projectRoot: t, paths: n, skipPrompts: r, runCommand: i = q } = e, o = n.backend.root, s = l.join(t, o);
+	if (!await J(l.join(s, "package.json"))) return;
+	if (r) {
+		er(o);
+		return;
+	}
+	let c = await a.confirm({
+		message: `Run database setup now? (${L.command("prisma generate")} + ${L.command("prisma migrate")})`,
+		initialValue: !0
+	});
+	if (a.isCancel(c) || !c) {
+		er(o);
+		return;
+	}
+	let u = a.spinner();
+	if (u.start("Generating Prisma client..."), (await i("pnpm", [
+		"exec",
+		"prisma",
+		"generate"
+	], { cwd: s })).exitCode !== 0) {
+		u.stop(L.warning("Prisma client generation failed")), er(o);
+		return;
+	}
+	u.stop(L.success("Prisma client generated"));
+	let d = a.spinner();
+	if (d.start("Applying database schema..."), (await i("pnpm", [
+		"exec",
+		"prisma",
+		"migrate",
+		"dev",
+		"--name",
+		"add-packs"
+	], { cwd: s })).exitCode !== 0) {
+		d.stop(L.warning("Database migration failed (is your database running?)")), er(o);
+		return;
+	}
+	d.stop(L.success("Database schema applied"));
+}
+//#endregion
+//#region src/core/stack-config.ts
+async function nr(e) {
+	return Xn(l.join(e, w));
+}
+async function rr(e) {
+	return J(l.join(e, w));
+}
+async function ir(e, t) {
+	await Zn(l.join(e, w), t);
+}
+async function ar(e) {
+	let t = l.join(e, "apps"), n = l.join(e, "packages"), [r, i] = await Promise.all([Qn(t), Qn(n)]);
+	return {
+		apps: r,
+		packages: i
+	};
+}
+function or(e) {
+	let t = e.apps.backend ?? "apps/backend", n = e.apps.frontend ?? "apps/frontend", r = e.apps.admin ?? "apps/admin", i = 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`
+		},
+		admin: {
+			root: r,
+			features: `${r}/src/features`,
+			components: `${r}/src/components`,
+			layouts: `${r}/src/components/layouts`,
+			hooks: `${r}/src/hooks`,
+			utils: `${r}/src/lib`
+		},
+		enums: {
+			root: i,
+			src: `${i}/src`
+		}
+	};
+}
+function sr(e, t) {
+	return {
+		$schema: re(),
+		version: 1,
+		name: e,
+		apps: t.apps,
+		packages: t.packages,
+		paths: or(t),
+		installedPacks: [],
+		licenseKey: null
+	};
+}
+async function cr(e) {
+	let t = l.join(e, "package.json"), n = l.join(e, "apps"), [r, i] = await Promise.all([J(t), Jn(n)]);
+	return r && i;
+}
+function Y(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 lr(e) {
+	let { data: t, error: n, status: r } = await K.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 ur(e, t = {}) {
+	let n = K.createRequest()({
+		endpoint: `/packs/${encodeURIComponent(e)}/download`,
+		method: "POST"
+	}), r = {
+		"X-Device-Id": Bn(),
+		"X-Client-Info": Vn()
+	};
+	t.token && (r.Authorization = `Bearer ${t.token}`);
+	let { data: i, error: a, success: s } = await n.setPayload({ key: t.licenseKey ?? void 0 }).setHeaders(r).send();
+	if (!s || !i) throw Error(`Failed to download pack "${e}": ${String(a)}`);
+	if (!i.ok) return {
+		status: "denied",
+		reason: i.reason,
+		packs: i.packs ?? [],
+		expiresAt: i.expiresAt ?? null
+	};
+	let u = await o.mkdtemp(l.join(c.tmpdir(), `hype-stack-pack-${e}-`));
+	return await Promise.all(i.files.map(async (e) => {
+		let t = l.join(u, ...e.path.split("/"));
+		await o.mkdir(l.dirname(t), { recursive: !0 }), await o.writeFile(t, Buffer.from(e.content, "base64"));
+	})), {
+		status: "ok",
+		packDir: u
+	};
+}
+function dr(e, t, n) {
+	let r = Y(e, t);
+	return l.resolve(n, r);
+}
+function fr(e, t) {
+	return l.join(t, e);
+}
+var pr = K.createRequest()({
+	endpoint: "/packs/list",
+	method: "GET"
+});
+async function mr() {
+	let { data: e, error: t } = await pr.send();
+	if (t || !e) throw Error(`Failed to fetch pack list: ${String(t)}`);
+	return e.packs;
+}
+async function hr(e, t = {}) {
+	if (e.length === 0) return {};
+	let n = K.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 gr = "@hype-stack/";
+function _r(e, t) {
+	return Y(e === "admin" ? "{{admin.root}}" : "{{frontend.root}}", t);
+}
+async function vr(e, t, n) {
+	let r = Y("{{backend.root}}", t), i = l.resolve(n, r, "src/config/env/env.config.ts"), a = l.resolve(n, r, ".env.example"), s = l.resolve(n, r, ".env.test");
+	if (await J(i)) {
+		let t = await o.readFile(i, "utf-8");
+		for (let n of e) t.includes(`from "${n.from}"`) || (t = yr(t, n), t = br(t, n));
+		await o.writeFile(i, t, "utf-8");
+	}
+	if (await J(a)) {
+		let t = await o.readFile(a, "utf-8");
+		for (let n of e) t = xr(t, n);
+		await o.writeFile(a, t, "utf-8");
+	}
+	if (await J(s)) {
+		let t = await o.readFile(s, "utf-8");
+		for (let n of e) t = Sr(t, n);
+		await o.writeFile(s, t, "utf-8");
+	}
+}
+function yr(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 br(e, t) {
+	let n = `.extend(${t.import}.shape)`;
+	if (e.includes(n)) return e;
+	let r = e.indexOf("export const envSchema = z.object({");
+	if (r === -1) return e;
+	let i = 0, a = r + 35 - 1;
+	for (; a < e.length; a++) {
+		let t = e[a];
+		if (t === "{") i++;
+		else if (t === "}" && (i--, i === 0)) break;
+	}
+	if (e[a + 1] !== ")") return e;
+	let o = a + 2;
+	return e.slice(0, o) + n + e.slice(o);
+}
+function xr(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 Sr(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 Cr(e, t, n) {
+	let r = l.resolve(n, Y("{{backend.routes}}", t), "index.ts");
+	if (!await J(r)) return;
+	let i = await o.readFile(r, "utf-8");
+	for (let t of e) i.includes(`from "${t.from}"`) || (i = wr(i, t), i = Tr(i, t));
+	await o.writeFile(r, i, "utf-8");
+}
+function wr(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 Tr(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 Er(e, t, n) {
+	let r = l.resolve(n, Y("{{backend.root}}", t), "src/context.ts");
+	if (!await J(r)) return;
+	let i = await o.readFile(r, "utf-8");
+	for (let t of e) i.includes(`export let ${t.export}`) || (i = Dr(i, t), i = Or(i, t), i = kr(i, t), i = jr(i, t));
+	await o.writeFile(r, i, "utf-8");
+}
+function Dr(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 Or(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 kr(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]));
+	if (i === -1) return e;
+	let a = Ar(e, i);
+	return a === -1 ? e : e.slice(0, a) + n + "\n" + e.slice(a);
+}
+function Ar(e, t) {
+	let n = 0;
+	for (let r = t; r < e.length; r++) {
+		let t = e[r];
+		if (t === "{") n++;
+		else if (t === "}" && (n--, n === 0)) return r;
+	}
+	return -1;
+}
+function jr(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 Mr(e, t, n) {
+	let r = l.resolve(n, Y("{{enums.src}}", t), "index.ts");
+	if (!await J(r)) return;
+	let i = await o.readFile(r, "utf-8");
+	for (let t of e) i.includes(`from "${t.from}"`) || (i = Nr(i, t));
+	await o.writeFile(r, i, "utf-8");
+}
+function Nr(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 Pr(e, t, n) {
+	let r = Y("{{backend.root}}", t), i = l.resolve(n, r, "src/sockets/index.ts");
+	if (!await J(i)) return;
+	let a = await o.readFile(i, "utf-8");
+	for (let t of e) a.includes(`from "${t.from}"`) || (a = Fr(a, t), a = Ir(a, t));
+	await J(l.resolve(n, r, "src/libs/websocket/ws-authenticate.ts")) && (a = Lr(a)), await o.writeFile(i, a, "utf-8");
+}
+function Fr(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 Ir(e, t) {
+	let n = `.socket("${t.prefix}", ${t.import})`, r = e.indexOf("const sockets");
+	if (r === -1) return e;
+	let i = e.indexOf("new SocketRouter", r);
+	if (i === -1) return e;
+	let a = 0, o = !1;
+	for (let t = i; t < e.length; t++) {
+		let r = e[t];
+		if (r === "(" || r === "{" || r === "[") a++, o = !0;
+		else if (r === ")" || r === "}" || r === "]") a--;
+		else if (r === ";" && o && a === 0) return e.slice(0, t) + "\n  " + n + e.slice(t);
+	}
+	return e;
+}
+function Lr(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 Rr(e, t, n) {
+	let r = Y("{{frontend.root}}", t), i = l.resolve(n, r, "src/api/sdk.ts");
+	if (!await J(i)) return;
+	let a = await o.readFile(i, "utf-8");
+	for (let t of e) a.includes(`.$configure(${t.import})`) || (a = zr(a, t), a = Br(a, t));
+	await o.writeFile(i, a, "utf-8");
+}
+function zr(e, t) {
+	let n = `import { ${t.import} } from "${t.from}";`;
+	if (e.includes(n)) return e;
+	let 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 sdk");
+	return i === -1 ? e : e.slice(0, i) + n + "\n\n" + e.slice(i);
+}
+function Br(e, t) {
+	let n = `.$configure(${t.import})`, r = e.indexOf("export const sdk");
+	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 Vr(e, t, n) {
+	let r = l.resolve(n, Y("{{backend.utils}}", t), "frontend-url/frontend-url.ts");
+	if (!await J(r)) return;
+	let i = await o.readFile(r, "utf-8");
+	for (let t of e) i.includes(`"${t.path}"`) || (i = Hr(i, t));
+	await o.writeFile(r, i, "utf-8");
+}
+function Hr(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 Ur = "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", Wr = {
+	primary: "primaryNav",
+	secondary: "secondaryNav",
+	tertiary: "tertiaryNav",
+	settings: "settingsNav"
+};
+async function Gr(e) {
+	let { entries: t, paths: n, projectRoot: r, slot: i = "frontend" } = e, a = _r(i, n), s = l.resolve(r, a, "src/constants/nav.constants.ts"), c;
+	await J(s) ? c = await o.readFile(s, "utf-8") : (await o.mkdir(l.dirname(s), { recursive: !0 }), c = Ur);
+	for (let e of t) c.includes(`label: "${e.label}"`) || (c = Jr(c, e));
+	for (let e of t.toReversed()) c.includes(`label: "${e.label}"`) || (c = Xr(c, e));
+	await o.writeFile(s, c, "utf-8");
+}
+async function Kr(e) {
+	let { postLoginRedirect: t, paths: n, projectRoot: r, slot: i = "frontend" } = e, a = _r(i, n), s = l.resolve(r, a, "src/features/auth/constants/auth.constants.ts");
+	if (!await J(s)) return;
+	let c = await o.readFile(s, "utf-8"), u = /export const POST_LOGIN_REDIRECT_PATH = "[^"]*";/;
+	if (!u.test(c)) return;
+	let d = c.replace(u, `export const POST_LOGIN_REDIRECT_PATH = "${t}";`);
+	await o.writeFile(s, d, "utf-8");
+}
+function qr(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 Jr(e, t) {
+	let n = qr(t), r = e;
+	for (let e of n) r = Yr(r, e);
+	return r;
+}
+function Yr(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 Xr(e, t) {
+	let n = Wr[t.group];
+	if (!n) return e;
+	let r = Qr(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 = Zr(e, o - 1);
+	return s === -1 ? e : e.slice(o, s).trim() === "" ? e.slice(0, o) + "\n" + r + "\n" + e.slice(o) : e.slice(0, o) + "\n" + r + e.slice(o);
+}
+function Zr(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 Qr(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 $r(e, t, n) {
+	let r = Y("{{backend.features}}", t), i = l.resolve(n, r, "organizations/modules/setup-organization/steps/index.ts");
+	if (!await J(i)) return;
+	let a = await o.readFile(i, "utf-8");
+	for (let t of e) a.includes(`from "${t.from}"`) || (a = ei(a, t), a = ti(a, t));
+	await o.writeFile(i, a, "utf-8");
+}
+function ei(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 ti(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 = ni(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 ni(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 ri = "import { type ComponentType } from \"react\";\n\nexport type NavbarAction = {\n  id: string;\n  component: ComponentType;\n};\n\nexport const navbarActions: NavbarAction[] = [];\n\nexport const userMenuActions: NavbarAction[] = [];\n";
+async function ii(e) {
+	await oi({
+		...e,
+		arrayName: "navbarActions"
+	});
+}
+async function ai(e) {
+	await oi({
+		...e,
+		arrayName: "userMenuActions"
+	});
+}
+async function oi({ actions: e, arrayName: t, paths: n, projectRoot: r, slot: i }) {
+	let a = _r(i, n), s = l.resolve(r, a, "src/constants/navbar-actions.tsx"), c;
+	await J(s) ? c = await o.readFile(s, "utf-8") : (await o.mkdir(l.dirname(s), { recursive: !0 }), c = ri);
+	for (let n of e) c = si(c, n), c = ci(c, n, t);
+	await o.writeFile(s, c, "utf-8");
+}
+function si(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 ci(e, t, n) {
+	let r = e.match(RegExp(`export const ${n}:\\s*NavbarAction\\[\\]\\s*=\\s*\\[`));
+	if (!r) return e;
+	let i = e.indexOf(r[0]) + r[0].length, a = li(e, i - 1);
+	if (a === -1) return e;
+	let o = e.slice(i, a);
+	if (o.includes(`id: "${t.id}"`)) return e;
+	let s = `  { id: "${t.id}", component: ${t.import} },`;
+	return o.trim() === "" ? e.slice(0, a) + "\n" + s + "\n" + e.slice(a) : e.slice(0, a) + s + "\n" + e.slice(a);
+}
+function li(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 ui = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx"
+]);
+async function di(e) {
+	let { files: t, paths: n, projectRoot: r, projectName: i } = e;
+	if (i === "hype-stack") return;
+	let a = `@${i}/`;
+	await Promise.all(t.map(async (e) => {
+		let t = dr(e.target, n, r), i = await o.stat(t).catch(() => null);
+		i?.isDirectory() ? await mi(t, a) : i?.isFile() && ui.has(l.extname(t)) && await hi(t, a);
+	}));
+}
+var fi = new Set([
+	".git",
+	"node_modules",
+	"dist",
+	"build",
+	".nx",
+	".next",
+	"coverage"
+]);
+async function pi(e, t) {
+	t !== "hype-stack" && await mi(e, `@${t}/`);
+}
+async function mi(e, t) {
+	let n = await o.readdir(e, { withFileTypes: !0 });
+	await Promise.all(n.map(async (n) => {
+		let r = l.join(e, n.name);
+		if (n.isDirectory()) {
+			if (fi.has(n.name)) return;
+			await mi(r, t);
+		} else n.isFile() && ui.has(l.extname(n.name)) && await hi(r, t);
+	}));
+}
+async function hi(e, t) {
+	let n = await o.readFile(e, "utf-8");
+	if (!n.includes(gr)) return;
+	let r = n.replaceAll(gr, t);
+	await o.writeFile(e, r, "utf-8");
+}
+//#endregion
+//#region src/core/installer.ts
+function gi(e, t) {
+	return e.slot ? t ? t.includes(e.slot) : e.slot === "frontend" : !0;
+}
+async function _i(e, t) {
+	if ((await o.stat(e)).isDirectory()) {
+		await o.mkdir(t, { recursive: !0 });
+		let n = await o.readdir(e, { withFileTypes: !0 });
+		for (let r of n) await _i(l.join(e, r.name), l.join(t, r.name));
+	} else await o.mkdir(l.dirname(t), { recursive: !0 }), await o.copyFile(e, t);
+}
+async function vi(e) {
+	let { file: t, packDir: n, paths: r, projectRoot: i } = e, a = fr(t.source, n), o = dr(t.target, r, i);
+	return {
+		sourcePath: a,
+		targetPath: o,
+		sourceExists: await J(a) || await Jn(a),
+		targetExists: await J(o) || await Jn(o)
+	};
+}
+async function yi(e) {
+	let { file: t, packDir: n, paths: r, projectRoot: i } = e, { sourcePath: a, targetPath: s, sourceExists: c, targetExists: l } = await vi({
+		file: t,
+		packDir: n,
+		paths: r,
+		projectRoot: i
+	});
+	if (!c) return `${t.source}: Source not found (${a})`;
+	switch (t.strategy) {
+		case "create":
+		case "skip-if-exists":
+		case "override": return null;
+		case "merge": return !l || !t.marker || (await o.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 bi(e) {
+	let { file: t, packDir: n, paths: r, projectRoot: i, force: a, overwrite: s } = e, { sourcePath: c, targetPath: l, sourceExists: u, targetExists: d } = await vi({
+		file: t,
+		packDir: n,
+		paths: r,
+		projectRoot: i
+	});
+	if (!u) return {
+		status: "error",
+		path: t.source,
+		reason: "Source not found"
+	};
+	switch (t.strategy) {
+		case "create": {
+			let e = a || (s?.has(l) ?? !1);
+			return d && !e ? {
+				status: "skipped",
+				path: t.target,
+				reason: "Already exists"
+			} : (await _i(c, l), {
+				status: "installed",
+				path: t.target
+			});
+		}
+		case "skip-if-exists": return d ? {
+			status: "skipped",
+			path: t.target,
+			reason: "Already exists (skip-if-exists)"
+		} : (await _i(c, l), {
+			status: "installed",
+			path: t.target
+		});
+		case "override": return await _i(c, l), {
+			status: "installed",
+			path: t.target
+		};
+		case "merge": {
+			if (!d) return await _i(c, l), {
+				status: "installed",
+				path: t.target
+			};
+			let e = await o.readFile(c, "utf-8"), n = await o.readFile(l, "utf-8");
+			if (t.marker) {
+				let r = n.indexOf(t.marker);
+				if (r === -1) return {
+					status: "error",
+					path: t.target,
+					reason: `Marker "${t.marker}" not found`
+				};
+				let i = n.slice(0, r) + e + n.slice(r);
+				await o.writeFile(l, i);
+			} else {
+				let t = n + "\n" + e;
+				await o.writeFile(l, t);
+			}
+			return {
+				status: "installed",
+				path: t.target
+			};
+		}
+		default: return {
+			status: "error",
+			path: t.target,
+			reason: `Unknown strategy: ${String(t.strategy)}`
+		};
+	}
+}
+async function xi(e) {
+	let { packs: t, config: n, projectRoot: r, slotsByPack: i } = e, a = n.paths;
+	if (!a) throw Error("stack.json is missing 'paths' configuration. Run 'hype-stack init' to set it up.");
+	let o = [], s = /* @__PURE__ */ new Set();
+	for (let e of t) {
+		let t = i?.get(e.manifest.name);
+		for (let n of e.manifest.files) {
+			if (n.strategy !== "create" || !gi(n, t)) continue;
+			let { targetPath: i, targetExists: c } = await vi({
+				file: n,
+				packDir: e.packDir,
+				paths: a,
+				projectRoot: r
+			});
+			!c || s.has(i) || (s.add(i), o.push({
+				packName: e.manifest.name,
+				target: n.target,
+				targetPath: i
+			}));
+		}
+	}
+	return o;
+}
+async function Si(e) {
+	let { manifest: t, config: n, projectRoot: r, force: i, packDir: a, slots: o } = e, s = n.paths;
+	if (!s) throw Error("stack.json is missing 'paths' configuration. Run 'hype-stack init' to set it up.");
+	let c = [];
+	for (let e of t.files) {
+		if (!gi(e, o)) continue;
+		let t = await yi({
+			file: e,
+			packDir: a,
+			paths: s,
+			projectRoot: r,
+			force: i
+		});
+		t && c.push(t);
+	}
+	return c;
+}
+async function Ci(e) {
+	let { manifest: t, config: n, projectRoot: r, force: i, overwrite: a, packDir: o, slots: s } = e, c = n.paths;
+	if (!c) throw Error("stack.json is missing 'paths' configuration. Run 'hype-stack init' to set it up.");
+	let l = {
+		installed: [],
+		skipped: [],
+		errors: []
+	}, u = t.files.filter((e) => gi(e, s));
+	for (let e of u) {
+		let t = await bi({
+			file: e,
+			packDir: o,
+			paths: c,
+			projectRoot: r,
+			force: i,
+			overwrite: a
+		});
+		switch (t.status) {
+			case "installed":
+				l.installed.push(t.path);
+				break;
+			case "skipped":
+				l.skipped.push(`${t.path} (${t.reason})`);
+				break;
+			case "error":
+				l.errors.push(`${t.path}: ${t.reason}`);
+				break;
+		}
+	}
+	await di({
+		files: u,
+		paths: c,
+		projectRoot: r,
+		projectName: n.name
+	}), t.env && t.env.length > 0 && await vr(t.env, c, r), t.routes && t.routes.length > 0 && await Cr(t.routes, c, r), t.context && t.context.length > 0 && await Er(t.context, c, r), t.sockets && t.sockets.length > 0 && await Pr(t.sockets, c, r), t.sdkConfigurations && t.sdkConfigurations.length > 0 && await Rr(t.sdkConfigurations, c, r), t.enums && t.enums.length > 0 && await Mr(t.enums, c, r), t.frontendRoutes && t.frontendRoutes.length > 0 && await Vr(t.frontendRoutes, c, r);
+	let d = s && s.length > 0 ? s : ["frontend"];
+	for (let e of d) t.nav && t.nav.length > 0 && await Gr({
+		entries: t.nav,
+		paths: c,
+		projectRoot: r,
+		slot: e
+	}), t.navbarActions && t.navbarActions.length > 0 && await ii({
+		actions: t.navbarActions,
+		paths: c,
+		projectRoot: r,
+		slot: e
+	}), t.userMenuActions && t.userMenuActions.length > 0 && await ai({
+		actions: t.userMenuActions,
+		paths: c,
+		projectRoot: r,
+		slot: e
+	});
+	return t.onboardingSteps && t.onboardingSteps.length > 0 && await $r(t.onboardingSteps, c, r), t.postLoginRedirect && await Kr({
+		postLoginRedirect: t.postLoginRedirect,
+		paths: c,
+		projectRoot: r,
+		slot: d[0]
+	}), l;
+}
+async function wi(e) {
+	let { packs: t, config: n, projectRoot: r, force: i, overwrite: a, slotsByPack: o } = e, s = [];
+	for (let e of t) {
+		let t = o?.get(e.manifest.name), a = await Si({
+			manifest: e.manifest,
+			config: n,
+			projectRoot: r,
+			force: i,
+			packDir: e.packDir,
+			slots: t
+		});
+		for (let t of a) s.push(`${e.manifest.name}: ${t}`);
+	}
+	if (s.length > 0) return {
+		installed: [],
+		skipped: [],
+		errors: s,
+		appliedPacks: [],
+		aborted: !0,
+		config: n
+	};
+	let c = [], l = [], u = [], d = [], f = n;
+	for (let e of t) {
+		let t = o?.get(e.manifest.name), n = await Ci({
+			manifest: e.manifest,
+			config: f,
+			projectRoot: r,
+			force: i,
+			overwrite: a,
+			packDir: e.packDir,
+			slots: t
+		});
+		c.push(...n.installed), l.push(...n.skipped), u.push(...n.errors), f = await Ti(f, e.manifest.name, r), d.push(e.manifest.name);
+	}
+	return {
+		installed: c,
+		skipped: l,
+		errors: u,
+		appliedPacks: d,
+		aborted: !1,
+		config: f
+	};
+}
+async function Ti(e, t, n) {
+	let r = {
+		...e,
+		installedPacks: [...e.installedPacks ?? [], t]
+	};
+	return await ir(n, r), r;
+}
+async function Ei(e) {
+	let { manifest: t, config: n, projectRoot: r, templateDir: i } = e, a = n.paths;
+	if (!a) throw Error("stack.json is missing 'paths' configuration. Run 'hype-stack init' to set it up.");
+	let o = [], s = [];
+	for (let e of t.files) {
+		let t = await bi({
+			file: e,
+			packDir: i,
+			paths: a,
+			projectRoot: r,
+			force: !0,
+			overwrite: /* @__PURE__ */ new Set()
+		});
+		switch (t.status) {
+			case "installed":
+				o.push(t.path);
+				break;
+			case "error":
+				s.push(`${t.path}: ${t.reason}`);
+				break;
+			case "skipped": break;
+		}
+	}
+	return t.frontendRoutes && t.frontendRoutes.length > 0 && await Vr(t.frontendRoutes, a, r), t.nav && t.nav.length > 0 && await Gr({
+		entries: t.nav,
+		paths: a,
+		projectRoot: r
+	}), t.postLoginRedirect && await Kr({
+		postLoginRedirect: t.postLoginRedirect,
+		paths: a,
+		projectRoot: r
+	}), {
+		installed: o,
+		errors: s
+	};
+}
+//#endregion
+//#region src/core/pack-categories.ts
+var Di = [
+	"starter",
+	"layout",
+	"feature"
+], Oi = {
+	starter: "Starter",
+	layout: "Layout",
+	feature: "Features"
+}, ki = new Set(["starter", "layout"]), Ai = "layout-basic";
+function ji(e, t = {}) {
+	let n = [];
+	for (let r of Di) {
+		let i = e.filter((e) => e.category === r);
+		if (i.length === 0) continue;
+		let a = ki.has(r) ? "single" : "multiple";
+		if (r === "layout") {
+			n.push(Mi("frontend", i)), t.adminAvailable && n.push(Mi("admin", i));
+			continue;
+		}
+		n.push({
+			category: r,
+			label: Oi[r],
+			mode: a,
+			packs: i,
+			preselect: null
+		});
+	}
+	return n;
+}
+function Mi(e, t) {
+	let n = t.some((e) => e.name === Ai);
+	return {
+		category: "layout",
+		label: e === "admin" ? "Admin Layout" : "Layout",
+		mode: "single",
+		packs: t,
+		preselect: n ? Ai : null,
+		slot: e
+	};
+}
+//#endregion
+//#region src/core/resolve.ts
+function Ni(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) t.set(n.name, {
+		name: n.name,
+		dependencies: n.dependencies
+	});
+	return t;
+}
+function Pi(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 Fi(e, t, n = []) {
+	let r = new Set(n), i = new Set(n), a = [];
+	for (let n of e) {
+		let e = Pi(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 Ii(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/core/variants.ts
+function Li(e, t = {}) {
+	let n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map();
+	for (let i of e) {
+		let e = t[i.family] ?? i.default;
+		n.set(i.family, e);
+		for (let e of i.variants) r.set(e, i.family);
+	}
+	return {
+		chosen: n,
+		familyOf: r
+	};
+}
+function Ri(e, t, n) {
+	return [...e.map((e) => n.chosen.get(e.family) ?? e.default), ...t];
+}
+function zi(e, t) {
+	let n = t.familyOf.get(e);
+	return n ? t.chosen.get(n) ?? e : e;
+}
+function Bi(e, t) {
+	let n = /* @__PURE__ */ new Map();
+	for (let t of e) t.family && n.set(t.name, t.family);
+	let r = new Set(t), i = /* @__PURE__ */ new Map();
+	for (let [e, t] of n) if (r.has(e)) {
+		if (i.has(t)) {
+			i.delete(t);
+			continue;
+		}
+		i.set(t, e);
+	}
+	return {
+		chosen: i,
+		familyOf: n
+	};
+}
+function Vi(e, t) {
+	return e.map((e) => ({
+		...e,
+		dependencies: e.dependencies.map((e) => zi(e, t))
+	}));
+}
+//#endregion
+//#region src/ui/banner.ts
+var Hi = [
+	" ██╗  ██╗ ██╗   ██╗ ██████╗  ███████╗",
+	" ██║  ██║ ╚██╗ ██╔╝ ██╔══██╗ ██╔════╝",
+	" ███████║  ╚████╔╝  ██████╔╝ █████╗  ",
+	" ██╔══██║   ╚██╔╝   ██╔═══╝  ██╔══╝  ",
+	" ██║  ██║    ██║    ██║      ███████╗",
+	" ╚═╝  ╚═╝    ╚═╝    ╚═╝      ╚══════╝"
+], Ui = [
+	" ███████╗ ████████╗  █████╗   ██████╗ ██╗  ██╗",
+	" ██╔════╝ ╚══██╔══╝ ██╔══██╗ ██╔════╝ ██║ ██╔╝",
+	" ███████╗    ██║    ███████║ ██║      █████╔╝ ",
+	" ╚════██║    ██║    ██╔══██║ ██║      ██╔═██╗ ",
+	" ███████║    ██║    ██║  ██║ ╚██████╗ ██║  ██╗",
+	" ╚══════╝    ╚═╝    ╚═╝  ╚═╝  ╚═════╝ ╚═╝  ╚═╝"
+], Wi = [
+	253,
+	176,
+	21
+], Gi = [
+	245,
+	76,
+	2
+], Ki = 5, qi = [
+	17,
+	103,
+	248
+], Ji = [
+	42,
+	160,
+	250
+], Yi = .2;
+function Xi() {
+	console.log();
+	for (let e of de(Hi, {
+		start: Wi,
+		end: Gi,
+		angle: Ki
+	})) console.log(s.bold(e));
+	for (let e of de(Ui, {
+		start: qi,
+		end: Ji,
+		angle: Yi
+	})) console.log(s.bold(e));
+	console.log(), console.log(`  ${R.spark} ${s.dim("v" + S)}  ${s.dim("·")}  ${le("Ship web + desktop apps from one codebase")}`), console.log();
+}
+function X() {
+	console.log(), console.log(`  ${R.bolt} ${se.orange("Hype")}${se.skyBlue("Stack")}  ${s.dim("v" + S)}`), console.log();
+}
+//#endregion
+//#region src/ui/logger.ts
+function Zi(e) {
+	a.note(e.map((e) => `${R.arrow} ${e}`).join("\n"), "Next steps");
+}
+function Z() {
+	a.cancel(L.muted("Operation cancelled.")), process.exit(0);
+}
+//#endregion
+//#region src/core/clone.ts
+async function Qi(e) {
+	let t = await f(C, {
+		dir: e,
+		force: !0
+	});
+	return {
+		dir: t.dir,
+		source: t.source
+	};
+}
+//#endregion
+//#region src/core/apply-theme.ts
+function $i(e, t) {
+	let n = e.indexOf(t);
+	if (n === -1) return null;
+	let r = e.indexOf("{", n);
+	if (r === -1) return null;
+	let i = 1, a = r + 1;
+	for (; a < e.length && i > 0;) {
+		let t = e[a];
+		t === "{" ? i++ : t === "}" && i--, a++;
+	}
+	return i === 0 ? {
+		bodyStart: r + 1,
+		bodyEnd: a - 1
+	} : null;
+}
+function ea(e, t) {
+	let n = e;
+	for (let [e, r] of Object.entries(t)) {
+		let t = RegExp(`(^[ \\t]*--${ta(e)}[ \\t]*:[ \\t]*)([^;\\n]*);`, "m");
+		n = n.replace(t, (e, t) => `${t}${r};`);
+	}
+	return n;
+}
+function ta(e) {
+	return e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function na(e, t) {
+	let n = $i(e, ":root"), r = $i(e, ".dark"), i = e;
+	if (n) {
+		let e = i.slice(0, n.bodyStart), r = i.slice(n.bodyStart, n.bodyEnd), a = i.slice(n.bodyEnd);
+		i = e + ea(r, t.light) + a;
+	}
+	if (r) {
+		let e = $i(i, ".dark");
+		if (e) {
+			let n = i.slice(0, e.bodyStart), r = i.slice(e.bodyStart, e.bodyEnd), a = i.slice(e.bodyEnd);
+			i = n + ea(r, t.dark) + a;
+		}
+	}
+	return i;
+}
+var ra = "assets/styles.css";
+async function ia(e, t) {
+	let n = l.resolve(e, ra), r;
+	try {
+		r = await o.readFile(n, "utf-8");
+	} catch {
+		return !1;
+	}
+	let i = na(r, t);
+	return i === r || await o.writeFile(n, i, "utf-8"), !0;
+}
+//#endregion
+//#region src/core/editor-config.ts
+function aa(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 oa(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 sa(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 ca(e) {
+	return e.frontmatter.globs.length > 0 ? `---\napplyTo: "${e.frontmatter.globs.join(", ")}"\n---\n\n${e.content}` : e.content;
+}
+var la = {
+	claude: {
+		rulesDir: ".claude/rules",
+		extension: ".md",
+		convert: oa
+	},
+	windsurf: {
+		rulesDir: ".windsurf/rules",
+		extension: ".md",
+		convert: sa
+	},
+	copilot: {
+		rulesDir: ".github/instructions",
+		extension: ".instructions.md",
+		convert: ca
+	}
+};
+async function ua(e) {
+	let t = l.join(e, A), n = (await o.readdir(t, { withFileTypes: !0 }).catch(() => [])).filter((e) => e.isFile() && e.name.endsWith(".mdc"));
+	return await Promise.all(n.map(async (e) => {
+		let n = l.join(t, e.name), { frontmatter: r, content: i } = aa(await o.readFile(n, "utf-8"));
+		return {
+			frontmatter: r,
+			content: i,
+			filename: e.name
+		};
+	}));
+}
+async function da(e, t) {
+	if (t === "cursor") return;
+	let n = la[t], r = await ua(e), i = l.join(e, n.rulesDir);
+	await o.mkdir(i, { recursive: !0 }), await Promise.all(r.map((e) => {
+		let t = n.convert(e), r = e.filename.replace(/\.mdc$/, n.extension);
+		return o.writeFile(l.join(i, r), t, "utf-8");
+	})), await $n(l.join(e, j)), await $n(l.join(e, te));
+}
+//#endregion
+//#region src/core/env-files.ts
+var fa = [
+	"apps",
+	"packages",
+	"libs",
+	"shared"
+];
+async function pa(e) {
+	let t = await ma(e);
+	return (await Promise.all(t.map(async (t) => {
+		let n = l.join(l.dirname(t), ".env");
+		return await J(n) ? null : (await o.copyFile(t, n), l.relative(e, n));
+	}))).filter((e) => e !== null).sort();
+}
+async function ma(e) {
+	let t = [l.join(e, ".env.example")], n = await Promise.all(fa.map(async (t) => {
+		let n = l.join(e, t);
+		return (await o.readdir(n, { withFileTypes: !0 }).catch(() => [])).filter((e) => e.isDirectory()).map((e) => l.join(n, e.name, ".env.example"));
+	}));
+	return t.push(...n.flat()), (await Promise.all(t.map(async (e) => await J(e) ? e : null))).filter((e) => e !== null);
+}
+//#endregion
+//#region src/core/post-clone.ts
+var Q = "@hype-stack/", ha = "hype-stack";
+async function ga(e) {
+	await $n(l.join(e, ".git"));
+}
+async function _a(e) {
+	await q("git", ["init"], { cwd: e }), await q("git", ["add", "."], { cwd: e }), await q("git", [
+		"-c",
+		"user.name=Hype Stack CLI",
+		"-c",
+		"user.email=cli@hype-stack.dev",
+		"commit",
+		"-m",
+		"Initial commit from Hype Stack CLI"
+	], { cwd: e });
+}
+async function va(e, t) {
+	let n = `@${t}/`, r = await Sa(e);
+	for (let e of r) {
+		let t = await Xn(e);
+		if (!t) continue;
+		let r = !1;
+		t.name?.startsWith(Q) && (t.name = t.name.replace(Q, n), r = !0), ya(t.dependencies, n) && (r = !0), ya(t.devDependencies, n) && (r = !0), t.nx && ba(t.nx, n) && (r = !0);
+		let i = await o.readFile(e, "utf-8");
+		if (i.includes(Q)) {
+			let t = i.replaceAll(Q, n);
+			await o.writeFile(e, t, "utf-8");
+		} else r && await Zn(e, t);
+	}
+	await pi(e, t), await xa(e, t);
+}
+function ya(e, t) {
+	if (!e) return !1;
+	let n = !1;
+	for (let r of Object.keys(e)) if (r.startsWith(Q)) {
+		let i = r.replace(Q, t);
+		e[i] = e[r], delete e[r], n = !0;
+	}
+	return n;
+}
+function ba(e, t) {
+	if (!e) return !1;
+	let n = !1;
+	if (e.implicitDependencies &&= e.implicitDependencies.map((e) => e.startsWith(Q) ? (n = !0, e.replace(Q, t)) : e), e.targets) {
+		for (let r of Object.values(e.targets)) if (r.buildTarget?.includes(Q) && (r.buildTarget = r.buildTarget.replaceAll(Q, t), n = !0), r.dependsOn &&= r.dependsOn.map((e) => e.includes(Q) ? (n = !0, e.replaceAll(Q, t)) : e), r.configurations) for (let e of Object.values(r.configurations)) e.buildTarget?.includes(Q) && (e.buildTarget = e.buildTarget.replaceAll(Q, t), n = !0);
+	}
+	return n;
+}
+async function xa(e, t) {
+	let n = l.join(e, "packages/enums/src/app/index.ts"), r = await o.readFile(n, "utf-8").catch(() => null);
+	if (!r) return;
+	let i = t.split("-").map((e) => e.charAt(0).toUpperCase() + e.slice(1)).join(" "), a = r.replaceAll(`id: "${ha}"`, `id: "${t}"`).replaceAll(`name: "${ha}"`, `name: "${t}"`).replace(/name: "Hype Stack"/, `name: "${i}"`).replace(/description: ".*?"/, `description: "${i} application"`);
+	await o.writeFile(n, a, "utf-8");
+}
+async function Sa(e) {
+	let t = [], n = l.join(e, "package.json");
+	(await o.stat(n).catch(() => null))?.isFile() && t.push(n);
+	for (let n of [
+		"apps",
+		"packages",
+		"libs",
+		"shared"
+	]) {
+		let r = l.join(e, n), i = await o.readdir(r, { withFileTypes: !0 }).catch(() => []);
+		for (let e of i) {
+			if (!e.isDirectory()) continue;
+			let n = l.join(r, e.name, "package.json");
+			(await o.stat(n).catch(() => null))?.isFile() && t.push(n);
+		}
+	}
+	return t;
+}
+//#endregion
+//#region src/core/post-setup.ts
+async function Ca() {
+	return (await q("docker", ["info"], { cwd: process.cwd() })).exitCode === 0;
+}
+async function wa(e) {
+	return J(`${e}/apps/backend/.env`);
+}
+async function Ta(e, t, n) {
+	let r = n ? `Start services with ${L.command("docker compose up -d")}?` : `Docker is not running. Start services with ${L.command("docker compose up -d")}?`, i = t ? !0 : await a.confirm({
+		message: r,
+		initialValue: !0
+	});
+	if (a.isCancel(i) && Z(), !i) return a.log.info(L.muted("Skipping Docker services and database migrations.")), !1;
+	let o = a.spinner();
+	return o.start("Starting Docker services..."), (await q("docker", [
+		"compose",
+		"up",
+		"-d"
+	], { cwd: `${e}/apps/backend` })).exitCode === 0 ? (o.stop(L.success("Docker services started")), !0) : (o.stop(L.warning("Failed to start Docker services")), a.log.warn(L.muted("Run `docker compose up -d` in apps/backend manually to start services.")), a.log.info(L.muted("Skipping database migrations.")), !1);
+}
+async function Ea(e, t = 15, n = 2e3) {
+	for (let r = 0; r < t; r++) {
+		if ((await q("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 Da(e, t, n = {}) {
+	if (!await wa(e)) {
+		a.log.warn(`${L.path(".env")} not found in ${L.path("apps/backend")}. Skipping Docker and migrations - configure it first.`);
+		return;
+	}
+	if (!await Ta(e, t, await Ca())) return;
+	let r = a.spinner();
+	if (r.start("Waiting for Postgres to be ready..."), !await Ea(e, n.postgresMaxAttempts ?? 15, n.postgresCheckIntervalMs ?? 2e3)) {
+		r.stop(L.warning("Postgres health check timed out")), a.log.warn(L.muted("Run migrations manually once Postgres is ready: pnpm --filter @internal/backend migration:latest"));
+		return;
+	}
+	r.stop(L.success("Postgres is ready"));
+	let i = t ? !0 : await a.confirm({
+		message: `Run database migrations with ${L.command("prisma migrate deploy")}?`,
+		initialValue: !0
+	});
+	if (a.isCancel(i) && Z(), !i) {
+		a.log.info(L.muted("Skipping database migrations."));
+		return;
+	}
+	let o = a.spinner();
+	if (o.start("Running database migrations..."), (await q("pnpm", [
+		"--filter",
+		"@internal/backend",
+		"migration:latest"
+	], { cwd: e })).exitCode !== 0) {
+		o.stop(L.warning("Migrations failed")), a.log.warn(L.muted("Run `pnpm --filter @internal/backend migration:latest` manually to apply migrations."));
+		return;
+	}
+	o.stop(L.success("Database migrations applied"));
+	let s = a.spinner();
+	if (s.start("Generating Prisma client..."), (await q("pnpm", [
+		"--filter",
+		"@internal/backend",
+		"generate"
+	], { cwd: e })).exitCode !== 0) {
+		s.stop(L.warning("Prisma client generation failed")), a.log.warn(L.muted("Run `pnpm --filter @internal/backend generate` manually."));
+		return;
+	}
+	s.stop(L.success("Prisma client generated"));
+}
+//#endregion
+//#region src/core/readme.ts
+var Oa = {
+	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"
+	}
+}, ka = {
+	backend: "Hono API server (Postgres, Prisma, Kysely, Valkey cache, WorkOS auth)",
+	frontend: "React + Vite app talking to the backend through the typed HyperFetch SDK"
+}, Aa = {
+	enums: "Shared enums and app config used across apps",
+	cli: "Project tooling and code generators"
+};
+function ja(e) {
+	return e.split(/[-_]/).filter(Boolean).map((e) => e.charAt(0).toUpperCase() + e.slice(1)).join(" ");
+}
+function Ma(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 Na(e) {
+	let { projectName: t, editor: n, workspace: r } = e, i = ja(t), a = Oa[n], o = !!r.apps.backend, s = Ma(r.apps, ka), c = Ma(r.packages, Aa), 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://hype-stack.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 Pa(e, t) {
+	let n = l.join(e, "README.md");
+	await o.writeFile(n, Na(t), "utf-8");
+}
+//#endregion
+//#region src/core/tracking.ts
+async function Fa(e) {
+	try {
+		let t = {
+			"X-Device-Id": Bn(),
+			"X-Client-Info": Vn()
+		}, n = await In(M()).catch(() => null);
+		n?.token && (t.Authorization = `Bearer ${n.token}`), await K.createRequest()({
+			endpoint: "/cli/track",
+			method: "POST"
+		}).setPayload({ event: e }).setHeaders(t).send();
+	} catch {}
+}
+//#endregion
+//#region src/utils/validate.ts
+function Ia(e) {
+	if (!e.trim()) return "Project name cannot be empty";
+	if (!O.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 La(i) {
+	Xi(), a.intro(L.brandBold("Create a new Hype Stack project"));
+	let o = i.yes === !0, s;
+	if (o && i.name) {
+		let e = Ia(i.name);
+		e && (a.log.error(e), Z()), s = i.name;
+	} else {
+		let e = await a.text({
+			message: "What is your project named?",
+			placeholder: "my-app",
+			initialValue: i.name ?? "",
+			validate: (e) => Ia(e ?? "")
+		});
+		a.isCancel(e) && Z(), s = e;
+	}
+	let c;
+	if (o) c = i.directory ?? `./${s}`;
+	else {
+		let e = await a.text({
+			message: "Where should we create it?",
+			placeholder: `./${s}`,
+			initialValue: i.directory ?? `./${s}`
+		});
+		a.isCancel(e) && Z(), c = e;
+	}
+	let u = i.editor && ee.includes(i.editor) ? i.editor : null, d;
+	if (u) d = u;
+	else if (o) d = "cursor";
+	else {
+		let e = await a.select({
+			message: "Which code editor do you use?",
+			options: k.map((e) => ({
+				value: e.value,
+				label: e.label,
+				hint: "hint" in e ? e.hint : void 0
+			})),
+			initialValue: "cursor"
+		});
+		a.isCancel(e) && Z(), d = e;
+	}
+	let f = i.theme !== void 0 && r(i.theme), p;
+	if (f) p = i.theme;
+	else if (o) p = e;
+	else {
+		let n = await a.select({
+			message: "Pick a color theme",
+			options: t,
+			initialValue: e
+		});
+		a.isCancel(n) && Z(), p = n;
+	}
+	if (!o) {
+		let e = k.find((e) => e.value === d)?.label ?? d, n = t.find((e) => e.value === p)?.label ?? p, r = await a.confirm({ message: `Create ${L.highlight(s)} in ${L.path(c)} with ${L.highlight(e)} config and the ${L.highlight(n)} theme?` });
+		(a.isCancel(r) || !r) && Z();
+	}
+	let m = l.resolve(c);
+	if (await Jn(m) && !await Yn(m)) {
+		let e = await a.confirm({
+			message: `Directory ${L.path(m)} is not empty. Continue anyway?`,
+			initialValue: !1
+		});
+		(a.isCancel(e) || !e) && Z();
+	}
+	let h = a.spinner();
+	h.start("Cloning Hype Stack template..."), await Qi(m), h.stop(L.success("Template cloned"));
+	let g = a.spinner();
+	g.start("Setting up project..."), await ga(m), await va(m, s), await da(m, d);
+	let _ = await ar(m), v = sr(s, _);
+	await ir(m, v), await Pa(m, {
+		projectName: s,
+		editor: d,
+		workspace: _
+	}), r(p) && (await ia(l.resolve(m, v.paths?.frontend.root ?? "apps/frontend"), n(p)) || a.log.warn(L.muted(`Could not find ${L.path("assets/styles.css")} to apply the ${p} theme`))), g.stop(L.success("Project configured"));
+	let y = a.spinner();
+	y.start("Installing dependencies..."), (await q("pnpm", ["install"], { cwd: m })).exitCode === 0 ? y.stop(L.success("Dependencies installed")) : (y.stop(L.warning("Dependencies installed with warnings")), a.log.warn(L.muted("You may need to run `pnpm install` manually to resolve issues.")));
+	let b = a.spinner();
+	b.start("Initializing git repository..."), await _a(m), b.stop(L.success("Git repository initialized with clean history"));
+	let x = a.spinner();
+	x.start("Creating .env files from examples...");
+	let S = await pa(m);
+	if (S.length > 0) {
+		let e = S.length;
+		x.stop(L.success(`Created ${e} .env file${e === 1 ? "" : "s"} from examples`));
+	} else x.stop(L.muted("No .env.example files to copy"));
+	a.log.success(`${L.brandBold("Hype Stack")} project ${L.highlight(s)} is ready!`);
+	let C = l.relative(process.cwd(), m) || ".", w = [`${L.command(`cd ${C}`)}`];
+	S.length > 0 ? w.push(`Review your ${L.path(".env")} files and fill in any secrets`) : w.push(`Copy ${L.path(".env.example")} to ${L.path(".env")} and configure`), Zi(w);
+	let T = i.setup !== !1 && (o || await a.confirm({
+		message: "Would you like to start Docker services and run database migrations now?",
+		initialValue: !0
+	}));
+	a.isCancel(T) && Z(), T ? await Da(m, o) : (a.log.info(L.muted("You can start services later:")), Zi([
+		`${L.command("docker compose up -d")} ${L.muted("(in apps/backend - start Postgres, Valkey, RustFS)")}`,
+		`${L.command("pnpm --filter @internal/backend migration:latest")} ${L.muted("(apply migrations)")}`,
+		`${L.command("pnpm run generate")} ${L.muted("(generate Prisma client)")}`
+	])), Zi([`${L.command("pnpm dev")} ${L.muted("(start frontend + backend)")}`]), await Fa("project_create"), a.outro(L.muted("Happy building!"));
+}
+//#endregion
+//#region src/commands/init.ts
+async function Ra(e) {
+	let t = e.cwd ?? process.cwd(), n = e.silent ?? !1;
+	if (n || (X(), a.intro(L.brandBold("Initialize Hype Stack configuration"))), !await cr(t)) {
+		a.log.error(`This doesn't look like a Hype Stack project. ${L.muted("Expected apps/ directory and package.json")}`), a.outro(L.muted(`Run ${L.command("hype-stack create")} to scaffold a new project.`));
+		return;
+	}
+	if (await rr(t)) {
+		let e = await nr(t);
+		if (e && !n) {
+			a.log.info(`Found existing ${L.path("stack.json")} for project ${L.highlight(e.name)}`);
+			let t = await a.confirm({
+				message: "Overwrite existing configuration?",
+				initialValue: !1
+			});
+			if (a.isCancel(t) || !t) {
+				a.outro(L.muted("Keeping existing configuration."));
+				return;
+			}
+		}
+	}
+	let r = await ar(t);
+	if (!n) {
+		let e = Object.entries(r.apps), t = Object.entries(r.packages);
+		if (e.length > 0) {
+			a.log.info(L.bold("Detected apps:"));
+			for (let [t, n] of e) a.log.message(`  ${R.arrow} ${L.highlight(t)} ${L.muted(`→ ${n}`)}`);
+		}
+		if (t.length > 0) {
+			a.log.info(L.bold("Detected packages:"));
+			for (let [e, n] of t) a.log.message(`  ${R.arrow} ${L.highlight(e)} ${L.muted(`→ ${n}`)}`);
+		}
+		e.length === 0 && t.length === 0 && a.log.warn("No apps or packages detected in the workspace.");
+	}
+	let i = (await Xn(l.join(t, "package.json")))?.name?.replace(/^@/, "").replace(/\/source$/, "") ?? "my-app", o = i;
+	if (!n) {
+		let e = await a.text({
+			message: "Project name for stack.json?",
+			placeholder: i,
+			initialValue: i
+		});
+		a.isCancel(e) && Z(), o = e;
+	}
+	await ir(t, sr(o, r)), n || (a.log.success(`${L.path("stack.json")} written successfully`), a.outro(L.muted("Your project is mapped and ready for Hype Stack CLI commands.")));
+}
+async function za(e, t = {}) {
+	if (await rr(e)) return !0;
+	let n = t.runInit ?? ((e) => Ra({
+		cwd: e,
+		silent: !0
+	})), r = t.runCreate ?? ((e) => La({ directory: e }));
+	if (await cr(e)) {
+		a.log.warn(`No ${L.path("stack.json")} found in ${L.path(e)}.`);
+		let t = await a.confirm({
+			message: `Create ${L.path("stack.json")} now?`,
+			initialValue: !0
+		});
+		if (a.isCancel(t) || !t) return !1;
+		await n(e);
+		let r = await rr(e);
+		return r && a.log.success(`${L.path("stack.json")} created`), r;
+	}
+	a.log.warn(`This doesn't look like a Hype Stack project, and there's no ${L.path("stack.json")} here.`);
+	let i = await a.confirm({
+		message: `Is ${L.path(e)} where you want to work?`,
+		initialValue: !0
+	});
+	if (a.isCancel(i) || !i) return !1;
+	let o = await a.confirm({
+		message: "Create a new Hype Stack project here?",
+		initialValue: !0
+	});
+	return a.isCancel(o) || !o ? !1 : (await r(e), await rr(e));
+}
+//#endregion
+//#region src/core/npm-deps.ts
+function Ba(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 Va(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 Ha(e, t, n = q) {
+	let r = [];
+	for (let i of e) {
+		let e = l.join(t, i.relativeDir);
+		if (!await J(l.join(e, "package.json"))) {
+			r.push(`Cannot install npm dependencies under "${i.relativeDir}": package.json not found.`);
+			continue;
+		}
+		let a = l.normalize(i.relativeDir), o;
+		try {
+			o = await n("pnpm", [
+				"add",
+				...i.specs,
+				"--dir",
+				a
+			], { cwd: t });
+		} catch (e) {
+			let t = e instanceof Error ? e.message : String(e);
+			r.push(`pnpm add failed for "${i.relativeDir}": ${t}`);
+			continue;
+		}
+		if (o.exitCode !== 0) {
+			let e = o.stderr.trim() || o.stdout.trim() || `(exit ${String(o.exitCode)})`;
+			r.push(`pnpm add failed for "${i.relativeDir}": ${e}`);
+		}
+	}
+	return {
+		ok: r.length === 0,
+		errors: r
+	};
+}
+//#endregion
+//#region src/commands/install-helpers.ts
+function $(e) {
+	return e instanceof Error ? e.message : String(e);
+}
+async function Ua(e, t, n) {
+	let r = e.filter((e) => e.tier === "paid" && !t.has(e.name)).map((e) => e.name);
+	return r.length === 0 ? {} : hr(r, n).catch(() => ({}));
+}
+function Wa(e, t) {
+	return e === "free" ? L.success("free") : e === "owned" ? L.accent("owned") : `${L.highlight(`$${t}`)} ${L.muted("locked")}`;
+}
+async function Ga(e, t, n) {
+	let r = e.filter((e) => t(e)), i = e.filter((e) => !t(e));
+	i.length > 0 && a.log.warning(`Skipping ${i.join(", ")} because ${i.length === 1 ? "it depends" : "they depend"} on a pack you don't own yet.`), await qn(r.map((e) => n.get(e)).filter((e) => e !== void 0).map((e) => ({
+		name: e.name,
+		displayName: e.displayName,
+		price: e.price
+	})));
+}
+function Ka(e, t) {
+	let n = e.map((e, n) => {
+		let r = t.get(e), i = r ? r.displayName : e;
+		return `  ${L.muted(`${n + 1}.`)} ${L.brand(i)}`;
+	});
+	a.note([
+		"These packs will be installed, in order:",
+		"",
+		...n
+	].join("\n"), "Install Plan");
+}
+async function qa(e, t) {
+	let n = [];
+	for (let r of e) {
+		let e = await lr(r), i = await ur(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 Ja(e) {
+	let { prepared: t, paths: n, cwd: r, spinner: i } = e, o = Ba(Va(t.map((e) => e.manifest.dependencies_npm)), n);
+	if (o.errors.length > 0) {
+		for (let e of o.errors) a.log.error(e);
+		return;
+	}
+	if (o.operations.length === 0) return;
+	i.start("Installing npm dependencies...");
+	let s = await Ha(o.operations, r);
+	if (i.stop(s.ok ? "npm dependencies installed" : "npm dependency installation failed"), !s.ok) for (let e of s.errors) a.log.error(e);
+}
+function Ya(e) {
+	let t = e.flatMap((e) => e.manifest.postInstall ?? []), n = [...new Set(t)];
+	n.length !== 0 && a.note(n.map((e) => `  ${L.muted("→")} ${e}`).join("\n"), "Next Steps");
+}
+async function Xa(e) {
+	let { prepared: t, config: n, cwd: r, force: i, yes: o, slotsByPack: s } = e, c = /* @__PURE__ */ new Set();
+	if (i) return c;
+	let u = await xi({
+		packs: t,
+		config: n,
+		projectRoot: r,
+		slotsByPack: s
+	});
+	if (u.length === 0) return c;
+	if (o) return a.log.warning(`${u.length} existing file${u.length === 1 ? "" : "s"} kept. Pass ${L.command("--force")} to overwrite.`), c;
+	a.log.warning(`${u.length} file${u.length === 1 ? "" : "s"} already exist in your project.`);
+	for (let e of u) {
+		let t = l.relative(r, e.targetPath) || e.target, n = await a.confirm({
+			message: `Overwrite ${L.path(t)}? ${L.muted(`(${e.packName})`)}`,
+			initialValue: !1
+		});
+		a.isCancel(n) && (a.cancel("Installation cancelled."), process.exit(0)), n && c.add(e.targetPath);
+	}
+	return c;
+}
+//#endregion
+//#region src/commands/compose.ts
+async function Za(e = {}) {
+	let t = e.cwd ?? process.cwd();
+	X();
+	let n = await za(t), r;
+	try {
+		r = await nr(t);
+	} catch (e) {
+		a.cancel(`Could not parse ${L.path("stack.json")}: ${$(e)} Run 'hype-stack init' to regenerate it.`), process.exit(1);
+	}
+	r || (a.cancel(n ? `Could not read ${L.path("stack.json")}. Run 'hype-stack init' to regenerate it, then run 'hype-stack compose' again.` : `No ${L.path("stack.json")}. Run 'hype-stack init' first, then 'hype-stack compose'.`), process.exit(1)), r.paths || (a.cancel(`${L.path("stack.json")} is missing ${L.path("paths")}. Run 'hype-stack init' again to regenerate it.`), process.exit(1)), a.intro(L.brandBold("Compose your stack"));
+	let i = a.spinner();
+	i.start("Loading packs...");
+	let s;
+	try {
+		s = await mr();
+	} catch (e) {
+		i.stop("Failed to load packs"), a.cancel(`Could not reach Hype Stack. Check your connection and try again.\n${$(e)}`), process.exit(1);
+	}
+	i.stop("Packs loaded");
+	let c = r.installedPacks ?? [], l = new Set(c), u = new Map(s.map((e) => [e.name, e])), d = e.licenseKey ?? r.licenseKey ?? null, f = (await In(M()))?.token ?? null, p = await Ua(s, l, {
+		token: f,
+		key: d
+	}), m = (e) => {
+		let t = u.get(e);
+		return !t || t.tier === "free" ? "free" : p[e]?.owned ? "owned" : "locked";
+	}, h = (e) => !l.has(e) && m(e) === "locked", g = await Qa({
+		packs: s,
+		installedSet: l,
+		stateOf: m,
+		options: e,
+		adminAvailable: !!r.apps.admin
+	});
+	if (g === null && (a.cancel("Cancelled."), process.exit(0)), g.length === 0) {
+		a.outro(L.muted("No packs selected. Nothing to do."));
+		return;
+	}
+	let _ = to(g), v = no(g), y = Bi(s, _), b = Ni(Vi(s, y)), x;
+	try {
+		x = Fi(_, b, c);
+	} catch (e) {
+		a.cancel($(e)), process.exit(1);
+	}
+	if (x.order.length === 0) {
+		a.note(`${x.alreadyInstalled.join(", ")} already installed.`, "Nothing to do"), a.outro(L.muted("Your selection is already part of the project."));
+		return;
+	}
+	let S = Ii({
+		order: x.order,
+		graph: b,
+		isLocked: h,
+		installed: c
+	});
+	if (S.blocked.length > 0 && !f && !d) {
+		let e = await Kn();
+		e && (f = e, p = await Ua(s, l, {
+			token: f,
+			key: d
+		}), S = Ii({
+			order: x.order,
+			graph: b,
+			isLocked: h,
+			installed: c
+		}));
+	}
+	if (S.blocked.length > 0 && await Ga(S.blocked, h, u), S.installable.length === 0) {
+		a.outro(L.muted("Nothing left to install once locked packs are removed."));
+		return;
+	}
+	if (Ka(S.installable, u), !e.yes) {
+		let e = await a.confirm({ message: `Install ${S.installable.length} pack${S.installable.length === 1 ? "" : "s"}?` });
+		(a.isCancel(e) || !e) && (a.cancel("Installation cancelled."), process.exit(0));
+	}
+	i.start("Downloading packs...");
+	let C;
+	try {
+		C = await qa(S.installable, {
+			token: f,
+			key: d
+		});
+	} catch (e) {
+		i.stop("Download failed"), a.cancel($(e)), process.exit(1);
+	}
+	i.stop(`Downloaded ${C.length} pack${C.length === 1 ? "" : "s"}`);
+	let w = await Xa({
+		prepared: C,
+		config: r,
+		cwd: t,
+		force: e.force ?? !1,
+		yes: e.yes ?? !1,
+		slotsByPack: v
+	});
+	try {
+		i.start("Installing pack files...");
+		let n = await wi({
+			packs: C,
+			config: r,
+			projectRoot: t,
+			force: e.force ?? !1,
+			overwrite: w,
+			slotsByPack: v
+		});
+		if (n.aborted) {
+			i.stop("Installation aborted");
+			for (let e of n.errors) a.log.error(e);
+			a.cancel("No files were written. Fix the errors above (or pass --force for existing files) and try again."), process.exit(1);
+		}
+		i.stop("Files installed"), n.installed.length > 0 && a.log.success(`${L.highlight(String(n.installed.length))} files installed`), n.skipped.length > 0 && a.log.warning(`${n.skipped.length} files skipped (use --force to overwrite)`);
+		for (let e of n.errors) a.log.error(e);
+		await Ja({
+			prepared: C,
+			paths: r.paths,
+			cwd: t,
+			spinner: i
+		}), await tr({
+			projectRoot: t,
+			paths: r.paths,
+			skipPrompts: e.yes ?? !1
+		}), Ya(C), a.outro(L.brand(`Installed ${n.appliedPacks.join(", ")}.`));
+	} finally {
+		await Promise.all(C.map((e) => o.rm(e.packDir, {
+			recursive: !0,
+			force: !0
+		})));
+	}
+}
+async function Qa(e) {
+	let { packs: t, installedSet: n, stateOf: r, options: i, adminAvailable: o } = e;
+	if (i.packs && i.packs.length > 0) {
+		let e = i.packs.map(eo), n = e.filter((e) => !t.some((t) => t.name === e.name));
+		return n.length > 0 && (a.cancel(`Unknown pack${n.length === 1 ? "" : "s"}: ${n.map((e) => e.name).join(", ")}`), process.exit(1)), e;
+	}
+	let s = t.filter((e) => n.has(e.name));
+	s.length > 0 && a.note(s.map((e) => `  ${L.muted("✓")} ${e.displayName}`).join("\n"), "Already Installed");
+	let c = t.filter((e) => !n.has(e.name));
+	if (c.length === 0) return a.outro(L.muted("Every available pack is already installed.")), [];
+	let l = ji(c, { adminAvailable: o }), u = [];
+	for (let e of l) {
+		let t = e.packs.map((e) => {
+			let t = r(e.name);
+			return {
+				value: e.name,
+				label: `${e.displayName}  ${Wa(t, e.price)}`,
+				hint: e.description
+			};
+		});
+		if (e.mode === "single") {
+			let n = await a.select({
+				message: `Choose a ${e.label.toLowerCase()}`,
+				options: t,
+				initialValue: e.preselect ?? e.packs[0].name
+			});
+			if (a.isCancel(n)) return null;
+			u.push({
+				name: n,
+				slot: e.slot
+			});
+			continue;
+		}
+		let n = await a.multiselect({
+			message: `Select ${e.label.toLowerCase()} to add (optional)`,
+			options: t,
+			required: !1
+		});
+		if (a.isCancel(n)) return null;
+		for (let e of n) u.push({ name: e });
+	}
+	return u;
+}
+var $a = /@(frontend|admin)$/;
+function eo(e) {
+	let t = e.match($a);
+	return t ? {
+		name: e.slice(0, -t[0].length),
+		slot: t[1]
+	} : { name: e };
+}
+function to(e) {
+	let t = /* @__PURE__ */ new Set(), n = [];
+	for (let r of e) t.has(r.name) || (t.add(r.name), n.push(r.name));
+	return n;
+}
+function no(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		if (!n.slot) continue;
+		let e = t.get(n.name);
+		e && !e.includes(n.slot) ? e.push(n.slot) : e || t.set(n.name, [n.slot]);
+	}
+	return t;
+}
+//#endregion
+//#region src/commands/login.ts
+async function ro() {
+	X(), a.intro(L.brandBold("Log in to Hype Stack")), a.log.step("Opening your browser to sign in...");
+	let e;
+	try {
+		e = await Gn({ onUrl: (e) => {
+			a.log.info(`If your browser didn't open, visit:\n  ${L.path(e)}`);
+		} });
+	} catch (e) {
+		a.cancel(e instanceof Error ? e.message : String(e)), process.exit(1);
+	}
+	a.outro(L.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 io() {
+	X(), a.intro(L.brandBold("Log out of Hype Stack"));
+	let e = M(), t = await In(e);
+	if (!t) {
+		a.outro(L.muted("You're not logged in."));
+		return;
+	}
+	await On(t.token).catch(() => null), await Rn(e), a.outro(L.brand("Logged out."));
+}
+//#endregion
+//#region src/core/templates.ts
+var ao = K.createRequest()({
+	endpoint: "/templates/list",
+	method: "GET"
+});
+async function oo() {
+	let { data: e, error: t } = await ao.send();
+	if (t || !e) throw Error(`Failed to fetch template list: ${String(t)}`);
+	return e.templates;
+}
+async function so(e) {
+	let { data: t, error: n, status: r } = await K.createRequest()({
+		endpoint: `/templates/${encodeURIComponent(e)}/manifest`,
+		method: "GET"
+	}).send();
+	if (r === 404) throw Error(`Template "${e}" not found`);
+	if (n || !t) throw Error(`Failed to load manifest for template "${e}": ${String(n)}`);
+	return t;
+}
+async function co(e, t = {}) {
+	let n = K.createRequest()({
+		endpoint: `/templates/${encodeURIComponent(e)}/download`,
+		method: "POST"
+	}), r = {
+		"X-Device-Id": Bn(),
+		"X-Client-Info": Vn()
+	};
+	t.token && (r.Authorization = `Bearer ${t.token}`);
+	let { data: i, error: a, success: s } = await n.setPayload({ key: t.licenseKey ?? void 0 }).setHeaders(r).send();
+	if (!s || !i) throw Error(`Failed to download template "${e}": ${String(a)}`);
+	if (!i.ok) return {
+		status: "denied",
+		reason: i.reason,
+		packs: i.packs ?? [],
+		expiresAt: i.expiresAt ?? null
+	};
+	let u = await o.mkdtemp(l.join(c.tmpdir(), `hype-stack-template-${e}-`));
+	return await Promise.all(i.files.map(async (e) => {
+		let t = l.join(u, ...e.path.split("/"));
+		await o.mkdir(l.dirname(t), { recursive: !0 }), await o.writeFile(t, Buffer.from(e.content, "base64"));
+	})), {
+		status: "ok",
+		templateDir: u
+	};
+}
+//#endregion
+//#region src/commands/template.ts
+async function lo(e = {}) {
+	let t = e.cwd ?? process.cwd();
+	X();
+	let i = await za(t), s;
+	try {
+		s = await nr(t);
+	} catch (e) {
+		a.cancel(`Could not parse ${L.path("stack.json")}: ${$(e)} Run 'hype-stack init' to regenerate it.`), process.exit(1);
+	}
+	s || (a.cancel(i ? `Could not read ${L.path("stack.json")}. Run 'hype-stack init' to regenerate it, then run 'hype-stack template' again.` : `No ${L.path("stack.json")}. Run 'hype-stack init' first, then 'hype-stack template'.`), process.exit(1)), s.paths || (a.cancel(`${L.path("stack.json")} is missing ${L.path("paths")}. Run 'hype-stack init' again to regenerate it.`), process.exit(1)), a.intro(L.brandBold("Install a template"));
+	let c = a.spinner();
+	c.start("Loading packs...");
+	let u;
+	try {
+		u = await mr();
+	} catch (e) {
+		c.stop("Failed to load packs"), a.cancel(`Could not reach Hype Stack. Check your connection and try again.\n${$(e)}`), process.exit(1);
+	}
+	c.stop("Packs loaded");
+	let d = s.installedPacks ?? [], f = new Set(d), p = new Map(u.map((e) => [e.name, e])), m = e.licenseKey ?? s.licenseKey ?? null, h = (await In(M()))?.token ?? null;
+	c.start("Loading templates...");
+	let g;
+	try {
+		g = await oo();
+	} catch (e) {
+		c.stop("Failed to load templates"), a.cancel(`Could not reach Hype Stack. Check your connection and try again.\n${$(e)}`), process.exit(1);
+	}
+	let _ = e.templateId;
+	if (!_) {
+		e.yes && (c.stop("Template id required"), a.cancel("Pass a template id with `hype-stack template <id>` (required in --yes mode)."), process.exit(1)), g.length === 0 && (c.stop("No templates available"), a.cancel("No templates are available yet. Check back later."), process.exit(1)), c.stop("Templates loaded");
+		let t = await a.select({
+			message: "Choose a template",
+			options: g.map((e) => ({
+				value: e.id,
+				label: e.name,
+				hint: e.description
+			}))
+		});
+		a.isCancel(t) && (a.cancel("Cancelled."), process.exit(0)), _ = t;
+	}
+	let v = g.find((e) => e.id === _);
+	v || (c.stop("Template not found"), a.cancel(`Template "${_}" not found. Available: ${g.map((e) => e.id).join(", ") || "(none)"}`), process.exit(1)), c.stop(`Template: ${v.name}`);
+	let y = await uo(v, e.variants, e.yes ?? !1), b = Li(v.slots, y), x = Ri(v.slots, v.packs, b), S = await fo({
+		packs: u,
+		templatePacks: x,
+		installedSet: f,
+		options: e
+	}), C = [...x, ...S.filter((e) => !x.includes(e))], w = C.filter((e) => !p.has(e));
+	w.length > 0 && (a.cancel(`Unknown pack${w.length === 1 ? "" : "s"}: ${w.join(", ")}`), process.exit(1));
+	let T = Vi(u, b), E = Ni(T), D;
+	try {
+		D = Fi(C, E, d);
+	} catch (e) {
+		a.cancel($(e)), process.exit(1);
+	}
+	if (D.order.length === 0) {
+		a.outro(L.muted("Every pack in this template is already installed."));
+		return;
+	}
+	let O = await Ua(T, f, {
+		token: h,
+		key: m
+	}), k = (e) => {
+		let t = p.get(e);
+		return !t || t.tier === "free" ? "free" : O[e]?.owned ? "owned" : "locked";
+	}, ee = (e) => !f.has(e) && k(e) === "locked", A = Ii({
+		order: D.order,
+		graph: E,
+		isLocked: ee,
+		installed: d
+	});
+	if (A.blocked.length > 0 && !h && !m) {
+		let e = await Kn();
+		e && (h = e, O = await Ua(T, f, {
+			token: h,
+			key: m
+		}), A = Ii({
+			order: D.order,
+			graph: E,
+			isLocked: ee,
+			installed: d
+		}));
+	}
+	if (A.blocked.length > 0 && await Ga(A.blocked, ee, p), A.installable.length === 0) {
+		a.outro(L.muted("Nothing left to install once locked packs are removed."));
+		return;
+	}
+	if (Ka(A.installable, p), !e.yes) {
+		let e = await a.confirm({ message: `Install template ${L.brandBold(v.name)} (${A.installable.length} pack${A.installable.length === 1 ? "" : "s"})?` });
+		(a.isCancel(e) || !e) && (a.cancel("Installation cancelled."), process.exit(0));
+	}
+	c.start("Downloading packs...");
+	let j;
+	try {
+		j = await qa(A.installable, {
+			token: h,
+			key: m
+		});
+	} catch (e) {
+		c.stop("Download failed"), a.cancel($(e)), process.exit(1);
+	}
+	c.stop(`Downloaded ${j.length} pack${j.length === 1 ? "" : "s"}`);
+	let te = await Xa({
+		prepared: j,
+		config: s,
+		cwd: t,
+		force: e.force ?? !1,
+		yes: e.yes ?? !1
+	}), N = null;
+	try {
+		c.start("Installing pack files...");
+		let i = await wi({
+			packs: j,
+			config: s,
+			projectRoot: t,
+			force: e.force ?? !1,
+			overwrite: te
+		});
+		if (i.aborted) {
+			c.stop("Installation aborted");
+			for (let e of i.errors) a.log.error(e);
+			a.cancel("No files were written. Fix the errors above (or pass --force for existing files) and try again."), process.exit(1);
+		}
+		c.stop("Files installed"), i.installed.length > 0 && a.log.success(`${L.highlight(String(i.installed.length))} files installed`), i.skipped.length > 0 && a.log.warning(`${i.skipped.length} files skipped (use --force to overwrite)`);
+		for (let e of i.errors) a.log.error(e);
+		c.start("Applying template overrides...");
+		let o = await so(v.id), u = await co(v.id, {
+			token: h,
+			licenseKey: m
+		});
+		u.status === "denied" && (c.stop("Template download denied"), a.cancel(`Access to template "${v.id}" was denied (${u.reason}). Try 'hype-stack login' or check your license.`), process.exit(1)), N = u.templateDir;
+		let d = await Ei({
+			manifest: o,
+			config: s,
+			projectRoot: t,
+			templateDir: N
+		});
+		c.stop("Template overrides applied"), d.installed.length > 0 && a.log.success(`${d.installed.length} template file${d.installed.length === 1 ? "" : "s"} applied`);
+		for (let e of d.errors) a.log.error(e);
+		let f = o.theme ?? "zinc-mono";
+		r(f) && (await ia(l.resolve(t, s.paths?.frontend.root ?? "apps/frontend"), n(f)) ? a.log.success(`Applied the ${n(f).label} theme`) : a.log.warning(L.muted(`Could not find ${L.path("assets/styles.css")} to apply the theme`))), await po({
+			prepared: j,
+			templateNpm: o.dependencies_npm,
+			paths: s.paths,
+			cwd: t,
+			spinner: c
+		}), await tr({
+			projectRoot: t,
+			paths: s.paths,
+			skipPrompts: e.yes ?? !1
+		}), Ya(j), o.postInstall && o.postInstall.length > 0 && a.note(o.postInstall.map((e) => `  ${L.muted("→")} ${e}`).join("\n"), "Template Next Steps"), a.outro(L.brand(`Installed template ${v.name}.`));
+	} finally {
+		await Promise.all(j.map((e) => o.rm(e.packDir, {
+			recursive: !0,
+			force: !0
+		}))), N && await o.rm(N, {
+			recursive: !0,
+			force: !0
+		});
+	}
+}
+async function uo(e, t, n) {
+	let r = {};
+	for (let i of e.slots) {
+		if (t?.[i.family]) {
+			r[i.family] = t[i.family];
+			continue;
+		}
+		if (i.variants.length <= 1 || n) {
+			r[i.family] = i.default;
+			continue;
+		}
+		let e = i.variants.map((e) => ({
+			value: e,
+			label: e,
+			hint: e === i.default ? "default" : void 0
+		})), o = await a.select({
+			message: `Choose a ${i.family}`,
+			options: e,
+			initialValue: i.default
+		});
+		a.isCancel(o) && (a.cancel("Cancelled."), process.exit(0)), r[i.family] = o;
+	}
+	return r;
+}
+async function fo(e) {
+	let { packs: t, templatePacks: n, installedSet: r, options: i } = e, o = new Set(n);
+	if (i.packs && i.packs.length > 0) {
+		let e = i.packs.filter((e) => !t.some((t) => t.name === e));
+		return e.length > 0 && (a.cancel(`Unknown pack${e.length === 1 ? "" : "s"}: ${e.join(", ")}`), process.exit(1)), i.packs.filter((e) => !o.has(e));
+	}
+	if (i.yes) return [];
+	let s = t.filter((e) => e.category === "feature" && !o.has(e.name) && !r.has(e.name));
+	if (s.length === 0) return [];
+	let c = await a.multiselect({
+		message: "Add extra packs on top of the template (optional)",
+		options: s.map((e) => ({
+			value: e.name,
+			label: e.displayName,
+			hint: e.description
+		})),
+		required: !1
+	});
+	return a.isCancel(c) && (a.cancel("Cancelled."), process.exit(0)), c;
+}
+async function po(e) {
+	let { prepared: t, templateNpm: n, paths: r, cwd: i, spinner: o } = e, s = Va(t.map((e) => e.manifest.dependencies_npm)), c = Ba(n ? Va([s, n]) : s, r);
+	if (c.errors.length > 0) {
+		for (let e of c.errors) a.log.error(e);
+		return;
+	}
+	if (c.operations.length === 0) return;
+	o.start("Installing npm dependencies...");
+	let l = await Ha(c.operations, i);
+	if (o.stop(l.ok ? "npm dependencies installed" : "npm dependency installation failed"), !l.ok) for (let e of l.errors) a.log.error(e);
+}
+//#endregion
+//#region src/cli.ts
+function mo(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 ho(e) {
+	if (!e) return;
+	let t = {};
+	for (let n of e.split(",")) {
+		let [e, r] = n.split("=").map((e) => e?.trim());
+		e && r && (t[e] = r);
+	}
+	return Object.keys(t).length > 0 ? t : void 0;
+}
+function go() {
+	let e = new i();
+	return e.name("hype-stack").description("Build with Hype Stack -- templates, components, modules, and more").version(S, "-v, --version"), e.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("-t, --theme <theme>", "Color theme (default, slate, rose, emerald, violet, amber, ocean, zinc-mono, crimson, midnight)").option("--no-install", "Skip dependency installation").option("--no-setup", "Skip Docker services and database migrations after create").option("-y, --yes", "Skip confirmation prompts (requires --name)").action(async (e) => {
+		await La({
+			name: e.name,
+			directory: e.directory,
+			install: e.install,
+			editor: e.editor,
+			theme: e.theme,
+			yes: e.yes,
+			setup: e.setup
+		});
+	}), e.command("init").description("Initialize stack.json in the current project").action(async () => {
+		await Ra({});
+	}), e.command("compose").description("Choose feature packs to add to your project").option("--packs <list>", "Comma-separated pack names (non-interactive). Append @frontend or @admin to a layout pack to target that app shell, e.g. layout-basic@frontend,layout-native-app-shell@admin").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 Za({
+			packs: mo(e.packs),
+			force: e.force,
+			yes: e.yes,
+			licenseKey: e.key ?? e.licenseKey,
+			cwd: e.cwd
+		});
+	}), e.command("template <id>").description("Install a template by id, with starter/layout variant swaps and extra packs on top").argument("[id]", "Template id (omit to pick interactively)").option("--variants <map>", "Preselect slot variants, e.g. starter-saas=starter-saas-better-auth,layout=layout-basic").option("--packs <list>", "Extra packs to add on top of the template (comma-separated)").option("--force", "Overwrite existing files").option("-y, --yes", "Skip confirmation prompts (requires <id>)").option("-k, --key <key>", "License key").option("--license-key <key>", "License key (alias for --key)").option("--cwd <path>", "Working directory").action(async (e, t) => {
+		await lo({
+			templateId: e,
+			variants: ho(t.variants),
+			packs: mo(t.packs),
+			force: t.force,
+			yes: t.yes,
+			licenseKey: t.key ?? t.licenseKey,
+			cwd: t.cwd
+		});
+	}), e.command("login").description("Log in via your browser to install packs your organization owns").action(async () => {
+		await ro();
+	}), e.command("logout").description("Log out and remove the saved CLI token").action(async () => {
+		await io();
+	}), e.command("auth").description("Alias for `login`").action(async () => {
+		await ro();
+	}), e;
+}
+//#endregion
+export { za as a, Za as i, io as n, Ra as o, ro as r, La as s, go as t };