@sigx/terminal 0.2.1 → 0.2.3

package/dist/index.js

@@ -1,190 +1,100 @@
 //#region \0rolldown/runtime.js
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-//#endregion
-//#region ../reactivity/src/types.ts
-/** Symbol to identify computed values */
-var ComputedSymbol = Symbol("computed");
-//#endregion
-//#region ../reactivity/src/effect.ts
-var activeEffect = null;
-var batchDepth = 0;
-var pendingEffects = /* @__PURE__ */ new Set();
-function setActiveEffect(effect) {
-	activeEffect = effect;
-}
-function getActiveEffect() {
-	return activeEffect;
-}
-/**
-* Batch multiple reactive updates into a single flush.
-* Effects are deferred until the batch completes, avoiding redundant re-renders.
-*
-* @example
-* ```ts
-* batch(() => {
-*   count.value++;
-*   name.value = 'Alice';
-* }); // effects run once after both updates
-* ```
-*/
-function batch(fn) {
-	batchDepth++;
+var e = (e, t) => () => (t || e((t = { exports: {} }).exports, t), t.exports), t = Symbol("computed"), n = null, r = 0, i = /* @__PURE__ */ new Set();
+function a(e) {
+	n = e;
+}
+function o() {
+	return n;
+}
+function s(e) {
+	r++;
 	try {
-		fn();
+		e();
 	} finally {
-		batchDepth--;
-		if (batchDepth === 0) {
-			const effects = Array.from(pendingEffects);
-			pendingEffects.clear();
-			for (const effect of effects) effect();
+		if (r--, r === 0) {
+			let e = Array.from(i);
+			i.clear();
+			for (let t of e) t();
 		}
 	}
 }
-function cleanup(effect) {
-	if (!effect.deps) return;
-	for (const dep of effect.deps) dep.delete(effect);
-	effect.deps.length = 0;
-}
-function track(depSet) {
-	if (!activeEffect) return;
-	depSet.add(activeEffect);
-	activeEffect.deps.push(depSet);
-}
-function trigger(depSet) {
-	const effects = Array.from(depSet);
-	for (const effect of effects) if (batchDepth > 0) pendingEffects.add(effect);
-	else effect();
-}
-function runEffect(fn) {
-	let stopped = false;
-	const effectFn = function() {
-		if (stopped) return;
-		cleanup(effectFn);
-		const prev = activeEffect;
-		activeEffect = effectFn;
+function c(e) {
+	if (e.deps) {
+		for (let t of e.deps) t.delete(e);
+		e.deps.length = 0;
+	}
+}
+function l(e) {
+	n && (e.add(n), n.deps.push(e));
+}
+function u(e) {
+	let t = Array.from(e);
+	for (let e of t) r > 0 ? i.add(e) : e();
+}
+function d(e) {
+	let t = !1, r = function() {
+		if (t) return;
+		c(r);
+		let i = n;
+		n = r;
 		try {
-			fn();
+			e();
 		} finally {
-			activeEffect = prev;
+			n = i;
 		}
 	};
-	effectFn.deps = [];
-	effectFn();
-	const runner = (() => effectFn());
-	runner.stop = () => {
-		stopped = true;
-		cleanup(effectFn);
-	};
-	return runner;
-}
-/**
-* Create a reactive effect that re-runs whenever its tracked dependencies change.
-* Returns a runner with a `.stop()` method to dispose the effect.
-*
-* @example
-* ```ts
-* const count = signal(0);
-* const runner = effect(() => console.log(count.value));
-* count.value++; // logs: 1
-* runner.stop();
-* ```
-*/
-function effect(fn) {
-	return runEffect(fn);
-}
-/**
-* Execute a function without tracking any reactive dependencies.
-* Useful for reading signals inside an effect without creating a subscription.
-*
-* @example
-* ```ts
-* effect(() => {
-*   const val = untrack(() => someSignal.value); // not tracked
-* });
-* ```
-*/
-function untrack(fn) {
-	const prev = activeEffect;
-	activeEffect = null;
+	r.deps = [], r();
+	let i = (() => r());
+	return i.stop = () => {
+		t = !0, c(r);
+	}, i;
+}
+function f(e) {
+	return d(e);
+}
+function p(e) {
+	let t = n;
+	n = null;
 	try {
-		return fn();
+		return e();
 	} finally {
-		activeEffect = prev;
+		n = t;
 	}
 }
-/**
-* Create an effect scope that collects reactive effects for bulk disposal.
-*
-* @example
-* ```ts
-* const scope = effectScope();
-* scope.run(() => {
-*   effect(() => console.log(count.value));
-*   effect(() => console.log(name.value));
-* });
-* scope.stop(); // disposes both effects
-* ```
-*/
-function effectScope(_detached) {
-	const effects = [];
-	let active = true;
+function m(e) {
+	let t = [], n = !0;
 	return {
-		run(fn) {
-			if (!active) return void 0;
-			return fn();
+		run(e) {
+			if (n) return e();
 		},
 		stop() {
-			active = false;
-			effects.forEach((e) => e());
+			n = !1, t.forEach((e) => e());
 		}
 	};
 }
 //#endregion
 //#region ../reactivity/src/collections.ts
-/** Symbol for tracking iteration dependencies (forEach, keys, values, entries, size) */
-var ITERATE_KEY = Symbol("iterate");
-/** WeakMap to get raw object from reactive proxy */
-var reactiveToRaw = /* @__PURE__ */ new WeakMap();
-/** WeakMap to get reactive proxy from raw object */
-var rawToReactive = /* @__PURE__ */ new WeakMap();
-/**
-* Returns the raw, original object from a reactive proxy.
-* If the value is not a proxy, returns it as-is.
-*/
-function toRaw(observed) {
-	const raw = reactiveToRaw.get(observed);
-	return raw ? toRaw(raw) : observed;
-}
-/**
-* Checks if a value is a reactive proxy created by signal().
-*/
-function isReactive(value) {
-	return reactiveToRaw.has(value);
-}
-/**
-* Checks if a value is a collection type (Set, Map, WeakSet, WeakMap).
-*/
-function isCollection(value) {
-	if (!value || typeof value !== "object") return false;
-	const ctor = value.constructor;
-	return ctor === Set || ctor === Map || ctor === WeakSet || ctor === WeakMap;
-}
-/**
-* Checks if a value is an iterable collection (Set or Map, not Weak variants).
-*/
-function isIterableCollection(value) {
-	if (!value || typeof value !== "object") return false;
-	const ctor = value.constructor;
-	return ctor === Set || ctor === Map;
-}
-/**
-* Checks if a value is an "exotic" built-in object that should NOT be proxied.
-* These objects have internal slots that cannot be accessed through Proxy.
-* Proxying them causes errors like "Method X called on incompatible receiver".
-*/
-function shouldNotProxy(value) {
-	if (!value || typeof value !== "object") return false;
-	const proto = Object.prototype.toString.call(value);
+var h = Symbol("iterate"), g = /* @__PURE__ */ new WeakMap(), _ = /* @__PURE__ */ new WeakMap();
+function v(e) {
+	let t = g.get(e);
+	return t ? v(t) : e;
+}
+function ee(e) {
+	return g.has(e);
+}
+function y(e) {
+	if (!e || typeof e != "object") return !1;
+	let t = e.constructor;
+	return t === Set || t === Map || t === WeakSet || t === WeakMap;
+}
+function te(e) {
+	if (!e || typeof e != "object") return !1;
+	let t = e.constructor;
+	return t === Set || t === Map;
+}
+function b(e) {
+	if (!e || typeof e != "object") return !1;
+	let t = Object.prototype.toString.call(e);
 	return [
 		"[object Date]",
 		"[object RegExp]",
@@ -203,129 +113,83 @@ function shouldNotProxy(value) {
 		"[object Float64Array]",
 		"[object BigInt64Array]",
 		"[object BigUint64Array]"
-	].includes(proto);
-}
-/**
-* Creates instrumented collection methods that properly handle reactivity.
-* These methods call the real collection methods on the raw object while
-* tracking dependencies and triggering updates.
-*/
-function createCollectionInstrumentations(depsMap, getOrCreateDep) {
-	const instrumentations = {};
-	instrumentations.has = function(key) {
-		const target = toRaw(this);
-		const rawKey = toRaw(key);
-		track(getOrCreateDep(rawKey));
-		return target.has(rawKey);
-	};
-	instrumentations.get = function(key) {
-		const target = toRaw(this);
-		const rawKey = toRaw(key);
-		track(getOrCreateDep(rawKey));
-		const value = target.get(rawKey);
-		if (value && typeof value === "object") return rawToReactive.get(value) || value;
-		return value;
-	};
-	Object.defineProperty(instrumentations, "size", { get() {
-		const target = toRaw(this);
-		track(getOrCreateDep(ITERATE_KEY));
-		return target.size;
-	} });
-	instrumentations.forEach = function(callback, thisArg) {
-		const target = toRaw(this);
-		track(getOrCreateDep(ITERATE_KEY));
-		target.forEach((value, key) => {
-			const reactiveValue = value && typeof value === "object" ? rawToReactive.get(value) || value : value;
-			const reactiveKey = key && typeof key === "object" ? rawToReactive.get(key) || key : key;
-			callback.call(thisArg, reactiveValue, reactiveKey, this);
+	].includes(t);
+}
+function ne(e, t) {
+	let n = {};
+	return n.has = function(e) {
+		let n = v(this), r = v(e);
+		return l(t(r)), n.has(r);
+	}, n.get = function(e) {
+		let n = v(this), r = v(e);
+		l(t(r));
+		let i = n.get(r);
+		return i && typeof i == "object" && _.get(i) || i;
+	}, Object.defineProperty(n, "size", { get() {
+		let e = v(this);
+		return l(t(h)), e.size;
+	} }), n.forEach = function(e, n) {
+		let r = v(this);
+		l(t(h)), r.forEach((t, r) => {
+			let i = t && typeof t == "object" && _.get(t) || t, a = r && typeof r == "object" && _.get(r) || r;
+			e.call(n, i, a, this);
 		});
-	};
-	instrumentations.keys = function() {
-		const target = toRaw(this);
-		track(getOrCreateDep(ITERATE_KEY));
-		return createReactiveIterator(target.keys(), false);
-	};
-	instrumentations.values = function() {
-		const target = toRaw(this);
-		track(getOrCreateDep(ITERATE_KEY));
-		return createReactiveIterator(target.values(), true);
-	};
-	instrumentations.entries = function() {
-		const target = toRaw(this);
-		track(getOrCreateDep(ITERATE_KEY));
-		return createReactiveEntriesIterator(target.entries());
-	};
-	instrumentations[Symbol.iterator] = function() {
-		const target = toRaw(this);
-		track(getOrCreateDep(ITERATE_KEY));
-		if (target instanceof Set) return createReactiveIterator(target.values(), true);
-		else return createReactiveEntriesIterator(target.entries());
-	};
-	instrumentations.add = function(value) {
-		const target = toRaw(this);
-		const rawValue = toRaw(value);
-		const hadKey = target.has(rawValue);
-		target.add(rawValue);
-		if (!hadKey) {
-			const dep = depsMap.get(rawValue);
-			if (dep) trigger(dep);
-			const iterDep = depsMap.get(ITERATE_KEY);
-			if (iterDep) trigger(iterDep);
+	}, n.keys = function() {
+		let e = v(this);
+		return l(t(h)), x(e.keys(), !1);
+	}, n.values = function() {
+		let e = v(this);
+		return l(t(h)), x(e.values(), !0);
+	}, n.entries = function() {
+		let e = v(this);
+		return l(t(h)), S(e.entries());
+	}, n[Symbol.iterator] = function() {
+		let e = v(this);
+		return l(t(h)), e instanceof Set ? x(e.values(), !0) : S(e.entries());
+	}, n.add = function(t) {
+		let n = v(this), r = v(t), i = n.has(r);
+		if (n.add(r), !i) {
+			let t = e.get(r);
+			t && u(t);
+			let n = e.get(h);
+			n && u(n);
 		}
 		return this;
-	};
-	instrumentations.set = function(key, value) {
-		const target = toRaw(this);
-		const rawKey = toRaw(key);
-		const rawValue = toRaw(value);
-		const hadKey = target.has(rawKey);
-		const oldValue = target.get(rawKey);
-		target.set(rawKey, rawValue);
-		if (!hadKey) {
-			const iterDep = depsMap.get(ITERATE_KEY);
-			if (iterDep) trigger(iterDep);
+	}, n.set = function(t, n) {
+		let r = v(this), i = v(t), a = v(n), o = r.has(i), s = r.get(i);
+		if (r.set(i, a), !o) {
+			let t = e.get(h);
+			t && u(t);
 		}
-		if (!hadKey || !Object.is(oldValue, rawValue)) {
-			const dep = depsMap.get(rawKey);
-			if (dep) trigger(dep);
+		if (!o || !Object.is(s, a)) {
+			let t = e.get(i);
+			t && u(t);
 		}
 		return this;
-	};
-	instrumentations.delete = function(key) {
-		const target = toRaw(this);
-		const rawKey = toRaw(key);
-		const hadKey = target.has(rawKey);
-		const result = target.delete(rawKey);
-		if (hadKey) {
-			const dep = depsMap.get(rawKey);
-			if (dep) trigger(dep);
-			const iterDep = depsMap.get(ITERATE_KEY);
-			if (iterDep) trigger(iterDep);
+	}, n.delete = function(t) {
+		let n = v(this), r = v(t), i = n.has(r), a = n.delete(r);
+		if (i) {
+			let t = e.get(r);
+			t && u(t);
+			let n = e.get(h);
+			n && u(n);
 		}
-		return result;
-	};
-	instrumentations.clear = function() {
-		const target = toRaw(this);
-		const hadItems = target.size > 0;
-		target.clear();
-		if (hadItems) for (const dep of depsMap.values()) trigger(dep);
-	};
-	return instrumentations;
+		return a;
+	}, n.clear = function() {
+		let t = v(this), n = t.size > 0;
+		if (t.clear(), n) for (let t of e.values()) u(t);
+	}, n;
 }
-/**
-* Creates a reactive iterator that wraps values in reactive proxies.
-*/
-function createReactiveIterator(innerIterator, wrapValues) {
+function x(e, t) {
 	return {
 		next() {
-			const { value, done } = innerIterator.next();
-			if (done) return {
+			let { value: n, done: r } = e.next();
+			return r ? {
 				value: void 0,
-				done: true
-			};
-			return {
-				value: wrapValues && value && typeof value === "object" ? rawToReactive.get(value) || value : value,
-				done: false
+				done: !0
+			} : {
+				value: t && n && typeof n == "object" && _.get(n) || n,
+				done: !1
 			};
 		},
 		[Symbol.iterator]() {
@@ -333,21 +197,18 @@ function createReactiveIterator(innerIterator, wrapValues) {
 		}
 	};
 }
-/**
-* Creates a reactive entries iterator that wraps both keys and values.
-*/
-function createReactiveEntriesIterator(innerIterator) {
+function S(e) {
 	return {
 		next() {
-			const { value, done } = innerIterator.next();
-			if (done) return {
+			let { value: t, done: n } = e.next();
+			if (n) return {
 				value: void 0,
-				done: true
+				done: !0
 			};
-			const [key, val] = value;
+			let [r, i] = t;
 			return {
-				value: [key && typeof key === "object" ? rawToReactive.get(key) || key : key, val && typeof val === "object" ? rawToReactive.get(val) || val : val],
-				done: false
+				value: [r && typeof r == "object" && _.get(r) || r, i && typeof i == "object" && _.get(i) || i],
+				done: !1
 			};
 		},
 		[Symbol.iterator]() {
@@ -357,49 +218,31 @@ function createReactiveEntriesIterator(innerIterator) {
 }
 //#endregion
 //#region ../reactivity/src/signal.ts
-/** Check if a value is a primitive type */
-function isPrimitive(value) {
-	if (value === null || value === void 0) return true;
-	const type = typeof value;
-	return type === "string" || type === "number" || type === "boolean" || type === "symbol" || type === "bigint";
-}
-var accessObserver = null;
-/** @internal Get the current access observer for computed/model integration */
-function getAccessObserver() {
-	return accessObserver;
-}
-/** @internal Temporarily suspend the access observer (used by computed to prevent leakage) */
-function setAccessObserver(observer) {
-	accessObserver = observer;
-}
-/**
-* Detect which reactive property a selector function accesses.
-*
-* Runs `selector()` while observing property accesses and returns the
-* last `[target, key]` pair accessed, or `null` if nothing was read.
-* Used internally by the model/two-way-binding system.
-*
-* @example
-* ```ts
-* const state = signal({ form: { name: 'Alice' } });
-* const result = detectAccess(() => state.form.name);
-* // result === [state.form, 'name']
-* ```
-*/
-function detectAccess(selector) {
-	let result = null;
-	const prev = accessObserver;
-	accessObserver = (target, key) => {
-		result = [target, key];
+function C(e) {
+	if (e == null) return !0;
+	let t = typeof e;
+	return t === "string" || t === "number" || t === "boolean" || t === "symbol" || t === "bigint";
+}
+var w = null;
+function T() {
+	return w;
+}
+function E(e) {
+	w = e;
+}
+function D(e) {
+	let t = null, n = w;
+	w = (e, n) => {
+		t = [e, n];
 	};
 	try {
-		selector();
+		e();
 	} finally {
-		accessObserver = prev;
+		w = n;
 	}
-	return result;
+	return t;
 }
-var arrayInstrumentations = {};
+var O = {};
 [
 	"push",
 	"pop",
@@ -408,577 +251,265 @@ var arrayInstrumentations = {};
 	"splice",
 	"sort",
 	"reverse"
-].forEach((method) => {
-	arrayInstrumentations[method] = function(...args) {
-		let res;
-		batch(() => {
-			res = Array.prototype[method].apply(this, args);
-		});
-		return res;
-	};
-});
-[
+].forEach((e) => {
+	O[e] = function(...t) {
+		let n;
+		return s(() => {
+			n = Array.prototype[e].apply(this, t);
+		}), n;
+	};
+}), [
 	"includes",
 	"indexOf",
 	"lastIndexOf"
-].forEach((method) => {
-	arrayInstrumentations[method] = function(...args) {
-		const raw = toRaw(this);
-		const result = Array.prototype[method].apply(this, args);
-		if (result !== -1 && result !== false) return result;
-		return Array.prototype[method].apply(raw, args);
+].forEach((e) => {
+	O[e] = function(...t) {
+		let n = v(this), r = Array.prototype[e].apply(this, t);
+		return r !== -1 && r !== !1 ? r : Array.prototype[e].apply(n, t);
 	};
 });
-function signal(target) {
-	if (isPrimitive(target)) return signal({ value: target });
-	const objectTarget = target;
-	if (shouldNotProxy(objectTarget)) return objectTarget;
-	if (isReactive(objectTarget)) return objectTarget;
-	const existingProxy = rawToReactive.get(objectTarget);
-	if (existingProxy) return existingProxy;
-	const depsMap = /* @__PURE__ */ new Map();
-	const reactiveCache = /* @__PURE__ */ new WeakMap();
-	const getOrCreateDep = (key) => {
-		let dep = depsMap.get(key);
-		if (!dep) {
-			dep = /* @__PURE__ */ new Set();
-			depsMap.set(key, dep);
-		}
-		return dep;
-	};
-	const collectionInstrumentations = isCollection(objectTarget) ? createCollectionInstrumentations(depsMap, getOrCreateDep) : null;
-	const proxy = new Proxy(objectTarget, {
-		get(obj, prop, receiver) {
-			if (prop === "$set") return (newValue) => {
-				batch(() => {
-					if (Array.isArray(obj) && Array.isArray(newValue)) {
-						const len = newValue.length;
-						for (let i = 0; i < len; i++) Reflect.set(receiver, String(i), newValue[i]);
-						Reflect.set(receiver, "length", len);
+function k(e) {
+	if (C(e)) return k({ value: e });
+	let t = e;
+	if (b(t) || ee(t)) return t;
+	let r = _.get(t);
+	if (r) return r;
+	let i = y(t), a = i ? /* @__PURE__ */ new Map() : null, o = /* @__PURE__ */ new WeakMap(), c = (e) => {
+		a ||= /* @__PURE__ */ new Map();
+		let t = a.get(e);
+		return t || (t = /* @__PURE__ */ new Set(), a.set(e, t)), t;
+	}, d = i ? ne(a, c) : null, f = new Proxy(t, {
+		get(e, t, r) {
+			if (t === "$set") return (t) => {
+				s(() => {
+					if (Array.isArray(e) && Array.isArray(t)) {
+						let e = t.length;
+						for (let n = 0; n < e; n++) Reflect.set(r, String(n), t[n]);
+						Reflect.set(r, "length", e);
 					} else {
-						const newKeys = Object.keys(newValue);
-						const oldKeys = Object.keys(obj);
-						for (const key of newKeys) Reflect.set(receiver, key, newValue[key]);
-						for (const key of oldKeys) if (!(key in newValue)) Reflect.deleteProperty(receiver, key);
+						let n = Object.keys(t), i = Object.keys(e);
+						for (let e of n) Reflect.set(r, e, t[e]);
+						for (let e of i) e in t || Reflect.deleteProperty(r, e);
 					}
 				});
 			};
-			if (collectionInstrumentations) {
-				if (prop === "size" && isIterableCollection(obj)) {
-					track(getOrCreateDep(ITERATE_KEY));
-					return obj.size;
-				}
-				if (prop in collectionInstrumentations) {
-					const instrumented = collectionInstrumentations[prop];
-					if (typeof instrumented === "function") return instrumented.bind(receiver);
-					return instrumented;
+			if (d) {
+				if (t === "size" && te(e)) return n && l(c(h)), e.size;
+				if (t in d) {
+					let e = d[t];
+					return typeof e == "function" ? e.bind(r) : e;
 				}
 			}
-			if (Array.isArray(obj) && typeof prop === "string" && arrayInstrumentations.hasOwnProperty(prop)) return arrayInstrumentations[prop];
-			const value = Reflect.get(obj, prop);
-			if (accessObserver) accessObserver(receiver, prop);
-			if (!collectionInstrumentations) track(getOrCreateDep(prop));
-			if (value && typeof value === "object" && !shouldNotProxy(value)) {
-				let cached = reactiveCache.get(value);
-				if (!cached) {
-					cached = signal(value);
-					reactiveCache.set(value, cached);
-				}
-				return cached;
+			if (Array.isArray(e) && typeof t == "string" && O.hasOwnProperty(t)) return O[t];
+			let i = Reflect.get(e, t);
+			if (w && w(r, t), !d && n && l(c(t)), i && typeof i == "object" && !b(i)) {
+				let e = o.get(i);
+				return e || (e = k(i), o.set(i, e)), e;
 			}
-			return value;
+			return i;
 		},
-		set(obj, prop, newValue) {
-			const oldLength = Array.isArray(obj) ? obj.length : 0;
-			const oldValue = Reflect.get(obj, prop);
-			const result = Reflect.set(obj, prop, newValue);
-			if (!Object.is(oldValue, newValue)) {
-				const dep = depsMap.get(prop);
-				if (dep) trigger(dep);
-				if (Array.isArray(obj)) {
-					if (prop !== "length" && obj.length !== oldLength) {
-						const lengthDep = depsMap.get("length");
-						if (lengthDep) trigger(lengthDep);
+		set(e, t, n) {
+			let r = Array.isArray(e) ? e.length : 0, i = Reflect.get(e, t), o = Reflect.set(e, t, n);
+			if (!Object.is(i, n) && a) {
+				let i = a.get(t);
+				if (i && u(i), Array.isArray(e)) {
+					if (t !== "length" && e.length !== r) {
+						let e = a.get("length");
+						e && u(e);
 					}
-					if (prop === "length" && typeof newValue === "number" && newValue < oldLength) for (let i = newValue; i < oldLength; i++) {
-						const idxDep = depsMap.get(String(i));
-						if (idxDep) trigger(idxDep);
+					if (t === "length" && typeof n == "number" && n < r) for (let e = n; e < r; e++) {
+						let t = a.get(String(e));
+						t && u(t);
 					}
 				}
 			}
-			return result;
+			return o;
 		},
-		deleteProperty(obj, prop) {
-			const hasKey = Object.prototype.hasOwnProperty.call(obj, prop);
-			const result = Reflect.deleteProperty(obj, prop);
-			if (result && hasKey) {
-				const dep = depsMap.get(prop);
-				if (dep) trigger(dep);
+		deleteProperty(e, t) {
+			let n = Object.prototype.hasOwnProperty.call(e, t), r = Reflect.deleteProperty(e, t);
+			if (r && n && a) {
+				let e = a.get(t);
+				e && u(e);
 			}
-			return result;
+			return r;
 		}
 	});
-	reactiveToRaw.set(proxy, objectTarget);
-	rawToReactive.set(objectTarget, proxy);
-	return proxy;
+	return g.set(f, t), _.set(t, f), f;
 }
 //#endregion
 //#region ../reactivity/src/watch.ts
-/**
-* Deeply traverses an object to trigger reactive tracking on all nested properties.
-* @param value The value to traverse
-* @param depth Maximum depth to traverse (Infinity for unlimited, number for limited)
-* @param seen Set of already visited objects to prevent circular references
-*/
-function traverse(value, depth = Infinity, seen = /* @__PURE__ */ new Set()) {
-	if (depth <= 0) return value;
-	if (value === null || typeof value !== "object") return value;
-	if (seen.has(value)) return value;
-	seen.add(value);
-	if (Array.isArray(value)) for (let i = 0; i < value.length; i++) traverse(value[i], depth - 1, seen);
-	else if (value instanceof Map) value.forEach((v, k) => {
-		traverse(k, depth - 1, seen);
-		traverse(v, depth - 1, seen);
+function A(e, t = Infinity, n = /* @__PURE__ */ new Set()) {
+	if (t <= 0 || typeof e != "object" || !e || n.has(e)) return e;
+	if (n.add(e), Array.isArray(e)) for (let r = 0; r < e.length; r++) A(e[r], t - 1, n);
+	else if (e instanceof Map) e.forEach((e, r) => {
+		A(r, t - 1, n), A(e, t - 1, n);
 	});
-	else if (value instanceof Set) value.forEach((v) => {
-		traverse(v, depth - 1, seen);
+	else if (e instanceof Set) e.forEach((e) => {
+		A(e, t - 1, n);
 	});
-	else for (const key of Object.keys(value)) traverse(value[key], depth - 1, seen);
-	return value;
-}
-/**
-* Watch a reactive source and run a callback when it changes.
-* Supports deep watching, immediate invocation, and pause/resume.
-*
-* @example
-* ```ts
-* const count = signal(0);
-* const handle = watch(() => count.value, (newVal, oldVal) => {
-*   console.log(`${oldVal} → ${newVal}`);
-* });
-* handle.stop(); // stop watching
-* ```
-*/
-function watch(source, cb, options) {
-	let oldValue;
-	let isFirst = true;
-	let cleanupFn = null;
-	let paused = false;
-	let pendingValue;
-	let hasPending = false;
-	let stopped = false;
-	const deep = options?.deep;
-	const traverseDepth = deep === true ? Infinity : typeof deep === "number" ? deep : 0;
-	const runner = effect(() => {
-		if (stopped) return;
-		let newValue = typeof source === "function" ? source() : source;
-		if (traverseDepth > 0) traverse(newValue, traverseDepth);
-		if (paused) {
-			pendingValue = newValue;
-			hasPending = true;
+	else for (let r of Object.keys(e)) A(e[r], t - 1, n);
+	return e;
+}
+function re(e, t, n) {
+	let r, i = !0, a = null, o = !1, s, c = !1, l = !1, u = n?.deep, d = u === !0 ? Infinity : typeof u == "number" ? u : 0, p = f(() => {
+		if (l) return;
+		let u = typeof e == "function" ? e() : e;
+		if (d > 0 && A(u, d), o) {
+			s = u, c = !0;
 			return;
 		}
-		if (isFirst) {
-			if (options?.immediate) {
-				if (cleanupFn) cleanupFn();
-				cb(newValue, oldValue, (fn) => cleanupFn = fn);
-				if (options?.once) {
-					stopped = true;
-					queueMicrotask(() => stop());
-				}
-			}
-			isFirst = false;
-		} else {
-			if (cleanupFn) cleanupFn();
-			cb(newValue, oldValue, (fn) => cleanupFn = fn);
-			if (options?.once) {
-				stopped = true;
-				queueMicrotask(() => stop());
-			}
-		}
-		oldValue = newValue;
-	});
-	const stop = () => {
-		stopped = true;
-		runner.stop();
-		if (cleanupFn) cleanupFn();
-	};
-	const pause = () => {
-		paused = true;
-	};
-	const resume = () => {
-		if (!paused) return;
-		paused = false;
-		if (hasPending && !Object.is(pendingValue, oldValue)) {
-			if (cleanupFn) cleanupFn();
-			cb(pendingValue, oldValue, (fn) => cleanupFn = fn);
-			oldValue = pendingValue;
+		i ? (n?.immediate && (a && a(), t(u, r, (e) => a = e), n?.once && (l = !0, queueMicrotask(() => m()))), i = !1) : (a && a(), t(u, r, (e) => a = e), n?.once && (l = !0, queueMicrotask(() => m()))), r = u;
+	}), m = () => {
+		l = !0, p.stop(), a && a();
+	};
+	return Object.assign(m, {
+		stop: m,
+		pause: () => {
+			o = !0;
+		},
+		resume: () => {
+			o && (o = !1, c && !Object.is(s, r) && (a && a(), t(s, r, (e) => a = e), r = s), c = !1, s = void 0);
 		}
-		hasPending = false;
-		pendingValue = void 0;
-	};
-	return Object.assign(stop, {
-		stop,
-		pause,
-		resume
 	});
 }
 //#endregion
 //#region ../reactivity/src/computed.ts
-function computed(getterOrOptions) {
-	let getter;
-	let setter;
-	if (typeof getterOrOptions === "function") getter = getterOrOptions;
-	else {
-		getter = getterOrOptions.get;
-		setter = getterOrOptions.set;
-	}
-	const subscribers = /* @__PURE__ */ new Set();
-	let cachedValue;
-	let dirty = true;
-	const computedEffect = function() {
-		if (!dirty) {
-			dirty = true;
-			trigger(subscribers);
-		}
-	};
-	computedEffect.deps = [];
-	const computeValue = () => {
-		cleanup(computedEffect);
-		const prevEffect = getActiveEffect();
-		setActiveEffect(computedEffect);
+function ie(e) {
+	let n, r;
+	typeof e == "function" ? n = e : (n = e.get, r = e.set);
+	let i = /* @__PURE__ */ new Set(), s, d = !0, f = function() {
+		d || (d = !0, u(i));
+	};
+	f.deps = [];
+	let p = () => {
+		c(f);
+		let e = o();
+		a(f);
 		try {
-			cachedValue = getter();
-			dirty = false;
-			return cachedValue;
+			return s = n(), d = !1, s;
 		} finally {
-			setActiveEffect(prevEffect);
+			a(e);
 		}
-	};
-	const computedObj = {
-		[ComputedSymbol]: true,
+	}, m = {
+		[t]: !0,
 		get value() {
-			const observer = getAccessObserver();
-			if (observer) {
-				observer(computedObj, "value");
-				setAccessObserver(null);
-			}
-			track(subscribers);
-			const result = dirty ? computeValue() : cachedValue;
-			if (observer) setAccessObserver(observer);
-			return result;
+			let e = T();
+			e && (e(m, "value"), E(null)), l(i);
+			let t = d ? p() : s;
+			return e && E(e), t;
 		}
 	};
-	if (setter) {
-		Object.defineProperty(computedObj, "value", {
-			get() {
-				const observer = getAccessObserver();
-				if (observer) {
-					observer(computedObj, "value");
-					setAccessObserver(null);
-				}
-				track(subscribers);
-				const result = dirty ? computeValue() : cachedValue;
-				if (observer) setAccessObserver(observer);
-				return result;
-			},
-			set(newValue) {
-				setter(newValue);
-			},
-			enumerable: true,
-			configurable: false
-		});
-		return computedObj;
-	}
-	return computedObj;
-}
-/**
-* Type guard to check if a value is a computed signal.
-* 
-* @example
-* ```ts
-* const doubled = computed(() => count.value * 2);
-* console.log(isComputed(doubled)); // true
-* console.log(isComputed({ value: 1 })); // false
-* ```
-*/
-function isComputed(value) {
-	return value !== null && typeof value === "object" && ComputedSymbol in value;
+	return r && Object.defineProperty(m, "value", {
+		get() {
+			let e = T();
+			e && (e(m, "value"), E(null)), l(i);
+			let t = d ? p() : s;
+			return e && E(e), t;
+		},
+		set(e) {
+			r(e);
+		},
+		enumerable: !0,
+		configurable: !1
+	}), m;
+}
+function j(e) {
+	return typeof e == "object" && !!e && t in e;
 }
 //#endregion
 //#region ../runtime-core/src/plugins.ts
-var plugins = [];
-/**
-* Get all registered plugins (internal use)
-*/
-function getComponentPlugins() {
-	return plugins;
-}
-var contextExtensions = [];
-/**
-* Apply all registered context extensions to a context object.
-* Called internally by the renderer when creating component contexts.
-*/
-function applyContextExtensions(ctx) {
-	for (const extension of contextExtensions) extension(ctx);
+var ae = [];
+function oe() {
+	return ae;
+}
+var se = [];
+function ce(e) {
+	for (let t of se) t(e);
 }
 //#endregion
 //#region __vite-browser-external
-var require___vite_browser_external = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	module.exports = {};
-}));
-//#endregion
-//#region ../runtime-core/src/async-context.ts
-/**
-* Try to load AsyncLocalStorage from Node.js.
-* Returns null in browser environments.
-*/
-var asyncLocalStorage = null;
+var le = /* @__PURE__ */ e(((e, t) => {
+	t.exports = {};
+})), ue = null;
 try {
-	if (typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined") {
-		const nodeAsync = globalThis.process?.versions?.node ? require___vite_browser_external() : null;
-		if (nodeAsync?.AsyncLocalStorage) asyncLocalStorage = new nodeAsync.AsyncLocalStorage();
+	if (typeof globalThis < "u" && globalThis.process !== void 0) {
+		let e = globalThis.process?.versions?.node ? le() : null;
+		e?.AsyncLocalStorage && (ue = new e.AsyncLocalStorage());
 	}
 } catch {}
-var _fallbackContext = {
+var de = {
 	currentComponentContext: null,
 	currentSuspenseBoundary: null
 };
-/**
-* Get the current request context.
-* Returns the AsyncLocalStorage store if available, otherwise the module-level fallback.
-*/
-function getRequestContext() {
-	if (asyncLocalStorage) {
-		const store = asyncLocalStorage.getStore();
-		if (store) return store;
+function fe() {
+	if (ue) {
+		let e = ue.getStore();
+		if (e) return e;
 	}
-	return _fallbackContext;
-}
-/**
-* Get the current component context (request-safe).
-*/
-function getCurrentInstanceSafe() {
-	return getRequestContext().currentComponentContext;
-}
-/**
-* Set the current component context (request-safe).
-* Returns the previous value.
-*/
-function setCurrentInstanceSafe(ctx) {
-	const reqCtx = getRequestContext();
-	const prev = reqCtx.currentComponentContext;
-	reqCtx.currentComponentContext = ctx;
-	return prev;
-}
-/**
-* Get the current suspense boundary (request-safe).
-*/
-function getCurrentSuspenseBoundarySafe() {
-	return getRequestContext().currentSuspenseBoundary;
-}
-/**
-* Set the current suspense boundary (request-safe).
-* Returns the previous value.
-*/
-function setCurrentSuspenseBoundarySafe(boundary) {
-	const reqCtx = getRequestContext();
-	const prev = reqCtx.currentSuspenseBoundary;
-	reqCtx.currentSuspenseBoundary = boundary;
-	return prev;
+	return de;
+}
+function pe() {
+	return fe().currentComponentContext;
+}
+function me(e) {
+	let t = fe(), n = t.currentComponentContext;
+	return t.currentComponentContext = e, n;
+}
+function he() {
+	return fe().currentSuspenseBoundary;
+}
+function ge(e) {
+	let t = fe(), n = t.currentSuspenseBoundary;
+	return t.currentSuspenseBoundary = e, n;
 }
 //#endregion
 //#region ../runtime-core/src/component.ts
-var currentComponentContext = null;
-/**
-* Returns the setup context of the currently executing component, or `null` if called outside setup.
-*
-* Use this to access the component context (props, emit, etc.) from composable functions
-* or lifecycle hooks that run during component setup.
-*
-* @example
-* ```ts
-* function useMyComposable() {
-*     const ctx = getCurrentInstance();
-*     if (!ctx) throw new Error('Must be called during component setup');
-*     ctx.onMounted(({ el }) => console.log('Mounted to', el));
-* }
-* ```
-*/
-function getCurrentInstance() {
-	return getCurrentInstanceSafe() ?? currentComponentContext;
-}
-function setCurrentInstance(ctx) {
-	const prevSafe = setCurrentInstanceSafe(ctx);
-	const prevModule = currentComponentContext;
-	currentComponentContext = ctx;
-	return prevSafe ?? prevModule;
-}
-/**
-* Register a callback to run after the component is mounted to the DOM.
-* Must be called during component setup.
-*
-* @param fn - Callback receiving a {@link MountContext} with the component's root element.
-*
-* @example
-* ```ts
-* const MyComponent = component(() => {
-*     onMounted(({ el }) => {
-*         console.log('Mounted to', el);
-*     });
-*     return () => <div>Hello</div>;
-* });
-* ```
-*/
-function onMounted(fn) {
-	if (currentComponentContext) currentComponentContext.onMounted(fn);
-	else console.warn("onMounted called outside of component setup");
-}
-/**
-* Register a callback to run when the component is unmounted from the DOM.
-* Must be called during component setup. Use for cleanup (event listeners, timers, subscriptions).
-*
-* @param fn - Callback receiving a {@link MountContext} with the component's root element.
-*
-* @example
-* ```ts
-* const MyComponent = component(() => {
-*     const timer = setInterval(() => tick(), 1000);
-*     onUnmounted(() => clearInterval(timer));
-*     return () => <div>Tick</div>;
-* });
-* ```
-*/
-function onUnmounted(fn) {
-	if (currentComponentContext) currentComponentContext.onUnmounted(fn);
-	else console.warn("onUnmounted called outside of component setup");
-}
-/**
-* Register a callback to run immediately after component setup completes,
-* before the first render. Must be called during component setup.
-*
-* @example
-* ```ts
-* const MyComponent = component(() => {
-*     onCreated(() => console.log('Setup done, about to render'));
-*     return () => <div>Hello</div>;
-* });
-* ```
-*/
-function onCreated(fn) {
-	if (currentComponentContext) currentComponentContext.onCreated(fn);
-	else console.warn("onCreated called outside of component setup");
-}
-/**
-* Register a callback to run after every reactive re-render of the component.
-* Must be called during component setup.
-*
-* @example
-* ```ts
-* const Counter = component(() => {
-*     const state = signal({ count: 0 });
-*     onUpdated(() => console.log('Re-rendered with count:', state.count));
-*     return () => <button onClick={() => state.count++}>{state.count}</button>;
-* });
-* ```
-*/
-function onUpdated(fn) {
-	if (currentComponentContext) currentComponentContext.onUpdated(fn);
-	else console.warn("onUpdated called outside of component setup");
-}
-var componentRegistry = /* @__PURE__ */ new Map();
-/**
-* Get component metadata (for DevTools)
-*/
-function getComponentMeta(factory) {
-	return componentRegistry.get(factory);
-}
-/**
-* Define a component. Returns a JSX factory function.
-* 
-* @param setup - Setup function that receives context and returns a render function
-* @param options - Optional configuration (e.g., name for DevTools)
-* 
-* @example
-* ```tsx
-* type CardProps = DefineProp<"title", string> & DefineSlot<"header">;
-* 
-* export const Card = component<CardProps>((ctx) => {
-*     const { title } = ctx.props;
-*     const { slots } = ctx;
-*     
-*     return () => (
-*         <div class="card">
-*             {slots.header?.() ?? <h2>{title}</h2>}
-*             {slots.default()}
-*         </div>
-*     );
-* });
-* ```
-*/
-function component(setup, options) {
-	const factory = function(props) {
+var M = null;
+function _e() {
+	return pe() ?? M;
+}
+function ve(e) {
+	let t = me(e), n = M;
+	return M = e, t ?? n;
+}
+function N(e) {
+	M ? M.onMounted(e) : console.warn("onMounted called outside of component setup");
+}
+function P(e) {
+	M ? M.onUnmounted(e) : console.warn("onUnmounted called outside of component setup");
+}
+function ye(e) {
+	M ? M.onCreated(e) : console.warn("onCreated called outside of component setup");
+}
+function be(e) {
+	M ? M.onUpdated(e) : console.warn("onUpdated called outside of component setup");
+}
+var xe = /* @__PURE__ */ new Map();
+function Se(e) {
+	return xe.get(e);
+}
+function F(e, t) {
+	let n = function(e) {
 		return {
-			type: factory,
-			props: props || {},
-			key: props?.key || null,
+			type: n,
+			props: e || {},
+			key: e?.key || null,
 			children: [],
 			dom: null
 		};
 	};
-	factory.__setup = setup;
-	factory.__name = options?.name;
-	factory.__props = null;
-	factory.__events = null;
-	factory.__ref = null;
-	factory.__slots = null;
-	componentRegistry.set(factory, {
-		name: options?.name,
-		setup
-	});
-	getComponentPlugins().forEach((p) => p.onDefine?.(options?.name, factory, setup));
-	return factory;
+	return n.__setup = e, n.__name = t?.name, n.__props = null, n.__events = null, n.__ref = null, n.__slots = null, xe.set(n, {
+		name: t?.name,
+		setup: e
+	}), oe().forEach((r) => r.onDefine?.(t?.name, n, e)), n;
 }
 //#endregion
 //#region ../runtime-core/src/errors.ts
-/**
-* Structured error system for SignalX runtime.
-*
-* Every runtime error has a unique code (SIGX001–SIGX999) so users can
-* programmatically handle errors and look them up in documentation.
-*
-* @example
-* ```ts
-* try {
-*     app.mount('#app');
-* } catch (e) {
-*     if (e instanceof SigxError && e.code === 'SIGX101') {
-*         // handle missing mount target
-*     }
-* }
-* ```
-*/
-/**
-* Base error class for all SignalX runtime errors.
-*/
-var SigxError = class extends Error {
-	constructor(message, options) {
-		super(message);
-		this.name = "SigxError";
-		this.code = options.code;
-		this.suggestion = options.suggestion;
-		if (options.cause) this.cause = options.cause;
+var I = class extends Error {
+	constructor(e, t) {
+		super(e), this.name = "SigxError", this.code = t.code, this.suggestion = t.suggestion, t.cause && (this.cause = t.cause);
 	}
-};
-/**
-* Error codes for the SignalX runtime.
-*
-* Ranges:
-* - SIGX001–SIGX099: App lifecycle
-* - SIGX100–SIGX199: Rendering / mounting
-* - SIGX200–SIGX299: Dependency injection
-*/
-var SigxErrorCode = {
+}, L = {
 	NO_MOUNT_FUNCTION: "SIGX001",
 	RENDER_TARGET_NOT_FOUND: "SIGX100",
 	MOUNT_TARGET_NOT_FOUND: "SIGX101",
@@ -986,1902 +517,1037 @@ var SigxErrorCode = {
 	PROVIDE_OUTSIDE_SETUP: "SIGX200",
 	PROVIDE_INVALID_INJECTABLE: "SIGX201"
 };
-function noMountFunctionError() {
-	return new SigxError("No mount function provided and no default mount function set.", {
-		code: SigxErrorCode.NO_MOUNT_FUNCTION,
+function Ce() {
+	return new I("No mount function provided and no default mount function set.", {
+		code: L.NO_MOUNT_FUNCTION,
 		suggestion: "Either pass a mount function to app.mount(), or import a platform package (e.g., @sigx/runtime-dom or @sigx/runtime-terminal) that sets the default."
 	});
 }
-function renderTargetNotFoundError(selector) {
-	return new SigxError(`Render target "${selector}" not found.`, {
-		code: SigxErrorCode.RENDER_TARGET_NOT_FOUND,
-		suggestion: `Make sure the element exists in your HTML: <div id="${selector.replace(/^#/, "")}"></div>`
+function we(e) {
+	return new I(`Render target "${e}" not found.`, {
+		code: L.RENDER_TARGET_NOT_FOUND,
+		suggestion: `Make sure the element exists in your HTML: <div id="${e.replace(/^#/, "")}"></div>`
 	});
 }
-function mountTargetNotFoundError(selector) {
-	return new SigxError(`Mount target "${selector}" not found.`, {
-		code: SigxErrorCode.MOUNT_TARGET_NOT_FOUND,
-		suggestion: `Make sure the element exists in your HTML: <div id="${selector.replace(/^#/, "")}"></div>`
+function Te(e) {
+	return new I(`Mount target "${e}" not found.`, {
+		code: L.MOUNT_TARGET_NOT_FOUND,
+		suggestion: `Make sure the element exists in your HTML: <div id="${e.replace(/^#/, "")}"></div>`
 	});
 }
-function asyncSetupClientError(componentName) {
-	return new SigxError(`Async setup in component "${componentName}" is only supported during SSR.`, {
-		code: SigxErrorCode.ASYNC_SETUP_CLIENT,
+function Ee(e) {
+	return new I(`Async setup in component "${e}" is only supported during SSR.`, {
+		code: L.ASYNC_SETUP_CLIENT,
 		suggestion: "On the client, use pre-loaded data from hydration or fetch in onMounted."
 	});
 }
-function provideOutsideSetupError() {
-	return new SigxError("defineProvide must be called inside a component setup function.", {
-		code: SigxErrorCode.PROVIDE_OUTSIDE_SETUP,
+function De() {
+	return new I("defineProvide must be called inside a component setup function.", {
+		code: L.PROVIDE_OUTSIDE_SETUP,
 		suggestion: "Move the defineProvide() call inside your component's setup function, or use app.defineProvide() at the app level."
 	});
 }
-function provideInvalidInjectableError() {
-	return new SigxError("defineProvide must be called with a function created by defineInjectable.", {
-		code: SigxErrorCode.PROVIDE_INVALID_INJECTABLE,
+function Oe() {
+	return new I("defineProvide must be called with a function created by defineInjectable.", {
+		code: L.PROVIDE_INVALID_INJECTABLE,
 		suggestion: "Create an injectable first:\n  const useMyService = defineInjectable(() => new MyService());\n  defineProvide(useMyService);"
 	});
 }
 //#endregion
 //#region ../runtime-core/src/di/injectable.ts
-/**
-* Global singleton instances (fallback when no provider found)
-*/
-var globalInstances = /* @__PURE__ */ new Map();
-/**
-* Token for the AppContext injectable.
-* Used to provide/lookup the AppContext in the component tree.
-*/
-var appContextToken = Symbol("sigx:appContext");
-/**
-* Lookup a provided value by token, traversing component tree.
-* The AppContext is provided at the root component level, so it's found
-* just like any other provided value.
-* @internal
-*/
-function lookupProvided(token) {
-	const ctx = getCurrentInstance();
-	if (!ctx) return;
-	let current = ctx;
-	while (current) {
-		if (current.provides && current.provides.has(token)) return current.provides.get(token);
-		current = current.parent;
+var ke = /* @__PURE__ */ new Map(), Ae = Symbol("sigx:appContext");
+function je(e) {
+	let t = _e();
+	if (!t) return;
+	let n = t;
+	for (; n;) {
+		if (n.provides && n.provides.has(e)) return n.provides.get(e);
+		n = n.parent;
 	}
 }
-/**
-* Provide a value at the current component level
-* @internal
-*/
-function provideAtComponent(token, value) {
-	const ctx = getCurrentInstance();
-	if (!ctx) throw provideOutsideSetupError();
-	const node = ctx;
-	if (!node.provides) node.provides = /* @__PURE__ */ new Map();
-	node.provides.set(token, value);
-}
-/**
-* Define an injectable service/value that can be provided at app or component level.
-* 
-* The returned function can be called to get the current instance:
-* - If provided at component level via `defineProvide()`, returns that instance
-* - If provided at app level via `app.defineProvide()`, returns that instance  
-* - Otherwise falls back to a global singleton created by the factory
-* 
-* @example
-* ```typescript
-* // Define a service
-* const useApiConfig = defineInjectable(() => ({ 
-*     baseUrl: 'https://api.example.com' 
-* }));
-* 
-* // Use it in any component - gets nearest provided instance or global singleton
-* const config = useApiConfig();
-* console.log(config.baseUrl);
-* ```
-*/
-function defineInjectable(factory) {
-	const token = Symbol();
-	const useFn = (() => {
-		const provided = lookupProvided(token);
-		if (provided !== void 0) return provided;
-		if (!globalInstances.has(token)) globalInstances.set(token, factory());
-		return globalInstances.get(token);
+function Me(e, t) {
+	let n = _e();
+	if (!n) throw De();
+	let r = n;
+	r.provides ||= /* @__PURE__ */ new Map(), r.provides.set(e, t);
+}
+function Ne(e) {
+	let t = Symbol(), n = (() => {
+		let n = je(t);
+		return n === void 0 ? (ke.has(t) || ke.set(t, e()), ke.get(t)) : n;
 	});
-	useFn._factory = factory;
-	useFn._token = token;
-	return useFn;
-}
-/**
-* Provide a new instance of an injectable at the current component level.
-* Child components will receive this instance when calling the injectable function.
-* 
-* @param useFn - The injectable function created by defineInjectable
-* @param factory - Optional custom factory to create the instance (overrides default)
-* 
-* @example
-* ```typescript
-* const useApiConfig = defineInjectable(() => ({ baseUrl: 'https://api.example.com' }));
-* 
-* const MyComponent = component(() => {
-*     // Create and provide a new instance for this subtree
-*     const config = defineProvide(useApiConfig);
-*     config.baseUrl = 'https://custom.api.com';
-*     
-*     return () => <ChildComponent />;
-* });
-* 
-* // Or provide a pre-constructed instance:
-* const MyComponent2 = component(() => {
-*     const customService = createMyService({ custom: 'options' });
-*     defineProvide(useMyService, () => customService);
-*     
-*     return () => <ChildComponent />;
-* });
-* ```
-*/
-function defineProvide(useFn, factory) {
-	const actualFactory = factory ?? useFn._factory;
-	const token = useFn._token;
-	if (!actualFactory || !token) throw provideInvalidInjectableError();
-	const instance = actualFactory();
-	provideAtComponent(token, instance);
-	return instance;
-}
-/**
-* Get the current AppContext from the component tree.
-* The AppContext is provided at the root component level during mount/hydrate/SSR.
-* 
-* @example
-* ```typescript
-* const appContext = useAppContext();
-* console.log(appContext?.app);
-* ```
-*/
-function useAppContext() {
-	return lookupProvided(appContextToken) ?? null;
-}
-/**
-* Get the AppContext token.
-* Used by renderers to provide the AppContext at the root component level.
-* @internal
-*/
-function getAppContextToken() {
-	return appContextToken;
-}
-/**
-* Provide the AppContext on a component's provides Map.
-* Called by the renderer for the ROOT component only.
-* @internal
-*/
-function provideAppContext(ctx, appContext) {
-	const node = ctx;
-	if (!node.provides) node.provides = /* @__PURE__ */ new Map();
-	node.provides.set(appContextToken, appContext);
-	if (appContext.provides) for (const [token, value] of appContext.provides) node.provides.set(token, value);
+	return n._factory = e, n._token = t, n;
+}
+function Pe(e, t) {
+	let n = t ?? e._factory, r = e._token;
+	if (!n || !r) throw Oe();
+	let i = n();
+	return Me(r, i), i;
+}
+function Fe() {
+	return je(Ae) ?? null;
+}
+function Ie() {
+	return Ae;
+}
+function Le(e, t) {
+	let n = e;
+	if (n.provides ||= /* @__PURE__ */ new Map(), n.provides.set(Ae, t), t.provides) for (let [e, r] of t.provides) n.provides.set(e, r);
 }
 //#endregion
 //#region ../runtime-core/src/directives.ts
-/**
-* Marker symbol to identify directive definitions.
-* @internal
-*/
-var __DIRECTIVE__ = Symbol.for("sigx.directive");
-/**
-* Define a directive. This is an identity function that marks the definition
-* for type inference and runtime identification.
-*
-* @example
-* ```ts
-* const highlight = defineDirective<string>({
-*     mounted(el, { value }) {
-*         el.style.backgroundColor = value;
-*     },
-*     updated(el, { value }) {
-*         el.style.backgroundColor = value;
-*     }
-* });
-* ```
-*/
-function defineDirective(definition) {
-	definition[__DIRECTIVE__] = true;
-	return definition;
-}
-/**
-* Check if a value is a directive definition.
-*/
-function isDirective(value) {
-	return value != null && typeof value === "object" && value[__DIRECTIVE__] === true;
+var Re = Symbol.for("sigx.directive");
+function ze(e) {
+	return e[Re] = !0, e;
+}
+function Be(e) {
+	return typeof e == "object" && !!e && e[Re] === !0;
 }
 //#endregion
 //#region ../runtime-core/src/app.ts
-var isDev = typeof process !== "undefined" && process.env.NODE_ENV !== "production" || true;
-var defaultMountFn = null;
-/**
-* Set the default mount function for the platform.
-* Called by platform packages (runtime-dom, runtime-terminal) on import.
-* 
-* @example
-* ```typescript
-* // In @sigx/runtime-dom
-* import { setDefaultMount } from '@sigx/runtime-core';
-* setDefaultMount(domMount);
-* ```
-*/
-function setDefaultMount(mountFn) {
-	defaultMountFn = mountFn;
-}
-/**
-* Create an application instance.
-* 
-* @example
-* ```tsx
-* import { defineApp, defineInjectable } from '@sigx/runtime-core';
-* 
-* // Define an injectable service
-* const useApiConfig = defineInjectable(() => ({ baseUrl: 'https://api.example.com' }));
-* 
-* const app = defineApp(<App />);
-* 
-* app.use(myPlugin, { option: 'value' });
-* 
-* // Provide custom instance at app level
-* const config = app.defineProvide(useApiConfig);
-* config.baseUrl = 'https://custom.api.com';
-* 
-* app.mount(document.getElementById('app')!);
-* ```
-*/
-function defineApp(rootComponent) {
-	const installedPlugins = /* @__PURE__ */ new Set();
-	const context = {
+var R = typeof process < "u" && process.env.NODE_ENV !== "production" || !0, Ve = null;
+function He(e) {
+	Ve = e;
+}
+function Ue(e) {
+	let t = /* @__PURE__ */ new Set(), n = {
 		app: null,
 		provides: /* @__PURE__ */ new Map(),
 		config: {},
 		hooks: [],
 		directives: /* @__PURE__ */ new Map()
-	};
-	let isMounted = false;
-	let container = null;
-	let unmountFn = null;
-	const app = {
-		config: context.config,
-		use(plugin, options) {
-			if (installedPlugins.has(plugin)) {
-				if (isDev) console.warn(`Plugin ${plugin.name || "anonymous"} is already installed.`);
-				return app;
-			}
-			installedPlugins.add(plugin);
-			if (typeof plugin === "function") plugin(app, options);
-			else if (plugin && typeof plugin.install === "function") plugin.install(app, options);
-			else if (isDev) console.warn("Invalid plugin: must be a function or have an install() method.");
-			return app;
+	}, r = !1, i = null, a = null, o = {
+		config: n.config,
+		use(e, n) {
+			return t.has(e) ? (R && console.warn(`Plugin ${e.name || "anonymous"} is already installed.`), o) : (t.add(e), typeof e == "function" ? e(o, n) : e && typeof e.install == "function" ? e.install(o, n) : R && console.warn("Invalid plugin: must be a function or have an install() method."), o);
 		},
-		defineProvide(useFn, factory) {
-			const actualFactory = factory ?? useFn._factory;
-			const token = useFn._token;
-			if (!actualFactory || !token) throw provideInvalidInjectableError();
-			const instance = actualFactory();
-			context.provides.set(token, instance);
-			return instance;
+		defineProvide(e, t) {
+			let r = t ?? e._factory, i = e._token;
+			if (!r || !i) throw Oe();
+			let a = r();
+			return n.provides.set(i, a), a;
 		},
-		hook(hooks) {
-			context.hooks.push(hooks);
-			return app;
+		hook(e) {
+			return n.hooks.push(e), o;
 		},
-		directive(name, definition) {
-			if (definition !== void 0) {
-				if (isDev && !isDirective(definition)) console.warn(`[sigx] app.directive('${name}', ...) received a value that is not a valid directive definition. Use defineDirective() to create directive definitions.`);
-				context.directives.set(name, definition);
-				return app;
-			}
-			return context.directives.get(name);
+		directive(e, t) {
+			return t === void 0 ? n.directives.get(e) : (R && !Be(t) && console.warn(`[sigx] app.directive('${e}', ...) received a value that is not a valid directive definition. Use defineDirective() to create directive definitions.`), n.directives.set(e, t), o);
 		},
-		mount(target, renderFn) {
-			if (isMounted) {
-				if (isDev) console.warn("App is already mounted. Call app.unmount() first.");
-				return app;
-			}
-			const mountFn = renderFn ?? defaultMountFn;
-			if (!mountFn) throw noMountFunctionError();
-			container = target;
-			isMounted = true;
-			const result = mountFn(rootComponent, target, context);
-			if (typeof result === "function") unmountFn = result;
-			return app;
+		mount(t, s) {
+			if (r) return R && console.warn("App is already mounted. Call app.unmount() first."), o;
+			let c = s ?? Ve;
+			if (!c) throw Ce();
+			i = t, r = !0;
+			let l = c(e, t, n);
+			return typeof l == "function" && (a = l), o;
 		},
 		unmount() {
-			if (!isMounted) {
-				if (isDev) console.warn("App is not mounted.");
+			if (!r) {
+				R && console.warn("App is not mounted.");
 				return;
 			}
-			if (unmountFn) unmountFn();
-			context.provides.clear();
-			isMounted = false;
-			container = null;
+			a && a(), n.provides.clear(), r = !1, i = null;
 		},
 		get _context() {
-			return context;
+			return n;
 		},
 		get _isMounted() {
-			return isMounted;
+			return r;
 		},
 		get _container() {
-			return container;
+			return i;
 		},
 		get _rootComponent() {
-			return rootComponent;
+			return e;
 		}
 	};
-	context.app = app;
-	const appContextToken = getAppContextToken();
-	context.provides.set(appContextToken, context);
-	return app;
-}
-/**
-* Notify all app hooks that a component was created.
-* Called by the renderer after setup() returns.
-*/
-function notifyComponentCreated(context, instance) {
-	if (!context) return;
-	for (const hooks of context.hooks) try {
-		hooks.onComponentCreated?.(instance);
-	} catch (err) {
-		handleHookError(context, err, instance, "onComponentCreated");
+	n.app = o;
+	let s = Ie();
+	return n.provides.set(s, n), o;
+}
+function We(e, t) {
+	if (e) for (let n of e.hooks) try {
+		n.onComponentCreated?.(t);
+	} catch (n) {
+		Ye(e, n, t, "onComponentCreated");
 	}
 }
-/**
-* Notify all app hooks that a component was mounted.
-* Called by the renderer after mount hooks run.
-*/
-function notifyComponentMounted(context, instance) {
-	if (!context) return;
-	for (const hooks of context.hooks) try {
-		hooks.onComponentMounted?.(instance);
-	} catch (err) {
-		handleHookError(context, err, instance, "onComponentMounted");
+function Ge(e, t) {
+	if (e) for (let n of e.hooks) try {
+		n.onComponentMounted?.(t);
+	} catch (n) {
+		Ye(e, n, t, "onComponentMounted");
 	}
 }
-/**
-* Notify all app hooks that a component was unmounted.
-* Called by the renderer before cleanup.
-*/
-function notifyComponentUnmounted(context, instance) {
-	if (!context) return;
-	for (const hooks of context.hooks) try {
-		hooks.onComponentUnmounted?.(instance);
-	} catch (err) {
-		handleHookError(context, err, instance, "onComponentUnmounted");
+function Ke(e, t) {
+	if (e) for (let n of e.hooks) try {
+		n.onComponentUnmounted?.(t);
+	} catch (n) {
+		Ye(e, n, t, "onComponentUnmounted");
 	}
 }
-/**
-* Notify all app hooks that a component updated.
-* Called by the renderer after re-render.
-*/
-function notifyComponentUpdated(context, instance) {
-	if (!context) return;
-	for (const hooks of context.hooks) try {
-		hooks.onComponentUpdated?.(instance);
-	} catch (err) {
-		handleHookError(context, err, instance, "onComponentUpdated");
+function qe(e, t) {
+	if (e) for (let n of e.hooks) try {
+		n.onComponentUpdated?.(t);
+	} catch (n) {
+		Ye(e, n, t, "onComponentUpdated");
 	}
 }
-/**
-* Handle an error in a component. Returns true if the error was handled.
-* Called by the renderer when an error occurs in setup or render.
-*/
-function handleComponentError(context, err, instance, info) {
-	if (!context) return false;
-	for (const hooks of context.hooks) try {
-		if (hooks.onComponentError?.(err, instance, info) === true) return true;
-	} catch (hookErr) {
-		console.error("Error in onComponentError hook:", hookErr);
+function Je(e, t, n, r) {
+	if (!e) return !1;
+	for (let i of e.hooks) try {
+		if (i.onComponentError?.(t, n, r) === !0) return !0;
+	} catch (e) {
+		console.error("Error in onComponentError hook:", e);
 	}
-	if (context.config.errorHandler) try {
-		if (context.config.errorHandler(err, instance, info) === true) return true;
-	} catch (handlerErr) {
-		console.error("Error in app.config.errorHandler:", handlerErr);
+	if (e.config.errorHandler) try {
+		if (e.config.errorHandler(t, n, r) === !0) return !0;
+	} catch (e) {
+		console.error("Error in app.config.errorHandler:", e);
 	}
-	return false;
-}
-/**
-* Handle errors that occur in hooks themselves
-*/
-function handleHookError(context, err, instance, hookName) {
-	console.error(`Error in ${hookName} hook:`, err);
-	if (context.config.errorHandler) try {
-		context.config.errorHandler(err, instance, `plugin hook: ${hookName}`);
+	return !1;
+}
+function Ye(e, t, n, r) {
+	if (console.error(`Error in ${r} hook:`, t), e.config.errorHandler) try {
+		e.config.errorHandler(t, n, `plugin hook: ${r}`);
 	} catch {}
 }
 //#endregion
 //#region ../runtime-core/src/compound.ts
-/**
-* Creates a compound component by attaching sub-components as static properties.
-* 
-* This enables the pattern of `Parent.Child` components (e.g., `Menu.Item`, `Card.Body`)
-* while preserving full TypeScript type inference for both the parent and children.
-* 
-* @param main - The main/parent component factory
-* @param sub - An object containing sub-components to attach
-* @returns The main component with sub-components attached as static properties
-* 
-* @example
-* ```tsx
-* // Define individual components
-* const _Menu = component<MenuProps>(ctx => { ... });
-* const _MenuItem = component<MenuItemProps>(ctx => { ... });
-* const _MenuTitle = component<MenuTitleProps>(ctx => { ... });
-* 
-* // Create compound component
-* export const Menu = compound(_Menu, {
-*     Item: _MenuItem,
-*     Title: _MenuTitle,
-* });
-* 
-* // Usage in JSX
-* <Menu>
-*     <Menu.Title>Navigation</Menu.Title>
-*     <Menu.Item value="home">Home</Menu.Item>
-*     <Menu.Item value="about">About</Menu.Item>
-* </Menu>
-* ```
-*/
-function compound(main, sub) {
-	return Object.assign(main, sub);
+function Xe(e, t) {
+	return Object.assign(e, t);
 }
 //#endregion
 //#region ../runtime-core/src/model.ts
-/**
-* Model<T> - Unified two-way binding type for SignalX components.
-* 
-* Provides a single interface for reading, writing, and forwarding model bindings.
-* 
-* @example
-* ```tsx
-* const Input = component<InputProps>(({ props }) => {
-*     // Read
-*     console.log(props.model.value);
-*     
-*     // Write
-*     props.model.value = "new value";
-*     
-*     // Forward to child
-*     <Child model={props.model} />
-*     
-*     // Forward via context
-*     defineProvide(inputContext, () => props.model);
-* });
-* ```
-*/
-/** Symbol to identify Model objects */
-var MODEL_SYMBOL = Symbol.for("sigx.model");
-/**
-* Creates a Model<T> from a binding tuple and update handler.
-* 
-* @param tuple - The [sourceObject, key] tuple from reactivity detection
-* @param updateHandler - Function called when value is set (enables parent interception)
-* @returns A Model<T> with .value getter/setter and .binding for forwarding
-*/
-function createModel(tuple, updateHandler) {
-	const [obj, key] = tuple;
+var Ze = Symbol.for("sigx.model");
+function Qe(e, t) {
+	let [n, r] = e;
 	return {
 		get value() {
-			return obj[key];
+			return n[r];
 		},
-		set value(v) {
-			updateHandler(v);
+		set value(e) {
+			t(e);
 		},
 		get binding() {
 			return [
-				obj,
-				key,
-				updateHandler
+				n,
+				r,
+				t
 			];
 		},
-		[MODEL_SYMBOL]: true
+		[Ze]: !0
 	};
 }
-/**
-* Creates a Model<T> from an existing binding (for forwarding scenarios).
-* 
-* @param binding - The full binding tuple [obj, key, handler]
-* @returns A new Model<T> wrapping the same binding
-*/
-function createModelFromBinding(binding) {
-	const [obj, key, handler] = binding;
-	return createModel([obj, key], handler);
-}
-/**
-* Type guard to check if a value is a Model<T>.
-* 
-* Used by JSX runtime to detect forwarded models and extract their bindings.
-*/
-function isModel(value) {
-	return value !== null && typeof value === "object" && MODEL_SYMBOL in value && value[MODEL_SYMBOL] === true;
+function $e(e) {
+	let [t, n, r] = e;
+	return Qe([t, n], r);
+}
+function z(e) {
+	return typeof e == "object" && !!e && Ze in e && e[Ze] === !0;
 }
 //#endregion
 //#region ../runtime-core/src/platform.ts
-var platformModelProcessor = null;
-/**
-* Get the current platform model processor (for internal use).
-*/
-function getPlatformModelProcessor() {
-	return platformModelProcessor;
+var et = null;
+function tt() {
+	return et;
 }
 //#endregion
 //#region ../runtime-core/src/utils/is-component.ts
-/**
-* Check if a value is a SignalX component (has __setup).
-* 
-* SignalX components are created with component() and have a __setup
-* property containing the setup function.
-* 
-* @example
-* ```ts
-* const MyComponent = component((ctx) => () => <div/>);
-* isComponent(MyComponent); // true
-* isComponent(() => <div/>); // false (plain function component)
-* isComponent('div'); // false
-* ```
-*/
-function isComponent(type) {
-	return typeof type === "function" && "__setup" in type;
+function B(e) {
+	return typeof e == "function" && "__setup" in e;
 }
 //#endregion
 //#region ../runtime-core/src/jsx-runtime.ts
-var Fragment = Symbol.for("sigx.Fragment");
-var Text = Symbol.for("sigx.Text");
-var Comment = Symbol.for("sigx.Comment");
-function normalizeChildren(children) {
-	if (children == null || children === false || children === true) return [];
-	if (isComputed(children)) return normalizeChildren(children.value);
-	if (Array.isArray(children)) return children.map((c) => {
-		if (c == null || c === false || c === true) return {
-			type: Comment,
-			props: {},
-			key: null,
-			children: [],
-			dom: null
-		};
-		if (isComputed(c)) return normalizeChildren(c.value)[0] ?? {
-			type: Comment,
-			props: {},
+var V = Symbol.for("sigx.Fragment"), H = Symbol.for("sigx.Text"), U = Symbol.for("sigx.Comment"), nt = {}, rt = [];
+function it() {
+	return {
+		type: U,
+		props: nt,
+		key: null,
+		children: rt,
+		dom: null
+	};
+}
+function at(e) {
+	return {
+		type: H,
+		props: nt,
+		key: null,
+		children: rt,
+		dom: null,
+		text: e
+	};
+}
+function W(e) {
+	return e == null || e === !1 || e === !0 ? [] : j(e) ? W(e.value) : typeof e == "string" || typeof e == "number" ? [at(e)] : e.type ? [e] : Array.isArray(e) ? e.map(ot) : [];
+}
+function ot(e) {
+	if (e == null || e === !1 || e === !0) return it();
+	if (typeof e == "string" || typeof e == "number") return at(e);
+	if (j(e)) return W(e.value)[0] ?? it();
+	if (Array.isArray(e)) {
+		let t = W(e);
+		return t.length === 0 ? it() : t.length === 1 ? t[0] : {
+			type: V,
+			props: nt,
 			key: null,
-			children: [],
+			children: t,
 			dom: null
 		};
-		if (typeof c === "string" || typeof c === "number") return {
-			type: Text,
-			props: {},
-			key: null,
-			children: [],
-			dom: null,
-			text: c
-		};
-		if (Array.isArray(c)) {
-			const nested = normalizeChildren(c);
-			if (nested.length === 0) return {
-				type: Comment,
-				props: {},
-				key: null,
-				children: [],
-				dom: null
-			};
-			if (nested.length === 1) return nested[0];
+	}
+	return e.type ? e : it();
+}
+function G(e, t, n) {
+	let r = B(e), i = !1;
+	if (t) {
+		for (let e in t) if (e === "model" || e.startsWith("model:")) {
+			i = !0;
+			break;
+		}
+	}
+	if (!i) {
+		if (r) {
+			let { children: r, ...i } = t || {};
 			return {
-				type: Fragment,
-				props: {},
-				key: null,
-				children: nested,
+				type: e,
+				props: {
+					...i,
+					children: r
+				},
+				key: n || i.key || null,
+				children: rt,
 				dom: null
 			};
 		}
-		if (c.type) return c;
+		if (typeof e == "function" && e !== V) return e(t);
+		let { children: i, ...a } = t || {};
 		return {
-			type: Comment,
-			props: {},
-			key: null,
-			children: [],
+			type: e,
+			props: a,
+			key: n || a.key || null,
+			children: W(i),
 			dom: null
 		};
-	});
-	if (typeof children === "string" || typeof children === "number") return [{
-		type: Text,
-		props: {},
-		key: null,
-		children: [],
-		dom: null,
-		text: children
-	}];
-	if (children.type) return [children];
-	return [];
-}
-/**
-* Create a JSX element - this is the core function called by TSX transpilation
-*/
-function jsx(type, props, key) {
-	const processedProps = { ...props };
-	const models = {};
-	const isComponentType = isComponent(type);
-	if (props) {
-		for (const propKey in props) if (propKey === "model") {
-			let modelBinding = props[propKey];
-			let tuple = null;
-			let updateHandler = null;
-			if (isModel(modelBinding)) {
-				const [obj, key, handler] = modelBinding.binding;
-				tuple = [obj, key];
-				updateHandler = handler;
-			} else if (typeof modelBinding === "function") {
-				const detected = detectAccess(modelBinding);
-				if (detected && typeof detected[1] === "string") tuple = detected;
-			} else if (Array.isArray(modelBinding) && modelBinding.length === 2 && typeof modelBinding[1] === "string") tuple = modelBinding;
-			if (tuple) {
-				const [stateObj, stateKey] = tuple;
-				let handled = false;
-				if (!updateHandler) {
-					const existingHandler = processedProps["onUpdate:modelValue"];
-					updateHandler = (v) => {
-						const customHandler = stateObj[`onUpdate:${stateKey}`];
-						if (typeof customHandler === "function") customHandler(v);
-						else stateObj[stateKey] = v;
-						if (existingHandler) existingHandler(v);
+	}
+	let a = { ...t }, o = {};
+	if (t) {
+		for (let n in t) if (n === "model") {
+			let i = t[n], s = null, c = null;
+			if (z(i)) {
+				let [e, t, n] = i.binding;
+				s = [e, t], c = n;
+			} else if (typeof i == "function") {
+				let e = D(i);
+				e && typeof e[1] == "string" && (s = e);
+			} else Array.isArray(i) && i.length === 2 && typeof i[1] == "string" && (s = i);
+			if (s) {
+				let [n, i] = s, l = !1;
+				if (!c) {
+					let e = a["onUpdate:modelValue"];
+					c = (t) => {
+						let r = n[`onUpdate:${i}`];
+						typeof r == "function" ? r(t) : n[i] = t, e && e(t);
 					};
 				}
-				const platformProcessor = getPlatformModelProcessor();
-				if (typeof type === "string" && platformProcessor) handled = platformProcessor(type, processedProps, tuple, props);
-				if (isComponentType) {
-					models.model = createModel(tuple, updateHandler);
-					processedProps["onUpdate:modelValue"] = updateHandler;
-				} else if (!handled) {
-					processedProps.modelValue = stateObj[stateKey];
-					processedProps["onUpdate:modelValue"] = updateHandler;
-				}
-				delete processedProps.model;
+				let u = tt();
+				typeof e == "string" && u && (l = u(e, a, s, t)), r ? (o.model = Qe(s, c), a["onUpdate:modelValue"] = c) : l || (a.modelValue = n[i], a["onUpdate:modelValue"] = c), delete a.model;
 			}
-		} else if (propKey.startsWith("model:")) {
-			let modelBinding = props[propKey];
-			const name = propKey.slice(6);
-			let tuple = null;
-			let updateHandler = null;
-			if (isModel(modelBinding)) {
-				const [obj, key, handler] = modelBinding.binding;
-				tuple = [obj, key];
-				updateHandler = handler;
-			} else if (typeof modelBinding === "function") {
-				const detected = detectAccess(modelBinding);
-				if (detected && typeof detected[1] === "string") tuple = detected;
-			} else if (Array.isArray(modelBinding) && modelBinding.length === 2 && typeof modelBinding[1] === "string") tuple = modelBinding;
-			if (tuple) {
-				const [stateObj, stateKey] = tuple;
-				const eventName = `onUpdate:${name}`;
-				if (!updateHandler) {
-					const existingHandler = processedProps[eventName];
-					updateHandler = (v) => {
-						const customHandler = stateObj[`onUpdate:${stateKey}`];
-						if (typeof customHandler === "function") customHandler(v);
-						else stateObj[stateKey] = v;
-						if (existingHandler) existingHandler(v);
+		} else if (n.startsWith("model:")) {
+			let e = t[n], i = n.slice(6), s = null, c = null;
+			if (z(e)) {
+				let [t, n, r] = e.binding;
+				s = [t, n], c = r;
+			} else if (typeof e == "function") {
+				let t = D(e);
+				t && typeof t[1] == "string" && (s = t);
+			} else Array.isArray(e) && e.length === 2 && typeof e[1] == "string" && (s = e);
+			if (s) {
+				let [e, t] = s, l = `onUpdate:${i}`;
+				if (!c) {
+					let n = a[l];
+					c = (r) => {
+						let i = e[`onUpdate:${t}`];
+						typeof i == "function" ? i(r) : e[t] = r, n && n(r);
 					};
 				}
-				if (isComponentType) {
-					models[name] = createModel(tuple, updateHandler);
-					processedProps[eventName] = updateHandler;
-				} else {
-					processedProps[name] = stateObj[stateKey];
-					processedProps[eventName] = updateHandler;
-				}
-				delete processedProps[propKey];
+				r ? (o[i] = Qe(s, c), a[l] = c) : (a[i] = e[t], a[l] = c), delete a[n];
 			}
 		}
 	}
-	if (Object.keys(models).length > 0) processedProps.$models = models;
-	if (isComponent(type)) {
-		const { children, ...rest } = processedProps;
+	if (Object.keys(o).length > 0 && (a.$models = o), B(e)) {
+		let { children: t, ...r } = a;
 		return {
-			type,
+			type: e,
 			props: {
-				...rest,
-				children
+				...r,
+				children: t
 			},
-			key: key || rest.key || null,
+			key: n || r.key || null,
 			children: [],
 			dom: null
 		};
 	}
-	if (typeof type === "function" && type !== Fragment) return type(processedProps);
-	const { children, ...rest } = processedProps;
+	if (typeof e == "function" && e !== V) return e(a);
+	let { children: s, ...c } = a;
 	return {
-		type,
-		props: rest,
-		key: key || rest.key || null,
-		children: normalizeChildren(children),
+		type: e,
+		props: c,
+		key: n || c.key || null,
+		children: W(s),
 		dom: null
 	};
 }
-/**
-* JSX Factory for fragments
-*/
-function jsxs(type, props, key) {
-	return jsx(type, props, key);
+function K(e, t, n) {
+	return G(e, t, n);
 }
-var jsxDEV = jsx;
-//#endregion
-//#region ../runtime-core/src/lazy.tsx
-/**
-* Lazy loading utilities for sigx components.
-* 
-* Provides runtime-only lazy loading with no build dependencies.
-* Works with any bundler that supports dynamic import().
-*/
-var currentSuspenseBoundary = null;
-/**
-* Register a promise with the current Suspense boundary
-* @internal
-*/
-function registerPendingPromise(promise) {
-	const boundary = getCurrentSuspenseBoundarySafe() ?? currentSuspenseBoundary;
-	if (boundary) {
-		boundary.pending.add(promise);
-		promise.finally(() => {
-			boundary.pending.delete(promise);
-			if (boundary.pending.size === 0) boundary.onResolve();
-		});
-		return true;
-	}
-	return false;
-}
-/**
-* Create a lazy-loaded component wrapper.
-* 
-* The component will be loaded on first render. Use with `<Suspense>` to show
-* a fallback while loading.
-* 
-* @param loader - Function that returns a Promise resolving to the component
-* @returns A component factory that loads the real component on demand
-* 
-* @example
-* ```tsx
-* import { lazy, Suspense } from 'sigx';
-* 
-* // Component will be in a separate chunk
-* const HeavyChart = lazy(() => import('./components/HeavyChart'));
-* 
-* // Usage
-* <Suspense fallback={<Spinner />}>
-*     <HeavyChart data={chartData} />
-* </Suspense>
-* 
-* // Preload on hover
-* <button onMouseEnter={() => HeavyChart.preload()}>
-*     Show Chart
-* </button>
-* ```
-*/
-function lazy(loader) {
-	let Component = null;
-	let promise = null;
-	let error = null;
-	let state = "pending";
-	const LazyWrapper = component((ctx) => {
-		const loadState = ctx.signal({
-			state,
+var st = G, ct = null;
+function lt(e) {
+	let t = he() ?? ct;
+	return t ? (t.pending.add(e), e.finally(() => {
+		t.pending.delete(e), t.pending.size === 0 && t.onResolve();
+	}), !0) : !1;
+}
+function ut(e) {
+	let t = null, n = null, r = null, i = "pending", a = F((a) => {
+		let o = a.signal({
+			state: i,
 			tick: 0
 		});
-		function renderInner(Comp) {
-			const fwdProps = { ...ctx.props };
-			const defaultContent = ctx.slots.default();
-			if (defaultContent.length > 0) fwdProps.children = defaultContent;
-			const slotsFromProps = ctx.slots._slotsFromProps;
-			if (slotsFromProps) {
-				const namedSlots = {};
-				let hasNamed = false;
-				for (const key of Object.keys(slotsFromProps)) {
-					namedSlots[key] = slotsFromProps[key];
-					hasNamed = true;
-				}
-				if (hasNamed) fwdProps.slots = namedSlots;
+		function c(e) {
+			let t = { ...a.props }, n = a.slots.default();
+			n.length > 0 && (t.children = n);
+			let r = a.slots._slotsFromProps;
+			if (r) {
+				let e = {}, n = !1;
+				for (let t of Object.keys(r)) e[t] = r[t], n = !0;
+				n && (t.slots = e);
 			}
-			return jsx(Comp, fwdProps);
+			return G(e, t);
 		}
-		if (!promise) promise = loader().then((mod) => {
-			Component = "default" in mod ? mod.default : mod;
-			state = "resolved";
-			batch(() => {
-				loadState.state = "resolved";
-				loadState.tick++;
-			});
-			return Component;
-		}).catch((err) => {
-			error = err instanceof Error ? err : new Error(String(err));
-			state = "rejected";
-			batch(() => {
-				loadState.state = "rejected";
-				loadState.tick++;
-			});
-			throw error;
-		});
-		else if (state === "pending") promise.then(() => {
-			if (loadState.state === "pending") batch(() => {
-				loadState.state = "resolved";
-				loadState.tick++;
+		if (n ? i === "pending" && n.then(() => {
+			o.state === "pending" && s(() => {
+				o.state = "resolved", o.tick++;
 			});
 		}).catch(() => {
-			if (loadState.state === "pending") batch(() => {
-				loadState.state = "rejected";
-				loadState.tick++;
+			o.state === "pending" && s(() => {
+				o.state = "rejected", o.tick++;
 			});
-		});
-		if (state === "resolved" && Component) return () => renderInner(Component);
-		if (state === "rejected" && error) throw error;
-		if (!registerPendingPromise(promise)) promise.catch(() => {});
-		return () => {
-			const currentState = loadState.state;
-			loadState.tick;
-			if (currentState === "resolved" && Component) return renderInner(Component);
-			if (currentState === "rejected" && error) throw error;
+		}) : n = e().then((e) => (t = "default" in e ? e.default : e, i = "resolved", s(() => {
+			o.state = "resolved", o.tick++;
+		}), t)).catch((e) => {
+			throw r = e instanceof Error ? e : Error(String(e)), i = "rejected", s(() => {
+				o.state = "rejected", o.tick++;
+			}), r;
+		}), i === "resolved" && t) return () => c(t);
+		if (i === "rejected" && r) throw r;
+		return lt(n) || n.catch(() => {}), () => {
+			let e = o.state;
+			if (o.tick, e === "resolved" && t) return c(t);
+			if (e === "rejected" && r) throw r;
 			return null;
 		};
 	}, { name: "LazyComponent" });
-	LazyWrapper.__lazy = true;
-	LazyWrapper.preload = () => {
-		if (!promise) promise = loader().then((mod) => {
-			Component = "default" in mod ? mod.default : mod;
-			state = "resolved";
-			return Component;
-		}).catch((err) => {
-			error = err instanceof Error ? err : new Error(String(err));
-			state = "rejected";
-			throw error;
-		});
-		return promise;
-	};
-	LazyWrapper.isLoaded = () => {
-		return state === "resolved";
-	};
-	return LazyWrapper;
-}
-/**
-* Suspense boundary component for handling async loading states.
-* 
-* Wraps lazy-loaded components and shows a fallback while they load.
-* 
-* @example
-* ```tsx
-* import { lazy, Suspense } from 'sigx';
-* 
-* const LazyDashboard = lazy(() => import('./Dashboard'));
-* 
-* // Basic usage
-* <Suspense fallback={<div>Loading...</div>}>
-*     <LazyDashboard />
-* </Suspense>
-* 
-* // With spinner component
-* <Suspense fallback={<Spinner size="large" />}>
-*     <LazyDashboard />
-*     <LazyCharts />
-* </Suspense>
-* ```
-*/
-var Suspense = component((ctx) => {
-	const { props, slots } = ctx;
-	const state = ctx.signal({
-		isReady: false,
+	return a.__lazy = !0, a.preload = () => (n ||= e().then((e) => (t = "default" in e ? e.default : e, i = "resolved", t)).catch((e) => {
+		throw r = e instanceof Error ? e : Error(String(e)), i = "rejected", r;
+	}), n), a.isLoaded = () => i === "resolved", a;
+}
+var dt = F((e) => {
+	let { props: t, slots: n } = e, r = e.signal({
+		isReady: !1,
 		pendingCount: 0
-	});
-	const boundary = {
+	}), i = {
 		pending: /* @__PURE__ */ new Set(),
 		onResolve: () => {
-			state.pendingCount = boundary.pending.size;
-			if (boundary.pending.size === 0) state.isReady = true;
+			r.pendingCount = i.pending.size, i.pending.size === 0 && (r.isReady = !0);
 		}
 	};
-	ctx.onMounted(() => {
-		if (boundary.pending.size === 0) state.isReady = true;
-	});
-	return () => {
-		state.isReady;
-		state.pendingCount;
-		const prevBoundary = getCurrentSuspenseBoundarySafe() ?? currentSuspenseBoundary;
-		currentSuspenseBoundary = boundary;
-		setCurrentSuspenseBoundarySafe(boundary);
+	return e.onMounted(() => {
+		i.pending.size === 0 && (r.isReady = !0);
+	}), () => {
+		r.isReady, r.pendingCount;
+		let e = he() ?? ct;
+		ct = i, ge(i);
 		try {
-			const children = slots.default();
-			if (boundary.pending.size > 0) {
-				const fallback = props.fallback;
-				if (typeof fallback === "function") return fallback();
-				return fallback ?? null;
+			let e = n.default();
+			if (i.pending.size > 0) {
+				let e = t.fallback;
+				return typeof e == "function" ? e() : e ?? null;
 			}
-			if (Array.isArray(children)) {
-				const filtered = children.filter((c) => c != null && c !== false && c !== true);
-				if (filtered.length === 0) return null;
-				if (filtered.length === 1) return filtered[0];
-				return filtered;
+			if (Array.isArray(e)) {
+				let t = e.filter((e) => e != null && e !== !1 && e !== !0);
+				return t.length === 0 ? null : t.length === 1 ? t[0] : t;
 			}
-			return children;
-		} catch (err) {
-			if (err instanceof Promise) {
-				registerPendingPromise(err);
-				const fallback = props.fallback;
-				if (typeof fallback === "function") return fallback();
-				return fallback ?? null;
+			return e;
+		} catch (e) {
+			if (e instanceof Promise) {
+				lt(e);
+				let n = t.fallback;
+				return typeof n == "function" ? n() : n ?? null;
 			}
-			throw err;
+			throw e;
 		} finally {
-			currentSuspenseBoundary = prevBoundary;
-			setCurrentSuspenseBoundarySafe(prevBoundary);
+			ct = e, ge(e);
 		}
 	};
 }, { name: "Suspense" });
-/**
-* Check if a component is a lazy-loaded component
-*/
-function isLazyComponent(component) {
-	return component && component.__lazy === true;
+function ft(e) {
+	return e && e.__lazy === !0;
 }
 //#endregion
 //#region ../runtime-core/src/use-async.ts
-/**
-* useAsync — composable for loading async dependencies in components.
-*
-* Wraps an async loader in a reactive signal with loading/error states.
-* No renderer changes required — works with sigx's existing effect system.
-*
-* @example
-* ```tsx
-* import { component, useAsync } from 'sigx';
-*
-* const CodeEditor = component(({ signal: s }) => {
-*     const libs = useAsync(async () => {
-*         const { EditorView } = await import('@codemirror/view');
-*         const { json } = await import('@codemirror/lang-json');
-*         return { EditorView, json };
-*     });
-*
-*     return () => {
-*         if (libs.loading) return <div class="skeleton" />;
-*         if (libs.error) return <div class="error">{libs.error.message}</div>;
-*         return <div ref={el => new libs.value!.EditorView({ parent: el })} />;
-*     };
-* });
-* ```
-*/
-/**
-* Load an async resource inside a component's setup function.
-*
-* Returns a reactive object with `value`, `loading`, and `error` fields.
-* The component's render function re-runs automatically when the state changes.
-*
-* @param loader — async function that returns the resource
-* @returns reactive AsyncState
-*/
-function useAsync(loader) {
-	const state = signal({
+function pt(e) {
+	let t = k({
 		value: null,
-		loading: true,
+		loading: !0,
 		error: null
 	});
-	loader().then((val) => {
-		batch(() => {
-			state.value = val;
-			state.loading = false;
+	return e().then((e) => {
+		s(() => {
+			t.value = e, t.loading = !1;
 		});
-	}).catch((err) => {
-		batch(() => {
-			state.error = err instanceof Error ? err : new Error(String(err));
-			state.loading = false;
+	}).catch((e) => {
+		s(() => {
+			t.error = e instanceof Error ? e : Error(String(e)), t.loading = !1;
 		});
-	});
-	return state;
+	}), t;
 }
 //#endregion
 //#region ../runtime-core/src/error-boundary.ts
-/**
-* ErrorBoundary component for catching render errors.
-*
-* Catches errors thrown during child component rendering and displays
-* a fallback UI. Works during both SSR and client-side rendering.
-*
-* @example
-* ```tsx
-* import { ErrorBoundary } from 'sigx';
-*
-* <ErrorBoundary
-*     fallback={(error, retry) => (
-*         <div>
-*             <p>Something went wrong: {error.message}</p>
-*             <button onClick={retry}>Retry</button>
-*         </div>
-*     )}
-* >
-*     <RiskyComponent />
-* </ErrorBoundary>
-* ```
-*/
-/**
-* ErrorBoundary component.
-*
-* Wraps children and catches errors thrown during rendering.
-* When an error occurs, displays the `fallback` UI.
-* Provides a `retry` function to reset and re-render children.
-*/
-var ErrorBoundary = component((ctx) => {
-	const { fallback } = ctx.props;
-	const { slots } = ctx;
-	const state = ctx.signal({
-		hasError: false,
+var mt = F((e) => {
+	let { fallback: t } = e.props, { slots: n } = e, r = e.signal({
+		hasError: !1,
 		error: null
-	});
-	const retry = () => {
-		state.hasError = false;
-		state.error = null;
+	}), i = () => {
+		r.hasError = !1, r.error = null;
 	};
 	return () => {
-		if (state.hasError && state.error) {
-			if (typeof fallback === "function") return fallback(state.error, retry);
-			return fallback ?? null;
-		}
+		if (r.hasError && r.error) return typeof t == "function" ? t(r.error, i) : t ?? null;
 		try {
-			return slots.default();
+			return n.default();
 		} catch (e) {
-			const error = e instanceof Error ? e : new Error(String(e));
-			state.hasError = true;
-			state.error = error;
-			if (process.env.NODE_ENV !== "production") console.error("[ErrorBoundary] Caught error during render:", error);
-			if (typeof fallback === "function") return fallback(error, retry);
-			return fallback ?? null;
+			let n = e instanceof Error ? e : Error(String(e));
+			return r.hasError = !0, r.error = n, process.env.NODE_ENV !== "production" && console.error("[ErrorBoundary] Caught error during render:", n), typeof t == "function" ? t(n, i) : t ?? null;
 		}
 	};
-}, { name: "ErrorBoundary" });
-//#endregion
-//#region ../runtime-core/src/utils/index.ts
-var Utils = class {
-	static isPromise(value) {
-		return !!value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}, { name: "ErrorBoundary" }), ht = class {
+	static isPromise(e) {
+		return !!e && (typeof e == "object" || typeof e == "function") && typeof e.then == "function";
 	}
 };
-function guid$1() {
-	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
-		var r = Math.random() * 16 | 0;
-		return (c == "x" ? r : r & 3 | 8).toString(16);
+function gt() {
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(e) {
+		var t = Math.random() * 16 | 0;
+		return (e == "x" ? t : t & 3 | 8).toString(16);
 	});
 }
 //#endregion
 //#region ../runtime-core/src/models/index.ts
-var guid = guid$1;
-var InstanceLifetimes = /* @__PURE__ */ function(InstanceLifetimes) {
-	InstanceLifetimes[InstanceLifetimes["Transient"] = 0] = "Transient";
-	InstanceLifetimes[InstanceLifetimes["Scoped"] = 1] = "Scoped";
-	InstanceLifetimes[InstanceLifetimes["Singleton"] = 2] = "Singleton";
-	return InstanceLifetimes;
+var _t = gt, vt = /* @__PURE__ */ function(e) {
+	return e[e.Transient = 0] = "Transient", e[e.Scoped = 1] = "Scoped", e[e.Singleton = 2] = "Singleton", e;
 }({});
 //#endregion
 //#region ../runtime-core/src/messaging/index.ts
-function createTopic(_options) {
-	let subscribers = [];
-	const publish = (data) => {
-		subscribers.forEach((s) => s(data));
-	};
-	const subscribe = (handler) => {
-		subscribers.push(handler);
-		const unsubscribe = () => {
-			const idx = subscribers.indexOf(handler);
-			if (idx > -1) subscribers.splice(idx, 1);
-		};
-		try {
-			onUnmounted(unsubscribe);
-		} catch {}
-		return { unsubscribe };
-	};
-	const destroy = () => {
-		subscribers = [];
-	};
+function yt(e) {
+	let t = [];
 	return {
-		publish,
-		subscribe,
-		destroy
+		publish: (e) => {
+			t.forEach((t) => t(e));
+		},
+		subscribe: (e) => {
+			t.push(e);
+			let n = () => {
+				let n = t.indexOf(e);
+				n > -1 && t.splice(n, 1);
+			};
+			try {
+				P(n);
+			} catch {}
+			return { unsubscribe: n };
+		},
+		destroy: () => {
+			t = [];
+		}
 	};
 }
-function toSubscriber(topic) {
-	return { subscribe: (handler) => topic.subscribe(handler) };
+function bt(e) {
+	return { subscribe: (t) => e.subscribe(t) };
 }
 //#endregion
 //#region ../runtime-core/src/di/factory.ts
-var SubscriptionHandler = class {
+var xt = class {
 	constructor() {
 		this.unsubs = [];
 	}
-	add(unsub) {
-		this.unsubs.push(unsub);
+	add(e) {
+		this.unsubs.push(e);
 	}
 	unsubscribe() {
-		this.unsubs.forEach((u) => u());
-		this.unsubs = [];
+		this.unsubs.forEach((e) => e()), this.unsubs = [];
 	}
 };
-function defineFactory(setup, _lifetime, _typeIdentifier) {
-	const factoryCreator = (...args) => {
-		const subscriptions = new SubscriptionHandler();
-		const deactivations = /* @__PURE__ */ new Set();
-		let customDispose = null;
-		const result = setup({
-			onDeactivated: (fn) => deactivations.add(fn),
-			subscriptions,
-			overrideDispose: (fn) => customDispose = fn
-		}, ...args);
-		const dispose = () => {
-			deactivations.forEach((d) => d());
-			subscriptions.unsubscribe();
-			if (result && typeof result === "object" && "dispose" in result && typeof result.dispose === "function") result.dispose();
+function St(e, t, n) {
+	let r = (...t) => {
+		let n = new xt(), r = /* @__PURE__ */ new Set(), i = null, a = e({
+			onDeactivated: (e) => r.add(e),
+			subscriptions: n,
+			overrideDispose: (e) => i = e
+		}, ...t), o = () => {
+			r.forEach((e) => e()), n.unsubscribe(), a && typeof a == "object" && "dispose" in a && typeof a.dispose == "function" && a.dispose();
 		};
-		if (customDispose) customDispose(dispose);
+		if (i) i(o);
 		else try {
-			onUnmounted(() => dispose());
+			P(() => o());
 		} catch {}
 		return {
-			...result,
-			dispose
+			...a,
+			dispose: o
 		};
 	};
-	if (setup.length <= 1) return defineInjectable(() => factoryCreator());
-	return factoryCreator;
+	return e.length <= 1 ? Ne(() => r()) : r;
 }
 //#endregion
 //#region ../runtime-core/src/utils/props-accessor.ts
-/**
-* Creates a props accessor - a simple reactive proxy for props.
-* Use destructuring with defaults for optional props.
-* 
-* @example
-* ```ts
-* // In component setup:
-* const { count = 0, label = 'Default' } = ctx.props;
-* 
-* // Or spread to forward props
-* <ChildComponent {...ctx.props} />
-* ```
-*/
-function createPropsAccessor(reactiveProps) {
-	return new Proxy(reactiveProps, {
-		get(target, key) {
-			if (typeof key === "symbol") return void 0;
-			return target[key];
+function Ct(e) {
+	return new Proxy(e, {
+		get(e, t) {
+			if (typeof t != "symbol") return e[t];
 		},
-		has(target, key) {
-			if (typeof key === "symbol") return false;
-			return key in target;
+		has(e, t) {
+			return typeof t == "symbol" ? !1 : t in e;
 		},
-		ownKeys(target) {
-			return Object.keys(target);
+		ownKeys(e) {
+			return Object.keys(e);
 		},
-		getOwnPropertyDescriptor(target, key) {
-			if (typeof key === "symbol") return void 0;
-			if (key in target) return {
-				enumerable: true,
-				configurable: true,
-				writable: false
+		getOwnPropertyDescriptor(e, t) {
+			if (typeof t != "symbol" && t in e) return {
+				enumerable: !0,
+				configurable: !0,
+				writable: !1
 			};
 		}
 	});
 }
 //#endregion
 //#region ../runtime-core/src/utils/slots.ts
-/**
-* Slots system for component children.
-* Supports default and named slots with reactivity.
-*/
-/**
-* Create slots object from children and slots prop.
-* Uses a version signal to trigger re-renders when children change.
-* 
-* Supports named slots via:
-* - `slots` prop object (e.g., `slots={{ header: () => <div>...</div> }}`)
-* - `slot` prop on children (e.g., `<div slot="header">...</div>`)
-* 
-* @example
-* ```tsx
-* // Parent component
-* <Card slots={{ header: () => <h1>Title</h1> }}>
-*   <p>Default content</p>
-*   <span slot="footer">Footer text</span>
-* </Card>
-* 
-* // Card component setup
-* const slots = createSlots(children, slotsFromProps);
-* return () => (
-*   <div>
-*     {slots.header()}
-*     {slots.default()}
-*     {slots.footer()}
-*   </div>
-* );
-* ```
-*/
-function createSlots(children, slotsFromProps) {
-	const versionSignal = signal({ v: 0 });
-	function extractNamedSlotsFromChildren(c) {
-		const defaultChildren = [];
-		const namedSlots = {};
-		if (c == null) return {
-			defaultChildren,
-			namedSlots
+function wt(e, t) {
+	let n = k({ v: 0 });
+	function r(e) {
+		let t = [], n = {};
+		if (e == null) return {
+			defaultChildren: t,
+			namedSlots: n
 		};
-		const items = Array.isArray(c) ? c : [c];
-		for (const child of items) if (child && typeof child === "object" && child.props && child.props.slot) {
-			const slotName = child.props.slot;
-			if (!namedSlots[slotName]) namedSlots[slotName] = [];
-			namedSlots[slotName].push(child);
-		} else defaultChildren.push(child);
+		let r = Array.isArray(e) ? e : [e];
+		for (let e of r) if (e && typeof e == "object" && e.props && e.props.slot) {
+			let t = e.props.slot;
+			n[t] || (n[t] = []), n[t].push(e);
+		} else t.push(e);
 		return {
-			defaultChildren,
-			namedSlots
+			defaultChildren: t,
+			namedSlots: n
 		};
 	}
 	return new Proxy({
-		_children: children,
-		_slotsFromProps: slotsFromProps || {},
-		_version: versionSignal,
-		_isPatching: false,
+		_children: e,
+		_slotsFromProps: t || {},
+		_version: n,
+		_isPatching: !1,
 		default: function() {
 			this._version.v;
-			const c = this._children;
-			const { defaultChildren } = extractNamedSlotsFromChildren(c);
-			return defaultChildren.filter((child) => child != null && child !== false && child !== true);
+			let e = this._children, { defaultChildren: t } = r(e);
+			return t.filter((e) => e != null && e !== !1 && e !== !0);
 		}
-	}, { get(target, prop) {
-		if (prop in target) return target[prop];
-		if (typeof prop === "string") return function(scopedProps) {
-			target._version.v;
-			if (target._slotsFromProps && typeof target._slotsFromProps[prop] === "function") {
-				const result = target._slotsFromProps[prop](scopedProps);
-				if (result == null) return [];
-				return Array.isArray(result) ? result : [result];
+	}, { get(e, t) {
+		if (t in e) return e[t];
+		if (typeof t == "string") return function(n) {
+			if (e._version.v, e._slotsFromProps && typeof e._slotsFromProps[t] == "function") {
+				let r = e._slotsFromProps[t](n);
+				return r == null ? [] : Array.isArray(r) ? r : [r];
 			}
-			const { namedSlots } = extractNamedSlotsFromChildren(target._children);
-			return namedSlots[prop] || [];
+			let { namedSlots: i } = r(e._children);
+			return i[t] || [];
 		};
 	} });
 }
 //#endregion
 //#region ../runtime-core/src/utils/normalize.ts
-/**
-* VNode normalization utilities.
-* Converts render results into proper VNode structures.
-*/
-/**
-* Normalize render result to a VNode (wrapping arrays in Fragment).
-* Handles null, undefined, false, true by returning an empty Text node.
-* 
-* This is used to normalize the return value of component render functions
-* into a consistent VNode structure for the renderer to process.
-* 
-* @example
-* ```ts
-* // Conditional rendering returns null/false
-* normalizeSubTree(null)     // → empty Text node
-* normalizeSubTree(false)    // → empty Text node
-* 
-* // Arrays become Fragments
-* normalizeSubTree([<A/>, <B/>])  // → Fragment with children
-* 
-* // Primitives become Text nodes
-* normalizeSubTree("hello")  // → Text node
-* normalizeSubTree(42)       // → Text node
-* 
-* // Computed signals are auto-unwrapped
-* normalizeSubTree(computed(() => "hi"))  // → Text node with "hi"
-* 
-* // VNodes pass through
-* normalizeSubTree(<div/>)   // → same VNode
-* ```
-*/
-function normalizeSubTree(result) {
-	if (result == null || result === false || result === true) return {
-		type: Text,
+function Tt(e) {
+	return e == null || e === !1 || e === !0 ? {
+		type: H,
 		props: {},
 		key: null,
 		children: [],
 		dom: null,
 		text: ""
-	};
-	if (isComputed(result)) return normalizeSubTree(result.value);
-	if (Array.isArray(result)) return {
-		type: Fragment,
+	} : j(e) ? Tt(e.value) : Array.isArray(e) ? {
+		type: V,
 		props: {},
 		key: null,
-		children: result,
+		children: e,
 		dom: null
-	};
-	if (typeof result === "string" || typeof result === "number") return {
-		type: Text,
+	} : typeof e == "string" || typeof e == "number" ? {
+		type: H,
 		props: {},
 		key: null,
 		children: [],
 		dom: null,
-		text: result
-	};
-	return result;
+		text: e
+	} : e;
 }
 //#endregion
 //#region ../runtime-core/src/hydration/index.ts
-/**
-* Hydration utilities for SSR
-* 
-* These utilities are shared between server-side rendering (stream.ts)
-* and client-side hydration (hydrate.ts). They are placed in runtime-core
-* to allow any SSR implementation to use them.
-* 
-* @module
-*/
-/**
-* Client directive prefix used for selective hydration
-*/
-var CLIENT_DIRECTIVE_PREFIX = "client:";
-/**
-* Valid client directive names
-*/
-var CLIENT_DIRECTIVES = [
+var Et = "client:", Dt = [
 	"client:load",
 	"client:idle",
 	"client:visible",
 	"client:media",
 	"client:only"
 ];
-/**
-* Create an emit function for component context.
-* This is a common pattern used in both mountComponent and hydrateComponent.
-* 
-* @example
-* ```ts
-* const emit = createEmit(reactiveProps);
-* emit('click', eventData); // Calls props.onClick(eventData)
-* ```
-*/
-function createEmit(reactiveProps) {
-	return (event, ...args) => {
-		const eventName = `on${event[0].toUpperCase() + event.slice(1)}`;
-		const handler = ("value" in reactiveProps ? reactiveProps.value : reactiveProps)?.[eventName];
-		if (handler && typeof handler === "function") handler(...args);
+function Ot(e) {
+	return (t, ...n) => {
+		let r = `on${t[0].toUpperCase() + t.slice(1)}`, i = ("value" in e ? e.value : e)?.[r];
+		i && typeof i == "function" && i(...n);
 	};
 }
 //#endregion
 //#region ../runtime-core/src/renderer.ts
-function createRenderer(options) {
-	const { insert: hostInsert, remove: hostRemove, patchProp: hostPatchProp, createElement: hostCreateElement, createText: hostCreateText, createComment: hostCreateComment, setText: hostSetText, setElementText: _hostSetElementText, parentNode: hostParentNode, nextSibling: hostNextSibling, cloneNode: _hostCloneNode, insertStaticContent: _hostInsertStaticContent, patchDirective: hostPatchDirective, onElementMounted: hostOnElementMounted, onElementUnmounted: hostOnElementUnmounted, getActiveElement: hostGetActiveElement, restoreFocus: hostRestoreFocus } = options;
-	let currentAppContext = null;
-	function render(element, container, appContext) {
-		if (appContext) currentAppContext = appContext;
-		const oldVNode = container._vnode;
-		let vnode = null;
-		if (element != null && element !== false && element !== true) if (typeof element === "string" || typeof element === "number") vnode = {
-			type: Text,
+function kt(e) {
+	let { insert: t, remove: n, patchProp: r, createElement: i, createText: a, createComment: o, setText: s, setElementText: c, parentNode: l, nextSibling: u, cloneNode: d, insertStaticContent: m, patchDirective: h, onElementMounted: g, onElementUnmounted: _, getActiveElement: v, restoreFocus: ee } = e, y = null;
+	function te(e, t, n) {
+		n && (y = n);
+		let r = t._vnode, i = null;
+		e != null && e !== !1 && e !== !0 && (i = typeof e == "string" || typeof e == "number" ? {
+			type: H,
 			props: {},
 			key: null,
 			children: [],
 			dom: null,
-			text: element
-		};
-		else if (isComponent(element)) vnode = {
-			type: element,
+			text: e
+		} : B(e) ? {
+			type: e,
 			props: {},
 			key: null,
 			children: [],
 			dom: null
-		};
-		else vnode = element;
-		if (vnode) {
-			if (oldVNode) patch(oldVNode, vnode, container);
-			else mount(vnode, container);
-			container._vnode = vnode;
-		} else if (oldVNode) {
-			unmount(oldVNode, container);
-			container._vnode = null;
-		}
+		} : e), i ? (r ? C(r, i, t) : x(i, t), t._vnode = i) : r && (S(r, t), t._vnode = null);
 	}
-	const svgTags = new Set([
-		"svg",
-		"animate",
-		"animateMotion",
-		"animateTransform",
-		"circle",
-		"clipPath",
-		"defs",
-		"desc",
-		"ellipse",
-		"feBlend",
-		"feColorMatrix",
-		"feComponentTransfer",
-		"feComposite",
-		"feConvolveMatrix",
-		"feDiffuseLighting",
-		"feDisplacementMap",
-		"feDistantLight",
-		"feDropShadow",
-		"feFlood",
-		"feFuncA",
-		"feFuncB",
-		"feFuncG",
-		"feFuncR",
-		"feGaussianBlur",
-		"feImage",
-		"feMerge",
-		"feMergeNode",
-		"feMorphology",
-		"feOffset",
-		"fePointLight",
-		"feSpecularLighting",
-		"feSpotLight",
-		"feTile",
-		"feTurbulence",
-		"filter",
-		"foreignObject",
-		"g",
-		"image",
-		"line",
-		"linearGradient",
-		"marker",
-		"mask",
-		"metadata",
-		"mpath",
-		"path",
-		"pattern",
-		"polygon",
-		"polyline",
-		"radialGradient",
-		"rect",
-		"set",
-		"stop",
-		"switch",
-		"symbol",
-		"text",
-		"textPath",
-		"title",
-		"tspan",
-		"use",
-		"view"
-	]);
-	function isSvgTag(tag) {
-		return svgTags.has(tag);
+	let b = new Set(/* @__PURE__ */ "svg.animate.animateMotion.animateTransform.circle.clipPath.defs.desc.ellipse.feBlend.feColorMatrix.feComponentTransfer.feComposite.feConvolveMatrix.feDiffuseLighting.feDisplacementMap.feDistantLight.feDropShadow.feFlood.feFuncA.feFuncB.feFuncG.feFuncR.feGaussianBlur.feImage.feMerge.feMergeNode.feMorphology.feOffset.fePointLight.feSpecularLighting.feSpotLight.feTile.feTurbulence.filter.foreignObject.g.image.line.linearGradient.marker.mask.metadata.mpath.path.pattern.polygon.polyline.radialGradient.rect.set.stop.switch.symbol.text.textPath.title.tspan.use.view".split("."));
+	function ne(e) {
+		return b.has(e);
 	}
-	function mount(vnode, container, before = null, parentIsSVG = false) {
-		if (vnode == null || vnode === false || vnode === true) return;
-		if (vnode.type === Text) {
-			const node = hostCreateText(String(vnode.text));
-			vnode.dom = node;
-			node.__vnode = vnode;
-			hostInsert(node, container, before);
+	function x(e, n, s = null, c = !1) {
+		if (e == null || e === !1 || e === !0) return;
+		if (e.type === H) {
+			let r = a(String(e.text));
+			e.dom = r, r.__vnode = e, t(r, n, s);
 			return;
 		}
-		if (vnode.type === Comment) {
-			const node = hostCreateComment("");
-			vnode.dom = node;
-			hostInsert(node, container, before);
+		if (e.type === U) {
+			let r = o("");
+			e.dom = r, t(r, n, s);
 			return;
 		}
-		if (vnode.type === Fragment) {
-			const anchor = hostCreateComment("");
-			vnode.dom = anchor;
-			hostInsert(anchor, container, before);
-			if (vnode.children) vnode.children.forEach((child) => mount(child, container, anchor, parentIsSVG));
+		if (e.type === V) {
+			let r = o("");
+			e.dom = r, t(r, n, s), e.children && e.children.forEach((e) => x(e, n, r, c));
 			return;
 		}
-		if (isComponent(vnode.type)) {
-			mountComponent(vnode, container, before, vnode.type.__setup);
+		if (B(e.type)) {
+			re(e, n, s, e.type.__setup);
 			return;
 		}
-		const tag = vnode.type;
-		const isSVG = tag === "svg" || parentIsSVG && tag !== "foreignObject";
-		const element = hostCreateElement(tag, isSVG);
-		vnode.dom = element;
-		element.__vnode = vnode;
-		if (vnode.props) {
-			for (const key in vnode.props) if (key !== "children" && key !== "key" && key !== "ref") if (key.charCodeAt(0) === 117 && key.startsWith("use:")) {
-				if (hostPatchDirective) hostPatchDirective(element, key.slice(4), null, vnode.props[key], currentAppContext);
-			} else hostPatchProp(element, key, null, vnode.props[key], isSVG);
-			if (vnode.props.ref) untrack(() => {
-				if (typeof vnode.props.ref === "function") vnode.props.ref(element);
-				else if (typeof vnode.props.ref === "object") vnode.props.ref.current = element;
+		let l = e.type, u = l === "svg" || c && l !== "foreignObject", d = i(l, u);
+		if (e.dom = d, d.__vnode = e, e.props) {
+			for (let t in e.props) t !== "children" && t !== "key" && t !== "ref" && (t.charCodeAt(0) === 117 && t.startsWith("use:") ? h && h(d, t.slice(4), null, e.props[t], y) : r(d, t, null, e.props[t], u));
+			e.props.ref && p(() => {
+				typeof e.props.ref == "function" ? e.props.ref(d) : typeof e.props.ref == "object" && (e.props.ref.current = d);
 			});
 		}
-		const childIsSVG = isSVG && tag !== "foreignObject";
-		if (vnode.children) vnode.children.forEach((child) => {
-			child.parent = vnode;
-			mount(child, element, null, childIsSVG);
-		});
-		hostInsert(element, container, before);
-		if (hostOnElementMounted) hostOnElementMounted(element);
+		let f = u && l !== "foreignObject";
+		e.children && e.children.forEach((t) => {
+			t.parent = e, x(t, d, null, f);
+		}), t(d, n, s), g && g(d);
 	}
-	function unmount(vnode, container) {
-		const internalVNode = vnode;
-		if (internalVNode._effect) internalVNode._effect.stop();
-		if (vnode.cleanup) vnode.cleanup();
-		if (isComponent(vnode.type)) {
-			const subTree = internalVNode._subTreeRef?.current ?? internalVNode._subTree;
-			if (subTree) unmount(subTree, container);
-			if (vnode.dom) hostRemove(vnode.dom);
-			if (vnode.props?.ref) untrack(() => {
-				if (typeof vnode.props.ref === "function") vnode.props.ref(null);
-				else if (typeof vnode.props.ref === "object") vnode.props.ref.current = null;
+	function S(e, t) {
+		let r = e;
+		if (r._effect && r._effect.stop(), e.cleanup && e.cleanup(), B(e.type)) {
+			let i = r._subTreeRef?.current ?? r._subTree;
+			i && S(i, t), e.dom && n(e.dom), e.props?.ref && p(() => {
+				typeof e.props.ref == "function" ? e.props.ref(null) : typeof e.props.ref == "object" && (e.props.ref.current = null);
 			});
 			return;
 		}
-		if (vnode.type === Fragment) {
-			if (vnode.children) vnode.children.forEach((child) => unmount(child, container));
-			if (vnode.dom) hostRemove(vnode.dom);
+		if (e.type === V) {
+			e.children && e.children.forEach((e) => S(e, t)), e.dom && n(e.dom);
 			return;
 		}
-		if (vnode.type === Comment) {
-			if (vnode.dom) hostRemove(vnode.dom);
+		if (e.type === U) {
+			e.dom && n(e.dom);
 			return;
 		}
-		if (vnode.props?.ref) untrack(() => {
-			if (typeof vnode.props.ref === "function") vnode.props.ref(null);
-			else if (vnode.props.ref && typeof vnode.props.ref === "object") vnode.props.ref.current = null;
-		});
-		if (hostOnElementUnmounted && vnode.dom) hostOnElementUnmounted(vnode.dom);
-		if (vnode.children && vnode.children.length > 0) vnode.children.forEach((child) => unmount(child, vnode.dom));
-		if (vnode.dom) hostRemove(vnode.dom);
+		e.props?.ref && p(() => {
+			typeof e.props.ref == "function" ? e.props.ref(null) : e.props.ref && typeof e.props.ref == "object" && (e.props.ref.current = null);
+		}), _ && e.dom && _(e.dom), e.children && e.children.length > 0 && e.children.forEach((t) => S(t, e.dom)), e.dom && n(e.dom);
 	}
-	function patch(oldVNode, newVNode, container) {
-		if (oldVNode === newVNode) return;
-		if (!isSameVNode(oldVNode, newVNode)) {
-			const parent = hostParentNode(oldVNode.dom) || container;
-			const nextSibling = oldVNode.dom ? hostNextSibling(oldVNode.dom) : null;
-			unmount(oldVNode, parent);
-			mount(newVNode, parent, nextSibling);
+	function C(e, n, i) {
+		if (e === n) return;
+		if (!D(e, n)) {
+			let t = l(e.dom) || i, r = e.dom ? u(e.dom) : null;
+			S(e, t), x(n, t, r);
 			return;
 		}
-		const oldInternal = oldVNode;
-		const newInternal = newVNode;
-		if (oldInternal._effect) {
-			newVNode.dom = oldVNode.dom;
-			newInternal._effect = oldInternal._effect;
-			newInternal._subTree = oldInternal._subTree;
-			newInternal._subTreeRef = oldInternal._subTreeRef;
-			newInternal._slots = oldInternal._slots;
-			const props = oldInternal._componentProps;
-			newInternal._componentProps = props;
-			if (props) {
-				const newProps = newVNode.props || {};
-				const newModels = newVNode.props?.$models || {};
-				untrack(() => {
-					for (const key in newProps) if (key !== "children" && key !== "key" && key !== "ref" && key !== "$models") {
-						if (props[key] !== newProps[key]) props[key] = newProps[key];
-					}
-					for (const modelKey in newModels) {
-						const newModel = newModels[modelKey];
-						const oldModel = props[modelKey];
-						if (isModel(newModel)) {
-							if (isModel(oldModel)) {
-								const [newObj, newKey] = newModel.binding;
-								const [oldObj, oldKey] = oldModel.binding;
-								if (newObj === oldObj && newKey === oldKey) continue;
+		let o = e, c = n;
+		if (o._effect) {
+			n.dom = e.dom, c._effect = o._effect, c._subTree = o._subTree, c._subTreeRef = o._subTreeRef, c._slots = o._slots;
+			let t = o._componentProps;
+			if (c._componentProps = t, t) {
+				let e = n.props || {}, r = n.props?.$models || {};
+				p(() => {
+					for (let n in e) n !== "children" && n !== "key" && n !== "ref" && n !== "$models" && t[n] !== e[n] && (t[n] = e[n]);
+					for (let e in r) {
+						let n = r[e], i = t[e];
+						if (z(n)) {
+							if (z(i)) {
+								let [e, t] = n.binding, [r, a] = i.binding;
+								if (e === r && t === a) continue;
 							}
-							props[modelKey] = newModel;
+							t[e] = n;
 						}
 					}
-					for (const key in props) if (!(key in newProps) && !(key in newModels) && key !== "children" && key !== "key" && key !== "ref" && key !== "$models") delete props[key];
+					for (let n in t) !(n in e) && !(n in r) && n !== "children" && n !== "key" && n !== "ref" && n !== "$models" && delete t[n];
 				});
 			}
-			const slotsRef = oldInternal._slots;
-			const newChildren = newVNode.props?.children;
-			const newSlotsFromProps = newVNode.props?.slots;
-			if (slotsRef) {
-				if (newChildren !== void 0) slotsRef._children = newChildren;
-				if (newSlotsFromProps !== void 0) slotsRef._slotsFromProps = newSlotsFromProps;
-				if (!slotsRef._isPatching) {
-					slotsRef._isPatching = true;
-					try {
-						untrack(() => {
-							slotsRef._version.v++;
-						});
-					} finally {
-						slotsRef._isPatching = false;
-					}
+			let r = o._slots, i = n.props?.children, a = n.props?.slots;
+			if (r && (i !== void 0 && (r._children = i), a !== void 0 && (r._slotsFromProps = a), !r._isPatching)) {
+				r._isPatching = !0;
+				try {
+					p(() => {
+						r._version.v++;
+					});
+				} finally {
+					r._isPatching = !1;
 				}
 			}
 			return;
 		}
-		if (newVNode.type === Text) {
-			newVNode.dom = oldVNode.dom;
-			if (!newVNode.dom) {
-				const textNode = hostCreateText(String(newVNode.text));
-				newVNode.dom = textNode;
-				if (container) hostInsert(textNode, container, oldVNode.dom || null);
+		if (n.type === H) {
+			if (n.dom = e.dom, !n.dom) {
+				let r = a(String(n.text));
+				n.dom = r, i && t(r, i, e.dom || null);
 				return;
 			}
-			if (oldVNode.text !== newVNode.text) hostSetText(newVNode.dom, String(newVNode.text));
+			e.text !== n.text && s(n.dom, String(n.text));
 			return;
 		}
-		if (newVNode.type === Comment) {
-			newVNode.dom = oldVNode.dom;
+		if (n.type === U) {
+			n.dom = e.dom;
 			return;
 		}
-		if (newVNode.type === Fragment) {
-			patchChildren(oldVNode, newVNode, container, false);
+		if (n.type === V) {
+			w(e, n, i, !1);
 			return;
 		}
-		const element = newVNode.dom = oldVNode.dom;
-		if (!element) {
-			mount(newVNode, container);
+		let d = n.dom = e.dom;
+		if (!d) {
+			x(n, i);
 			return;
 		}
-		const tag = newVNode.type;
-		const isSVG = tag === "svg" || isSvgTag(tag);
-		const oldProps = oldVNode.props || {};
-		const newProps = newVNode.props || {};
-		for (const key in oldProps) if (!(key in newProps) && key !== "children" && key !== "key" && key !== "ref") if (key.charCodeAt(0) === 117 && key.startsWith("use:")) {
-			if (hostPatchDirective) hostPatchDirective(element, key.slice(4), oldProps[key], null, currentAppContext);
-		} else hostPatchProp(element, key, oldProps[key], null, isSVG);
-		for (const key in newProps) {
-			const oldValue = oldProps[key];
-			const newValue = newProps[key];
-			if (key !== "children" && key !== "key" && key !== "ref" && oldValue !== newValue) if (key.charCodeAt(0) === 117 && key.startsWith("use:")) {
-				if (hostPatchDirective) hostPatchDirective(element, key.slice(4), oldValue, newValue, currentAppContext);
-			} else hostPatchProp(element, key, oldValue, newValue, isSVG);
+		let f = n.type, m = f === "svg" || ne(f), g = e.props || {}, _ = n.props || {};
+		for (let e in g) !(e in _) && e !== "children" && e !== "key" && e !== "ref" && (e.charCodeAt(0) === 117 && e.startsWith("use:") ? h && h(d, e.slice(4), g[e], null, y) : r(d, e, g[e], null, m));
+		for (let e in _) {
+			let t = g[e], n = _[e];
+			e !== "children" && e !== "key" && e !== "ref" && t !== n && (e.charCodeAt(0) === 117 && e.startsWith("use:") ? h && h(d, e.slice(4), t, n, y) : r(d, e, t, n, m));
 		}
-		patchChildren(oldVNode, newVNode, element, isSVG && tag !== "foreignObject");
+		w(e, n, d, m && f !== "foreignObject");
 	}
-	function patchChildren(oldVNode, newVNode, container, parentIsSVG = false) {
-		const oldChildren = oldVNode.children;
-		const newChildren = newVNode.children;
-		newChildren.forEach((c) => c.parent = newVNode);
-		reconcileChildrenArray(container, oldChildren, newChildren, parentIsSVG);
+	function w(e, t, n, r = !1) {
+		let i = e.children, a = t.children;
+		a.forEach((e) => e.parent = t), E(n, i, a, r);
 	}
-	/**
-	* Check for duplicate keys in an array of VNodes and warn in development.
-	*/
-	function checkDuplicateKeys(children) {
+	function T(e) {
 		if (process.env.NODE_ENV === "production") return;
-		const seenKeys = /* @__PURE__ */ new Set();
-		for (const child of children) if (child?.key != null) {
-			const keyStr = String(child.key);
-			if (seenKeys.has(keyStr)) console.warn(`[SignalX] Duplicate key "${child.key}" detected in list. Keys should be unique among siblings to ensure correct reconciliation. This may cause unexpected behavior when items are reordered, added, or removed.`);
-			seenKeys.add(keyStr);
+		let t = /* @__PURE__ */ new Set();
+		for (let n of e) if (n?.key != null) {
+			let e = String(n.key);
+			t.has(e) && console.warn(`[SignalX] Duplicate key "${n.key}" detected in list. Keys should be unique among siblings to ensure correct reconciliation. This may cause unexpected behavior when items are reordered, added, or removed.`), t.add(e);
 		}
 	}
-	function reconcileChildrenArray(parent, oldChildren, newChildren, parentIsSVG = false) {
-		if (process.env.NODE_ENV !== "production") checkDuplicateKeys(newChildren);
-		let oldStartIdx = 0;
-		let oldEndIdx = oldChildren.length - 1;
-		let oldStartVNode = oldChildren[0];
-		let oldEndVNode = oldChildren[oldEndIdx];
-		let newStartIdx = 0;
-		let newEndIdx = newChildren.length - 1;
-		let newStartVNode = newChildren[0];
-		let newEndVNode = newChildren[newEndIdx];
-		let oldKeyToIdx;
-		while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) if (oldStartVNode == null) oldStartVNode = oldChildren[++oldStartIdx];
-		else if (oldEndVNode == null) oldEndVNode = oldChildren[--oldEndIdx];
-		else if (isSameVNode(oldStartVNode, newStartVNode)) {
-			patch(oldStartVNode, newStartVNode, parent);
-			oldStartVNode = oldChildren[++oldStartIdx];
-			newStartVNode = newChildren[++newStartIdx];
-		} else if (isSameVNode(oldEndVNode, newEndVNode)) {
-			patch(oldEndVNode, newEndVNode, parent);
-			oldEndVNode = oldChildren[--oldEndIdx];
-			newEndVNode = newChildren[--newEndIdx];
-		} else if (isSameVNode(oldStartVNode, newEndVNode)) {
-			patch(oldStartVNode, newEndVNode, parent);
-			const nodeToMove = oldStartVNode.dom;
-			const anchor = oldEndVNode.dom ? hostNextSibling(oldEndVNode.dom) : null;
-			if (nodeToMove) hostInsert(nodeToMove, parent, anchor);
-			oldStartVNode = oldChildren[++oldStartIdx];
-			newEndVNode = newChildren[--newEndIdx];
-		} else if (isSameVNode(oldEndVNode, newStartVNode)) {
-			patch(oldEndVNode, newStartVNode, parent);
-			const nodeToMove = oldEndVNode.dom;
-			const anchor = oldStartVNode.dom ?? null;
-			if (nodeToMove) hostInsert(nodeToMove, parent, anchor);
-			oldEndVNode = oldChildren[--oldEndIdx];
-			newStartVNode = newChildren[++newStartIdx];
+	function E(e, n, r, i = !1) {
+		process.env.NODE_ENV !== "production" && T(r);
+		let a = 0, o = n.length - 1, s = n[0], c = n[o], l = 0, d = r.length - 1, f = r[0], p = r[d], m;
+		for (; a <= o && l <= d;) if (s == null) s = n[++a];
+		else if (c == null) c = n[--o];
+		else if (D(s, f)) C(s, f, e), s = n[++a], f = r[++l];
+		else if (D(c, p)) C(c, p, e), c = n[--o], p = r[--d];
+		else if (D(s, p)) {
+			C(s, p, e);
+			let i = s.dom, o = c.dom ? u(c.dom) : null;
+			i && t(i, e, o), s = n[++a], p = r[--d];
+		} else if (D(c, f)) {
+			C(c, f, e);
+			let i = c.dom, a = s.dom ?? null;
+			i && t(i, e, a), c = n[--o], f = r[++l];
 		} else {
-			if (!oldKeyToIdx) oldKeyToIdx = createKeyToKeyIndexMap(oldChildren, oldStartIdx, oldEndIdx);
-			const idxInOld = newStartVNode.key != null ? oldKeyToIdx.get(String(newStartVNode.key)) : findIndexInOld(oldChildren, newStartVNode, oldStartIdx, oldEndIdx);
-			if (idxInOld != null) {
-				const vnodeToMove = oldChildren[idxInOld];
-				patch(vnodeToMove, newStartVNode, parent);
-				oldChildren[idxInOld] = void 0;
-				if (vnodeToMove.dom && oldStartVNode.dom) hostInsert(vnodeToMove.dom, parent, oldStartVNode.dom);
-			} else mount(newStartVNode, parent, oldStartVNode.dom ?? null, parentIsSVG);
-			newStartVNode = newChildren[++newStartIdx];
+			m ||= O(n, a, o);
+			let c = f.key == null ? A(n, f, a, o) : m.get(String(f.key));
+			if (c != null) {
+				let r = n[c];
+				C(r, f, e), n[c] = void 0, r.dom && s.dom && t(r.dom, e, s.dom);
+			} else x(f, e, s.dom ?? null, i);
+			f = r[++l];
 		}
-		if (oldStartIdx > oldEndIdx) {
-			if (newStartIdx <= newEndIdx) {
-				const anchor = newChildren[newEndIdx + 1] == null ? null : newChildren[newEndIdx + 1].dom ?? null;
-				for (let i = newStartIdx; i <= newEndIdx; i++) mount(newChildren[i], parent, anchor, parentIsSVG);
+		if (a > o) {
+			if (l <= d) {
+				let t = r[d + 1] == null ? null : r[d + 1].dom ?? null;
+				for (let n = l; n <= d; n++) x(r[n], e, t, i);
 			}
-		} else if (newStartIdx > newEndIdx) {
-			for (let i = oldStartIdx; i <= oldEndIdx; i++) if (oldChildren[i]) unmount(oldChildren[i], parent);
-		}
+		} else if (l > d) for (let t = a; t <= o; t++) n[t] && S(n[t], e);
 	}
-	function isSameVNode(n1, n2) {
-		const k1 = n1.key == null ? null : n1.key;
-		const k2 = n2.key == null ? null : n2.key;
-		if (n1.type !== n2.type) return false;
-		if (k1 === k2) return true;
-		return String(k1) === String(k2);
+	function D(e, t) {
+		let n = e.key == null ? null : e.key, r = t.key == null ? null : t.key;
+		return e.type === t.type ? n === r ? !0 : String(n) === String(r) : !1;
 	}
-	function createKeyToKeyIndexMap(children, beginIdx, endIdx) {
-		const map = /* @__PURE__ */ new Map();
-		for (let i = beginIdx; i <= endIdx; i++) {
-			const key = children[i]?.key;
-			if (key != null) {
-				const keyStr = String(key);
-				if (process.env.NODE_ENV !== "production" && map.has(keyStr)) console.warn(`[SignalX] Duplicate key "${key}" detected in list. Keys should be unique among siblings to ensure correct reconciliation. This may cause unexpected behavior when items are reordered, added, or removed.`);
-				map.set(keyStr, i);
+	function O(e, t, n) {
+		let r = /* @__PURE__ */ new Map();
+		for (let i = t; i <= n; i++) {
+			let t = e[i]?.key;
+			if (t != null) {
+				let e = String(t);
+				process.env.NODE_ENV !== "production" && r.has(e) && console.warn(`[SignalX] Duplicate key "${t}" detected in list. Keys should be unique among siblings to ensure correct reconciliation. This may cause unexpected behavior when items are reordered, added, or removed.`), r.set(e, i);
 			}
 		}
-		return map;
+		return r;
 	}
-	function findIndexInOld(children, newChild, beginIdx, endIdx) {
-		for (let i = beginIdx; i <= endIdx; i++) if (children[i] && isSameVNode(children[i], newChild)) return i;
+	function A(e, t, n, r) {
+		for (let i = n; i <= r; i++) if (e[i] && D(e[i], t)) return i;
 		return null;
 	}
-	function mountComponent(vnode, container, before, setup) {
-		const anchor = hostCreateComment("");
-		vnode.dom = anchor;
-		anchor.__vnode = vnode;
-		hostInsert(anchor, container, before);
-		let exposed = null;
-		let exposeCalled = false;
-		const { children, slots: slotsFromProps, $models: modelsData, ...propsData } = vnode.props || {};
-		const propsWithModels = { ...propsData };
-		if (modelsData) for (const modelKey in modelsData) {
-			const modelValue = modelsData[modelKey];
-			if (isModel(modelValue)) propsWithModels[modelKey] = modelValue;
+	function re(e, n, r, i) {
+		let a = o("");
+		e.dom = a, a.__vnode = e, t(a, n, r);
+		let s = null, c = !1, { children: l, slots: u, $models: d, ...m } = e.props || {}, h = { ...m };
+		if (d) for (let e in d) {
+			let t = d[e];
+			z(t) && (h[e] = t);
 		}
-		const reactiveProps = signal(propsWithModels);
-		const internalVNode = vnode;
-		internalVNode._componentProps = reactiveProps;
-		const slots = createSlots(children, slotsFromProps);
-		internalVNode._slots = slots;
-		const createdHooks = [];
-		const mountHooks = [];
-		const updatedHooks = [];
-		const unmountHooks = [];
-		const parentInstance = getCurrentInstance();
-		const componentName = vnode.type.__name;
-		const ctx = {
-			el: container,
-			signal,
-			props: createPropsAccessor(reactiveProps),
-			slots,
-			emit: createEmit(reactiveProps),
-			parent: parentInstance,
-			onMounted: (fn) => {
-				mountHooks.push(fn);
+		let g = k(h), _ = e;
+		_._componentProps = g;
+		let te = wt(l, u);
+		_._slots = te;
+		let b = [], ne = [], w = [], T = [], E = _e(), D = e.type.__name, O = {
+			el: n,
+			signal: k,
+			props: Ct(g),
+			slots: te,
+			emit: Ot(g),
+			parent: E,
+			onMounted: (e) => {
+				ne.push(e);
 			},
-			onUnmounted: (fn) => {
-				unmountHooks.push(fn);
+			onUnmounted: (e) => {
+				T.push(e);
 			},
-			onCreated: (fn) => {
-				createdHooks.push(fn);
+			onCreated: (e) => {
+				b.push(e);
 			},
-			onUpdated: (fn) => {
-				updatedHooks.push(fn);
+			onUpdated: (e) => {
+				w.push(e);
 			},
-			expose: (exposedValue) => {
-				exposed = exposedValue;
-				exposeCalled = true;
+			expose: (e) => {
+				s = e, c = !0;
 			},
 			renderFn: null,
 			update: () => {}
 		};
-		applyContextExtensions(ctx);
-		ctx.__name = componentName;
-		if (!parentInstance && currentAppContext) provideAppContext(ctx, currentAppContext);
-		const componentInstance = {
-			name: componentName,
-			ctx,
-			vnode
-		};
-		const prev = setCurrentInstance(ctx);
-		let renderFn;
+		ce(O), O.__name = D, !E && y && Le(O, y);
+		let A = {
+			name: D,
+			ctx: O,
+			vnode: e
+		}, re = ve(O), ie;
 		try {
-			const setupResult = setup(ctx);
-			if (setupResult && typeof setupResult.then === "function") throw asyncSetupClientError(componentName ?? "anonymous");
-			renderFn = setupResult;
-			notifyComponentCreated(currentAppContext, componentInstance);
-			createdHooks.forEach((hook) => hook());
-		} catch (err) {
-			if (!handleComponentError(currentAppContext, err, componentInstance, "setup")) throw err;
+			let e = i(O);
+			if (e && typeof e.then == "function") throw Ee(D ?? "anonymous");
+			ie = e, We(y, A), b.forEach((e) => e());
+		} catch (e) {
+			if (!Je(y, e, A, "setup")) throw e;
 		} finally {
-			setCurrentInstance(prev);
+			ve(re);
 		}
-		if (vnode.props?.ref) {
-			const refValue = exposeCalled ? exposed : null;
-			untrack(() => {
-				if (typeof vnode.props.ref === "function") vnode.props.ref(refValue);
-				else if (vnode.props.ref && typeof vnode.props.ref === "object") vnode.props.ref.current = refValue;
+		if (e.props?.ref) {
+			let t = c ? s : null;
+			p(() => {
+				typeof e.props.ref == "function" ? e.props.ref(t) : e.props.ref && typeof e.props.ref == "object" && (e.props.ref.current = t);
 			});
 		}
-		if (renderFn) {
-			ctx.renderFn = renderFn;
-			const subTreeRef = { current: null };
-			internalVNode._subTreeRef = subTreeRef;
-			const componentEffect = effect(() => {
-				const prevInstance = setCurrentInstance(ctx);
+		if (ie) {
+			O.renderFn = ie;
+			let e = { current: null };
+			_._subTreeRef = e;
+			let t = f(() => {
+				let t = ve(O);
 				try {
-					const subTreeResult = ctx.renderFn();
-					if (subTreeResult == null) {
-						if (subTreeRef.current) {
-							unmount(subTreeRef.current, container);
-							subTreeRef.current = null;
-							internalVNode._subTree = null;
-						}
+					let t = O.renderFn();
+					if (t == null) {
+						e.current && (S(e.current, n), e.current = null, _._subTree = null);
 						return;
 					}
-					const subTree = normalizeSubTree(subTreeResult);
-					const prevSubTree = subTreeRef.current;
-					if (prevSubTree) {
-						const prevFocus = hostGetActiveElement ? hostGetActiveElement() : null;
-						patch(prevSubTree, subTree, container);
-						if (prevFocus && hostRestoreFocus && hostGetActiveElement() !== prevFocus) hostRestoreFocus(prevFocus);
-						notifyComponentUpdated(currentAppContext, componentInstance);
-						updatedHooks.forEach((hook) => hook());
-					} else mount(subTree, container, anchor);
-					subTreeRef.current = subTree;
-					internalVNode._subTree = subTree;
-				} catch (err) {
-					if (!handleComponentError(currentAppContext, err, componentInstance, "render")) throw err;
+					let r = Tt(t), i = e.current;
+					if (i) {
+						let e = v ? v() : null;
+						C(i, r, n), e && ee && v() !== e && ee(e), qe(y, A), w.forEach((e) => e());
+					} else x(r, n, a);
+					e.current = r, _._subTree = r;
+				} catch (e) {
+					if (!Je(y, e, A, "render")) throw e;
 				} finally {
-					setCurrentInstance(prevInstance);
+					ve(t);
 				}
 			});
-			internalVNode._effect = componentEffect;
-			ctx.update = () => {
-				componentEffect();
+			_._effect = t, O.update = () => {
+				t();
 			};
 		}
-		const mountCtx = { el: container };
-		untrack(() => mountHooks.forEach((hook) => hook(mountCtx)));
-		notifyComponentMounted(currentAppContext, componentInstance);
-		vnode.cleanup = () => {
-			notifyComponentUnmounted(currentAppContext, componentInstance);
-			unmountHooks.forEach((hook) => hook(mountCtx));
+		let j = { el: n };
+		p(() => ne.forEach((e) => e(j))), Ge(y, A), e.cleanup = () => {
+			Ke(y, A), T.forEach((e) => e(j));
 		};
 	}
 	return {
-		render,
-		patch,
-		mount,
-		unmount,
-		mountComponent
+		render: te,
+		patch: C,
+		mount: x,
+		unmount: S,
+		mountComponent: re
 	};
 }
 //#endregion
 //#region ../runtime-terminal/src/focus.ts
-var focusableIds = /* @__PURE__ */ new Set();
-var focusState = signal({ activeId: null });
-function registerFocusable(id) {
-	focusableIds.add(id);
-	if (focusState.activeId === null) focusState.activeId = id;
-}
-function unregisterFocusable(id) {
-	focusableIds.delete(id);
-	if (focusState.activeId === id) {
-		focusState.activeId = null;
-		if (focusableIds.size > 0) focusState.activeId = focusableIds.values().next().value || null;
-	}
+var q = /* @__PURE__ */ new Set(), J = k({ activeId: null });
+function Y(e) {
+	q.add(e), J.activeId === null && (J.activeId = e);
 }
-function focus(id) {
-	if (focusableIds.has(id)) focusState.activeId = id;
+function X(e) {
+	q.delete(e), J.activeId === e && (J.activeId = null, q.size > 0 && (J.activeId = q.values().next().value || null));
 }
-function focusNext() {
-	if (focusableIds.size === 0) return;
-	const ids = Array.from(focusableIds);
-	focusState.activeId = ids[((focusState.activeId ? ids.indexOf(focusState.activeId) : -1) + 1) % ids.length];
+function At(e) {
+	q.has(e) && (J.activeId = e);
 }
-function focusPrev() {
-	if (focusableIds.size === 0) return;
-	const ids = Array.from(focusableIds);
-	focusState.activeId = ids[((focusState.activeId ? ids.indexOf(focusState.activeId) : -1) - 1 + ids.length) % ids.length];
+function jt() {
+	if (q.size === 0) return;
+	let e = Array.from(q);
+	J.activeId = e[((J.activeId ? e.indexOf(J.activeId) : -1) + 1) % e.length];
+}
+function Mt() {
+	if (q.size === 0) return;
+	let e = Array.from(q);
+	J.activeId = e[((J.activeId ? e.indexOf(J.activeId) : -1) - 1 + e.length) % e.length];
 }
 //#endregion
 //#region ../runtime-terminal/src/utils.ts
-function getColorCode(color) {
-	switch (color) {
+function Nt(e) {
+	switch (e) {
 		case "red": return "\x1B[31m";
 		case "green": return "\x1B[32m";
 		case "blue": return "\x1B[34m";
@@ -2892,8 +1558,8 @@ function getColorCode(color) {
 		default: return "";
 	}
 }
-function getBackgroundColorCode(color) {
-	switch (color) {
+function Pt(e) {
+	switch (e) {
 		case "red": return "\x1B[41m";
 		case "green": return "\x1B[42m";
 		case "blue": return "\x1B[44m";
@@ -2904,431 +1570,284 @@ function getBackgroundColorCode(color) {
 		default: return "";
 	}
 }
-function stripAnsi(str) {
-	return str.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
+function Ft(e) {
+	return e.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
 }
 //#endregion
 //#region ../runtime-terminal/src/components/Input.tsx
-/** @jsxImportSource @sigx/runtime-core */
-var Input = component(({ props, emit }) => {
-	const id = Math.random().toString(36).slice(2);
-	let isReady = false;
-	const isFocused = () => focusState.activeId === id;
-	const getValue = () => props.model?.value || "";
-	const handleKey = (key) => {
-		if (!isFocused()) return;
-		if (!isReady) return;
-		if (key === "\r") {
-			emit("submit", getValue());
+var It = F(({ props: e, emit: t }) => {
+	let n = Math.random().toString(36).slice(2), r = !1, i = () => J.activeId === n, a = () => e.model?.value || "", o = (n) => {
+		if (!i() || !r) return;
+		if (n === "\r") {
+			t("submit", a());
 			return;
 		}
-		if (key === "\n") return;
-		if (key === "" || key === "\b") {
-			const val = getValue();
-			if (val.length > 0) {
-				const newValue = val.slice(0, -1);
-				if (props.model) props.model.value = newValue;
-				emit("input", newValue);
+		if (n === "\n") return;
+		if (n === "" || n === "\b") {
+			let n = a();
+			if (n.length > 0) {
+				let r = n.slice(0, -1);
+				e.model && (e.model.value = r), t("input", r);
 			}
 			return;
 		}
-		if (key.length > 1) return;
-		const newValue = getValue() + key;
-		if (props.model) props.model.value = newValue;
-		emit("input", newValue);
-	};
-	let keyCleanup = null;
-	onMounted(() => {
-		registerFocusable(id);
-		if (props.autofocus) focus(id);
-		keyCleanup = onKey(handleKey);
-		setTimeout(() => {
-			isReady = true;
+		if (n.length > 1) return;
+		let o = a() + n;
+		e.model && (e.model.value = o), t("input", o);
+	}, s = null;
+	return N(() => {
+		Y(n), e.autofocus && At(n), s = Jt(o), setTimeout(() => {
+			r = !0;
 		}, 50);
-	});
-	onUnmounted(() => {
-		if (keyCleanup) keyCleanup();
-		unregisterFocusable(id);
-	});
-	return () => {
-		const val = getValue().replace(/[\r\n]+/g, " ");
-		const placeholder = (props.placeholder || "").replace(/[\r\n]+/g, " ");
-		const showCursor = isFocused();
-		return /* @__PURE__ */ jsxs("box", {
+	}), P(() => {
+		s && s(), X(n);
+	}), () => {
+		let t = a().replace(/[\r\n]+/g, " "), n = (e.placeholder || "").replace(/[\r\n]+/g, " "), r = i();
+		return /* @__PURE__ */ K("box", {
 			border: "single",
-			borderColor: showCursor ? "green" : "white",
-			label: props.label,
-			children: [/* @__PURE__ */ jsx("text", { children: val || placeholder }), showCursor && /* @__PURE__ */ jsx("text", {
+			borderColor: r ? "green" : "white",
+			label: e.label,
+			children: [/* @__PURE__ */ G("text", { children: t || n }), r && /* @__PURE__ */ G("text", {
 				color: "cyan",
 				children: "_"
 			})]
 		});
 	};
-}, { name: "Input" });
-//#endregion
-//#region ../runtime-terminal/src/components/ProgressBar.tsx
-/** @jsxImportSource @sigx/runtime-core */
-var ProgressBar = component(({ props }) => {
-	return () => {
-		const value = props.value || 0;
-		const max = props.max || 100;
-		const width = props.width || 20;
-		const barChar = props.char || "█";
-		const emptyChar = props.emptyChar || "░";
-		const color = props.color;
-		const colorCode = color ? getColorCode(color) : "";
-		const reset = color ? "\x1B[0m" : "";
-		const percentage = Math.min(Math.max(value / max, 0), 1);
-		const filledLen = Math.round(width * percentage);
-		const emptyLen = width - filledLen;
-		return /* @__PURE__ */ jsx("box", { children: /* @__PURE__ */ jsx("text", { children: colorCode + barChar.repeat(filledLen) + emptyChar.repeat(emptyLen) + reset + ` ${Math.round(percentage * 100)}%` }) });
-	};
-}, { name: "ProgressBar" });
-//#endregion
-//#region ../runtime-terminal/src/components/Button.tsx
-/** @jsxImportSource @sigx/runtime-core */
-var Button = component(({ props, emit }) => {
-	const id = Math.random().toString(36).slice(2);
-	const isFocused = () => focusState.activeId === id;
-	const pressed = signal({ value: false });
-	const handleKey = (key) => {
-		if (!isFocused()) return;
-		if (key === "\r" || key === " ") {
-			pressed.value = true;
-			if (pressTimer) clearTimeout(pressTimer);
-			pressTimer = setTimeout(() => {
-				pressed.value = false;
-				pressTimer = null;
-			}, 120);
-			emit("click");
-		}
-	};
-	let keyCleanup = null;
-	let pressTimer = null;
-	onMounted(() => {
-		registerFocusable(id);
-		keyCleanup = onKey(handleKey);
-	});
-	onUnmounted(() => {
-		if (keyCleanup) keyCleanup();
-		unregisterFocusable(id);
-		if (pressTimer) clearTimeout(pressTimer);
-	});
-	return () => {
-		const focused = isFocused();
-		const label = props.label || "Button";
-		const isPressed = pressed.value;
-		return /* @__PURE__ */ jsx("box", {
+}, { name: "Input" }), Lt = F(({ props: e }) => () => {
+	let t = e.value || 0, n = e.max || 100, r = e.width || 20, i = e.char || "█", a = e.emptyChar || "░", o = e.color, s = o ? Nt(o) : "", c = o ? "\x1B[0m" : "", l = Math.min(Math.max(t / n, 0), 1), u = Math.round(r * l), d = r - u;
+	return /* @__PURE__ */ G("box", { children: /* @__PURE__ */ G("text", { children: s + i.repeat(u) + a.repeat(d) + c + ` ${Math.round(l * 100)}%` }) });
+}, { name: "ProgressBar" }), Rt = F(({ props: e, emit: t }) => {
+	let n = Math.random().toString(36).slice(2), r = () => J.activeId === n, i = k({ value: !1 }), a = (e) => {
+		r() && (e === "\r" || e === " ") && (i.value = !0, s && clearTimeout(s), s = setTimeout(() => {
+			i.value = !1, s = null;
+		}, 120), t("click"));
+	}, o = null, s = null;
+	return N(() => {
+		Y(n), o = Jt(a);
+	}), P(() => {
+		o && o(), X(n), s && clearTimeout(s);
+	}), () => {
+		let t = r(), n = e.label || "Button", a = i.value;
+		return /* @__PURE__ */ G("box", {
 			border: "single",
-			borderColor: isPressed ? "yellow" : focused ? "green" : "white",
-			backgroundColor: isPressed ? "red" : focused ? "blue" : void 0,
-			dropShadow: props.dropShadow,
-			children: /* @__PURE__ */ jsx("text", {
-				color: focused ? "white" : void 0,
-				children: label
+			borderColor: a ? "yellow" : t ? "green" : "white",
+			backgroundColor: a ? "red" : t ? "blue" : void 0,
+			dropShadow: e.dropShadow,
+			children: /* @__PURE__ */ G("text", {
+				color: t ? "white" : void 0,
+				children: n
 			})
 		});
 	};
-}, { name: "Button" });
-//#endregion
-//#region ../runtime-terminal/src/components/Checkbox.tsx
-/** @jsxImportSource @sigx/runtime-core */
-var Checkbox = component(({ props, emit }) => {
-	const id = Math.random().toString(36).slice(2);
-	const isFocused = () => focusState.activeId === id;
-	const checked = () => !!props.model?.value;
-	const handleKey = (key) => {
-		if (!isFocused()) return;
-		if (props.disabled) return;
-		if (key === "\r" || key === " ") {
-			const next = !checked();
-			if (props.model) props.model.value = next;
-			emit("change", next);
+}, { name: "Button" }), zt = F(({ props: e, emit: t }) => {
+	let n = Math.random().toString(36).slice(2), r = () => J.activeId === n, i = () => !!e.model?.value, a = (n) => {
+		if (r() && !e.disabled && (n === "\r" || n === " ")) {
+			let n = !i();
+			e.model && (e.model.value = n), t("change", n);
 		}
-	};
-	let keyCleanup = null;
-	onMounted(() => {
-		registerFocusable(id);
-		if (props.autofocus) focus(id);
-		keyCleanup = onKey(handleKey);
-	});
-	onUnmounted(() => {
-		if (keyCleanup) keyCleanup();
-		unregisterFocusable(id);
-	});
-	return () => {
-		const label = props.label || "";
-		const focused = isFocused();
-		const isChecked = checked();
-		const disabled = !!props.disabled;
-		return /* @__PURE__ */ jsxs("box", { children: [
-			/* @__PURE__ */ jsx("text", {
-				color: focused ? "cyan" : "white",
-				children: focused ? ">" : " "
+	}, o = null;
+	return N(() => {
+		Y(n), e.autofocus && At(n), o = Jt(a);
+	}), P(() => {
+		o && o(), X(n);
+	}), () => {
+		let t = e.label || "", n = r(), a = i(), o = !!e.disabled;
+		return /* @__PURE__ */ K("box", { children: [
+			/* @__PURE__ */ G("text", {
+				color: n ? "cyan" : "white",
+				children: n ? ">" : " "
 			}),
-			/* @__PURE__ */ jsxs("text", {
-				color: disabled ? "white" : isChecked ? "green" : focused ? "cyan" : "white",
+			/* @__PURE__ */ K("text", {
+				color: o ? "white" : a ? "green" : n ? "cyan" : "white",
 				children: [
 					"[",
-					isChecked ? "x" : " ",
+					a ? "x" : " ",
 					"]"
 				]
 			}),
-			label && /* @__PURE__ */ jsxs("text", {
-				color: disabled ? "white" : focused ? "cyan" : void 0,
-				children: [" ", label]
+			t && /* @__PURE__ */ K("text", {
+				color: o ? "white" : n ? "cyan" : void 0,
+				children: [" ", t]
 			})
 		] });
 	};
-}, { name: "Checkbox" });
-//#endregion
-//#region ../runtime-terminal/src/components/Select.tsx
-/** @jsxImportSource @sigx/runtime-core */
-var Select = component(({ props, emit }) => {
-	const id = Math.random().toString(36).slice(2);
-	let isReady = false;
-	const isFocused = () => focusState.activeId === id;
-	const getCurrentIndex = () => {
-		const idx = (props.options || []).findIndex((o) => o.value === props.model?.value);
-		return idx >= 0 ? idx : 0;
-	};
-	const handleKey = (key) => {
-		if (!isFocused()) return;
-		if (!isReady) return;
-		const options = props.options || [];
-		if (options.length === 0) return;
-		const currentIndex = getCurrentIndex();
-		if (key === "\x1B[A" || key === "k") {
-			const newValue = options[currentIndex > 0 ? currentIndex - 1 : options.length - 1].value;
-			if (props.model) props.model.value = newValue;
-			emit("change", newValue);
+}, { name: "Checkbox" }), Bt = F(({ props: e, emit: t }) => {
+	let n = Math.random().toString(36).slice(2), r = !1, i = () => J.activeId === n, a = () => {
+		let t = (e.options || []).findIndex((t) => t.value === e.model?.value);
+		return t >= 0 ? t : 0;
+	}, o = (n) => {
+		if (!i() || !r) return;
+		let o = e.options || [];
+		if (o.length === 0) return;
+		let s = a();
+		if (n === "\x1B[A" || n === "k") {
+			let n = o[s > 0 ? s - 1 : o.length - 1].value;
+			e.model && (e.model.value = n), t("change", n);
 			return;
 		}
-		if (key === "\x1B[B" || key === "j") {
-			const newValue = options[currentIndex < options.length - 1 ? currentIndex + 1 : 0].value;
-			if (props.model) props.model.value = newValue;
-			emit("change", newValue);
+		if (n === "\x1B[B" || n === "j") {
+			let n = o[s < o.length - 1 ? s + 1 : 0].value;
+			e.model && (e.model.value = n), t("change", n);
 			return;
 		}
-		if (key === "\r") {
-			emit("submit", props.model?.value || options[0]?.value || "");
+		if (n === "\r") {
+			t("submit", e.model?.value || o[0]?.value || "");
 			return;
 		}
-	};
-	let keyCleanup = null;
-	onMounted(() => {
-		registerFocusable(id);
-		if (props.autofocus) focus(id);
-		keyCleanup = onKey(handleKey);
-		setTimeout(() => {
-			isReady = true;
+	}, s = null;
+	return N(() => {
+		Y(n), e.autofocus && At(n), s = Jt(o), setTimeout(() => {
+			r = !0;
 		}, 50);
-	});
-	onUnmounted(() => {
-		if (keyCleanup) keyCleanup();
-		unregisterFocusable(id);
-	});
-	return () => {
-		const options = props.options || [];
-		const focused = isFocused();
-		const currentValue = props.model?.value || options[0]?.value || "";
-		const label = props.label;
-		const selectedOption = options.find((o) => o.value === currentValue);
-		const optionElements = options.map((option) => {
-			const isSelected = option.value === currentValue;
-			return /* @__PURE__ */ jsx("box", { children: /* @__PURE__ */ jsxs("text", {
-				color: isSelected ? "cyan" : "white",
+	}), P(() => {
+		s && s(), X(n);
+	}), () => {
+		let t = e.options || [], n = i(), r = e.model?.value || t[0]?.value || "", a = e.label, o = t.find((e) => e.value === r), s = t.map((e) => {
+			let t = e.value === r;
+			return /* @__PURE__ */ G("box", { children: /* @__PURE__ */ K("text", {
+				color: t ? "cyan" : "white",
 				children: [
-					isSelected ? "❯" : " ",
+					t ? "❯" : " ",
 					" ",
-					option.label
+					e.label
 				]
 			}) });
-		});
-		const descriptionElement = props.showDescription && selectedOption?.description ? /* @__PURE__ */ jsx("box", { children: /* @__PURE__ */ jsxs("text", {
+		}), c = e.showDescription && o?.description ? /* @__PURE__ */ G("box", { children: /* @__PURE__ */ K("text", {
 			color: "#666666",
-			children: ["  ↳ ", selectedOption.description]
+			children: ["  ↳ ", o.description]
 		}) }) : null;
-		return /* @__PURE__ */ jsxs("box", { children: [/* @__PURE__ */ jsx("box", {
+		return /* @__PURE__ */ K("box", { children: [/* @__PURE__ */ G("box", {
 			border: "single",
-			borderColor: focused ? "green" : "white",
-			label,
-			children: optionElements
-		}), descriptionElement] });
-	};
-}, { name: "Select" });
-var { render } = createRenderer({
-	patchProp: (el, key, prev, next) => {
-		el.props[key] = next;
-		scheduleRender();
+			borderColor: n ? "green" : "white",
+			label: a,
+			children: s
+		}), c] });
+	};
+}, { name: "Select" }), { render: Z } = kt({
+	patchProp: (e, t, n, r) => {
+		e.props[t] = r, $();
 	},
-	insert: (child, parent, anchor) => {
-		child.parentNode = parent;
-		const index = anchor ? parent.children.indexOf(anchor) : -1;
-		if (index > -1) parent.children.splice(index, 0, child);
-		else parent.children.push(child);
-		scheduleRender();
+	insert: (e, t, n) => {
+		e.parentNode = t;
+		let r = n ? t.children.indexOf(n) : -1;
+		r > -1 ? t.children.splice(r, 0, e) : t.children.push(e), $();
 	},
-	remove: (child) => {
-		if (child.parentNode) {
-			const index = child.parentNode.children.indexOf(child);
-			if (index > -1) child.parentNode.children.splice(index, 1);
-			child.parentNode = null;
+	remove: (e) => {
+		if (e.parentNode) {
+			let t = e.parentNode.children.indexOf(e);
+			t > -1 && e.parentNode.children.splice(t, 1), e.parentNode = null;
 		}
-		scheduleRender();
+		$();
 	},
-	createElement: (tag) => {
-		return {
-			type: "element",
-			tag,
-			props: {},
-			children: []
-		};
-	},
-	createText: (text) => {
-		return {
-			type: "text",
-			text,
-			props: {},
-			children: []
-		};
-	},
-	createComment: (text) => {
-		return {
-			type: "comment",
-			text,
-			props: {},
-			children: []
-		};
-	},
-	setText: (node, text) => {
-		node.text = text;
-		scheduleRender();
+	createElement: (e) => ({
+		type: "element",
+		tag: e,
+		props: {},
+		children: []
+	}),
+	createText: (e) => ({
+		type: "text",
+		text: e,
+		props: {},
+		children: []
+	}),
+	createComment: (e) => ({
+		type: "comment",
+		text: e,
+		props: {},
+		children: []
+	}),
+	setText: (e, t) => {
+		e.text = t, $();
 	},
-	setElementText: (node, text) => {
-		node.children = [{
+	setElementText: (e, t) => {
+		e.children = [{
 			type: "text",
-			text,
+			text: t,
 			props: {},
 			children: [],
-			parentNode: node
-		}];
-		scheduleRender();
+			parentNode: e
+		}], $();
 	},
-	parentNode: (node) => node.parentNode || null,
-	nextSibling: (node) => {
-		if (!node.parentNode) return null;
-		const idx = node.parentNode.children.indexOf(node);
-		return node.parentNode.children[idx + 1] || null;
+	parentNode: (e) => e.parentNode || null,
+	nextSibling: (e) => {
+		if (!e.parentNode) return null;
+		let t = e.parentNode.children.indexOf(e);
+		return e.parentNode.children[t + 1] || null;
 	},
-	cloneNode: (node) => {
-		return {
-			...node,
-			children: []
-		};
-	}
-});
-var rootNode = null;
-var isRendering = false;
-function scheduleRender() {
-	if (isRendering) return;
-	isRendering = true;
-	setTimeout(() => {
-		flushRender();
-		isRendering = false;
-	}, 10);
-}
-function flushRender() {
-	if (!rootNode) return;
+	cloneNode: (e) => ({
+		...e,
+		children: []
+	})
+}), Q = null, Vt = !1;
+function $() {
+	Vt || (Vt = !0, setTimeout(() => {
+		Ht(), Vt = !1;
+	}, 10));
+}
+function Ht() {
+	if (!Q) return;
 	process.stdout.write("\x1B[H");
-	const lines = renderNodeToLines(rootNode);
-	process.stdout.write(lines.join("\x1B[K\n") + "\x1B[K");
-	process.stdout.write("\x1B[J");
-}
-/**
-* Check if a node has a box element as an immediate child.
-* This is used to determine if a component wrapper should be treated as a block element.
-*/
-function hasBoxChild(node) {
-	for (const child of node.children) if (child.tag === "box") return true;
-	return false;
-}
-function renderNodeToLines(node) {
-	if (node.type === "text") return [node.text || ""];
-	if (node.type === "comment") return [];
-	let lines = [""];
-	const color = node.props.color;
-	const reset = color ? "\x1B[0m" : "";
-	const colorCode = getColorCode(color);
-	for (const child of node.children) if (child.type === "text") lines[lines.length - 1] += colorCode + (child.text || "") + reset;
-	else if (child.tag === "br") lines.push("");
+	let e = Wt(Q);
+	process.stdout.write(e.join("\x1B[K\n") + "\x1B[K"), process.stdout.write("\x1B[J");
+}
+function Ut(e) {
+	for (let t of e.children) if (t.tag === "box") return !0;
+	return !1;
+}
+function Wt(e) {
+	if (e.type === "text") return [e.text || ""];
+	if (e.type === "comment") return [];
+	let t = [""], n = e.props.color, r = n ? "\x1B[0m" : "", i = Nt(n);
+	for (let n of e.children) if (n.type === "text") t[t.length - 1] += i + (n.text || "") + r;
+	else if (n.tag === "br") t.push("");
 	else {
-		const childLines = renderNodeToLines(child);
-		if (child.tag === "box" || hasBoxChild(child)) if (lines.length === 1 && lines[0] === "") lines = childLines;
-		else lines.push(...childLines);
-		else if (childLines.length > 0) if (childLines.length > 1) if (lines.length === 1 && lines[0] === "") lines = childLines;
-		else lines.push(...childLines);
+		let e = Wt(n);
+		if (n.tag === "box" || Ut(n)) t.length === 1 && t[0] === "" ? t = e : t.push(...e);
+		else if (e.length > 0) if (e.length > 1) t.length === 1 && t[0] === "" ? t = e : t.push(...e);
 		else {
-			lines[lines.length - 1] += childLines[0];
-			for (let i = 1; i < childLines.length; i++) lines.push(childLines[i]);
+			t[t.length - 1] += e[0];
+			for (let n = 1; n < e.length; n++) t.push(e[n]);
 		}
 	}
-	if (node.tag === "box" && node.props.border) return drawBox(lines, node.props.border, node.props.borderColor, node.props.backgroundColor, node.props.dropShadow, node.props.label);
-	return lines;
-}
-function drawBox(contentLines, style, color, backgroundColor, dropShadow, label) {
-	const borderChars = getBorderChars(style);
-	const colorCode = color ? getColorCode(color) : "";
-	const bgCode = backgroundColor ? getBackgroundColorCode(backgroundColor) : "";
-	const reset = color || backgroundColor ? "\x1B[0m" : "";
-	const width = contentLines.reduce((max, line) => Math.max(max, stripAnsi(line).length), 0);
-	const labelText = label || "";
-	const labelLength = stripAnsi(labelText).length;
-	const boxInnerWidth = Math.max(width, labelLength + 2);
-	let topInner = "";
-	if (labelText) {
-		const spaceForLabel = boxInnerWidth - labelLength - 2;
-		const leftH = Math.floor(spaceForLabel / 2);
-		const rightH = spaceForLabel - leftH;
-		topInner = borderChars.h.repeat(leftH) + " " + labelText + " " + borderChars.h.repeat(rightH);
-	} else topInner = borderChars.h.repeat(boxInnerWidth);
-	const top = bgCode + colorCode + borderChars.tl + topInner + borderChars.tr + reset;
-	const bottom = bgCode + colorCode + borderChars.bl + borderChars.h.repeat(boxInnerWidth) + borderChars.br + reset;
-	const result = [];
-	result.push(top);
-	for (const line of contentLines) {
-		const visibleLength = stripAnsi(line).length;
-		const padding = " ".repeat(boxInnerWidth - visibleLength);
-		const lineWithBg = bgCode + line.replace(/\x1b\[0m/g, `\x1b[0m${bgCode}`);
-		result.push(bgCode + colorCode + borderChars.v + reset + lineWithBg + bgCode + padding + colorCode + borderChars.v + reset);
+	return e.tag === "box" && e.props.border ? Gt(t, e.props.border, e.props.borderColor, e.props.backgroundColor, e.props.dropShadow, e.props.label) : t;
+}
+function Gt(e, t, n, r, i, a) {
+	let o = Kt(t), s = n ? Nt(n) : "", c = r ? Pt(r) : "", l = n || r ? "\x1B[0m" : "", u = e.reduce((e, t) => Math.max(e, Ft(t).length), 0), d = a || "", f = Ft(d).length, p = Math.max(u, f + 2), m = "";
+	if (d) {
+		let e = p - f - 2, t = Math.floor(e / 2), n = e - t;
+		m = o.h.repeat(t) + " " + d + " " + o.h.repeat(n);
+	} else m = o.h.repeat(p);
+	let h = c + s + o.tl + m + o.tr + l, g = c + s + o.bl + o.h.repeat(p) + o.br + l, _ = [];
+	_.push(h);
+	for (let t of e) {
+		let e = Ft(t).length, n = " ".repeat(p - e), r = c + t.replace(/\x1b\[0m/g, `\x1b[0m${c}`);
+		_.push(c + s + o.v + l + r + c + n + s + o.v + l);
 	}
-	result.push(bottom);
-	if (dropShadow) {
-		const shadowBlock = "\x1B[90m▒\x1B[0m";
-		for (let i = 1; i < result.length; i++) result[i] += shadowBlock;
-		const bottomShadow = " " + shadowBlock.repeat(width + 2);
-		result.push(bottomShadow);
+	if (_.push(g), i) {
+		let e = "\x1B[90m▒\x1B[0m";
+		for (let t = 1; t < _.length; t++) _[t] += e;
+		let t = " " + e.repeat(u + 2);
+		_.push(t);
 	}
-	return result;
+	return _;
 }
-function getBorderChars(style) {
-	if (style === "double") return {
+function Kt(e) {
+	return e === "double" ? {
 		tl: "╔",
 		tr: "╗",
 		bl: "╚",
 		br: "╝",
 		h: "═",
 		v: "║"
-	};
-	if (style === "rounded") return {
+	} : e === "rounded" ? {
 		tl: "╭",
 		tr: "╮",
 		bl: "╰",
 		br: "╯",
 		h: "─",
 		v: "│"
-	};
-	return {
+	} : {
 		tl: "┌",
 		tr: "┐",
 		bl: "└",
@@ -3337,126 +1856,58 @@ function getBorderChars(style) {
 		v: "│"
 	};
 }
-var keyHandlers = /* @__PURE__ */ new Set();
-function onKey(handler) {
-	keyHandlers.add(handler);
-	return () => keyHandlers.delete(handler);
+var qt = /* @__PURE__ */ new Set();
+function Jt(e) {
+	return qt.add(e), () => qt.delete(e);
 }
-function handleInput(key) {
-	if (key === "") {
-		process.stdout.write("\x1B[?25h");
-		process.exit();
-	}
-	if (key === "	") {
-		focusNext();
+function Yt(e) {
+	if (e === "" && (process.stdout.write("\x1B[?25h"), process.exit()), e === "	") {
+		jt();
 		return;
 	}
-	if (key === "\x1B[Z") {
-		focusPrev();
+	if (e === "\x1B[Z") {
+		Mt();
 		return;
 	}
-	for (const handler of keyHandlers) handler(key);
+	for (let t of qt) t(e);
 }
-function renderTerminal(app, options = {}) {
-	rootNode = {
+function Xt(e, t = {}) {
+	Q = {
 		type: "root",
 		props: {},
 		children: []
 	};
-	const container = rootNode;
-	if (process.stdin.isTTY) {
-		process.stdin.setRawMode(true);
-		process.stdin.resume();
-		process.stdin.setEncoding("utf8");
-		process.stdin.on("data", handleInput);
-	}
-	if (options.clearConsole) process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
-	process.stdout.write("\x1B[?25l");
-	render(app, container);
-	flushRender();
-	return { unmount: () => {
-		render(null, container);
-		process.stdout.write("\x1B[?25h");
-		if (process.stdin.isTTY) {
-			process.stdin.setRawMode(false);
-			process.stdin.pause();
-			process.stdin.off("data", handleInput);
-		}
+	let n = Q;
+	return process.stdin.isTTY && (process.stdin.setRawMode(!0), process.stdin.resume(), process.stdin.setEncoding("utf8"), process.stdin.on("data", Yt)), t.clearConsole && process.stdout.write("\x1B[2J\x1B[3J\x1B[H"), process.stdout.write("\x1B[?25l"), Z(e, n), Ht(), { unmount: () => {
+		Z(null, n), process.stdout.write("\x1B[?25h"), process.stdin.isTTY && (process.stdin.setRawMode(!1), process.stdin.pause(), process.stdin.off("data", Yt));
 	} };
 }
-var unmountFn = null;
-/**
-* Helper function to mount the terminal for CLI apps.
-* Returns a mount target that can be passed to defineApp().mount().
-* 
-* @example
-* ```tsx
-* defineApp(MyApp).mount(mountTerminal());
-* ```
-*/
-function mountTerminal(options = { clearConsole: true }) {
+var Zt = null;
+function Qt(e = { clearConsole: !0 }) {
 	return {
-		mount: terminalMount,
-		options,
-		onMount: (unmount) => {
-			unmountFn = unmount;
+		mount: en,
+		options: e,
+		onMount: (e) => {
+			Zt = e;
 		}
 	};
 }
-/**
-* Exit the terminal app cleanly, restoring terminal state.
-*/
-function exitTerminal() {
-	if (unmountFn) {
-		unmountFn();
-		unmountFn = null;
-	}
-	process.stdout.write("\x1B[?25h");
-	process.stdout.write("\x1B[2J\x1B[H");
-}
-/**
-* Mount function for Terminal environments.
-* Use this with defineApp().mount() to render to the terminal.
-* 
-* @example
-* ```tsx
-* import { defineApp } from '@sigx/runtime-core';
-* import { terminalMount } from '@sigx/runtime-terminal';
-* 
-* const app = defineApp(<Counter />);
-* app.use(loggingPlugin)
-*    .mount({ clearConsole: true }, terminalMount);
-* ```
-*/
-var terminalMount = (component, options, appContext) => {
-	rootNode = {
+function $t() {
+	Zt &&= (Zt(), null), process.stdout.write("\x1B[?25h"), process.stdout.write("\x1B[2J\x1B[H");
+}
+var en = (e, t, n) => {
+	Q = {
 		type: "root",
 		props: {},
 		children: []
 	};
-	const container = rootNode;
-	if (process.stdin.isTTY) {
-		process.stdin.setRawMode(true);
-		process.stdin.resume();
-		process.stdin.setEncoding("utf8");
-		process.stdin.on("data", handleInput);
-	}
-	if (options?.clearConsole) process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
-	process.stdout.write("\x1B[?25l");
-	render(component, container, appContext);
-	flushRender();
-	return () => {
-		render(null, container);
-		process.stdout.write("\x1B[?25h");
-		if (process.stdin.isTTY) {
-			process.stdin.setRawMode(false);
-			process.stdin.pause();
-			process.stdin.off("data", handleInput);
-		}
+	let r = Q;
+	return process.stdin.isTTY && (process.stdin.setRawMode(!0), process.stdin.resume(), process.stdin.setEncoding("utf8"), process.stdin.on("data", Yt)), t?.clearConsole && process.stdout.write("\x1B[2J\x1B[3J\x1B[H"), process.stdout.write("\x1B[?25l"), Z(e, r, n), Ht(), () => {
+		Z(null, r), process.stdout.write("\x1B[?25h"), process.stdin.isTTY && (process.stdin.setRawMode(!1), process.stdin.pause(), process.stdin.off("data", Yt));
 	};
 };
-setDefaultMount(terminalMount);
+He(en);
 //#endregion
-export { Button, CLIENT_DIRECTIVES, CLIENT_DIRECTIVE_PREFIX, Checkbox, Comment, ComputedSymbol, ErrorBoundary, Fragment, Input, InstanceLifetimes, ProgressBar, Select, SigxError, SigxErrorCode, SubscriptionHandler, Suspense, Text, Utils, asyncSetupClientError, batch, component, compound, computed, createModel, createModelFromBinding, createTopic, defineApp, defineDirective, defineFactory, defineInjectable, defineProvide, detectAccess, effect, effectScope, exitTerminal, focus, focusNext, focusPrev, focusState, getComponentMeta, getCurrentInstance, guid, isComponent, isComputed, isDirective, isLazyComponent, isModel, isReactive, jsx, jsxDEV, jsxs, lazy, mountTargetNotFoundError, mountTerminal, noMountFunctionError, onCreated, onKey, onMounted, onUnmounted, onUpdated, provideInvalidInjectableError, provideOutsideSetupError, registerFocusable, render, renderNodeToLines, renderTargetNotFoundError, renderTerminal, signal, terminalMount, toRaw, toSubscriber, unregisterFocusable, untrack, useAppContext, useAsync, watch };
+export { Rt as Button, Dt as CLIENT_DIRECTIVES, Et as CLIENT_DIRECTIVE_PREFIX, zt as Checkbox, U as Comment, t as ComputedSymbol, mt as ErrorBoundary, V as Fragment, It as Input, vt as InstanceLifetimes, Lt as ProgressBar, Bt as Select, I as SigxError, L as SigxErrorCode, xt as SubscriptionHandler, dt as Suspense, H as Text, ht as Utils, Ee as asyncSetupClientError, s as batch, F as component, Xe as compound, ie as computed, Qe as createModel, $e as createModelFromBinding, yt as createTopic, Ue as defineApp, ze as defineDirective, St as defineFactory, Ne as defineInjectable, Pe as defineProvide, D as detectAccess, f as effect, m as effectScope, $t as exitTerminal, At as focus, jt as focusNext, Mt as focusPrev, J as focusState, Se as getComponentMeta, _e as getCurrentInstance, _t as guid, B as isComponent, j as isComputed, Be as isDirective, ft as isLazyComponent, z as isModel, ee as isReactive, G as jsx, st as jsxDEV, K as jsxs, ut as lazy, Te as mountTargetNotFoundError, Qt as mountTerminal, Ce as noMountFunctionError, ye as onCreated, Jt as onKey, N as onMounted, P as onUnmounted, be as onUpdated, Oe as provideInvalidInjectableError, De as provideOutsideSetupError, Y as registerFocusable, Z as render, Wt as renderNodeToLines, we as renderTargetNotFoundError, Xt as renderTerminal, k as signal, en as terminalMount, v as toRaw, bt as toSubscriber, X as unregisterFocusable, p as untrack, Fe as useAppContext, pt as useAsync, re as watch };
 
 //# sourceMappingURL=index.js.map