@sigx/terminal 0.1.0

package/dist/index.js

@@ -0,0 +1,1929 @@
+//#region ../reactivity/src/index.ts
+let activeEffect = null;
+let batchDepth = 0;
+const pendingEffects = /* @__PURE__ */ new Set();
+function batch(fn) {
+	batchDepth++;
+	try {
+		fn();
+	} finally {
+		batchDepth--;
+		if (batchDepth === 0) {
+			const effects = Array.from(pendingEffects);
+			pendingEffects.clear();
+			for (const effect$1 of effects) effect$1();
+		}
+	}
+}
+function runEffect(fn) {
+	const effect$1 = function() {
+		cleanup(effect$1);
+		activeEffect = effect$1;
+		fn();
+		activeEffect = null;
+	};
+	effect$1.deps = [];
+	effect$1();
+	return () => cleanup(effect$1);
+}
+function cleanup(effect$1) {
+	if (!effect$1.deps) return;
+	for (const dep of effect$1.deps) dep.delete(effect$1);
+	effect$1.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$1 of effects) if (batchDepth > 0) pendingEffects.add(effect$1);
+	else effect$1();
+}
+let accessObserver = null;
+function detectAccess(selector) {
+	let result = null;
+	const prev = accessObserver;
+	accessObserver = (target, key) => {
+		result = [target, key];
+	};
+	try {
+		selector();
+	} finally {
+		accessObserver = prev;
+	}
+	return result;
+}
+function untrack(fn) {
+	const prev = activeEffect;
+	activeEffect = null;
+	try {
+		return fn();
+	} finally {
+		activeEffect = prev;
+	}
+}
+function signal(target) {
+	const depsMap = /* @__PURE__ */ new Map();
+	const reactiveCache = /* @__PURE__ */ new WeakMap();
+	return new Proxy(target, {
+		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);
+					} 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);
+					}
+				});
+			};
+			if (Array.isArray(obj) && typeof prop === "string" && arrayInstrumentations.hasOwnProperty(prop)) return arrayInstrumentations[prop];
+			const value = Reflect.get(obj, prop);
+			if (accessObserver) accessObserver(receiver, prop);
+			let dep = depsMap.get(prop);
+			if (!dep) {
+				dep = /* @__PURE__ */ new Set();
+				depsMap.set(prop, dep);
+			}
+			track(dep);
+			if (value && typeof value === "object") {
+				let cached = reactiveCache.get(value);
+				if (!cached) {
+					cached = signal(value);
+					reactiveCache.set(value, cached);
+				}
+				return cached;
+			}
+			return value;
+		},
+		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);
+					}
+					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);
+					}
+				}
+			}
+			return result;
+		},
+		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);
+			}
+			return result;
+		}
+	});
+}
+function effect(fn) {
+	return runEffect(fn);
+}
+const arrayInstrumentations = {};
+[
+	"push",
+	"pop",
+	"shift",
+	"unshift",
+	"splice",
+	"sort",
+	"reverse"
+].forEach((method) => {
+	arrayInstrumentations[method] = function(...args) {
+		let res;
+		batch(() => {
+			res = Array.prototype[method].apply(this, args);
+		});
+		return res;
+	};
+});
+function watch(source, cb, options) {
+	let oldValue;
+	let isFirst = true;
+	let cleanupFn = null;
+	const runner = effect(() => {
+		const newValue = typeof source === "function" ? source() : source;
+		if (isFirst) {
+			if (options?.immediate) {
+				if (cleanupFn) cleanupFn();
+				cb(newValue, oldValue, (fn) => cleanupFn = fn);
+			}
+			isFirst = false;
+		} else {
+			if (cleanupFn) cleanupFn();
+			cb(newValue, oldValue, (fn) => cleanupFn = fn);
+		}
+		oldValue = newValue;
+	});
+	const stop = () => {
+		runner();
+		if (cleanupFn) cleanupFn();
+	};
+	const handle = stop;
+	handle.stop = stop;
+	handle.pause = () => {};
+	handle.resume = () => {};
+	return handle;
+}
+function effectScope(detached) {
+	const effects = [];
+	let active = true;
+	return {
+		run(fn) {
+			if (!active) return void 0;
+			return fn();
+		},
+		stop() {
+			active = false;
+			effects.forEach((e) => e());
+		}
+	};
+}
+
+//#endregion
+//#region ../runtime-core/src/platform.ts
+let platformSyncProcessor$1 = null;
+/**
+* Set the platform-specific sync processor for intrinsic elements.
+* Called by runtime-dom to handle checkbox/radio/select sync bindings.
+*/
+function setPlatformSyncProcessor(fn) {
+	platformSyncProcessor$1 = fn;
+}
+/**
+* Get the current platform sync processor (for internal use).
+*/
+function getPlatformSyncProcessor() {
+	return platformSyncProcessor$1;
+}
+
+//#endregion
+//#region ../runtime-core/src/plugins.ts
+const plugins = [];
+function registerComponentPlugin(plugin) {
+	plugins.push(plugin);
+}
+/**
+* Get all registered plugins (internal use)
+*/
+function getComponentPlugins() {
+	return plugins;
+}
+
+//#endregion
+//#region ../runtime-core/src/app.ts
+const isDev = typeof process !== "undefined" && true || true;
+/**
+* Unique symbol for app context injection
+*/
+const AppContextKey = Symbol("sigx:app");
+let 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;
+}
+/**
+* Get the current default mount function.
+* @internal
+*/
+function getDefaultMount() {
+	return defaultMountFn;
+}
+/**
+* Create an application instance.
+* 
+* @example
+* ```tsx
+* import { defineApp, defineInjectable } from '@sigx/runtime-core';
+* import { render } from '@sigx/runtime-dom';
+* 
+* // Define an injectable service
+* const useApiConfig = defineInjectable(() => ({ baseUrl: 'https://api.example.com' }));
+* 
+* const app = defineApp(<App />);
+* 
+* app.use(myPlugin, { option: 'value' });
+* 
+* // Provide using the injectable token (works with inject())
+* app.provide(useApiConfig, { baseUrl: 'https://custom.api.com' });
+* 
+* app.mount(document.getElementById('app')!, render);
+* ```
+*/
+function defineApp(rootComponent) {
+	const installedPlugins = /* @__PURE__ */ new Set();
+	const context = {
+		app: null,
+		provides: /* @__PURE__ */ new Map(),
+		config: {},
+		hooks: []
+	};
+	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;
+		},
+		provide(token, value) {
+			const actualToken = token?._token ?? token;
+			if (isDev && context.provides.has(actualToken)) console.warn(`App-level provide: token is being overwritten.`);
+			context.provides.set(actualToken, value);
+			return app;
+		},
+		hook(hooks) {
+			context.hooks.push(hooks);
+			return app;
+		},
+		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 new Error("No mount function provided and no default mount function set. 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.");
+			container = target;
+			isMounted = true;
+			const result = mountFn(rootComponent, target, context);
+			if (typeof result === "function") unmountFn = result;
+			return app;
+		},
+		unmount() {
+			if (!isMounted) {
+				if (isDev) console.warn("App is not mounted.");
+				return;
+			}
+			if (unmountFn) unmountFn();
+			context.provides.clear();
+			isMounted = false;
+			container = null;
+		},
+		get _context() {
+			return context;
+		},
+		get _isMounted() {
+			return isMounted;
+		},
+		get _container() {
+			return container;
+		}
+	};
+	context.app = app;
+	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");
+	}
+}
+/**
+* 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");
+	}
+}
+/**
+* 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");
+	}
+}
+/**
+* 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");
+	}
+}
+/**
+* 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);
+	}
+	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);
+	}
+	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}`);
+	} catch {}
+}
+
+//#endregion
+//#region ../runtime-core/src/component.ts
+let currentComponentContext = null;
+function getCurrentInstance() {
+	return currentComponentContext;
+}
+function setCurrentInstance(ctx) {
+	const prev = currentComponentContext;
+	currentComponentContext = ctx;
+	return prev;
+}
+function onMount(fn) {
+	if (currentComponentContext) currentComponentContext.onMount(fn);
+	else console.warn("onMount called outside of component setup");
+}
+function onCleanup(fn) {
+	if (currentComponentContext) currentComponentContext.onCleanup(fn);
+	else console.warn("onCleanup called outside of component setup");
+}
+const componentRegistry = /* @__PURE__ */ new Map();
+/**
+* Get component metadata (for DevTools)
+*/
+function getComponentMeta(factory) {
+	return componentRegistry.get(factory);
+}
+/**
+* Helper to create a proxy that tracks property access
+*/
+function createPropsProxy(target, onAccess) {
+	return new Proxy(target, { get(obj, prop) {
+		if (typeof prop === "string" && onAccess) onAccess(prop);
+		return obj[prop];
+	} });
+}
+/**
+* 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 = defineComponent<CardProps>((ctx) => {
+*     const { title } = ctx.props;
+*     const { slots } = ctx;
+*     
+*     return () => (
+*         <div class="card">
+*             {slots.header?.() ?? <h2>{title}</h2>}
+*             {slots.default()}
+*         </div>
+*     );
+* });
+* ```
+*/
+function defineComponent(setup, options) {
+	const factory = function(props) {
+		return {
+			type: factory,
+			props: props || {},
+			key: props?.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;
+}
+
+//#endregion
+//#region ../runtime-core/src/jsx-runtime.ts
+const Fragment = Symbol.for("sigx.Fragment");
+const Text = Symbol.for("sigx.Text");
+function normalizeChildren$1(children) {
+	if (children == null || children === false || children === true) return [];
+	if (Array.isArray(children)) return children.flatMap((c) => normalizeChildren$1(c));
+	if (typeof children === "string" || typeof children === "number") return [{
+		type: Text,
+		props: {},
+		key: null,
+		children: [],
+		dom: null,
+		text: children
+	}];
+	if (children.type) return [children];
+	return [];
+}
+/**
+* Check if a type is a sigx component (has __setup)
+*/
+function isComponent$2(type) {
+	return typeof type === "function" && "__setup" in type;
+}
+/**
+* Create a JSX element - this is the core function called by TSX transpilation
+*/
+function jsx(type, props, key) {
+	const processedProps = { ...props || {} };
+	if (props) {
+		for (const propKey in props) if (propKey === "sync") {
+			let syncBinding = props[propKey];
+			if (typeof syncBinding === "function") {
+				const detected = detectAccess(syncBinding);
+				if (detected) syncBinding = detected;
+			}
+			if (Array.isArray(syncBinding) && syncBinding.length === 2) {
+				const [stateObj, key$1] = syncBinding;
+				let handled = false;
+				const platformProcessor = getPlatformSyncProcessor();
+				if (typeof type === "string" && platformProcessor) handled = platformProcessor(type, processedProps, [stateObj, key$1], props);
+				if (!handled) {
+					processedProps.value = stateObj[key$1];
+					const existingHandler = processedProps["onUpdate:value"];
+					processedProps["onUpdate:value"] = (v) => {
+						stateObj[key$1] = v;
+						if (existingHandler) existingHandler(v);
+					};
+				}
+				delete processedProps.sync;
+			}
+		} else if (propKey.startsWith("sync:")) {
+			const syncBinding = props[propKey];
+			if (Array.isArray(syncBinding) && syncBinding.length === 2) {
+				const [stateObj, key$1] = syncBinding;
+				const name = propKey.slice(5);
+				processedProps[name] = stateObj[key$1];
+				const eventName = `onUpdate:${name}`;
+				const existingHandler = processedProps[eventName];
+				processedProps[eventName] = (v) => {
+					stateObj[key$1] = v;
+					if (existingHandler) existingHandler(v);
+				};
+				delete processedProps[propKey];
+			}
+		}
+	}
+	if (isComponent$2(type)) {
+		const { children: children$1, ...rest$1 } = processedProps;
+		return {
+			type,
+			props: {
+				...rest$1,
+				children: children$1
+			},
+			key: key || rest$1.key || null,
+			children: [],
+			dom: null
+		};
+	}
+	if (typeof type === "function" && type !== Fragment) return type(processedProps);
+	const { children, ...rest } = processedProps;
+	return {
+		type,
+		props: rest,
+		key: key || rest.key || null,
+		children: normalizeChildren$1(children),
+		dom: null
+	};
+}
+/**
+* JSX Factory for fragments
+*/
+function jsxs(type, props, key) {
+	return jsx(type, props, key);
+}
+const jsxDEV = jsx;
+
+//#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";
+	}
+};
+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);
+	});
+}
+
+//#endregion
+//#region ../runtime-core/src/models/index.ts
+const guid = guid$1;
+let InstanceLifetimes = /* @__PURE__ */ function(InstanceLifetimes$1) {
+	InstanceLifetimes$1[InstanceLifetimes$1["Transient"] = 0] = "Transient";
+	InstanceLifetimes$1[InstanceLifetimes$1["Scoped"] = 1] = "Scoped";
+	InstanceLifetimes$1[InstanceLifetimes$1["Singleton"] = 2] = "Singleton";
+	return InstanceLifetimes$1;
+}({});
+function valueOf(obj) {
+	return obj;
+}
+
+//#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 {
+			onCleanup(unsubscribe);
+		} catch (e) {}
+		return { unsubscribe };
+	};
+	const destroy = () => {
+		subscribers = [];
+	};
+	return {
+		publish,
+		subscribe,
+		destroy
+	};
+}
+function toSubscriber(topic) {
+	return { subscribe: (handler) => topic.subscribe(handler) };
+}
+
+//#endregion
+//#region ../runtime-core/src/di/injectable.ts
+function inject(token) {
+	const ctx = getCurrentInstance();
+	if (!ctx) return void 0;
+	let current = ctx;
+	while (current) {
+		if (current.provides && current.provides.has(token)) return current.provides.get(token);
+		current = current.parent;
+	}
+	const appContext = getAppContext(ctx);
+	if (appContext && appContext.provides.has(token)) return appContext.provides.get(token);
+}
+/**
+* Get the app context from the current component context
+*/
+function getAppContext(ctx) {
+	let current = ctx;
+	while (current) {
+		if (current._appContext) return current._appContext;
+		current = current.parent;
+	}
+	return null;
+}
+/**
+* Inject the App instance (useful for plugins)
+*/
+function injectApp() {
+	return inject(AppContextKey);
+}
+function provide(token, value) {
+	const ctx = getCurrentInstance();
+	if (!ctx) {
+		console.warn("provide called outside of component setup");
+		return;
+	}
+	if (!ctx.provides) ctx.provides = /* @__PURE__ */ new Map();
+	ctx.provides.set(token, value);
+}
+const globalInstances = /* @__PURE__ */ new Map();
+function defineInjectable(factory) {
+	const token = factory;
+	const useFn = () => {
+		const injected = inject(token);
+		if (injected) return injected;
+		if (!globalInstances.has(token)) globalInstances.set(token, factory());
+		return globalInstances.get(token);
+	};
+	useFn._factory = factory;
+	useFn._token = token;
+	return useFn;
+}
+function defineProvide(useFn) {
+	const factory = useFn._factory;
+	const token = useFn._token;
+	if (!factory || !token) throw new Error("defineProvide must be called with a function created by defineInjectable");
+	const instance = factory();
+	provide(token, instance);
+	return instance;
+}
+
+//#endregion
+//#region ../runtime-core/src/di/factory.ts
+var SubscriptionHandler = class {
+	unsubs = [];
+	add(unsub) {
+		this.unsubs.push(unsub);
+	}
+	unsubscribe() {
+		this.unsubs.forEach((u) => u());
+		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();
+			result.dispose?.();
+		};
+		if (customDispose) customDispose(dispose);
+		else try {
+			onCleanup(() => dispose());
+		} catch (e) {}
+		return {
+			...result,
+			dispose
+		};
+	};
+	if (setup.length <= 1) return defineInjectable(() => factoryCreator());
+	return factoryCreator;
+}
+
+//#endregion
+//#region ../runtime-core/src/stores/store.ts
+function defineStore(name, setup, lifetime = InstanceLifetimes.Scoped) {
+	return defineFactory((ctxFactory, ...args) => {
+		const scope = effectScope(true);
+		let messages = [];
+		const id = `${name}_${guid()}`;
+		const result = setup({
+			...ctxFactory,
+			defineState: (state) => {
+				return defineState(state, id, scope, messages);
+			},
+			defineActions: (actions) => {
+				return defineActions(actions, id, messages);
+			}
+		}, ...args);
+		ctxFactory.onDeactivated(() => {
+			scope.stop();
+			messages?.forEach((m) => m.destroy());
+			messages = null;
+		});
+		if (!result.name) result.name = id;
+		return result;
+	}, lifetime);
+}
+function defineActions(actions, storeInstanceName, messages) {
+	const events = {};
+	const namespace = `${storeInstanceName}.actions.${guid()}`;
+	const onDispatching = {};
+	const onDispatched = {};
+	const onFailure = {};
+	const result = {
+		onDispatching,
+		onDispatched,
+		onFailure
+	};
+	function getEvent(actionName, type) {
+		const name = `${actionName}.${type}`;
+		if (!events[name]) {
+			events[name] = createTopic({
+				namespace,
+				name
+			});
+			messages.push(events[name]);
+		}
+		return events[name];
+	}
+	Object.keys(actions).forEach((actionName) => {
+		onDispatching[actionName] = { subscribe: (fn) => {
+			return getEvent(actionName, "onDispatching").subscribe(function() {
+				fn.apply(this, arguments[0]);
+			});
+		} };
+		onDispatched[actionName] = { subscribe: (fn) => {
+			return getEvent(actionName, "onDispatched").subscribe(function() {
+				const msg = arguments[0];
+				const allArguments = [msg.result].concat(Array.from(msg.args));
+				fn.apply(this, allArguments);
+			});
+		} };
+		onFailure[actionName] = { subscribe: (fn) => {
+			return getEvent(actionName, "onFailure").subscribe(function() {
+				const msg = arguments[0];
+				const allArguments = [msg.reason].concat(Array.from(msg.args));
+				fn.apply(this, allArguments);
+			});
+		} };
+		result[actionName] = function() {
+			try {
+				const currentArguments = arguments;
+				getEvent(actionName, "onDispatching").publish(currentArguments);
+				const returnedResult = actions[actionName].apply(this, currentArguments);
+				if (Utils.isPromise(returnedResult)) returnedResult.then((result$1) => {
+					getEvent(actionName, "onDispatched").publish({
+						result: returnedResult,
+						args: currentArguments
+					});
+				});
+				else getEvent(actionName, "onDispatched").publish({
+					result: returnedResult,
+					args: currentArguments
+				});
+				return returnedResult;
+			} catch (err) {
+				console.error(err);
+				getEvent(actionName, "onFailure").publish({
+					reason: err,
+					args: arguments
+				});
+			}
+		};
+	});
+	return result;
+}
+function defineState(value, storeInstanceName, scope, messages) {
+	const state = signal(value);
+	const events = {};
+	const mutate = {};
+	function initProperty(key) {
+		scope.run(() => {
+			watch(() => state[key], (newValue) => {
+				triggerEvent(key, newValue);
+			}, {
+				deep: true,
+				immediate: true
+			});
+		});
+		mutate[key] = (val) => {
+			try {
+				let newValue;
+				if (typeof val === "function") newValue = val(state[key]);
+				else newValue = val;
+				state[key] = newValue;
+			} catch (err) {
+				console.error(err);
+			}
+		};
+		const eventKey = `onMutated${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+		if (!events[eventKey]) {
+			const topic = createTopic({
+				namespace: `${storeInstanceName}.events`,
+				name: eventKey
+			});
+			events[eventKey] = topic;
+			messages.push(topic);
+		}
+	}
+	function triggerEvent(name, value$1) {
+		const keyString = name;
+		events[`onMutated${keyString.charAt(0).toUpperCase()}${keyString.slice(1)}`]?.publish(value$1);
+	}
+	if (value) Object.keys(value).forEach((key) => {
+		initProperty(key);
+	});
+	return {
+		state,
+		events,
+		mutate
+	};
+}
+
+//#endregion
+//#region ../runtime-core/src/renderer.ts
+/**
+* Check if a vnode type is a component (has __setup)
+*/
+function isComponent(type) {
+	return typeof type === "function" && "__setup" in type;
+}
+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 } = options;
+	let isPatching = false;
+	let currentAppContext = null;
+	function render$1(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,
+			props: {},
+			key: null,
+			children: [],
+			dom: null,
+			text: element
+		};
+		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;
+		}
+	}
+	function mount(vnode, container, before = null) {
+		if (vnode.type === Text) {
+			const node = hostCreateText(String(vnode.text));
+			vnode.dom = node;
+			node.__vnode = vnode;
+			hostInsert(node, container, before);
+			return;
+		}
+		if (vnode.type === Fragment) {
+			const anchor = hostCreateComment("");
+			vnode.dom = anchor;
+			hostInsert(anchor, container, before);
+			vnode.children.forEach((child) => mount(child, container, anchor));
+			return;
+		}
+		if (isComponent(vnode.type)) {
+			mountComponent(vnode, container, before, vnode.type.__setup);
+			return;
+		}
+		const element = hostCreateElement(vnode.type);
+		vnode.dom = element;
+		element.__vnode = vnode;
+		if (vnode.props) {
+			for (const key in vnode.props) if (key !== "children" && key !== "key" && key !== "ref") hostPatchProp(element, key, null, vnode.props[key]);
+		}
+		if (vnode.props.ref) {
+			if (typeof vnode.props.ref === "function") vnode.props.ref(element);
+			else if (vnode.props.ref && typeof vnode.props.ref === "object") vnode.props.ref.current = element;
+		}
+		vnode.children.forEach((child) => {
+			child.parent = vnode;
+			mount(child, element);
+		});
+		hostInsert(element, container, before);
+	}
+	function unmount(vnode, container) {
+		if (vnode._effect) vnode._effect();
+		if (vnode.cleanup) vnode.cleanup();
+		if (isComponent(vnode.type)) {
+			const subTree = vnode._subTree;
+			if (subTree) unmount(subTree, container);
+			if (vnode.dom) hostRemove(vnode.dom);
+			if (vnode.props?.ref) {
+				if (typeof vnode.props.ref === "function") vnode.props.ref(null);
+				else if (typeof vnode.props.ref === "object") vnode.props.ref.current = null;
+			}
+			return;
+		}
+		if (vnode.type === Fragment) {
+			vnode.children.forEach((child) => unmount(child, container));
+			if (vnode.dom) hostRemove(vnode.dom);
+			return;
+		}
+		if (vnode.props?.ref) {
+			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 (vnode.children && vnode.children.length > 0) vnode.children.forEach((child) => unmount(child, vnode.dom));
+		if (vnode.dom) hostRemove(vnode.dom);
+	}
+	function patch(oldVNode, newVNode, container) {
+		if (oldVNode === newVNode) return;
+		if (!isSameVNode(oldVNode, newVNode)) {
+			const parent = hostParentNode(oldVNode.dom) || container;
+			const nextSibling = hostNextSibling(oldVNode.dom);
+			unmount(oldVNode, parent);
+			mount(newVNode, parent, nextSibling);
+			return;
+		}
+		if (oldVNode._effect) {
+			newVNode.dom = oldVNode.dom;
+			newVNode._effect = oldVNode._effect;
+			newVNode._subTree = oldVNode._subTree;
+			newVNode._slots = oldVNode._slots;
+			const props = oldVNode._componentProps;
+			newVNode._componentProps = props;
+			if (props) {
+				const newProps$1 = newVNode.props || {};
+				untrack(() => {
+					for (const key in newProps$1) if (key !== "children" && key !== "key" && key !== "ref") {
+						if (props[key] !== newProps$1[key]) props[key] = newProps$1[key];
+					}
+					for (const key in props) if (!(key in newProps$1) && key !== "children" && key !== "key" && key !== "ref") delete props[key];
+				});
+			}
+			const slotsRef = oldVNode._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 (!isPatching) {
+					isPatching = true;
+					try {
+						untrack(() => {
+							slotsRef._version.v++;
+						});
+					} finally {
+						isPatching = false;
+					}
+				}
+			}
+			return;
+		}
+		if (newVNode.type === Text) {
+			newVNode.dom = oldVNode.dom;
+			if (oldVNode.text !== newVNode.text) hostSetText(newVNode.dom, String(newVNode.text));
+			return;
+		}
+		if (newVNode.type === Fragment) {
+			patchChildren(oldVNode, newVNode, container);
+			return;
+		}
+		const element = newVNode.dom = oldVNode.dom;
+		const oldProps = oldVNode.props || {};
+		const newProps = newVNode.props || {};
+		for (const key in oldProps) if (!(key in newProps) && key !== "children" && key !== "key" && key !== "ref") hostPatchProp(element, key, oldProps[key], null);
+		for (const key in newProps) {
+			const oldValue = oldProps[key];
+			const newValue = newProps[key];
+			if (key !== "children" && key !== "key" && key !== "ref" && oldValue !== newValue) hostPatchProp(element, key, oldValue, newValue);
+		}
+		patchChildren(oldVNode, newVNode, element);
+	}
+	function patchChildren(oldVNode, newVNode, container) {
+		const oldChildren = oldVNode.children;
+		const newChildren = newVNode.children;
+		newChildren.forEach((c) => c.parent = newVNode);
+		reconcileChildrenArray(container, oldChildren, newChildren);
+	}
+	function reconcileChildrenArray(parent, oldChildren, 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 = hostNextSibling(oldEndVNode.dom);
+			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;
+			if (nodeToMove) hostInsert(nodeToMove, parent, anchor);
+			oldEndVNode = oldChildren[--oldEndIdx];
+			newStartVNode = newChildren[++newStartIdx];
+		} 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);
+			newStartVNode = newChildren[++newStartIdx];
+		}
+		if (oldStartIdx > oldEndIdx) {
+			if (newStartIdx <= newEndIdx) {
+				const anchor = newChildren[newEndIdx + 1] == null ? null : newChildren[newEndIdx + 1].dom;
+				for (let i = newStartIdx; i <= newEndIdx; i++) mount(newChildren[i], parent, anchor);
+			}
+		} else if (newStartIdx > newEndIdx) {
+			for (let i = oldStartIdx; i <= oldEndIdx; i++) if (oldChildren[i]) unmount(oldChildren[i], parent);
+		}
+	}
+	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 createKeyToKeyIndexMap(children, beginIdx, endIdx) {
+		const map = /* @__PURE__ */ new Map();
+		for (let i = beginIdx; i <= endIdx; i++) {
+			const key = children[i]?.key;
+			if (key != null) map.set(String(key), i);
+		}
+		return map;
+	}
+	function findIndexInOld(children, newChild, beginIdx, endIdx) {
+		for (let i = beginIdx; i <= endIdx; i++) if (children[i] && isSameVNode(children[i], newChild)) 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, ...propsData } = vnode.props || {};
+		const reactiveProps = signal(propsData);
+		vnode._componentProps = reactiveProps;
+		const slots = createSlots(children, slotsFromProps);
+		vnode._slots = slots;
+		const mountHooks = [];
+		const cleanupHooks = [];
+		const parentInstance = getCurrentInstance();
+		const componentName = vnode.type.__name;
+		const ctx = {
+			el: container,
+			signal,
+			props: reactiveProps,
+			slots,
+			emit: (event, ...args) => {
+				const handler = reactiveProps[`on${event[0].toUpperCase() + event.slice(1)}`];
+				if (handler && typeof handler === "function") handler(...args);
+			},
+			parent: parentInstance,
+			onMount: (fn) => {
+				mountHooks.push(fn);
+			},
+			onCleanup: (fn) => {
+				cleanupHooks.push(fn);
+			},
+			expose: (exposedValue) => {
+				exposed = exposedValue;
+				exposeCalled = true;
+			}
+		};
+		ctx.__name = componentName;
+		if (currentAppContext) ctx._appContext = currentAppContext;
+		const componentInstance = {
+			name: componentName,
+			ctx,
+			vnode
+		};
+		const prev = setCurrentInstance(ctx);
+		let renderFn;
+		try {
+			renderFn = setup(ctx);
+			notifyComponentCreated(currentAppContext, componentInstance);
+		} catch (err) {
+			if (!handleComponentError(currentAppContext, err, componentInstance, "setup")) throw err;
+		} finally {
+			setCurrentInstance(prev);
+		}
+		if (vnode.props.ref) {
+			const refValue = exposeCalled ? exposed : null;
+			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 (renderFn) vnode._effect = effect(() => {
+			const prevInstance = setCurrentInstance(ctx);
+			try {
+				const subTreeResult = renderFn();
+				if (subTreeResult == null) return;
+				const subTree = normalizeSubTree(subTreeResult);
+				const prevSubTree = vnode._subTree;
+				if (prevSubTree) {
+					patch(prevSubTree, subTree, container);
+					notifyComponentUpdated(currentAppContext, componentInstance);
+				} else mount(subTree, container, anchor);
+				vnode._subTree = subTree;
+			} catch (err) {
+				if (!handleComponentError(currentAppContext, err, componentInstance, "render")) throw err;
+			} finally {
+				setCurrentInstance(prevInstance);
+			}
+		});
+		const mountCtx = { el: container };
+		mountHooks.forEach((hook) => hook(mountCtx));
+		notifyComponentMounted(currentAppContext, componentInstance);
+		vnode.cleanup = () => {
+			notifyComponentUnmounted(currentAppContext, componentInstance);
+			cleanupHooks.forEach((hook) => hook(mountCtx));
+		};
+	}
+	/**
+	* 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>)
+	*/
+	function createSlots(children, slotsFromProps) {
+		const versionSignal = signal({ v: 0 });
+		function extractNamedSlotsFromChildren(c) {
+			const defaultChildren = [];
+			const namedSlots = {};
+			if (c == null) return {
+				defaultChildren,
+				namedSlots
+			};
+			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);
+			return {
+				defaultChildren,
+				namedSlots
+			};
+		}
+		const slotsObj = {
+			_children: children,
+			_slotsFromProps: slotsFromProps || {},
+			_version: versionSignal,
+			default: function() {
+				this._version.v;
+				const c = this._children;
+				const { defaultChildren } = extractNamedSlotsFromChildren(c);
+				return defaultChildren;
+			}
+		};
+		return new Proxy(slotsObj, { 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];
+				}
+				const { namedSlots } = extractNamedSlotsFromChildren(target._children);
+				return namedSlots[prop] || [];
+			};
+		} });
+	}
+	/**
+	* Normalize render result to a VNode (wrapping arrays in Fragment)
+	*/
+	function normalizeSubTree(result) {
+		if (Array.isArray(result)) return {
+			type: Fragment,
+			props: {},
+			key: null,
+			children: result,
+			dom: null
+		};
+		if (typeof result === "string" || typeof result === "number") return {
+			type: Text,
+			props: {},
+			key: null,
+			children: [],
+			dom: null,
+			text: result
+		};
+		return result;
+	}
+	return {
+		render: render$1,
+		createApp: (rootComponent) => {
+			return { mount(selectorOrContainer) {
+				let container = null;
+				if (typeof selectorOrContainer === "string") {
+					if (options.querySelector) container = options.querySelector(selectorOrContainer);
+				} else container = selectorOrContainer;
+				if (!container) {
+					console.warn(`Container not found: ${selectorOrContainer}`);
+					return;
+				}
+				render$1(rootComponent, container);
+			} };
+		}
+	};
+}
+
+//#endregion
+//#region ../runtime-terminal/src/focus.ts
+const focusableIds = /* @__PURE__ */ new Set();
+const 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;
+	}
+}
+function focus(id) {
+	if (focusableIds.has(id)) focusState.activeId = id;
+}
+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 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];
+}
+
+//#endregion
+//#region ../runtime-terminal/src/utils.ts
+function getColorCode(color) {
+	switch (color) {
+		case "red": return "\x1B[31m";
+		case "green": return "\x1B[32m";
+		case "blue": return "\x1B[34m";
+		case "yellow": return "\x1B[33m";
+		case "cyan": return "\x1B[36m";
+		case "white": return "\x1B[37m";
+		case "black": return "\x1B[30m";
+		default: return "";
+	}
+}
+function getBackgroundColorCode(color) {
+	switch (color) {
+		case "red": return "\x1B[41m";
+		case "green": return "\x1B[42m";
+		case "blue": return "\x1B[44m";
+		case "yellow": return "\x1B[43m";
+		case "cyan": return "\x1B[46m";
+		case "white": return "\x1B[47m";
+		case "black": return "\x1B[40m";
+		default: return "";
+	}
+}
+function stripAnsi(str) {
+	return str.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
+}
+
+//#endregion
+//#region ../runtime-core/dist/index.js
+let platformSyncProcessor = null;
+/**
+* Get the current platform sync processor (for internal use).
+*/
+function getPlatformSyncProcessor$1() {
+	return platformSyncProcessor;
+}
+const Fragment$1 = Symbol.for("sigx.Fragment");
+const Text$1 = Symbol.for("sigx.Text");
+function normalizeChildren(children) {
+	if (children == null || children === false || children === true) return [];
+	if (Array.isArray(children)) return children.flatMap((c) => normalizeChildren(c));
+	if (typeof children === "string" || typeof children === "number") return [{
+		type: Text$1,
+		props: {},
+		key: null,
+		children: [],
+		dom: null,
+		text: children
+	}];
+	if (children.type) return [children];
+	return [];
+}
+/**
+* Check if a type is a sigx component (has __setup)
+*/
+function isComponent$1(type) {
+	return typeof type === "function" && "__setup" in type;
+}
+/**
+* Create a JSX element - this is the core function called by TSX transpilation
+*/
+function jsx$1(type, props, key) {
+	const processedProps = { ...props || {} };
+	if (props) {
+		for (const propKey in props) if (propKey === "sync") {
+			let syncBinding = props[propKey];
+			if (typeof syncBinding === "function") {
+				const detected = detectAccess(syncBinding);
+				if (detected) syncBinding = detected;
+			}
+			if (Array.isArray(syncBinding) && syncBinding.length === 2) {
+				const [stateObj, key$1] = syncBinding;
+				let handled = false;
+				const platformProcessor = getPlatformSyncProcessor$1();
+				if (typeof type === "string" && platformProcessor) handled = platformProcessor(type, processedProps, [stateObj, key$1], props);
+				if (!handled) {
+					processedProps.value = stateObj[key$1];
+					const existingHandler = processedProps["onUpdate:value"];
+					processedProps["onUpdate:value"] = (v) => {
+						stateObj[key$1] = v;
+						if (existingHandler) existingHandler(v);
+					};
+				}
+				delete processedProps.sync;
+			}
+		} else if (propKey.startsWith("sync:")) {
+			const syncBinding = props[propKey];
+			if (Array.isArray(syncBinding) && syncBinding.length === 2) {
+				const [stateObj, key$1] = syncBinding;
+				const name = propKey.slice(5);
+				processedProps[name] = stateObj[key$1];
+				const eventName = `onUpdate:${name}`;
+				const existingHandler = processedProps[eventName];
+				processedProps[eventName] = (v) => {
+					stateObj[key$1] = v;
+					if (existingHandler) existingHandler(v);
+				};
+				delete processedProps[propKey];
+			}
+		}
+	}
+	if (isComponent$1(type)) {
+		const { children: children$1, ...rest$1 } = processedProps;
+		return {
+			type,
+			props: {
+				...rest$1,
+				children: children$1
+			},
+			key: key || rest$1.key || null,
+			children: [],
+			dom: null
+		};
+	}
+	if (typeof type === "function" && type !== Fragment$1) return type(processedProps);
+	const { children, ...rest } = processedProps;
+	return {
+		type,
+		props: rest,
+		key: key || rest.key || null,
+		children: normalizeChildren(children),
+		dom: null
+	};
+}
+/**
+* JSX Factory for fragments
+*/
+function jsxs$1(type, props, key) {
+	return jsx$1(type, props, key);
+}
+
+//#endregion
+//#region ../runtime-terminal/src/components/Input.tsx
+/** @jsxImportSource @sigx/runtime-core */
+const Input = defineComponent(({ props, emit }) => {
+	const id = Math.random().toString(36).slice(2);
+	const isFocused = () => focusState.activeId === id;
+	const handleKey = (key) => {
+		if (!isFocused()) return;
+		if (key === "\r") {
+			emit("submit", props.value || "");
+			return;
+		}
+		if (key === "\n") return;
+		if (key === "" || key === "\b") {
+			const val = props.value || "";
+			if (val.length > 0) {
+				const newValue$1 = val.slice(0, -1);
+				emit("update:value", newValue$1);
+				emit("input", newValue$1);
+			}
+			return;
+		}
+		if (key.length > 1) return;
+		const newValue = (props.value || "") + key;
+		emit("update:value", newValue);
+		emit("input", newValue);
+	};
+	let keyCleanup = null;
+	onMount(() => {
+		registerFocusable(id);
+		if (props.autofocus) focus(id);
+		keyCleanup = onKey(handleKey);
+	});
+	onCleanup(() => {
+		if (keyCleanup) keyCleanup();
+		unregisterFocusable(id);
+	});
+	return () => {
+		const val = (props.value || "").replace(/[\r\n]+/g, " ");
+		const placeholder = (props.placeholder || "").replace(/[\r\n]+/g, " ");
+		const showCursor = isFocused();
+		return /* @__PURE__ */ jsxs$1("box", {
+			border: "single",
+			borderColor: showCursor ? "green" : "white",
+			label: props.label,
+			children: [/* @__PURE__ */ jsx$1("text", { children: val || placeholder }), showCursor && /* @__PURE__ */ jsx$1("text", {
+				color: "cyan",
+				children: "_"
+			})]
+		});
+	};
+}, { name: "Input" });
+
+//#endregion
+//#region ../runtime-terminal/src/components/ProgressBar.tsx
+/** @jsxImportSource @sigx/runtime-core */
+const ProgressBar = defineComponent(({ 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$1("box", { children: /* @__PURE__ */ jsx$1("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 */
+const Button = defineComponent(({ 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;
+	onMount(() => {
+		registerFocusable(id);
+		keyCleanup = onKey(handleKey);
+	});
+	onCleanup(() => {
+		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$1("box", {
+			border: "single",
+			borderColor: isPressed ? "yellow" : focused ? "green" : "white",
+			backgroundColor: isPressed ? "red" : focused ? "blue" : void 0,
+			dropShadow: props.dropShadow,
+			children: /* @__PURE__ */ jsx$1("text", {
+				color: focused ? "white" : void 0,
+				children: label
+			})
+		});
+	};
+}, { name: "Button" });
+
+//#endregion
+//#region ../runtime-terminal/src/components/Checkbox.tsx
+/** @jsxImportSource @sigx/runtime-core */
+const Checkbox = defineComponent(({ props, emit }) => {
+	const id = Math.random().toString(36).slice(2);
+	const isFocused = () => focusState.activeId === id;
+	const checked = () => !!props.value;
+	const handleKey = (key) => {
+		if (!isFocused()) return;
+		if (props.disabled) return;
+		if (key === "\r" || key === " ") {
+			const next = !checked();
+			emit("update:value", next);
+			emit("change", next);
+		}
+	};
+	let keyCleanup = null;
+	onMount(() => {
+		registerFocusable(id);
+		if (props.autofocus) focus(id);
+		keyCleanup = onKey(handleKey);
+	});
+	onCleanup(() => {
+		if (keyCleanup) keyCleanup();
+		unregisterFocusable(id);
+	});
+	return () => {
+		const label = props.label || "";
+		const focused = isFocused();
+		const isChecked = checked();
+		const disabled = !!props.disabled;
+		return /* @__PURE__ */ jsxs$1("box", { children: [
+			/* @__PURE__ */ jsx$1("text", {
+				color: focused ? "cyan" : "white",
+				children: focused ? ">" : " "
+			}),
+			/* @__PURE__ */ jsxs$1("text", {
+				color: disabled ? "white" : isChecked ? "green" : focused ? "cyan" : "white",
+				children: [
+					"[",
+					isChecked ? "x" : " ",
+					"]"
+				]
+			}),
+			label && /* @__PURE__ */ jsxs$1("text", {
+				color: disabled ? "white" : focused ? "cyan" : void 0,
+				children: [" ", label]
+			})
+		] });
+	};
+}, { name: "Checkbox" });
+
+//#endregion
+//#region ../runtime-terminal/src/index.ts
+const renderer = createRenderer({
+	patchProp: (el, key, prev, next) => {
+		el.props[key] = next;
+		scheduleRender();
+	},
+	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();
+	},
+	remove: (child) => {
+		if (child.parentNode) {
+			const index = child.parentNode.children.indexOf(child);
+			if (index > -1) child.parentNode.children.splice(index, 1);
+			child.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();
+	},
+	setElementText: (node, text) => {
+		node.children = [{
+			type: "text",
+			text,
+			props: {},
+			children: [],
+			parentNode: node
+		}];
+		scheduleRender();
+	},
+	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;
+	},
+	cloneNode: (node) => {
+		return {
+			...node,
+			children: []
+		};
+	}
+});
+const { render, createApp } = renderer;
+let rootNode = null;
+let isRendering = false;
+function scheduleRender() {
+	if (isRendering) return;
+	isRendering = true;
+	setTimeout(() => {
+		flushRender();
+		isRendering = false;
+	}, 10);
+}
+function flushRender() {
+	if (!rootNode) 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("");
+	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);
+		else {
+			lines[lines.length - 1] += childLines[0];
+			for (let i = 1; i < childLines.length; i++) lines.push(childLines[i]);
+		}
+	}
+	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);
+	}
+	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);
+	}
+	return result;
+}
+function getBorderChars(style) {
+	if (style === "double") return {
+		tl: "╔",
+		tr: "╗",
+		bl: "╚",
+		br: "╝",
+		h: "═",
+		v: "║"
+	};
+	if (style === "rounded") return {
+		tl: "╭",
+		tr: "╮",
+		bl: "╰",
+		br: "╯",
+		h: "─",
+		v: "│"
+	};
+	return {
+		tl: "┌",
+		tr: "┐",
+		bl: "└",
+		br: "┘",
+		h: "─",
+		v: "│"
+	};
+}
+const keyHandlers = /* @__PURE__ */ new Set();
+function onKey(handler) {
+	keyHandlers.add(handler);
+	return () => keyHandlers.delete(handler);
+}
+function handleInput(key) {
+	if (key === "") {
+		process.stdout.write("\x1B[?25h");
+		process.exit();
+	}
+	if (key === "	") {
+		focusNext();
+		return;
+	}
+	if (key === "\x1B[Z") {
+		focusPrev();
+		return;
+	}
+	for (const handler of keyHandlers) handler(key);
+}
+function renderTerminal(app, options = {}) {
+	rootNode = {
+		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);
+		}
+	} };
+}
+/**
+* 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);
+* ```
+*/
+const terminalMount = (component, options, appContext) => {
+	rootNode = {
+		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);
+		}
+	};
+};
+setDefaultMount(terminalMount);
+
+//#endregion
+export { AppContextKey, Button, Checkbox, Fragment, Input, InstanceLifetimes, ProgressBar, SubscriptionHandler, Text, Utils, batch, createApp, createPropsProxy, createRenderer, createTopic, defineApp, defineComponent, defineFactory, defineInjectable, defineProvide, defineStore, detectAccess, effect, effectScope, focus, focusNext, focusPrev, focusState, getComponentMeta, getComponentPlugins, getCurrentInstance, getDefaultMount, getPlatformSyncProcessor, guid, handleComponentError, inject, injectApp, jsx, jsxDEV, jsxs, notifyComponentCreated, notifyComponentMounted, notifyComponentUnmounted, notifyComponentUpdated, onCleanup, onKey, onMount, provide, registerComponentPlugin, registerFocusable, render, renderNodeToLines, renderTerminal, setCurrentInstance, setDefaultMount, setPlatformSyncProcessor, signal, terminalMount, toSubscriber, unregisterFocusable, untrack, valueOf, watch };
+//# sourceMappingURL=index.js.map