@sigx/terminal 0.1.26 → 0.2.0

package/dist/index.js

@@ -1,6 +1,12 @@
+//#region \0rolldown/runtime.js
 var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-const ComputedSymbol = Symbol("computed");
-let activeEffect = null;
+//#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) {
@@ -9,6 +15,18 @@ function setActiveEffect(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++;
 	try {
@@ -59,9 +77,32 @@ function runEffect(fn) {
 	};
 	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;
@@ -71,6 +112,19 @@ function untrack(fn) {
 		activeEffect = prev;
 	}
 }
+/**
+* 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;
@@ -85,26 +139,49 @@ function effectScope(_detached) {
 		}
 	};
 }
-const ITERATE_KEY = Symbol("iterate");
-const reactiveToRaw = /* @__PURE__ */ new WeakMap();
-const rawToReactive = /* @__PURE__ */ new WeakMap();
+//#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);
@@ -128,6 +205,11 @@ function shouldNotProxy(value) {
 		"[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) {
@@ -230,6 +312,9 @@ function createCollectionInstrumentations(depsMap, getOrCreateDep) {
 	};
 	return instrumentations;
 }
+/**
+* Creates a reactive iterator that wraps values in reactive proxies.
+*/
 function createReactiveIterator(innerIterator, wrapValues) {
 	return {
 		next() {
@@ -248,6 +333,9 @@ function createReactiveIterator(innerIterator, wrapValues) {
 		}
 	};
 }
+/**
+* Creates a reactive entries iterator that wraps both keys and values.
+*/
 function createReactiveEntriesIterator(innerIterator) {
 	return {
 		next() {
@@ -267,18 +355,37 @@ 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;
@@ -415,6 +522,14 @@ function signal(target) {
 	rawToReactive.set(objectTarget, proxy);
 	return proxy;
 }
+//#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;
@@ -431,6 +546,19 @@ function traverse(value, depth = Infinity, seen = /* @__PURE__ */ new Set()) {
 	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;
@@ -495,6 +623,8 @@ function watch(source, cb, options) {
 		resume
 	});
 }
+//#endregion
+//#region ../reactivity/src/computed.ts
 function computed(getterOrOptions) {
 	let getter;
 	let setter;
@@ -562,20 +692,47 @@ function computed(getterOrOptions) {
 	}
 	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;
 }
+//#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);
 }
+//#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;
 try {
 	if (typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined") {
@@ -587,6 +744,10 @@ var _fallbackContext = {
 	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();
@@ -594,25 +755,56 @@ function getRequestContext() {
 	}
 	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;
 }
+//#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;
 }
@@ -622,26 +814,108 @@ function setCurrentInstance(ctx) {
 	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) {
 		return {
@@ -665,6 +939,28 @@ function component(setup, options) {
 	getComponentPlugins().forEach((p) => p.onDefine?.(options?.name, factory, setup));
 	return factory;
 }
+//#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);
@@ -674,7 +970,15 @@ var SigxError = class extends Error {
 		if (options.cause) this.cause = options.cause;
 	}
 };
-const SigxErrorCode = {
+/**
+* Error codes for the SignalX runtime.
+*
+* Ranges:
+* - SIGX001–SIGX099: App lifecycle
+* - SIGX100–SIGX199: Rendering / mounting
+* - SIGX200–SIGX299: Dependency injection
+*/
+var SigxErrorCode = {
 	NO_MOUNT_FUNCTION: "SIGX001",
 	RENDER_TARGET_NOT_FOUND: "SIGX100",
 	MOUNT_TARGET_NOT_FOUND: "SIGX101",
@@ -718,8 +1022,23 @@ function provideInvalidInjectableError() {
 		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;
@@ -729,6 +1048,10 @@ function lookupProvided(token) {
 		current = current.parent;
 	}
 }
+/**
+* Provide a value at the current component level
+* @internal
+*/
 function provideAtComponent(token, value) {
 	const ctx = getCurrentInstance();
 	if (!ctx) throw provideOutsideSetupError();
@@ -736,6 +1059,26 @@ function provideAtComponent(token, value) {
 	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 = (() => {
@@ -748,6 +1091,34 @@ function defineInjectable(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;
@@ -756,31 +1127,110 @@ function defineProvide(useFn, factory) {
 	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);
 }
-const __DIRECTIVE__ = Symbol.for("sigx.directive");
+//#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;
 }
+//#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 = {
@@ -867,6 +1317,10 @@ function defineApp(rootComponent) {
 	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 {
@@ -875,6 +1329,10 @@ function notifyComponentCreated(context, instance) {
 		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 {
@@ -883,6 +1341,10 @@ function notifyComponentMounted(context, instance) {
 		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 {
@@ -891,6 +1353,10 @@ function notifyComponentUnmounted(context, instance) {
 		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 {
@@ -899,6 +1365,10 @@ function notifyComponentUpdated(context, instance) {
 		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 {
@@ -913,16 +1383,84 @@ function handleComponentError(context, err, instance, info) {
 	}
 	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/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);
 }
+//#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;
 	return {
@@ -942,23 +1480,57 @@ function createModel(tuple, updateHandler) {
 		[MODEL_SYMBOL]: true
 	};
 }
+/**
+* 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;
 }
+//#endregion
+//#region ../runtime-core/src/platform.ts
 var platformModelProcessor = null;
+/**
+* Get the current platform model processor (for internal use).
+*/
 function getPlatformModelProcessor() {
 	return platformModelProcessor;
 }
+//#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;
 }
-const Fragment = Symbol.for("sigx.Fragment");
-const Text = Symbol.for("sigx.Text");
-const Comment = Symbol.for("sigx.Comment");
+//#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);
@@ -1023,6 +1595,9 @@ function normalizeChildren(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 = {};
@@ -1123,11 +1698,26 @@ function jsx(type, props, key) {
 		dom: null
 	};
 }
+/**
+* JSX Factory for fragments
+*/
 function jsxs(type, props, key) {
 	return jsx(type, props, key);
 }
-const jsxDEV = jsx;
+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) {
@@ -1140,6 +1730,33 @@ function registerPendingPromise(promise) {
 	}
 	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;
@@ -1223,7 +1840,30 @@ function lazy(loader) {
 	};
 	return LazyWrapper;
 }
-const Suspense = component((ctx) => {
+/**
+* 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,
@@ -1273,9 +1913,48 @@ const Suspense = component((ctx) => {
 		}
 	};
 }, { name: "Suspense" });
+/**
+* Check if a component is a lazy-loaded component
+*/
 function isLazyComponent(component) {
 	return component && component.__lazy === true;
 }
+//#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({
 		value: null,
@@ -1295,7 +1974,38 @@ function useAsync(loader) {
 	});
 	return state;
 }
-const ErrorBoundary = component((ctx) => {
+//#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({
@@ -1323,6 +2033,8 @@ const ErrorBoundary = component((ctx) => {
 		}
 	};
 }, { 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";
@@ -1334,13 +2046,17 @@ function guid$1() {
 		return (c == "x" ? r : r & 3 | 8).toString(16);
 	});
 }
-const guid = guid$1;
-let InstanceLifetimes = /* @__PURE__ */ function(InstanceLifetimes) {
+//#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;
 }({});
+//#endregion
+//#region ../runtime-core/src/messaging/index.ts
 function createTopic(_options) {
 	let subscribers = [];
 	const publish = (data) => {
@@ -1369,6 +2085,8 @@ function createTopic(_options) {
 function toSubscriber(topic) {
 	return { subscribe: (handler) => topic.subscribe(handler) };
 }
+//#endregion
+//#region ../runtime-core/src/di/factory.ts
 var SubscriptionHandler = class {
 	constructor() {
 		this.unsubs = [];
@@ -1408,6 +2126,21 @@ function defineFactory(setup, _lifetime, _typeIdentifier) {
 	if (setup.length <= 1) return defineInjectable(() => factoryCreator());
 	return factoryCreator;
 }
+//#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) {
@@ -1431,6 +2164,39 @@ function createPropsAccessor(reactiveProps) {
 		}
 	});
 }
+//#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) {
@@ -1451,7 +2217,7 @@ function createSlots(children, slotsFromProps) {
 			namedSlots
 		};
 	}
-	const slotsObj = {
+	return new Proxy({
 		_children: children,
 		_slotsFromProps: slotsFromProps || {},
 		_version: versionSignal,
@@ -1462,8 +2228,7 @@ function createSlots(children, slotsFromProps) {
 			const { defaultChildren } = extractNamedSlotsFromChildren(c);
 			return defaultChildren.filter((child) => child != null && child !== false && child !== true);
 		}
-	};
-	return new Proxy(slotsObj, { get(target, prop) {
+	}, { get(target, prop) {
 		if (prop in target) return target[prop];
 		if (typeof prop === "string") return function(scopedProps) {
 			target._version.v;
@@ -1477,6 +2242,39 @@ function createSlots(children, slotsFromProps) {
 		};
 	} });
 }
+//#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,
@@ -1504,14 +2302,41 @@ function normalizeSubTree(result) {
 	};
 	return result;
 }
-const CLIENT_DIRECTIVE_PREFIX = "client:";
-const CLIENT_DIRECTIVES = [
+//#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 = [
 	"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)}`;
@@ -1519,6 +2344,8 @@ function createEmit(reactiveProps) {
 		if (handler && typeof handler === "function") handler(...args);
 	};
 }
+//#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;
@@ -1801,6 +2628,9 @@ function createRenderer(options) {
 		newChildren.forEach((c) => c.parent = newVNode);
 		reconcileChildrenArray(container, oldChildren, newChildren, parentIsSVG);
 	}
+	/**
+	* Check for duplicate keys in an array of VNodes and warn in development.
+	*/
 	function checkDuplicateKeys(children) {
 		if (process.env.NODE_ENV === "production") return;
 		const seenKeys = /* @__PURE__ */ new Set();
@@ -2020,8 +2850,10 @@ function createRenderer(options) {
 		mountComponent
 	};
 }
+//#endregion
+//#region ../runtime-terminal/src/focus.ts
 var focusableIds = /* @__PURE__ */ new Set();
-const focusState = signal({ activeId: null });
+var focusState = signal({ activeId: null });
 function registerFocusable(id) {
 	focusableIds.add(id);
 	if (focusState.activeId === null) focusState.activeId = id;
@@ -2046,6 +2878,8 @@ function focusPrev() {
 	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";
@@ -2073,7 +2907,10 @@ function getBackgroundColorCode(color) {
 function stripAnsi(str) {
 	return str.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
 }
-const Input = component(({ props, emit }) => {
+//#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;
@@ -2128,7 +2965,10 @@ const Input = component(({ props, emit }) => {
 		});
 	};
 }, { name: "Input" });
-const ProgressBar = component(({ props }) => {
+//#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;
@@ -2144,7 +2984,10 @@ const ProgressBar = component(({ props }) => {
 		return /* @__PURE__ */ jsx("box", { children: /* @__PURE__ */ jsx("text", { children: colorCode + barChar.repeat(filledLen) + emptyChar.repeat(emptyLen) + reset + ` ${Math.round(percentage * 100)}%` }) });
 	};
 }, { name: "ProgressBar" });
-const Button = component(({ props, emit }) => {
+//#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 });
@@ -2187,7 +3030,10 @@ const Button = component(({ props, emit }) => {
 		});
 	};
 }, { name: "Button" });
-const Checkbox = component(({ props, emit }) => {
+//#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;
@@ -2235,7 +3081,10 @@ const Checkbox = component(({ props, emit }) => {
 		] });
 	};
 }, { name: "Checkbox" });
-const Select = component(({ props, emit }) => {
+//#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;
@@ -2308,7 +3157,7 @@ const Select = component(({ props, emit }) => {
 		}), descriptionElement] });
 	};
 }, { name: "Select" });
-const { render } = createRenderer({
+var { render } = createRenderer({
 	patchProp: (el, key, prev, next) => {
 		el.props[key] = next;
 		scheduleRender();
@@ -2396,6 +3245,10 @@ function flushRender() {
 	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;
@@ -2532,6 +3385,15 @@ function renderTerminal(app, options = {}) {
 	} };
 }
 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 }) {
 	return {
 		mount: terminalMount,
@@ -2541,6 +3403,9 @@ function mountTerminal(options = { clearConsole: true }) {
 		}
 	};
 }
+/**
+* Exit the terminal app cleanly, restoring terminal state.
+*/
 function exitTerminal() {
 	if (unmountFn) {
 		unmountFn();
@@ -2549,7 +3414,21 @@ function exitTerminal() {
 	process.stdout.write("\x1B[?25h");
 	process.stdout.write("\x1B[2J\x1B[H");
 }
-const terminalMount = (component, options, appContext) => {
+/**
+* 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 = {
 		type: "root",
 		props: {},
@@ -2577,6 +3456,7 @@ const terminalMount = (component, options, appContext) => {
 	};
 };
 setDefaultMount(terminalMount);
+//#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 };
 
 //# sourceMappingURL=index.js.map