@simon_he/vue-tui 0.0.8 → 1.0.0

package/dist/vue.js

@@ -0,0 +1,3957 @@
+import "./create-terminal-C2oiWFJU.js";
+import { charCellWidth } from "./hyperlink-Bn02UXJb.js";
+import "./sgr-BmzxEjAO.js";
+import "./ansi-palette-CNXqFciC.js";
+import "./dom-renderer-BqGijQID.js";
+import { EventZIndexContextKey, LayoutContextKey, RenderStackKey, TInputPluginsContextKey, TPathPickerProviderContextKey, VisibilityContextKey, applyWheelScroll, createWheelScrollState, injectionKey, intersectRect, padEndByCells$1 as padEndByCells, repeatChar, sanitizeInlineText, sanitizeTextBlock, sliceByCells, sliceByCellsRange, spaces, textCellWidth$1 as textCellWidth, translateRect, useLayout, useRenderNode, useRenderStack, useTerminal, useTerminalNode, useVisibility, wrapByCells } from "./wheel-scroll-vBRaQ7p-.js";
+import { TView, createTheme, linkifyTextSegments, tuiDefaultTheme } from "./linkify-D_gzn9Xq.js";
+import "./runtime-rfcZCyJq.js";
+import "./trace-CjzYeIxN.js";
+import "./env-Cl8qmNFN.js";
+import { TAutocompleteInput, TBadge, TCheckbox, TCode, TDataTable, TDivider, TForm, TFormContextKey, TFormField, TLink, TLinkifyText, TList, TPasswordInput, TProgress, TRadioGroup, TSlider, TSpinner, TSwitch, TTable, TTag, TToastViewport, TTree, TerminalProvider, createTInputHostPlugin, useTForm } from "./TTree-DK_DQBYm.js";
+import "./terminal-selection-DBinO6p5.js";
+import { TBox, TCommandPalette, TDialog, TInput, TRenderPlane, TSelect, TText, clamp as clamp$1, clamp$1 as clamp, computeCommandPaletteMatchRanges, createOverlayFocusStack, fitCellText, isCommitMention, isWhitespace, mentionChipStyle, mergeStyle, padEndByCells as padEndByCells$1, resolveOverlayPlacement, sliceByCellsWindow, textCellWidth as textCellWidth$1 } from "./TSelect-BwJJbuTt.js";
+import "./frame-perf-C6Xfg85O.js";
+import { normalizePath, stripTrailingSlash } from "./path-mnSgEpCm.js";
+import { parsePathQuery, resolveUserPath, suggestPaths } from "./path-suggest-BNqcuE3-.js";
+import { computed, defineComponent, h, inject, onBeforeUnmount, onMounted, onUnmounted, provide, reactive, ref, shallowReactive, shallowRef, watch, watchEffect } from "vue";
+
+//#region src/observability/cli-latency.ts
+const GLOBAL_PROFILER_KEY = "__vueTuiCliLatencyProfiler";
+function getCliLatencyProfiler() {
+	const getProfiler = globalThis[GLOBAL_PROFILER_KEY];
+	return typeof getProfiler === "function" ? getProfiler() : null;
+}
+
+//#endregion
+//#region src/vue/components/input/plugins/promptMentionState.ts
+const MENTION_SUGGEST_DEBOUNCE_MS = 80;
+function fuzzyScore(query, candidate) {
+	const q = query.trim().toLowerCase();
+	const c = candidate.toLowerCase();
+	if (!q) return 0;
+	if (c === q) return 1e4;
+	let score = 0;
+	if (c.startsWith(q)) score += 1e3;
+	let qi = 0;
+	let streak = 0;
+	for (let ci = 0; ci < c.length && qi < q.length; ci++) if (c[ci] === q[qi]) {
+		qi++;
+		streak++;
+		score += 10 + streak * 5;
+	} else streak = 0;
+	if (qi < q.length) return null;
+	score += Math.max(0, 40 - c.length);
+	return score;
+}
+function isMentionBoundary(ch, multilineToken, mentionToken) {
+	if (ch === multilineToken || ch === mentionToken) return true;
+	if (isWhitespace(ch)) return true;
+	return /[,;:!?，。！？、()[\]{}<>]/.test(ch);
+}
+function isMentionStart(text, index, trigger, multilineToken, mentionToken) {
+	if (!trigger || text[index] !== trigger) return false;
+	if (index <= 0) return true;
+	const prev = text[index - 1];
+	return isMentionBoundary(prev, multilineToken, mentionToken) || !/\w/.test(prev);
+}
+function isMentionChar(ch) {
+	return /^[\p{L}\p{M}\p{N}_./~\\:-]$/u.test(ch);
+}
+function computePromptContext(value, cursorIndex, triggers) {
+	if (!triggers.length) return null;
+	const idx = clamp(cursorIndex, 0, value.length);
+	const lineStart = value.lastIndexOf("\n", Math.max(0, idx - 1)) + 1;
+	let matchedTrigger = null;
+	for (const t of triggers) if (t && value.slice(lineStart, lineStart + t.length) === t) {
+		matchedTrigger = t;
+		break;
+	}
+	if (!matchedTrigger) return null;
+	let tokenEnd = value.length;
+	for (let i = lineStart; i < value.length; i++) if (isWhitespace(value[i])) {
+		tokenEnd = i;
+		break;
+	}
+	if (idx < lineStart || idx > tokenEnd) return null;
+	const tokenText = value.slice(lineStart, tokenEnd);
+	const query = tokenText.slice(matchedTrigger.length);
+	const key = `${lineStart}:${tokenText}`;
+	return {
+		tokenStart: lineStart,
+		tokenEnd,
+		tokenText,
+		query,
+		key,
+		trigger: matchedTrigger
+	};
+}
+function computeMentionContext(value, cursorIndex, trigger, multilineToken, mentionToken) {
+	if (!trigger) return null;
+	const idx = clamp(cursorIndex, 0, value.length);
+	let start = -1;
+	for (let i = idx - 1; i >= 0; i--) {
+		const ch = value[i];
+		if (isMentionStart(value, i, trigger, multilineToken, mentionToken)) {
+			start = i;
+			break;
+		}
+		if (isMentionBoundary(ch, multilineToken, mentionToken)) break;
+	}
+	if (start < 0) return null;
+	let end = start + trigger.length;
+	const next = value[end];
+	if (next === "\"" || next === "'") {
+		const quote = next;
+		end += 1;
+		while (end < value.length && value[end] !== quote) end++;
+		if (end < value.length && value[end] === quote) end++;
+	} else while (end < value.length && isMentionChar(value[end])) end++;
+	if (idx < start || idx > end) return null;
+	const tokenText = value.slice(start, end);
+	const queryEnd = clamp(idx, start + trigger.length, end);
+	const query = value.slice(start + trigger.length, queryEnd);
+	const key = `${start}:${tokenText}`;
+	return {
+		tokenStart: start,
+		tokenEnd: end,
+		tokenText,
+		query,
+		key,
+		trigger
+	};
+}
+function usePromptMentionState(options) {
+	const { props, mentionSuggestionProviders, mentionPathProvider, focused, cursor, getValue, rawAbsRect, terminal, scheduler, multilineToken, mentionToken } = options;
+	const promptActive = ref(0);
+	const promptSuppressedKey = ref(null);
+	const providerList = mentionSuggestionProviders ?? [];
+	const mentionKindVersion = ref(0);
+	const mentionKindByPath = new Map();
+	let mentionKindSeq = 0;
+	function clearMentionKinds() {
+		if (mentionKindByPath.size === 0) return;
+		mentionKindByPath.clear();
+		mentionKindVersion.value++;
+		scheduler.invalidate();
+	}
+	watchEffect(() => {
+		const list = (props.mentions ?? []).map((p) => String(p ?? "")).filter(Boolean).filter((p) => !isCommitMention(p));
+		const statPath = mentionPathProvider?.stat;
+		if (!statPath || list.length === 0) {
+			clearMentionKinds();
+			return;
+		}
+		const seq = ++mentionKindSeq;
+		Promise.allSettled(list.map(async (absPath) => {
+			const kind = await Promise.resolve(statPath(absPath));
+			return {
+				absPath,
+				kind
+			};
+		})).then((results) => {
+			if (seq !== mentionKindSeq) return;
+			mentionKindByPath.clear();
+			for (const r of results) {
+				if (r.status !== "fulfilled") continue;
+				if (!r.value.kind) continue;
+				mentionKindByPath.set(r.value.absPath, r.value.kind);
+			}
+			mentionKindVersion.value++;
+			scheduler.invalidate();
+		}).catch(() => {
+			if (seq !== mentionKindSeq) return;
+			clearMentionKinds();
+		});
+	});
+	const promptContext = computed(() => {
+		if (!focused.value) return null;
+		if (!props.promptSuggestions?.length) return null;
+		const triggers = props.promptTriggers?.length ? props.promptTriggers : [props.promptTrigger || "/"];
+		return computePromptContext(getValue(), cursor.value, triggers);
+	});
+	const mentionContext = computed(() => {
+		if (!focused.value) return null;
+		const hasStatic = props.mentionSuggestions?.length > 0;
+		const hasDynamic = providerList.length > 0 || Boolean(mentionPathProvider?.suggest);
+		if (!hasStatic && !hasDynamic) return null;
+		return computeMentionContext(getValue(), cursor.value, props.mentionTrigger || "@", multilineToken, mentionToken);
+	});
+	const skillContext = computed(() => {
+		if (!focused.value) return null;
+		const trigger = props.skillTrigger;
+		if (!trigger || !props.skillSuggestions?.length) return null;
+		return computeMentionContext(getValue(), cursor.value, trigger, multilineToken, mentionToken);
+	});
+	const activeContext = computed(() => mentionContext.value ?? skillContext.value ?? promptContext.value);
+	watch(() => activeContext.value?.key ?? null, (next, prev) => {
+		if (prev && next !== prev) promptSuppressedKey.value = null;
+	});
+	const mentionPathItems = ref([]);
+	let mentionSeq = 0;
+	watchEffect((onCleanup) => {
+		const ctx = mentionContext.value;
+		const suggestPathsForMention = mentionPathProvider?.suggest;
+		if (!ctx || !suggestPathsForMention) {
+			mentionPathItems.value = [];
+			return;
+		}
+		const seq = ++mentionSeq;
+		const max = Math.max(0, Math.floor(props.mentionMaxItems));
+		const q = ctx.query.trim();
+		const maxDepth = q.length <= 1 ? 2 : q.length === 2 ? 4 : 8;
+		let done = false;
+		const timer = setTimeout(() => {
+			Promise.resolve(suggestPathsForMention({
+				workspaceAbs: props.mentionWorkspace,
+				input: ctx.query,
+				mode: props.mentionMode,
+				max,
+				showHidden: props.mentionShowHidden,
+				maxDepth
+			})).then((res) => {
+				if (done || seq !== mentionSeq) return;
+				mentionPathItems.value = (res ?? []).map((s) => ({
+					value: `${props.mentionTrigger}${s.completion}`,
+					insert: `${props.mentionTrigger}${s.completion} `,
+					detail: s.kind,
+					mentionValue: s.absPath
+				}));
+				scheduler.invalidate();
+			}).catch(() => {
+				if (done || seq !== mentionSeq) return;
+				mentionPathItems.value = [];
+				scheduler.invalidate();
+			});
+		}, MENTION_SUGGEST_DEBOUNCE_MS);
+		onCleanup(() => {
+			done = true;
+			clearTimeout(timer);
+		});
+	});
+	const mentionProviderItems = ref([]);
+	let mentionProviderSeq = 0;
+	watchEffect((onCleanup) => {
+		const ctx = mentionContext.value;
+		if (!ctx || providerList.length === 0) {
+			mentionProviderItems.value = [];
+			return;
+		}
+		const seq = ++mentionProviderSeq;
+		const max = Math.max(0, Math.floor(props.mentionMaxItems));
+		const trigger = props.mentionTrigger || "@";
+		let done = false;
+		const timer = setTimeout(() => {
+			Promise.all(providerList.map((provider) => Promise.resolve(provider({
+				query: ctx.query,
+				tokenText: ctx.tokenText,
+				trigger,
+				workspace: props.mentionWorkspace,
+				maxItems: max
+			})).catch(() => []))).then((results) => {
+				if (done || seq !== mentionProviderSeq) return;
+				const merged = [];
+				for (const list of results) {
+					if (!list?.length) continue;
+					merged.push(...list);
+				}
+				mentionProviderItems.value = merged;
+				scheduler.invalidate();
+			}).catch(() => {
+				if (done || seq !== mentionProviderSeq) return;
+				mentionProviderItems.value = [];
+				scheduler.invalidate();
+			});
+		}, MENTION_SUGGEST_DEBOUNCE_MS);
+		onCleanup(() => {
+			done = true;
+			clearTimeout(timer);
+		});
+	});
+	const promptMatches = computed(() => {
+		const ctx = activeContext.value;
+		if (!ctx) return [];
+		const mentionTrigger = props.mentionTrigger || "@";
+		const skillTrigger = props.skillTrigger || "";
+		const isMention = ctx.tokenText.startsWith(mentionTrigger);
+		const isSkill = !isMention && Boolean(skillTrigger && ctx.tokenText.startsWith(skillTrigger));
+		const trigger = isMention ? mentionTrigger : isSkill ? skillTrigger : ctx.trigger;
+		const pathItems = isMention ? mentionPathItems.value : [];
+		const candidates = isMention ? [...props.mentionSuggestions ?? [], ...mentionProviderItems.value] : isSkill ? props.skillSuggestions ?? [] : props.promptSuggestions ?? [];
+		const q = ctx.query.trim();
+		const pathMatches = [];
+		for (let i = 0; i < pathItems.length; i++) {
+			const s = pathItems[i];
+			const value = s.value || "";
+			if (!value.startsWith(trigger)) continue;
+			pathMatches.push({
+				item: s,
+				score: 0,
+				order: i
+			});
+		}
+		const otherMatches = [];
+		for (let i = 0; i < candidates.length; i++) {
+			const s = candidates[i];
+			const value = s.value || "";
+			if (!value.startsWith(trigger)) continue;
+			if (!q) {
+				otherMatches.push({
+					item: s,
+					score: 0,
+					order: i
+				});
+				continue;
+			}
+			const commandText = value.slice(trigger.length);
+			const valueScore = fuzzyScore(q, commandText);
+			if (valueScore != null) {
+				otherMatches.push({
+					item: s,
+					score: valueScore + 1e3,
+					order: i
+				});
+				continue;
+			}
+			if (!/[^\u0000-\u007F]/.test(q)) continue;
+			const metaText = [
+				s.label ?? "",
+				s.detail ?? "",
+				...s.keywords ?? []
+			].join(" ");
+			const metaScore = fuzzyScore(q, metaText);
+			if (metaScore != null) otherMatches.push({
+				item: s,
+				score: metaScore,
+				order: i
+			});
+		}
+		if (!q) return [...pathMatches, ...otherMatches];
+		otherMatches.sort((a, b) => b.score - a.score || a.order - b.order);
+		return [...pathMatches, ...otherMatches];
+	});
+	watch(() => promptMatches.value.length, (len) => {
+		promptActive.value = clamp(promptActive.value, 0, Math.max(0, len - 1));
+	});
+	const promptMaxVisible = computed(() => {
+		const ctx = activeContext.value;
+		if (!ctx) return 0;
+		const mentionTrigger = props.mentionTrigger || "@";
+		const isMention = ctx.tokenText.startsWith(mentionTrigger);
+		return Math.max(0, Math.floor(isMention ? props.mentionMaxItems : props.promptMaxItems));
+	});
+	const promptWindowStart = computed(() => {
+		const total = promptMatches.value.length;
+		const maxVisible = promptMaxVisible.value;
+		if (total <= 0 || maxVisible <= 0) return 0;
+		const visible = Math.min(maxVisible, total);
+		const maxStart = Math.max(0, total - visible);
+		return clamp(promptActive.value - (visible - 1), 0, maxStart);
+	});
+	const promptMatchesVisible = computed(() => {
+		const total = promptMatches.value.length;
+		const maxVisible = promptMaxVisible.value;
+		if (total <= 0 || maxVisible <= 0) return [];
+		const visible = Math.min(maxVisible, total);
+		const start = promptWindowStart.value;
+		return promptMatches.value.slice(start, start + visible);
+	});
+	const promptActiveVisible = computed(() => {
+		const start = promptWindowStart.value;
+		const rel = promptActive.value - start;
+		return clamp(rel, 0, Math.max(0, promptMatchesVisible.value.length - 1));
+	});
+	const promptVisible = computed(() => {
+		const ctx = activeContext.value;
+		if (!ctx) return false;
+		if (promptSuppressedKey.value && promptSuppressedKey.value === ctx.key) return false;
+		return true;
+	});
+	const promptRect = computed(() => {
+		const base = rawAbsRect.value;
+		const s = terminal.size();
+		const clip = {
+			x: 0,
+			y: 0,
+			w: s.cols,
+			h: s.rows
+		};
+		const listH = Math.max(1, promptMatchesVisible.value.length || 1);
+		const h$1 = clamp(2 + listH, 3, Math.max(3, Math.floor(clip.h)));
+		const w = clamp(Math.floor(base.w), 0, Math.max(0, Math.floor(clip.w)));
+		const preferAboveY = Math.floor(base.y) - h$1;
+		const preferBelowY = Math.floor(base.y) + Math.floor(base.h);
+		const aboveFits = preferAboveY >= Math.floor(clip.y);
+		const belowFits = preferBelowY + h$1 <= Math.floor(clip.y) + Math.floor(clip.h);
+		const yPref = aboveFits ? preferAboveY : belowFits ? preferBelowY : preferAboveY;
+		const y = clamp(yPref, Math.floor(clip.y), Math.floor(clip.y) + Math.floor(clip.h) - h$1);
+		const align = props.promptAlign || "input";
+		const baseX = Math.floor(base.x);
+		const centeredX = Math.floor(Math.floor(clip.x) + Math.floor((Math.floor(clip.w) - w) / 2));
+		const preferX = align === "center" ? centeredX : baseX;
+		const x = clamp(preferX, Math.floor(clip.x), Math.floor(clip.x) + Math.floor(clip.w) - w);
+		return {
+			x,
+			y,
+			w,
+			h: h$1
+		};
+	});
+	return {
+		promptActive,
+		promptSuppressedKey,
+		mentionKindByPath,
+		mentionKindVersion,
+		promptContext,
+		mentionContext,
+		activeContext,
+		promptMatches,
+		promptMatchesVisible,
+		promptWindowStart,
+		promptActiveVisible,
+		promptVisible,
+		promptRect
+	};
+}
+
+//#endregion
+//#region src/vue/components/input/plugins/promptMentionPlugin.ts
+function omitInverse(style) {
+	if (!style) return {};
+	const { inverse: _inverse,...rest } = style;
+	return rest;
+}
+function resolveSelectedPromptStyle(popupBase, selectedOverride) {
+	if (!selectedOverride) return {
+		...popupBase,
+		inverse: true,
+		bold: true,
+		dim: false
+	};
+	if (selectedOverride.bg == null) return {
+		...omitInverse(popupBase),
+		...omitInverse(selectedOverride),
+		inverse: true,
+		bold: true,
+		dim: false
+	};
+	return {
+		...popupBase,
+		...selectedOverride,
+		dim: false
+	};
+}
+function computeHighlightRanges$1(text, query) {
+	const q = query.trim().toLowerCase();
+	if (!q) return [];
+	const t = text.toLowerCase();
+	const idx = t.indexOf(q);
+	if (idx >= 0) return [{
+		start: idx,
+		end: idx + q.length
+	}];
+	const positions = [];
+	let qi = 0;
+	for (let i = 0; i < t.length && qi < q.length; i++) if (t[i] === q[qi]) {
+		positions.push(i);
+		qi++;
+	}
+	if (qi < q.length) return [];
+	const ranges = [];
+	let start = positions[0];
+	let prev = positions[0];
+	for (let i = 1; i < positions.length; i++) {
+		const pos = positions[i];
+		if (pos === prev + 1) {
+			prev = pos;
+			continue;
+		}
+		ranges.push({
+			start,
+			end: prev + 1
+		});
+		start = pos;
+		prev = pos;
+	}
+	ranges.push({
+		start,
+		end: prev + 1
+	});
+	return ranges;
+}
+function writeHighlightedText$1(opts) {
+	const { text, ranges, x, y, maxCells, baseStyle, highlightStyle, terminal } = opts;
+	const safeMax = Math.max(0, Math.floor(maxCells));
+	if (!text || safeMax <= 0) return 0;
+	let rangeIndex = 0;
+	let activeRange = ranges[rangeIndex];
+	let cellPos = 0;
+	let cursorX = x;
+	let buffer = "";
+	let currentStyle = baseStyle;
+	const flush = () => {
+		if (!buffer) return;
+		terminal.write(buffer, {
+			x: cursorX,
+			y,
+			style: currentStyle
+		});
+		cursorX += textCellWidth$1(buffer);
+		buffer = "";
+	};
+	for (let i = 0; i < text.length && cellPos < safeMax;) {
+		const code = text.charCodeAt(i);
+		const seg = code <= 127 ? text[i] : String.fromCodePoint(text.codePointAt(i) ?? 0);
+		const segLen = seg.length;
+		const segWidth = charCellWidth(seg);
+		if (cellPos + segWidth > safeMax) break;
+		while (activeRange && activeRange.end <= i) {
+			rangeIndex++;
+			activeRange = ranges[rangeIndex];
+		}
+		const isHighlighted = Boolean(activeRange && i < activeRange.end && i + segLen > activeRange.start);
+		const nextStyle = isHighlighted ? highlightStyle : baseStyle;
+		if (nextStyle !== currentStyle) {
+			flush();
+			currentStyle = nextStyle;
+		}
+		buffer += seg;
+		cellPos += segWidth;
+		i += segLen;
+	}
+	flush();
+	return cellPos;
+}
+function buildPromptMatchHighlightStyle(baseStyle, overrideStyle) {
+	return {
+		...baseStyle,
+		...overrideStyle ?? {
+			fg: "yellow",
+			bold: true,
+			dim: false
+		}
+	};
+}
+function countMentionTokens(value, mentionToken, endIndex = value.length) {
+	let count = 0;
+	const limit = clamp(endIndex, 0, value.length);
+	for (let i = 0; i < limit; i++) if (value[i] === mentionToken) count++;
+	return count;
+}
+function mentionIndexAt(value, mentionToken, index) {
+	return countMentionTokens(value, mentionToken, index);
+}
+function createPromptMentionPlugin(options = {}) {
+	const latency = getCliLatencyProfiler();
+	return {
+		name: "promptMention",
+		install: (ctx) => {
+			const getProps = () => ctx.getProps();
+			const promptOverlayStack = ctx.render.createStack(ctx.render.rootStack, 1e4);
+			let lastTopClampedRect = null;
+			let lastPromptRect = null;
+			const derivedStyleCache = new WeakMap();
+			const reactiveProps = reactive({
+				promptSuggestions: getProps().promptSuggestions,
+				promptTrigger: getProps().promptTrigger,
+				promptTriggers: getProps().promptTriggers,
+				promptMaxItems: getProps().promptMaxItems,
+				promptAlign: getProps().promptAlign,
+				mentionTrigger: getProps().mentionTrigger,
+				mentionWorkspace: getProps().mentionWorkspace,
+				mentionMode: getProps().mentionMode,
+				mentionShowHidden: getProps().mentionShowHidden,
+				mentionSuggestions: getProps().mentionSuggestions,
+				mentionMaxItems: getProps().mentionMaxItems,
+				mentions: getProps().mentions,
+				skillTrigger: getProps().skillTrigger,
+				skillSuggestions: getProps().skillSuggestions
+			});
+			watchEffect(() => {
+				const p = getProps();
+				reactiveProps.promptSuggestions = p.promptSuggestions;
+				reactiveProps.promptTrigger = p.promptTrigger;
+				reactiveProps.promptTriggers = p.promptTriggers;
+				reactiveProps.promptMaxItems = p.promptMaxItems;
+				reactiveProps.promptAlign = p.promptAlign;
+				reactiveProps.mentionTrigger = p.mentionTrigger;
+				reactiveProps.mentionWorkspace = p.mentionWorkspace;
+				reactiveProps.mentionMode = p.mentionMode;
+				reactiveProps.mentionShowHidden = p.mentionShowHidden;
+				reactiveProps.mentionSuggestions = p.mentionSuggestions;
+				reactiveProps.mentionMaxItems = p.mentionMaxItems;
+				reactiveProps.mentions = p.mentions;
+				reactiveProps.skillTrigger = p.skillTrigger;
+				reactiveProps.skillSuggestions = p.skillSuggestions;
+			});
+			const promptMention = usePromptMentionState({
+				props: reactiveProps,
+				mentionSuggestionProviders: options.mentionSuggestionProviders,
+				mentionPathProvider: options.mentionPathProvider,
+				focused: ctx.focused,
+				cursor: ctx.cursor,
+				getValue: ctx.getValue,
+				rawAbsRect: ctx.rawAbsRect,
+				terminal: ctx.terminal,
+				scheduler: ctx.scheduler,
+				multilineToken: "",
+				mentionToken: ctx.mentionToken
+			});
+			watch(() => {
+				if (!ctx.visible.value || !promptMention.promptVisible.value) return null;
+				const rect = promptMention.promptRect.value;
+				return [
+					Math.floor(rect.x),
+					Math.floor(rect.y),
+					Math.floor(rect.w),
+					Math.floor(rect.h)
+				].join(":");
+			}, (nextRectKey, prevRectKey) => {
+				if (!prevRectKey || nextRectKey === prevRectKey) return;
+				ctx.render.invalidatePlane("default");
+				ctx.scheduler.invalidate({ priority: "high" });
+			});
+			ctx.registerChipStyleProvider({
+				getStyle: (baseStyle, chip) => {
+					if (chip.kind !== "mention") return null;
+					const absPath = String(chip.absPath ?? "");
+					if (!absPath) return null;
+					const fsKind = promptMention.mentionKindByPath.get(absPath);
+					return {
+						...mentionChipStyle(baseStyle, absPath, fsKind),
+						...getProps().mentionChipStyle ?? {}
+					};
+				},
+				version: promptMention.mentionKindVersion
+			});
+			function replaceMentionInContext(absPath, tokenStart, tokenEnd) {
+				const cleaned = String(absPath || "").trim();
+				if (!cleaned) return;
+				const value = ctx.getValue();
+				const start = clamp(tokenStart, 0, value.length);
+				const end = clamp(tokenEnd, start, value.length);
+				const currentMentions = getProps().mentions ?? [];
+				const nextMentions = [...currentMentions];
+				let before = value.slice(0, start);
+				let after = value.slice(end);
+				const closeMatch = after.match(/^[\s\u200B]*\]+/u);
+				if (closeMatch) {
+					after = after.slice(closeMatch[0].length);
+					let i = before.length - 1;
+					while (i >= 0 && /[\s\u200B]/u.test(before[i])) i--;
+					if (i >= 0 && before[i] === "[") before = before.slice(0, i) + before.slice(i + 1);
+				}
+				const insertIndex = mentionIndexAt(value, ctx.mentionToken, start);
+				nextMentions.splice(insertIndex, 0, cleaned);
+				ctx.emit("update:mentions", nextMentions);
+				let nextAfter = after;
+				if (nextAfter.startsWith(" ")) nextAfter = nextAfter.slice(1);
+				const nextValue = `${before}${ctx.mentionToken} ${nextAfter}`;
+				const nextCursor = before.length + 2;
+				ctx.pushUndoSnapshot(nextValue);
+				ctx.applyEdit(nextValue, nextCursor);
+			}
+			function acceptPrompt(index) {
+				const ctx0 = promptMention.activeContext.value;
+				if (!ctx0) return;
+				const list = promptMention.promptMatches.value;
+				const match = list[clamp(index, 0, Math.max(0, list.length - 1))];
+				if (!match) return;
+				const suggestion = match.item;
+				const mentionTrigger = getProps().mentionTrigger || "@";
+				const isMention = ctx0.tokenText.startsWith(mentionTrigger);
+				if (isMention) {
+					if (!getProps().collectMentions || suggestion.mentionBehavior === "inline") {
+						const insert$1 = suggestion.insert ?? (suggestion.value.endsWith(" ") ? suggestion.value : `${suggestion.value} `);
+						const before$1 = ctx.getValue().slice(0, ctx0.tokenStart);
+						let after$1 = ctx.getValue().slice(ctx0.tokenEnd);
+						if (insert$1.endsWith(" ") && after$1.startsWith(" ")) after$1 = after$1.slice(1);
+						const nextValue$1 = `${before$1}${insert$1}${after$1}`;
+						const nextCursor$1 = ctx0.tokenStart + insert$1.length;
+						promptMention.promptSuppressedKey.value = null;
+						ctx.pushUndoSnapshot(nextValue$1);
+						ctx.applyEdit(nextValue$1, nextCursor$1);
+						return;
+					}
+					const mentionValue = typeof suggestion.mentionValue === "string" ? String(suggestion.mentionValue) : "";
+					const raw = mentionValue || (String(suggestion.value || "").startsWith(mentionTrigger) ? String(suggestion.value).slice(mentionTrigger.length) : String(suggestion.value));
+					const absPath = mentionValue ? raw : getProps().mentionWorkspace ? ctx.resolvePath(raw) : raw;
+					if (!absPath) {
+						promptMention.promptSuppressedKey.value = null;
+						return;
+					}
+					replaceMentionInContext(absPath, ctx0.tokenStart, ctx0.tokenEnd);
+					promptMention.promptSuppressedKey.value = null;
+					ctx.scheduler.invalidate();
+					return;
+				}
+				if (typeof suggestion.onSelect === "function") {
+					const handled = suggestion.onSelect({
+						value: suggestion.value,
+						query: ctx0.query
+					});
+					if (handled !== false) {
+						const value = ctx.getValue();
+						const before$1 = value.slice(0, ctx0.tokenStart);
+						const after$1 = value.slice(ctx0.tokenEnd);
+						const nextValue$1 = `${before$1}${after$1}`;
+						ctx.pushUndoSnapshot(nextValue$1);
+						ctx.applyEdit(nextValue$1, ctx0.tokenStart);
+						promptMention.promptSuppressedKey.value = ctx0.key;
+						ctx.scheduler.invalidate();
+						return;
+					}
+				}
+				const insert = suggestion.insert ?? (suggestion.value.endsWith(" ") ? suggestion.value : `${suggestion.value} `);
+				const before = ctx.getValue().slice(0, ctx0.tokenStart);
+				let after = ctx.getValue().slice(ctx0.tokenEnd);
+				if (insert.endsWith(" ") && after.startsWith(" ")) after = after.slice(1);
+				const nextValue = `${before}${insert}${after}`;
+				const nextCursor = ctx0.tokenStart + insert.length;
+				promptMention.promptSuppressedKey.value = null;
+				ctx.pushUndoSnapshot(nextValue);
+				ctx.applyEdit(nextValue, nextCursor);
+			}
+			function completeMentionDirectory(suggestion, ctx0) {
+				const mentionTrigger = getProps().mentionTrigger || "@";
+				if (!ctx0.tokenText.startsWith(mentionTrigger)) return false;
+				if (String(suggestion.detail ?? "") !== "directory") return false;
+				let insert = String(suggestion.value ?? "");
+				if (!insert.startsWith(mentionTrigger)) return false;
+				if (!insert.endsWith("/") && !insert.endsWith("\\")) insert = `${insert}/`;
+				const value = ctx.getValue();
+				const before = value.slice(0, clamp(ctx0.tokenStart, 0, value.length));
+				const after = value.slice(clamp(ctx0.tokenEnd, 0, value.length));
+				const nextValue = `${before}${insert}${after}`;
+				const nextCursor = before.length + insert.length;
+				promptMention.promptSuppressedKey.value = null;
+				promptMention.promptActive.value = 0;
+				ctx.pushUndoSnapshot(nextValue);
+				ctx.applyEdit(nextValue, nextCursor);
+				ctx.scheduler.invalidate();
+				return true;
+			}
+			function handlePromptKeydown(e) {
+				if (!promptMention.promptVisible.value) return false;
+				const markPromptOperation = (suffix) => {
+					const ctx0 = promptMention.activeContext.value;
+					const mentionTrigger = getProps().mentionTrigger || "@";
+					const skillTrigger = getProps().skillTrigger || "";
+					const tokenText = String(ctx0?.tokenText ?? "");
+					const scope = tokenText.startsWith(mentionTrigger) ? "prompt.mention" : skillTrigger && tokenText.startsWith(skillTrigger) ? "prompt.skill" : "prompt.command";
+					latency?.markOperation(`${scope}.${suffix}`);
+				};
+				const len = promptMention.promptMatches.value.length;
+				if (e.key === "ArrowDown") {
+					markPromptOperation("navigate.next");
+					e.preventDefault();
+					if (len <= 0) promptMention.promptActive.value = 0;
+					else if (promptMention.promptActive.value >= len - 1) promptMention.promptActive.value = 0;
+					else promptMention.promptActive.value = clamp(promptMention.promptActive.value + 1, 0, len - 1);
+					ctx.scheduler.invalidate();
+					return true;
+				}
+				if (e.key === "ArrowUp") {
+					markPromptOperation("navigate.prev");
+					e.preventDefault();
+					if (len <= 0) promptMention.promptActive.value = 0;
+					else if (promptMention.promptActive.value <= 0) promptMention.promptActive.value = len - 1;
+					else promptMention.promptActive.value = clamp(promptMention.promptActive.value - 1, 0, len - 1);
+					ctx.scheduler.invalidate();
+					return true;
+				}
+				if (e.key === "Tab" || e.key === "Enter" && !e.shiftKey) {
+					const ctx0 = promptMention.activeContext.value;
+					const mentionTrigger = getProps().mentionTrigger || "@";
+					const skillTrigger = getProps().skillTrigger || "";
+					const isMention = Boolean(ctx0?.tokenText?.startsWith(mentionTrigger));
+					const isSkill = Boolean(skillTrigger && ctx0?.tokenText?.startsWith(skillTrigger) && !isMention);
+					if (e.key === "Enter" && !e.shiftKey && !isMention && !isSkill) {
+						if (len === 0) return false;
+						const match = promptMention.promptMatches.value[clamp(promptMention.promptActive.value, 0, Math.max(0, promptMention.promptMatches.value.length - 1))];
+						const typed = String(ctx0?.tokenText ?? "");
+						const candidate = String(match?.item?.value ?? "");
+						if (!typed || !candidate.startsWith(typed)) return false;
+						markPromptOperation("accept");
+						e.preventDefault();
+						acceptPrompt(promptMention.promptActive.value);
+						return true;
+					}
+					if (e.key === "Tab" && (isMention || isSkill)) {
+						markPromptOperation("accept");
+						e.preventDefault();
+						if (len === 0) return true;
+						const list = promptMention.promptMatches.value;
+						const match = list[clamp(promptMention.promptActive.value, 0, Math.max(0, list.length - 1))];
+						if (isMention && match && ctx0 && completeMentionDirectory(match.item, ctx0)) return true;
+						acceptPrompt(promptMention.promptActive.value);
+						return true;
+					}
+					if (len === 0) return false;
+					markPromptOperation("accept");
+					e.preventDefault();
+					acceptPrompt(promptMention.promptActive.value);
+					return true;
+				}
+				if (e.key === "Escape") {
+					markPromptOperation("dismiss");
+					e.preventDefault();
+					promptMention.promptSuppressedKey.value = promptMention.activeContext.value?.key ?? null;
+					ctx.scheduler.invalidate();
+					return true;
+				}
+				return false;
+			}
+			ctx.registerKeydownInterceptor(handlePromptKeydown);
+			useRenderNode(() => ({
+				zIndex: getProps().zIndex + 5,
+				stack: promptOverlayStack,
+				dirtyRowsHint: (() => {
+					const currentRect = ctx.visible.value && promptMention.promptVisible.value ? {
+						y: Math.floor(promptMention.promptRect.value.y),
+						h: Math.max(0, Math.floor(promptMention.promptRect.value.h))
+					} : null;
+					const rects = [lastPromptRect, currentRect].filter(Boolean);
+					if (!rects.length) return void 0;
+					const maxRows = ctx.terminal.size().rows;
+					const start = Math.max(0, Math.min(...rects.map((rect) => rect.y)) - 1);
+					const end = Math.min(maxRows, Math.max(...rects.map((rect) => rect.y + rect.h)) + 1);
+					if (end <= start) return void 0;
+					return Array.from({ length: end - start }, (_, index) => start + index);
+				})(),
+				priority: "high",
+				rect: ctx.visible.value && promptMention.promptVisible.value ? promptMention.promptRect.value : {
+					x: 0,
+					y: 0,
+					w: 0,
+					h: 0
+				},
+				deps: [
+					ctx.visible.value,
+					promptMention.promptVisible.value,
+					promptMention.promptRect.value,
+					promptMention.promptMatches.value,
+					promptMention.promptMatchesVisible.value,
+					promptMention.promptWindowStart.value,
+					promptMention.promptActive.value,
+					promptMention.promptActiveVisible.value,
+					getProps().style,
+					getProps().promptPopupStyle,
+					getProps().promptPopupBorderStyle,
+					getProps().promptPopupMatchStyle,
+					getProps().promptSelectedStyle,
+					getProps().zIndex,
+					ctx.defaultStyle.value,
+					promptMention.mentionKindVersion.value
+				],
+				paint: () => {
+					if (!ctx.visible.value || !promptMention.promptVisible.value) return;
+					const r = promptMention.promptRect.value;
+					if (r.w < 3 || r.h < 3) return;
+					lastPromptRect = {
+						y: Math.floor(r.y),
+						h: Math.max(0, Math.floor(r.h))
+					};
+					const popupBase = getProps().promptPopupStyle ?? getProps().style ?? ctx.defaultStyle.value;
+					const popupBorderStyle = getProps().promptPopupBorderStyle;
+					const popupMatchStyle = getProps().promptPopupMatchStyle;
+					const selectedOverride = getProps().promptSelectedStyle;
+					const styleKey = popupBase ?? null;
+					const cacheKey = selectedOverride ? null : styleKey;
+					let derived = cacheKey ? derivedStyleCache.get(cacheKey) : null;
+					if (!derived) {
+						const borderStyle$1 = popupBorderStyle ? {
+							...popupBase,
+							...popupBorderStyle
+						} : {
+							...popupBase,
+							dim: true
+						};
+						const itemStyle = {
+							...popupBase,
+							dim: false
+						};
+						const selectedStyle = resolveSelectedPromptStyle(popupBase, selectedOverride);
+						const detailStyle = {
+							...popupBase,
+							dim: true
+						};
+						const selectedDetailStyle = {
+							...selectedStyle,
+							dim: true
+						};
+						const emptyStyle = {
+							...popupBase,
+							dim: true
+						};
+						derived = {
+							borderStyle: borderStyle$1,
+							itemStyle,
+							selectedStyle,
+							detailStyle,
+							selectedDetailStyle,
+							emptyStyle
+						};
+						if (cacheKey) derivedStyleCache.set(cacheKey, derived);
+					}
+					const x0 = Math.floor(r.x);
+					const y0 = Math.floor(r.y);
+					const w = Math.max(0, Math.floor(r.w));
+					const h$1 = Math.max(0, Math.floor(r.h));
+					const innerW = Math.max(0, w - 2);
+					const sidePad = innerW >= 4 ? 1 : 0;
+					const contentW = Math.max(0, innerW - sidePad * 2);
+					const contentX = x0 + 1 + sidePad;
+					const borderStyle = derived.borderStyle;
+					if (lastTopClampedRect && y0 > 0) {
+						ctx.terminal.write(spaces(lastTopClampedRect.w), {
+							x: lastTopClampedRect.x,
+							y: 0,
+							style: popupBase
+						});
+						lastTopClampedRect = null;
+					}
+					if (y0 === 0) lastTopClampedRect = {
+						x: x0,
+						w
+					};
+					else lastTopClampedRect = null;
+					ctx.terminal.write(`┌${repeatChar("─", innerW)}┐`, {
+						x: x0,
+						y: y0,
+						style: borderStyle
+					});
+					ctx.terminal.write(`└${repeatChar("─", innerW)}┘`, {
+						x: x0,
+						y: y0 + h$1 - 1,
+						style: borderStyle
+					});
+					const totalList = promptMention.promptMatches.value;
+					const start = promptMention.promptWindowStart.value;
+					const list = promptMention.promptMatchesVisible.value;
+					const query = promptMention.activeContext.value?.query ?? "";
+					const total = totalList.length;
+					const visible = list.length;
+					const hasAbove = start > 0;
+					const hasBelow = start + visible < total;
+					const contentH = Math.max(0, h$1 - 2);
+					for (let row = 0; row < contentH; row++) {
+						const y = y0 + 1 + row;
+						ctx.terminal.put(x0, y, "│", borderStyle);
+						const rightBorderChar = row === 0 && hasAbove ? "▲" : row === contentH - 1 && hasBelow ? "▼" : "│";
+						ctx.terminal.put(x0 + w - 1, y, rightBorderChar, borderStyle);
+						if (row >= list.length) {
+							ctx.terminal.write(spaces(innerW), {
+								x: x0 + 1,
+								y,
+								style: borderStyle
+							});
+							continue;
+						}
+						const match = list[row];
+						const isSelected = row === promptMention.promptActiveVisible.value;
+						const rawValue = sanitizeInlineText(match.item.value);
+						const rawDetail = match.item.detail ? sanitizeInlineText(match.item.detail) : "";
+						const highlightRanges = query ? computeHighlightRanges$1(rawValue, query) : [];
+						const valueCells = textCellWidth$1(rawValue);
+						const detailCells = rawDetail ? textCellWidth$1(rawDetail) : 0;
+						const minGap = 2;
+						const availableForDetail = contentW - valueCells - minGap;
+						if (rawDetail && availableForDetail >= 4) {
+							const valueStyle = isSelected ? derived.selectedStyle : derived.itemStyle;
+							const highlightStyle = buildPromptMatchHighlightStyle(valueStyle, popupMatchStyle);
+							const rowStyle = valueStyle;
+							if (sidePad > 0) ctx.terminal.write(spaces(sidePad), {
+								x: x0 + 1,
+								y,
+								style: rowStyle
+							});
+							writeHighlightedText$1({
+								text: rawValue,
+								ranges: highlightRanges,
+								x: contentX,
+								y,
+								maxCells: valueCells,
+								baseStyle: valueStyle,
+								highlightStyle,
+								terminal: ctx.terminal
+							});
+							const gapWidth = contentW - valueCells - Math.min(detailCells, availableForDetail);
+							const gapStyle = isSelected ? derived.selectedStyle : derived.itemStyle;
+							ctx.terminal.write(spaces(gapWidth), {
+								x: contentX + valueCells,
+								y,
+								style: gapStyle
+							});
+							const detailText = sliceByCellsWindow(rawDetail, 0, availableForDetail);
+							const dStyle = isSelected ? derived.selectedDetailStyle : derived.detailStyle;
+							ctx.terminal.write(detailText, {
+								x: contentX + valueCells + gapWidth,
+								y,
+								style: dStyle
+							});
+							if (sidePad > 0) ctx.terminal.write(spaces(sidePad), {
+								x: contentX + contentW,
+								y,
+								style: rowStyle
+							});
+						} else {
+							const style = isSelected ? derived.selectedStyle : derived.itemStyle;
+							const highlightStyle = buildPromptMatchHighlightStyle(style, popupMatchStyle);
+							if (sidePad > 0) ctx.terminal.write(spaces(sidePad), {
+								x: x0 + 1,
+								y,
+								style
+							});
+							const clippedValue = sliceByCellsWindow(rawValue, 0, contentW);
+							const usedCells = writeHighlightedText$1({
+								text: clippedValue,
+								ranges: highlightRanges,
+								x: contentX,
+								y,
+								maxCells: contentW,
+								baseStyle: style,
+								highlightStyle,
+								terminal: ctx.terminal
+							});
+							if (usedCells < contentW) ctx.terminal.write(spaces(contentW - usedCells), {
+								x: contentX + usedCells,
+								y,
+								style
+							});
+							if (sidePad > 0) ctx.terminal.write(spaces(sidePad), {
+								x: contentX + contentW,
+								y,
+								style
+							});
+						}
+					}
+					if (list.length === 0 && contentH > 0) {
+						const y = y0 + 1;
+						ctx.terminal.put(x0, y, "│", borderStyle);
+						ctx.terminal.put(x0 + w - 1, y, "│", borderStyle);
+						const msg = padEndByCells$1(sliceByCellsWindow("(no matches)", 0, contentW), contentW);
+						if (sidePad > 0) ctx.terminal.write(spaces(sidePad), {
+							x: x0 + 1,
+							y,
+							style: derived.emptyStyle
+						});
+						ctx.terminal.write(msg, {
+							x: contentX,
+							y,
+							style: derived.emptyStyle
+						});
+						if (sidePad > 0) ctx.terminal.write(spaces(sidePad), {
+							x: contentX + contentW,
+							y,
+							style: derived.emptyStyle
+						});
+					}
+				}
+			}));
+			useTerminalNode(() => ({
+				rect: promptMention.promptVisible.value ? promptMention.promptRect.value : {
+					x: 0,
+					y: 0,
+					w: 0,
+					h: 0
+				},
+				zIndex: ctx.eventZ.value + 1e4,
+				visible: ctx.visible.value && promptMention.promptVisible.value,
+				focusable: false,
+				handlers: { click: (e) => {
+					const r = promptMention.promptRect.value;
+					const y = e.cellY - r.y;
+					if (y <= 0 || y >= r.h - 1) return;
+					const idx = y - 1;
+					const start = promptMention.promptWindowStart.value;
+					const globalIdx = start + idx;
+					promptMention.promptActive.value = clamp(globalIdx, 0, Math.max(0, promptMention.promptMatches.value.length - 1));
+					acceptPrompt(promptMention.promptActive.value);
+				} }
+			}));
+			watchEffect(() => {
+				getProps().mentions;
+				promptMention.mentionKindVersion.value;
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/vue/components/input/plugins/restrictText.ts
+function computeProposedValue(info, text) {
+	const start = info.selection ? info.selection.start : info.cursor;
+	const end = info.selection ? info.selection.end : info.cursor;
+	return info.value.slice(0, start) + text + info.value.slice(end);
+}
+function applyRule(rule, info) {
+	if ("filter" in rule) return rule.filter(info);
+	if ("replace" in rule) return info.text.replace(rule.replace.from, rule.replace.to);
+	if ("allowChars" in rule) {
+		let out = "";
+		for (const ch of info.text) if (rule.allowChars.test(ch)) out += ch;
+		return out;
+	}
+	if ("denyChars" in rule) return info.text.replace(rule.denyChars, "");
+	if ("allow" in rule) {
+		const next = computeProposedValue(info, info.text);
+		return rule.allow.test(next) ? info.text : "";
+	}
+	return info.text;
+}
+function createTextRestrictionPlugin(options) {
+	const name = options.name ?? "restrictText";
+	const rules = options.rules ?? [];
+	return {
+		name,
+		install(ctx) {
+			ctx.registerTextFilter((info) => {
+				const originalText = info.text;
+				let text = info.text;
+				for (const rule of rules) {
+					text = applyRule(rule, {
+						...info,
+						text
+					});
+					if (!text) {
+						if (originalText) ctx.emit("validationError", {
+							plugin: name,
+							kind: "reject",
+							originalText,
+							acceptedText: "",
+							value: info.value,
+							cursor: info.cursor,
+							selection: info.selection
+						});
+						return "";
+					}
+				}
+				if (originalText && text !== originalText) ctx.emit("validationError", {
+					plugin: name,
+					kind: "filter",
+					originalText,
+					acceptedText: text,
+					value: info.value,
+					cursor: info.cursor,
+					selection: info.selection
+				});
+				return text;
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/vue/components/TAnchor.ts
+const EMPTY_RECT = Object.freeze({
+	x: 0,
+	y: 0,
+	w: 0,
+	h: 0
+});
+const TAnchor = defineComponent({
+	name: "TAnchor",
+	props: {
+		left: {
+			type: Number,
+			default: void 0
+		},
+		top: {
+			type: Number,
+			default: void 0
+		},
+		right: {
+			type: Number,
+			default: void 0
+		},
+		bottom: {
+			type: Number,
+			default: void 0
+		},
+		w: {
+			type: Number,
+			default: void 0
+		},
+		h: {
+			type: Number,
+			default: void 0
+		},
+		zIndex: {
+			type: Number,
+			default: 0
+		},
+		focusable: {
+			type: Boolean,
+			default: false
+		},
+		selectable: {
+			type: Boolean,
+			default: void 0
+		}
+	},
+	emits: [
+		"clickCapture",
+		"click",
+		"dblclickCapture",
+		"dblclick",
+		"pointerdownCapture",
+		"pointerdown",
+		"pointerupCapture",
+		"pointerup",
+		"pointermoveCapture",
+		"pointermove",
+		"wheelCapture",
+		"wheel",
+		"keydownCapture",
+		"keydown",
+		"keyupCapture",
+		"keyup",
+		"focusCapture",
+		"focus",
+		"blurCapture",
+		"blur"
+	],
+	setup(props, { emit, slots }) {
+		const parent = useLayout();
+		const { render } = useTerminal();
+		const parentStack = useRenderStack();
+		const { visible, rootProps } = useVisibility({ provide: true });
+		const parentEventZ = inject(EventZIndexContextKey, computed(() => 0));
+		const eventZ = computed(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0));
+		const rawRect = computed(() => {
+			const base = parent.clipRect ?? {
+				x: parent.originX,
+				y: parent.originY,
+				w: 0,
+				h: 0
+			};
+			const left = props.left;
+			const right = props.right;
+			const top = props.top;
+			const bottom = props.bottom;
+			const width = props.w;
+			const height = props.h;
+			let w = width;
+			let h$1 = height;
+			if (w == null && left != null && right != null) w = base.w - left - right;
+			if (h$1 == null && top != null && bottom != null) h$1 = base.h - top - bottom;
+			w = Math.max(0, Math.floor(w ?? 0));
+			h$1 = Math.max(0, Math.floor(h$1 ?? 0));
+			let x = base.x;
+			let y = base.y;
+			if (left != null) x = base.x + Math.floor(left);
+			else if (right != null) x = base.x + base.w - Math.floor(right) - w;
+			if (top != null) y = base.y + Math.floor(top);
+			else if (bottom != null) y = base.y + base.h - Math.floor(bottom) - h$1;
+			return translateRect({
+				x,
+				y,
+				w,
+				h: h$1
+			}, 0, 0);
+		});
+		const rect = computed(() => {
+			const translated = rawRect.value;
+			return parent.clipRect ? intersectRect(translated, parent.clipRect) ?? EMPTY_RECT : translated;
+		});
+		useTerminalNode(() => ({
+			rect: rect.value,
+			zIndex: eventZ.value,
+			visible: visible.value,
+			focusable: props.focusable,
+			selectable: props.selectable,
+			handlers: {
+				clickCapture: (e) => emit("clickCapture", e),
+				click: (e) => emit("click", e),
+				dblclickCapture: (e) => emit("dblclickCapture", e),
+				dblclick: (e) => emit("dblclick", e),
+				pointerdownCapture: (e) => emit("pointerdownCapture", e),
+				pointerdown: (e) => emit("pointerdown", e),
+				pointerupCapture: (e) => emit("pointerupCapture", e),
+				pointerup: (e) => emit("pointerup", e),
+				pointermoveCapture: (e) => emit("pointermoveCapture", e),
+				pointermove: (e) => emit("pointermove", e),
+				wheelCapture: (e) => emit("wheelCapture", e),
+				wheel: (e) => emit("wheel", e),
+				keydownCapture: (e) => emit("keydownCapture", e),
+				keydown: (e) => emit("keydown", e),
+				keyupCapture: (e) => emit("keyupCapture", e),
+				keyup: (e) => emit("keyup", e),
+				focusCapture: (e) => emit("focusCapture", e),
+				focus: (e) => emit("focus", e),
+				blurCapture: (e) => emit("blurCapture", e),
+				blur: (e) => emit("blur", e)
+			}
+		}));
+		const childLayout = shallowReactive({
+			originX: 0,
+			originY: 0,
+			clipRect: null
+		});
+		const childStack = computed(() => render.createStack(parentStack.value, props.zIndex));
+		watchEffect(() => {
+			const translated = rawRect.value;
+			childLayout.originX = translated.x;
+			childLayout.originY = translated.y;
+			childLayout.clipRect = rect.value;
+		});
+		provide(LayoutContextKey, childLayout);
+		provide(RenderStackKey, childStack);
+		provide(EventZIndexContextKey, eventZ);
+		return () => h("div", rootProps, slots.default?.());
+	}
+});
+
+//#endregion
+//#region src/vue/components/TDebugOverlay.ts
+const TDebugOverlay = defineComponent({
+	name: "TDebugOverlay",
+	props: {
+		mode: {
+			type: String,
+			default: "focus"
+		},
+		panel: {
+			type: Boolean,
+			default: true
+		},
+		maxRects: {
+			type: Number,
+			default: 40
+		},
+		zIndex: {
+			type: Number,
+			default: 90
+		}
+	},
+	setup(props) {
+		const { terminal, events, observability, scheduler } = useTerminal();
+		const trace = observability.trace;
+		const framePerf = observability.framePerf;
+		const releasePerf = framePerf.acquire("debug-overlay");
+		const latestPerf = shallowRef(framePerf.latest());
+		let timer = null;
+		function refreshLatestPerf() {
+			const next = framePerf.latest();
+			if (!next) return;
+			if (next.reason === "manual") return;
+			if (latestPerf.value?.frameId === next.frameId) return;
+			latestPerf.value = next;
+			scheduler.invalidate({
+				priority: "low",
+				reason: "manual"
+			});
+		}
+		onMounted(() => {
+			refreshLatestPerf();
+			timer = setInterval(refreshLatestPerf, 250);
+		});
+		onUnmounted(() => {
+			releasePerf();
+			if (timer) clearInterval(timer);
+			timer = null;
+		});
+		function boxStyle(kind) {
+			if (kind === "panel") return {
+				fg: "whiteBright",
+				bg: "black"
+			};
+			if (kind === "focus") return { fg: "cyanBright" };
+			return { fg: "magentaBright" };
+		}
+		return () => {
+			const { cols, rows } = terminal.size();
+			if (cols <= 0 || rows <= 0) return null;
+			const mgr = events.value;
+			const debugNodes = (() => {
+				const nodes = typeof mgr?.debugNodes === "function" ? mgr.debugNodes() : [];
+				return nodes.filter((n) => n && n.rect && n.visible);
+			})();
+			const focused = typeof mgr?.getFocused === "function" ? mgr.getFocused() : null;
+			const focusedRect = debugNodes.find((n) => n.id === focused)?.rect ?? null;
+			const panelText = (() => {
+				if (!props.panel) return "";
+				const records = trace.records;
+				const last = [...records].reverse().find((r) => r.type === "commit");
+				const perf = latestPerf.value ?? framePerf.latest();
+				const dirty = last ? last.dirtyRows === null ? "all" : String(last.dirtyRows?.length ?? 0) : "0";
+				const lines = [
+					`trace: ${trace.enabled.value ? "ON" : "OFF"}`,
+					`focus: ${focused ?? "null"}`,
+					last ? `last commit: dirtyRows=${dirty}` : "last commit: -"
+				];
+				if (perf) lines.push(`frame: ${perf.durationMs.toFixed(1)}ms`, `reason: ${perf.reason}`, `dirtyRows: ${perf.dirtyRows === null ? "all" : perf.dirtyRows}`, `scannedNodes: ${perf.scannedNodes}`, `paintedNodes: ${perf.paintedNodes}`, `commit: ${perf.commitMs.toFixed(1)}ms`, `domFlush: ${perf.domFlushMs == null ? "-" : `${perf.domFlushMs.toFixed(1)}ms`}`, `coalescedInvalidates: ${perf.coalescedInvalidates}`, `frameTasks: ${perf.frameTaskCount} queue:${perf.frameTaskQueueDepthBeforeRun}->${perf.frameTaskQueueDepthAfterRun}`, `coalescedTasks: ${perf.coalescedFrameTasks}`, `droppedUpdates: ${perf.droppedUpdates}`, `queueDepth: ${perf.queueDepth}`);
+				else lines.push("frame: -");
+				return lines.join("\n");
+			})();
+			const children = [];
+			if (props.mode === "all") for (const n of debugNodes.slice(0, Math.max(0, Math.floor(props.maxRects)))) {
+				const r = n.rect;
+				if (!r || r.w < 2 || r.h < 2) continue;
+				children.push(h(TBox, {
+					x: r.x,
+					y: r.y,
+					w: r.w,
+					h: r.h,
+					zIndex: props.zIndex,
+					clear: false,
+					padding: 0,
+					title: n.id,
+					style: boxStyle("rect")
+				}));
+			}
+			const fr = focusedRect;
+			if (fr && fr.w >= 2 && fr.h >= 2) children.push(h(TBox, {
+				x: fr.x,
+				y: fr.y,
+				w: fr.w,
+				h: fr.h,
+				zIndex: props.zIndex,
+				clear: false,
+				padding: 0,
+				title: `focus:${focused ?? ""}`,
+				style: boxStyle("focus")
+			}));
+			if (props.panel) {
+				const panelW = Math.min(cols, 42);
+				const panelH = rows >= 16 ? Math.min(rows, 17) : Math.min(rows, 6);
+				children.push(h(TBox, {
+					x: 0,
+					y: 0,
+					w: panelW,
+					h: panelH,
+					zIndex: props.zIndex,
+					clear: true,
+					padding: 0,
+					title: "debug",
+					style: boxStyle("panel")
+				}, () => h(TText, {
+					x: 0,
+					y: 0,
+					w: panelW - 2,
+					h: panelH - 2,
+					wrap: true,
+					value: panelText
+				})));
+			}
+			return h(TView, {
+				x: 0,
+				y: 0,
+				w: cols,
+				h: rows,
+				zIndex: props.zIndex
+			}, () => children);
+		};
+	}
+});
+
+//#endregion
+//#region src/vue/components/TFlow.ts
+const TFlow = defineComponent({
+	name: "TFlow",
+	props: {
+		x: {
+			type: Number,
+			required: true
+		},
+		y: {
+			type: Number,
+			required: true
+		},
+		w: {
+			type: Number,
+			required: true
+		},
+		h: {
+			type: Number,
+			required: true
+		},
+		items: {
+			type: Array,
+			required: true
+		},
+		direction: {
+			type: String,
+			default: "vertical"
+		},
+		gap: {
+			type: Number,
+			default: 0
+		},
+		itemSize: {
+			type: Number,
+			default: 1
+		},
+		zIndex: {
+			type: Number,
+			default: 0
+		}
+	},
+	setup(props, { slots }) {
+		return () => h(TView, {
+			x: props.x,
+			y: props.y,
+			w: props.w,
+			h: props.h,
+			zIndex: props.zIndex
+		}, () => props.items.map((item, index) => {
+			const step = Math.max(0, Math.floor(props.itemSize)) + Math.max(0, Math.floor(props.gap));
+			const offset = index * step;
+			const childProps = props.direction === "vertical" ? {
+				x: 0,
+				y: offset,
+				w: props.w,
+				h: Math.max(0, Math.floor(props.itemSize))
+			} : {
+				x: offset,
+				y: 0,
+				w: Math.max(0, Math.floor(props.itemSize)),
+				h: props.h
+			};
+			return h(TView, {
+				key: index,
+				...childProps
+			}, () => slots.item?.({
+				item,
+				index
+			}) ?? null);
+		}));
+	}
+});
+
+//#endregion
+//#region src/vue/components/TPanels.ts
+function normalizeCellCount(value) {
+	const n = Math.floor(Number(value));
+	return Number.isFinite(n) ? Math.max(0, n) : 0;
+}
+function normalizePaneSize(value, fallback = 0) {
+	const n = Math.floor(Number(value));
+	if (Number.isFinite(n)) return Math.max(0, n);
+	return normalizeCellCount(fallback);
+}
+function findEnabledTabIndex(items, start, delta) {
+	const total = items.length;
+	if (total <= 0) return null;
+	for (let step = 1; step <= total; step++) {
+		const index = (start + step * delta + total) % total;
+		if (!items[index]?.disabled) return index;
+	}
+	return null;
+}
+function edgeEnabledTabIndex(items, edge) {
+	if (edge === "first") {
+		for (let index = 0; index < items.length; index++) if (!items[index]?.disabled) return index;
+		return null;
+	}
+	for (let index = items.length - 1; index >= 0; index--) if (!items[index]?.disabled) return index;
+	return null;
+}
+const TTabs = defineComponent({
+	name: "TTabs",
+	props: {
+		x: {
+			type: Number,
+			required: true
+		},
+		y: {
+			type: Number,
+			required: true
+		},
+		w: {
+			type: Number,
+			required: true
+		},
+		zIndex: {
+			type: Number,
+			default: 0
+		},
+		items: {
+			type: Array,
+			required: true
+		},
+		activeKey: {
+			type: String,
+			required: true
+		},
+		style: {
+			type: Object,
+			default: void 0
+		},
+		activeStyle: {
+			type: Object,
+			default: () => ({ inverse: true })
+		},
+		disabledStyle: {
+			type: Object,
+			default: () => ({ dim: true })
+		}
+	},
+	emits: {
+		"update:activeKey": (_key) => true,
+		change: (_item) => true
+	},
+	setup(props, { emit }) {
+		const { defaultStyle } = useTerminal();
+		const focusedKey = ref(null);
+		const baseStyle = computed(() => mergeStyle(defaultStyle.value, props.style));
+		function activate(item) {
+			if (item.disabled) return;
+			if (item.key === props.activeKey) return;
+			emit("update:activeKey", item.key);
+			emit("change", item);
+		}
+		function enabledTabIndexByKey(key) {
+			if (!key) return -1;
+			return props.items.findIndex((item) => item.key === key && !item.disabled);
+		}
+		function activateIndex(index, opts = {}) {
+			const item = props.items[index];
+			if (!item) return;
+			if (opts.trackFocus && !item.disabled) focusedKey.value = item.key;
+			activate(item);
+		}
+		function navigationBaseIndex(fallbackIndex) {
+			const activeIndex = enabledTabIndexByKey(props.activeKey);
+			return activeIndex >= 0 ? activeIndex : fallbackIndex;
+		}
+		function activationBaseIndex(fallbackIndex) {
+			const focusedIndex = enabledTabIndexByKey(focusedKey.value);
+			return focusedIndex >= 0 ? focusedIndex : fallbackIndex;
+		}
+		function onTabKeydown(event, index) {
+			const key = event?.key;
+			if (key === "Enter" || key === " ") {
+				event.preventDefault?.();
+				activateIndex(activationBaseIndex(index));
+				return;
+			}
+			const baseIndex = navigationBaseIndex(index);
+			const next = key === "ArrowRight" ? findEnabledTabIndex(props.items, baseIndex, 1) : key === "ArrowLeft" ? findEnabledTabIndex(props.items, baseIndex, -1) : key === "Home" ? edgeEnabledTabIndex(props.items, "first") : key === "End" ? edgeEnabledTabIndex(props.items, "last") : null;
+			if (next == null) return;
+			event.preventDefault?.();
+			activateIndex(next, { trackFocus: true });
+		}
+		return () => {
+			const width = normalizeCellCount(props.w);
+			let x = 0;
+			const children = [h(TText, {
+				x: 0,
+				y: 0,
+				w: width,
+				value: " ".repeat(width),
+				style: baseStyle.value
+			})];
+			for (let index = 0; index < props.items.length; index++) {
+				const item = props.items[index];
+				const label = item.badge == null ? item.label : `${item.label} ${item.badge}`;
+				const text = ` ${label} `;
+				const itemWidth = Math.min(width - x, textCellWidth(text));
+				if (itemWidth <= 0) break;
+				const active = item.key === props.activeKey;
+				children.push(h(TText, {
+					key: `text:${item.key}`,
+					x,
+					y: 0,
+					w: itemWidth,
+					value: fitCellText(text, itemWidth),
+					style: item.disabled ? mergeStyle(baseStyle.value, props.disabledStyle) : active ? mergeStyle(baseStyle.value, props.activeStyle) : baseStyle.value
+				}), h(TView, {
+					key: `hit:${item.key}`,
+					x,
+					y: 0,
+					w: itemWidth,
+					h: 1,
+					focusable: !item.disabled,
+					onClick: () => {
+						if (!item.disabled) focusedKey.value = item.key;
+						activate(item);
+					},
+					onFocus: () => {
+						if (!item.disabled) focusedKey.value = item.key;
+					},
+					onKeydown: (event) => onTabKeydown(event, index)
+				}));
+				x += itemWidth;
+			}
+			return h(TView, {
+				x: props.x,
+				y: props.y,
+				w: width,
+				h: 1,
+				zIndex: props.zIndex
+			}, () => children);
+		};
+	}
+});
+function resolvePaneSizes(sizes, minSizes, available) {
+	const count = sizes.length;
+	if (count === 0) return [];
+	if (available <= 0) return sizes.map(() => 0);
+	const mins = sizes.map((_, index) => normalizePaneSize(minSizes[index], 1));
+	const minTotal = mins.reduce((sum, min) => sum + min, 0);
+	if (minTotal >= available) {
+		if (minTotal === 0) return sizes.map(() => 0);
+		const out$1 = mins.map((min) => Math.floor(available * min / minTotal));
+		let remaining = available - out$1.reduce((sum, size) => sum + size, 0);
+		const order = mins.map((min, index) => ({
+			index,
+			fraction: available * min / minTotal - Math.floor(available * min / minTotal)
+		})).sort((a, b) => b.fraction - a.fraction || a.index - b.index);
+		for (let i = 0; remaining > 0 && i < order.length; i++, remaining--) out$1[order[i].index] += 1;
+		return out$1;
+	}
+	const out = sizes.map((size, index) => Math.max(mins[index], normalizePaneSize(size, mins[index])));
+	const used = out.reduce((sum, size) => sum + size, 0);
+	if (used > available) {
+		let overflow = used - available;
+		for (let i = out.length - 1; i >= 0 && overflow > 0; i--) {
+			const shrink = Math.min(out[i] - mins[i], overflow);
+			out[i] -= shrink;
+			overflow -= shrink;
+		}
+		return out;
+	}
+	if (used < available) out[out.length - 1] += available - used;
+	return out;
+}
+const TSplitPane = defineComponent({
+	name: "TSplitPane",
+	props: {
+		x: {
+			type: Number,
+			required: true
+		},
+		y: {
+			type: Number,
+			required: true
+		},
+		w: {
+			type: Number,
+			required: true
+		},
+		h: {
+			type: Number,
+			required: true
+		},
+		zIndex: {
+			type: Number,
+			default: 0
+		},
+		direction: {
+			type: String,
+			default: "horizontal"
+		},
+		sizes: {
+			type: Array,
+			required: true
+		},
+		minSizes: {
+			type: Array,
+			default: () => []
+		},
+		separatorStyle: {
+			type: Object,
+			default: () => ({ dim: true })
+		}
+	},
+	emits: {
+		"update:sizes": (_sizes) => true,
+		resize: (_sizes) => true
+	},
+	setup(props, { emit, slots }) {
+		const { defaultStyle } = useTerminal();
+		const panes = computed(() => {
+			const width = normalizeCellCount(props.w);
+			const height = normalizeCellCount(props.h);
+			const sizes = props.sizes.length ? props.sizes : [1];
+			const count = Math.max(1, sizes.length);
+			const total = props.direction === "horizontal" ? width : height;
+			const separatorTotal = Math.max(0, count - 1);
+			const available = Math.max(0, total - separatorTotal);
+			const paneSizes = resolvePaneSizes(sizes, props.minSizes, available);
+			let cursor = 0;
+			return paneSizes.map((paneSize) => {
+				const rect = props.direction === "horizontal" ? {
+					x: cursor,
+					y: 0,
+					w: paneSize,
+					h: height
+				} : {
+					x: 0,
+					y: cursor,
+					w: width,
+					h: paneSize
+				};
+				cursor += paneSize + 1;
+				return rect;
+			});
+		});
+		function resizeAt(index, delta) {
+			const count = Math.max(1, props.sizes.length);
+			const total = props.direction === "horizontal" ? normalizeCellCount(props.w) : normalizeCellCount(props.h);
+			const separatorTotal = Math.max(0, count - 1);
+			const available = Math.max(0, total - separatorTotal);
+			const sizes = props.sizes.length ? props.sizes : [1];
+			const next = resolvePaneSizes(sizes, props.minSizes, available);
+			if (index < 0 || index >= next.length - 1) return;
+			const left0 = next[index];
+			const right0 = next[index + 1];
+			const leftMin = normalizePaneSize(props.minSizes[index], 1);
+			const rightMin = normalizePaneSize(props.minSizes[index + 1], 1);
+			const applied = Math.max(leftMin - left0, Math.min(right0 - rightMin, delta));
+			next[index] = left0 + applied;
+			next[index + 1] = right0 - applied;
+			emit("update:sizes", next);
+			emit("resize", next);
+		}
+		return () => {
+			const paneChildren = slots.default?.({ panes: panes.value }) ?? [];
+			const separatorChildren = panes.value.slice(0, -1).map((pane, index) => {
+				const separator = props.direction === "horizontal" ? {
+					x: pane.x + pane.w,
+					y: 0,
+					w: 1,
+					h: pane.h,
+					text: "|"
+				} : {
+					x: 0,
+					y: pane.y + pane.h,
+					w: pane.w,
+					h: 1,
+					text: "-".repeat(pane.w)
+				};
+				return h(TView, {
+					key: `separator:${index}`,
+					x: separator.x,
+					y: separator.y,
+					w: separator.w,
+					h: separator.h,
+					focusable: true,
+					onKeydown: (event) => {
+						const forward = props.direction === "horizontal" ? event.key === "ArrowRight" : event.key === "ArrowDown";
+						const backward = props.direction === "horizontal" ? event.key === "ArrowLeft" : event.key === "ArrowUp";
+						if (!forward && !backward) return;
+						event.preventDefault?.();
+						resizeAt(index, forward ? 1 : -1);
+					}
+				}, () => props.direction === "horizontal" ? Array.from({ length: separator.h }, (_, row) => h(TText, {
+					key: `separator-line:${row}`,
+					x: 0,
+					y: row,
+					w: 1,
+					value: separator.text,
+					style: mergeStyle(defaultStyle.value, props.separatorStyle)
+				})) : h(TText, {
+					x: 0,
+					y: 0,
+					w: separator.w,
+					h: separator.h,
+					value: separator.text,
+					style: mergeStyle(defaultStyle.value, props.separatorStyle)
+				}));
+			});
+			const children = [...paneChildren, ...separatorChildren];
+			return h(TView, {
+				x: props.x,
+				y: props.y,
+				w: normalizeCellCount(props.w),
+				h: normalizeCellCount(props.h),
+				zIndex: props.zIndex
+			}, () => children);
+		};
+	}
+});
+
+//#endregion
+//#region src/vue/components/TInputBox.ts
+const TInputBox = defineComponent({
+	name: "TInputBox",
+	props: {
+		x: {
+			type: Number,
+			required: true
+		},
+		y: {
+			type: Number,
+			required: true
+		},
+		w: {
+			type: Number,
+			required: true
+		},
+		h: {
+			type: Number,
+			required: true
+		},
+		zIndex: {
+			type: Number,
+			default: 0
+		},
+		title: {
+			type: String,
+			default: ""
+		},
+		padding: {
+			type: Number,
+			default: 0
+		},
+		modelValue: {
+			type: String,
+			required: true
+		},
+		placeholder: {
+			type: String,
+			default: ""
+		},
+		style: {
+			type: Object,
+			default: void 0
+		},
+		autoFocus: {
+			type: Boolean,
+			default: false
+		},
+		plugins: {
+			type: Array,
+			default: () => []
+		},
+		cursorBlink: {
+			type: Boolean,
+			default: true
+		},
+		cursorShape: {
+			type: String,
+			default: "block"
+		},
+		blinkInterval: {
+			type: Number,
+			default: 500
+		}
+	},
+	emits: [
+		"update:modelValue",
+		"input",
+		"change",
+		"keydown",
+		"focus",
+		"blur"
+	],
+	setup(props, { emit }) {
+		const innerW = computed(() => Math.max(0, Math.floor(props.w) - 2 - Math.max(0, Math.floor(props.padding)) * 2));
+		const innerH = computed(() => Math.max(1, Math.floor(props.h) - 2 - Math.max(0, Math.floor(props.padding)) * 2));
+		return () => h(TBox, {
+			x: props.x,
+			y: props.y,
+			w: props.w,
+			h: props.h,
+			zIndex: props.zIndex,
+			border: true,
+			title: props.title,
+			padding: props.padding,
+			style: props.style
+		}, () => h(TInput, {
+			x: 0,
+			y: 0,
+			w: innerW.value,
+			h: innerH.value,
+			modelValue: props.modelValue,
+			"onUpdate:modelValue": (v) => emit("update:modelValue", v),
+			placeholder: props.placeholder,
+			style: props.style,
+			autoFocus: props.autoFocus,
+			plugins: props.plugins,
+			cursorBlink: props.cursorBlink,
+			cursorShape: props.cursorShape,
+			blinkInterval: props.blinkInterval,
+			onInput: (v) => emit("input", v),
+			onChange: (v) => emit("change", v),
+			onKeydown: (e) => emit("keydown", e),
+			onFocus: () => emit("focus"),
+			onBlur: () => emit("blur")
+		}));
+	}
+});
+
+//#endregion
+//#region src/vue/components/TJsonEditor.ts
+function indexToLineColumn(text, index) {
+	const capped = Math.max(0, Math.min(text.length, Math.floor(index)));
+	let line = 1;
+	let column = 1;
+	for (let i = 0; i < capped; i += 1) if (text[i] === "\n") {
+		line += 1;
+		column = 1;
+	} else column += 1;
+	return {
+		line,
+		column
+	};
+}
+function parseJsonErrorPosition(message) {
+	const m = /position\s+(\d+)/iu.exec(String(message ?? ""));
+	if (!m?.[1]) return null;
+	const n = Number(m[1]);
+	if (!Number.isFinite(n)) return null;
+	return Math.max(0, Math.floor(n));
+}
+function lintJsonText(input) {
+	const text = String(input ?? "");
+	if (!text.trim()) return { state: "idle" };
+	try {
+		JSON.parse(text);
+		return {
+			state: "success",
+			message: "JSON syntax OK"
+		};
+	} catch (error) {
+		const raw = error instanceof Error ? error.message : String(error);
+		const short = raw.replace(/\s*at position\s+\d.*$/iu, "").trim() || raw;
+		const pos = parseJsonErrorPosition(raw);
+		if (pos != null) {
+			const { line, column } = indexToLineColumn(text, pos);
+			return {
+				state: "error",
+				message: short,
+				line,
+				column
+			};
+		}
+		return {
+			state: "error",
+			message: short
+		};
+	}
+}
+const DEFAULT_GUIDE_COLORS = [
+	"cyanBright",
+	"yellowBright",
+	"greenBright",
+	"magentaBright",
+	"blueBright",
+	"redBright"
+];
+function computeJsonIndentGuideDepths(input) {
+	const lines = String(input ?? "").replace(/\r/g, "").split("\n");
+	const depths = [];
+	let depth = 0;
+	let inString = false;
+	let escaping = false;
+	for (const line of lines) {
+		const trimmed = line.trimStart();
+		const startsWithCloser = trimmed.startsWith("}") || trimmed.startsWith("]");
+		const visualDepth = startsWithCloser ? Math.max(0, depth - 1) : depth;
+		depths.push(visualDepth);
+		for (let i = 0; i < line.length; i += 1) {
+			const ch = line[i];
+			if (inString) {
+				if (escaping) {
+					escaping = false;
+					continue;
+				}
+				if (ch === "\\") {
+					escaping = true;
+					continue;
+				}
+				if (ch === "\"") inString = false;
+				continue;
+			}
+			if (ch === "\"") {
+				inString = true;
+				continue;
+			}
+			if (ch === "{" || ch === "[") {
+				depth += 1;
+				continue;
+			}
+			if (ch === "}" || ch === "]") depth = Math.max(0, depth - 1);
+		}
+	}
+	return depths;
+}
+const TJsonEditor = defineComponent({
+	name: "TJsonEditor",
+	props: {
+		x: {
+			type: Number,
+			required: true
+		},
+		y: {
+			type: Number,
+			required: true
+		},
+		w: {
+			type: Number,
+			required: true
+		},
+		h: {
+			type: Number,
+			default: 8
+		},
+		zIndex: {
+			type: Number,
+			default: 0
+		},
+		modelValue: {
+			type: String,
+			required: true
+		},
+		placeholder: {
+			type: String,
+			default: ""
+		},
+		style: {
+			type: Object,
+			default: void 0
+		},
+		showIndentGuides: {
+			type: Boolean,
+			default: true
+		},
+		indentSize: {
+			type: Number,
+			default: 2
+		},
+		guideColors: {
+			type: Array,
+			default: () => [...DEFAULT_GUIDE_COLORS]
+		},
+		autoFocus: {
+			type: Boolean,
+			default: false
+		},
+		cursorToEndOnFirstFocus: {
+			type: Boolean,
+			default: true
+		},
+		cursorToEndOnExternalUpdate: {
+			type: Boolean,
+			default: true
+		},
+		submitOnEnter: {
+			type: Boolean,
+			default: false
+		}
+	},
+	emits: [
+		"update:modelValue",
+		"keydown",
+		"focus",
+		"blur",
+		"undo",
+		"redo",
+		"lintChange",
+		"validationError"
+	],
+	setup(props, { emit }) {
+		let cachedLintText = null;
+		let cachedLintStatus = { state: "idle" };
+		let lastPublishedLintText = null;
+		function normalizeText(value) {
+			return String(value ?? "").replace(/\r/g, "");
+		}
+		function getLintStatus(value) {
+			const normalized = normalizeText(value);
+			if (cachedLintText === normalized) return cachedLintStatus;
+			cachedLintText = normalized;
+			cachedLintStatus = lintJsonText(normalized);
+			return cachedLintStatus;
+		}
+		function publishLint(value) {
+			const normalized = normalizeText(value);
+			if (lastPublishedLintText === normalized) return;
+			lastPublishedLintText = normalized;
+			emit("lintChange", getLintStatus(normalized));
+		}
+		watch(() => props.modelValue, (value) => {
+			publishLint(value);
+		}, { immediate: true });
+		return () => {
+			const text = normalizeText(props.modelValue);
+			const lines = text.split("\n");
+			const lint = getLintStatus(text);
+			const indentSize = Math.max(1, Math.floor(props.indentSize ?? 2));
+			const contentW = Math.max(0, Math.floor(props.w) - 2);
+			const visibleLines = Math.max(0, Math.floor(props.h));
+			const colors = props.guideColors?.length ? props.guideColors : DEFAULT_GUIDE_COLORS;
+			const guideNodes = [];
+			if (props.showIndentGuides && contentW > 0 && visibleLines > 0) {
+				const depths = computeJsonIndentGuideDepths(text);
+				const lineCount = Math.min(visibleLines, lines.length, depths.length);
+				for (let row = 0; row < lineCount; row += 1) {
+					const line = lines[row] ?? "";
+					const leadingSpaces = line.match(/^ +/u)?.[0]?.length ?? 0;
+					const depth = depths[row] ?? 0;
+					const guides = Math.min(depth, Math.floor(leadingSpaces / indentSize));
+					const maxGuidesByWidth = Math.floor(contentW / indentSize);
+					const guideCount = Math.min(guides, maxGuidesByWidth);
+					for (let i = 0; i < guideCount; i += 1) {
+						const x = props.x + 1 + i * indentSize;
+						const y = props.y + row;
+						const color = colors[i % colors.length] ?? "cyanBright";
+						guideNodes.push(h(TText, {
+							key: `guide-${row}-${i}`,
+							x,
+							y,
+							w: 1,
+							h: 1,
+							zIndex: (props.zIndex ?? 0) + 1,
+							value: "│",
+							clear: false,
+							style: {
+								fg: color,
+								dim: true
+							}
+						}));
+					}
+				}
+			}
+			const markerNodes = [];
+			if (lint.state === "error" && typeof lint.line === "number" && typeof lint.column === "number") {
+				const row = lint.line - 1;
+				const col = lint.column - 1;
+				if (row >= 0 && row < visibleLines && col >= 0 && col < contentW) {
+					const line = lines[row] ?? "";
+					const ch = line[col] ?? " ";
+					markerNodes.push(h(TText, {
+						key: `marker-${row}-${col}`,
+						x: props.x + 1 + col,
+						y: props.y + row,
+						w: 1,
+						h: 1,
+						zIndex: (props.zIndex ?? 0) + 2,
+						value: ch,
+						clear: false,
+						style: {
+							fg: "redBright",
+							bold: true,
+							underline: true
+						}
+					}));
+				}
+			}
+			const inputNode = h(TInput, {
+				x: props.x,
+				y: props.y,
+				w: props.w,
+				h: props.h,
+				zIndex: props.zIndex,
+				modelValue: props.modelValue,
+				"onUpdate:modelValue": (v) => {
+					emit("update:modelValue", v);
+					publishLint(v);
+				},
+				placeholder: props.placeholder,
+				style: props.style,
+				autoFocus: props.autoFocus,
+				cursorToEndOnFirstFocus: props.cursorToEndOnFirstFocus,
+				cursorToEndOnExternalUpdate: props.cursorToEndOnExternalUpdate,
+				submitOnEnter: props.submitOnEnter,
+				onKeydown: (e) => {
+					emit("keydown", e);
+					if (e?.defaultPrevented) return;
+					const isShortcut = Boolean((e.metaKey || e.ctrlKey) && !e.altKey);
+					if (!isShortcut) return;
+					if (e.key === "z" || e.key === "Z") {
+						e.preventDefault?.();
+						e.stopPropagation?.();
+						if (e.shiftKey) emit("redo");
+						else emit("undo");
+						return;
+					}
+					if (e.key === "y" || e.key === "Y") {
+						e.preventDefault?.();
+						e.stopPropagation?.();
+						emit("redo");
+					}
+				},
+				onFocus: () => emit("focus"),
+				onBlur: () => emit("blur"),
+				onValidationError: (info) => emit("validationError", info)
+			});
+			return h("div", null, [
+				inputNode,
+				...guideNodes,
+				...markerNodes
+			]);
+		};
+	}
+});
+
+//#endregion
+//#region src/vue/components/TMultilineModal.ts
+const BORDER = {
+	tl: "┌",
+	tr: "┐",
+	bl: "└",
+	br: "┘",
+	h: "─",
+	v: "│"
+};
+const TMultilineModal = defineComponent({
+	name: "TMultilineModal",
+	props: {
+		visible: {
+			type: Boolean,
+			required: true
+		},
+		content: {
+			type: String,
+			required: true
+		},
+		title: {
+			type: String,
+			default: "Multiline Text"
+		},
+		style: {
+			type: Object,
+			default: void 0
+		},
+		zIndex: {
+			type: Number,
+			default: 1e3
+		}
+	},
+	emits: ["close"],
+	setup(props, { emit }) {
+		const { terminal, scheduler, defaultStyle, events } = useTerminal();
+		const layout = useLayout();
+		const { visible: parentVisible, rootProps } = useVisibility();
+		const parentEventZ = inject(EventZIndexContextKey, computed(() => 0));
+		const eventZ = computed(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0));
+		const isVisible = computed(() => parentVisible.value && props.visible);
+		const modalRect = computed(() => {
+			const size = terminal.size();
+			const termW = size.cols;
+			const termH = size.rows;
+			const w = Math.floor(termW * .8);
+			const h$1 = Math.floor(termH * .7);
+			const x = Math.floor((termW - w) / 2);
+			const y = Math.floor((termH - h$1) / 2);
+			return translateRect({
+				x,
+				y,
+				w,
+				h: h$1
+			}, layout.originX, layout.originY);
+		});
+		const contentLines = computed(() => {
+			const text = sanitizeTextBlock(String(props.content || ""));
+			return text.split("\n");
+		});
+		const scrollY = computed(() => 0);
+		function onKeydown(e) {
+			e.preventDefault();
+			e.stopPropagation();
+			if (e.key === "Escape") {
+				emit("close");
+				scheduler.invalidate();
+			}
+		}
+		const backdropNode = useTerminalNode(() => ({
+			rect: isVisible.value ? {
+				x: 0,
+				y: 0,
+				w: terminal.size().cols,
+				h: terminal.size().rows
+			} : {
+				x: 0,
+				y: 0,
+				w: 0,
+				h: 0
+			},
+			zIndex: eventZ.value,
+			visible: isVisible.value,
+			focusable: true,
+			handlers: {
+				click: (e) => {
+					e.preventDefault();
+					e.stopPropagation();
+					emit("close");
+					scheduler.invalidate();
+				},
+				keydown: onKeydown
+			}
+		}));
+		const contentNode = useTerminalNode(() => ({
+			rect: isVisible.value ? modalRect.value : {
+				x: 0,
+				y: 0,
+				w: 0,
+				h: 0
+			},
+			zIndex: eventZ.value + 1,
+			visible: isVisible.value,
+			focusable: true,
+			handlers: {
+				click: (e) => {
+					e.preventDefault();
+					e.stopPropagation();
+					const manager = events.value;
+					const nodeId = contentNode.id.value;
+					if (manager && nodeId) manager.focus(nodeId);
+				},
+				keydown: onKeydown
+			}
+		}));
+		watchEffect(() => {
+			if (!isVisible.value) return;
+			const manager = events.value;
+			const nodeId = contentNode.id.value || backdropNode.id.value;
+			if (!manager || !nodeId) return;
+			manager.focus(nodeId);
+		});
+		useRenderNode(() => ({
+			zIndex: props.zIndex,
+			rect: isVisible.value ? {
+				x: 0,
+				y: 0,
+				w: terminal.size().cols,
+				h: terminal.size().rows
+			} : {
+				x: 0,
+				y: 0,
+				w: 0,
+				h: 0
+			},
+			deps: [
+				isVisible.value,
+				modalRect.value,
+				props.content,
+				props.title,
+				props.style,
+				defaultStyle.value
+			],
+			paint: () => {
+				if (!isVisible.value) return;
+				const snapshot = terminal.size();
+				const style = props.style ?? defaultStyle.value;
+				const backdropStyle = {
+					...style,
+					bg: defaultStyle.value.bg ?? style.bg,
+					dim: true
+				};
+				const backdropRow = spaces(snapshot.cols);
+				for (let y = 0; y < snapshot.rows; y++) terminal.write(backdropRow, {
+					x: 0,
+					y,
+					style: backdropStyle
+				});
+				const r = modalRect.value;
+				const fallbackFg = style.fg ?? defaultStyle.value.fg;
+				const fallbackBg = style.bg ?? defaultStyle.value.bg;
+				const borderStyle = {
+					...style,
+					fg: defaultStyle.value.fg ?? style.fg
+				};
+				const contentStyle = {
+					...style,
+					fg: fallbackFg,
+					bg: fallbackBg
+				};
+				const footerStyle = {
+					...style,
+					dim: true
+				};
+				terminal.put(r.x, r.y, BORDER.tl, borderStyle);
+				terminal.put(r.x + r.w - 1, r.y, BORDER.tr, borderStyle);
+				terminal.put(r.x, r.y + r.h - 1, BORDER.bl, borderStyle);
+				terminal.put(r.x + r.w - 1, r.y + r.h - 1, BORDER.br, borderStyle);
+				const innerW = Math.max(0, r.w - 2);
+				const titleText = ` ${sanitizeInlineText(props.title)} `;
+				const titleW = Math.min(titleText.length, innerW);
+				const titleX = r.x + 1;
+				terminal.write(titleText.slice(0, titleW), {
+					x: titleX,
+					y: r.y,
+					style: borderStyle
+				});
+				const remainingTop = innerW - titleW;
+				if (remainingTop > 0) terminal.write(BORDER.h.repeat(remainingTop), {
+					x: titleX + titleW,
+					y: r.y,
+					style: borderStyle
+				});
+				const footer = " Press ESC to close ";
+				const footerW = Math.min(footer.length, innerW);
+				const footerX = r.x + Math.floor((r.w - footerW) / 2);
+				const leftBorder = footerX - r.x - 1;
+				const rightBorder = innerW - leftBorder - footerW;
+				if (leftBorder > 0) terminal.write(BORDER.h.repeat(leftBorder), {
+					x: r.x + 1,
+					y: r.y + r.h - 1,
+					style: borderStyle
+				});
+				terminal.write(footer, {
+					x: footerX,
+					y: r.y + r.h - 1,
+					style: footerStyle
+				});
+				if (rightBorder > 0) terminal.write(BORDER.h.repeat(rightBorder), {
+					x: footerX + footerW,
+					y: r.y + r.h - 1,
+					style: borderStyle
+				});
+				for (let y = 1; y < r.h - 1; y++) {
+					terminal.put(r.x, r.y + y, BORDER.v, borderStyle);
+					terminal.put(r.x + r.w - 1, r.y + y, BORDER.v, borderStyle);
+				}
+				const contentH = Math.max(0, r.h - 2);
+				const lines = contentLines.value;
+				const startLine = scrollY.value;
+				for (let row = 0; row < contentH; row++) {
+					const lineIndex = startLine + row;
+					const line = lines[lineIndex] ?? "";
+					const visible = sliceByCells(line, innerW);
+					const padded = padEndByCells(visible, innerW);
+					terminal.write(padded, {
+						x: r.x + 1,
+						y: r.y + 1 + row,
+						style: contentStyle
+					});
+				}
+			}
+		}));
+		return () => h("span", rootProps);
+	}
+});
+
+//#endregion
+//#region src/vue/components/TNavigation.ts
+const TKeyHint = defineComponent({
+	name: "TKeyHint",
+	props: {
+		x: {
+			type: Number,
+			required: true
+		},
+		y: {
+			type: Number,
+			required: true
+		},
+		w: {
+			type: Number,
+			default: void 0
+		},
+		zIndex: {
+			type: Number,
+			default: 0
+		},
+		combo: {
+			type: String,
+			required: true
+		},
+		label: {
+			type: String,
+			required: true
+		},
+		style: {
+			type: Object,
+			default: void 0
+		},
+		comboStyle: {
+			type: Object,
+			default: () => ({ inverse: true })
+		}
+	},
+	setup(props) {
+		const { defaultStyle } = useTerminal();
+		const baseStyle = computed(() => mergeStyle(defaultStyle.value, props.style));
+		const comboStyle = computed(() => mergeStyle(baseStyle.value, props.comboStyle));
+		return () => {
+			const comboW = textCellWidth(props.combo);
+			const gap = props.label ? 1 : 0;
+			const comboRenderW = props.w == null ? comboW : Math.min(comboW, Math.max(0, props.w));
+			const gapW = props.w == null ? gap : Math.min(gap, Math.max(0, props.w - comboW));
+			const labelW = props.w == null ? void 0 : Math.max(0, props.w - comboW - gap);
+			const children = [h(TText, {
+				x: props.x,
+				y: props.y,
+				zIndex: props.zIndex,
+				w: comboRenderW,
+				value: props.combo,
+				style: comboStyle.value
+			})];
+			if (gapW > 0) children.push(h(TText, {
+				x: props.x + comboW,
+				y: props.y,
+				zIndex: props.zIndex,
+				w: gapW,
+				value: " ",
+				style: baseStyle.value
+			}));
+			children.push(h(TText, {
+				x: props.x + comboW + gap,
+				y: props.y,
+				zIndex: props.zIndex,
+				w: labelW,
+				value: props.label,
+				style: baseStyle.value
+			}));
+			return children;
+		};
+	}
+});
+const TBreadcrumb = defineComponent({
+	name: "TBreadcrumb",
+	props: {
+		x: {
+			type: Number,
+			required: true
+		},
+		y: {
+			type: Number,
+			required: true
+		},
+		w: {
+			type: Number,
+			required: true
+		},
+		zIndex: {
+			type: Number,
+			default: 0
+		},
+		items: {
+			type: Array,
+			required: true
+		},
+		separator: {
+			type: String,
+			default: "/"
+		},
+		style: {
+			type: Object,
+			default: void 0
+		},
+		activeStyle: {
+			type: Object,
+			default: () => ({ bold: true })
+		},
+		disabledStyle: {
+			type: Object,
+			default: () => ({ dim: true })
+		}
+	},
+	emits: { select: (_payload) => true },
+	setup(props, { emit }) {
+		const { defaultStyle } = useTerminal();
+		const baseStyle = computed(() => mergeStyle(defaultStyle.value, props.style));
+		return () => {
+			let x = 0;
+			const children = [];
+			for (let index = 0; index < props.items.length; index++) {
+				const item = props.items[index];
+				const suffix = index < props.items.length - 1 ? ` ${props.separator} ` : "";
+				const text = `${item.label}${suffix}`;
+				const remaining = props.w - x;
+				const cellW = textCellWidth(text);
+				const w = Math.min(remaining, cellW);
+				if (w <= 0) break;
+				children.push(h(TView, {
+					key: item.id,
+					x,
+					y: 0,
+					w,
+					h: 1,
+					focusable: !item.disabled,
+					onClick: () => {
+						if (!item.disabled) emit("select", {
+							item,
+							index
+						});
+					},
+					onKeydown: (event) => {
+						if (item.disabled || event.key !== "Enter" && event.key !== " ") return;
+						event.preventDefault?.();
+						emit("select", {
+							item,
+							index
+						});
+					}
+				}, () => h(TText, {
+					x: 0,
+					y: 0,
+					w,
+					value: fitCellText(text, w),
+					style: item.disabled ? mergeStyle(baseStyle.value, props.disabledStyle) : index === props.items.length - 1 ? mergeStyle(baseStyle.value, props.activeStyle) : baseStyle.value
+				})));
+				x += w;
+				if (w < cellW) break;
+			}
+			return h(TView, {
+				x: props.x,
+				y: props.y,
+				w: props.w,
+				h: 1,
+				zIndex: props.zIndex
+			}, () => children);
+		};
+	}
+});
+const TStatusBar = defineComponent({
+	name: "TStatusBar",
+	props: {
+		x: {
+			type: Number,
+			required: true
+		},
+		y: {
+			type: Number,
+			required: true
+		},
+		w: {
+			type: Number,
+			required: true
+		},
+		zIndex: {
+			type: Number,
+			default: 0
+		},
+		left: {
+			type: String,
+			default: ""
+		},
+		center: {
+			type: String,
+			default: ""
+		},
+		right: {
+			type: String,
+			default: ""
+		},
+		style: {
+			type: Object,
+			default: () => ({ inverse: true })
+		}
+	},
+	setup(props, { slots }) {
+		const { defaultStyle } = useTerminal();
+		const baseStyle = computed(() => mergeStyle(defaultStyle.value, props.style));
+		return () => {
+			const children = slots.default?.();
+			if (children?.length) return h(TView, {
+				x: props.x,
+				y: props.y,
+				w: props.w,
+				h: 1,
+				zIndex: props.zIndex
+			}, () => children);
+			const leftW = Math.max(0, Math.floor(props.w / 3));
+			const rightW = leftW;
+			const centerW = Math.max(0, props.w - leftW - rightW);
+			return h(TView, {
+				x: props.x,
+				y: props.y,
+				w: props.w,
+				h: 1,
+				zIndex: props.zIndex
+			}, () => [
+				h(TText, {
+					x: 0,
+					y: 0,
+					w: leftW,
+					value: props.left,
+					style: baseStyle.value
+				}),
+				h(TText, {
+					x: leftW,
+					y: 0,
+					w: centerW,
+					value: props.center,
+					style: baseStyle.value
+				}),
+				h(TText, {
+					x: leftW + centerW,
+					y: 0,
+					w: rightW,
+					value: props.right,
+					style: baseStyle.value
+				})
+			]);
+		};
+	}
+});
+
+//#endregion
+//#region src/vue/components/TOverlay.ts
+const TContextMenu = defineComponent({
+	name: "TContextMenu",
+	props: {
+		modelValue: {
+			type: Boolean,
+			required: true
+		},
+		x: {
+			type: Number,
+			required: true
+		},
+		y: {
+			type: Number,
+			required: true
+		},
+		w: {
+			type: Number,
+			default: 24
+		},
+		zIndex: {
+			type: Number,
+			default: 20
+		},
+		items: {
+			type: Array,
+			required: true
+		},
+		selectedIndex: {
+			type: Number,
+			default: void 0
+		},
+		closeOnOutside: {
+			type: Boolean,
+			default: true
+		},
+		style: {
+			type: Object,
+			default: void 0
+		},
+		activeStyle: {
+			type: Object,
+			default: () => ({ inverse: true })
+		},
+		disabledStyle: {
+			type: Object,
+			default: () => ({ dim: true })
+		}
+	},
+	emits: {
+		"update:modelValue": (_value) => true,
+		"update:selectedIndex": (_index) => true,
+		select: (_payload) => true,
+		close: () => true
+	},
+	setup(props, { emit }) {
+		const { terminal, defaultStyle } = useTerminal();
+		const innerSelectedIndex = ref(0);
+		const baseStyle = computed(() => mergeStyle(defaultStyle.value, props.style));
+		function close() {
+			emit("update:modelValue", false);
+			emit("close");
+		}
+		function select(index) {
+			const item = props.items[index];
+			if (!item || item.disabled) return;
+			emit("select", {
+				item,
+				index
+			});
+			close();
+		}
+		function firstEnabledIndex() {
+			return props.items.findIndex((item) => !item.disabled);
+		}
+		function selectedIndex() {
+			if (!props.items.length) return 0;
+			const clamped = clamp$1(props.selectedIndex ?? innerSelectedIndex.value, 0, props.items.length - 1);
+			if (!props.items[clamped]?.disabled) return clamped;
+			const first = firstEnabledIndex();
+			return first >= 0 ? first : clamped;
+		}
+		function nextEnabledIndex(index, direction) {
+			let next = index + direction;
+			while (next >= 0 && next < props.items.length) {
+				if (!props.items[next]?.disabled) return next;
+				next += direction;
+			}
+			return index;
+		}
+		function setSelected(index) {
+			innerSelectedIndex.value = index;
+			emit("update:selectedIndex", index);
+		}
+		function handleMenuKeydown(event) {
+			if (event.key === "Escape") {
+				event.preventDefault?.();
+				close();
+			} else if (event.key === "Enter") {
+				event.preventDefault?.();
+				select(selectedIndex());
+			} else if (event.key === "ArrowDown") {
+				event.preventDefault?.();
+				setSelected(nextEnabledIndex(selectedIndex(), 1));
+			} else if (event.key === "ArrowUp") {
+				event.preventDefault?.();
+				setSelected(nextEnabledIndex(selectedIndex(), -1));
+			}
+		}
+		function closeFromOutside(event) {
+			event.preventDefault?.();
+			event.stopPropagation?.();
+			close();
+		}
+		function stopInsideClick(event) {
+			event.stopPropagation?.();
+		}
+		return () => {
+			if (!props.modelValue) return null;
+			const size = terminal.size();
+			const hgt = Math.max(2, props.items.length + 2);
+			const activeIndex = selectedIndex();
+			const hasEnabledItem = props.items.some((item) => !item.disabled);
+			const menu = h(TView, {
+				key: "menu",
+				x: props.x,
+				y: props.y,
+				w: props.w,
+				h: hgt,
+				zIndex: props.closeOnOutside ? props.zIndex + 1 : props.zIndex,
+				focusable: !hasEnabledItem,
+				autoFocus: !hasEnabledItem,
+				onClick: props.closeOnOutside ? stopInsideClick : void 0,
+				onKeydown: handleMenuKeydown
+			}, () => h(TBox, {
+				x: 0,
+				y: 0,
+				w: props.w,
+				h: hgt,
+				style: baseStyle.value
+			}, () => props.items.map((item, index) => {
+				const active = index === activeIndex;
+				const text = item.shortcut ? `${item.label} ${item.shortcut}` : item.label;
+				return h(TView, {
+					key: item.id,
+					x: 0,
+					y: index,
+					w: Math.max(1, props.w - 2),
+					h: 1,
+					focusable: !item.disabled,
+					autoFocus: active && !item.disabled,
+					onClick: () => select(index)
+				}, () => h(TText, {
+					x: 0,
+					y: 0,
+					w: Math.max(1, props.w - 2),
+					value: fitCellText(text, Math.max(1, props.w - 2)),
+					style: item.disabled ? mergeStyle(baseStyle.value, props.disabledStyle) : active ? mergeStyle(baseStyle.value, props.activeStyle) : baseStyle.value
+				}));
+			})));
+			if (!props.closeOnOutside) return menu;
+			return [h(TView, {
+				key: "outside",
+				x: 0,
+				y: 0,
+				w: size.cols,
+				h: size.rows,
+				zIndex: props.zIndex,
+				onClick: closeFromOutside
+			}), menu];
+		};
+	}
+});
+const TPopover = defineComponent({
+	name: "TPopover",
+	props: {
+		modelValue: {
+			type: Boolean,
+			required: true
+		},
+		x: {
+			type: Number,
+			required: true
+		},
+		y: {
+			type: Number,
+			required: true
+		},
+		w: {
+			type: Number,
+			required: true
+		},
+		h: {
+			type: Number,
+			required: true
+		},
+		zIndex: {
+			type: Number,
+			default: 15
+		},
+		title: {
+			type: String,
+			default: ""
+		},
+		content: {
+			type: String,
+			default: ""
+		},
+		style: {
+			type: Object,
+			default: void 0
+		},
+		contentStyle: {
+			type: Object,
+			default: void 0
+		}
+	},
+	setup(props, { slots }) {
+		const { defaultStyle } = useTerminal();
+		const baseStyle = computed(() => mergeStyle(defaultStyle.value, props.style));
+		const contentStyle = computed(() => mergeStyle(defaultStyle.value, props.contentStyle));
+		return () => props.modelValue ? h(TBox, {
+			x: props.x,
+			y: props.y,
+			w: props.w,
+			h: props.h,
+			zIndex: props.zIndex,
+			title: props.title,
+			style: baseStyle.value
+		}, () => slots.default?.() ?? h(TText, {
+			x: 0,
+			y: 0,
+			w: Math.max(1, props.w - 2),
+			h: Math.max(1, props.h - 2),
+			value: props.content,
+			wrap: true,
+			style: contentStyle.value
+		})) : null;
+	}
+});
+const TTooltip = defineComponent({
+	name: "TTooltip",
+	props: {
+		modelValue: {
+			type: Boolean,
+			default: true
+		},
+		x: {
+			type: Number,
+			required: true
+		},
+		y: {
+			type: Number,
+			required: true
+		},
+		w: {
+			type: Number,
+			default: void 0
+		},
+		zIndex: {
+			type: Number,
+			default: 30
+		},
+		content: {
+			type: String,
+			required: true
+		},
+		style: {
+			type: Object,
+			default: () => ({ inverse: true })
+		}
+	},
+	setup(props) {
+		const { defaultStyle } = useTerminal();
+		const baseStyle = computed(() => mergeStyle(defaultStyle.value, props.style));
+		return () => props.modelValue ? h(TText, {
+			x: props.x,
+			y: props.y,
+			zIndex: props.zIndex,
+			w: props.w,
+			value: props.content,
+			style: baseStyle.value
+		}) : null;
+	}
+});
+
+//#endregion
+//#region src/vue/components/TPathPicker.ts
+function clamp$2(n, min, max) {
+	return Math.max(min, Math.min(max, n));
+}
+function getWheelScrollInput(e) {
+	const deltaY = Number(e.deltaY ?? 0);
+	const deltaMode = typeof e.deltaMode === "number" ? e.deltaMode : void 0;
+	if (Number.isInteger(deltaY) && deltaY !== 0 && Math.abs(deltaY) >= 100 && Math.abs(deltaY) % 100 === 0 && deltaMode == null) return {
+		deltaY: deltaY / 100,
+		mode: "line"
+	};
+	if (deltaMode === 1) return {
+		deltaY,
+		mode: "line"
+	};
+	if (deltaMode === 0) return {
+		deltaY,
+		mode: "pixel"
+	};
+	return {
+		deltaY,
+		mode: "auto"
+	};
+}
+function isCtrlLike(e) {
+	return Boolean(e.ctrlKey || e.metaKey);
+}
+function computeHighlightRanges(text, query) {
+	const q = query.trim().toLowerCase();
+	if (!q) return [];
+	const t = text.toLowerCase();
+	const idx = t.indexOf(q);
+	if (idx >= 0) return [{
+		start: idx,
+		end: idx + q.length
+	}];
+	const positions = [];
+	let qi = 0;
+	for (let i = 0; i < t.length && qi < q.length; i++) if (t[i] === q[qi]) {
+		positions.push(i);
+		qi++;
+	}
+	if (qi < q.length) return [];
+	const ranges = [];
+	let start = positions[0];
+	let prev = positions[0];
+	for (let i = 1; i < positions.length; i++) {
+		const pos = positions[i];
+		if (pos === prev + 1) {
+			prev = pos;
+			continue;
+		}
+		ranges.push({
+			start,
+			end: prev + 1
+		});
+		start = pos;
+		prev = pos;
+	}
+	ranges.push({
+		start,
+		end: prev + 1
+	});
+	return ranges;
+}
+function writeHighlightedText(opts) {
+	const { text, ranges, x, y, maxCells, baseStyle, highlightStyle, terminal } = opts;
+	const safeMax = Math.max(0, Math.floor(maxCells));
+	if (!text || safeMax <= 0) return 0;
+	let rangeIndex = 0;
+	let activeRange = ranges[rangeIndex];
+	let cellPos = 0;
+	let cursorX = x;
+	let buffer = "";
+	let currentStyle = baseStyle;
+	const flush = () => {
+		if (!buffer) return;
+		terminal.write(buffer, {
+			x: cursorX,
+			y,
+			style: currentStyle
+		});
+		cursorX += textCellWidth(buffer);
+		buffer = "";
+	};
+	for (let i = 0; i < text.length && cellPos < safeMax;) {
+		const code = text.charCodeAt(i);
+		const seg = code <= 127 ? text[i] : String.fromCodePoint(text.codePointAt(i) ?? 0);
+		const segLen = seg.length;
+		const segWidth = charCellWidth(seg);
+		if (cellPos + segWidth > safeMax) break;
+		while (activeRange && activeRange.end <= i) {
+			rangeIndex++;
+			activeRange = ranges[rangeIndex];
+		}
+		const isHighlighted = Boolean(activeRange && i < activeRange.end && i + segLen > activeRange.start);
+		const nextStyle = isHighlighted ? highlightStyle : baseStyle;
+		if (nextStyle !== currentStyle) {
+			flush();
+			currentStyle = nextStyle;
+		}
+		buffer += seg;
+		cellPos += segWidth;
+		i += segLen;
+	}
+	flush();
+	return cellPos;
+}
+const TPathPicker = defineComponent({
+	name: "TPathPicker",
+	props: {
+		x: {
+			type: Number,
+			required: true
+		},
+		y: {
+			type: Number,
+			required: true
+		},
+		w: {
+			type: Number,
+			required: true
+		},
+		h: {
+			type: Number,
+			required: true
+		},
+		zIndex: {
+			type: Number,
+			default: 0
+		},
+		workspace: {
+			type: String,
+			required: true
+		},
+		mode: {
+			type: String,
+			default: "any"
+		},
+		modelValue: {
+			type: String,
+			required: true
+		},
+		placeholder: {
+			type: String,
+			default: ""
+		},
+		style: {
+			type: Object,
+			default: void 0
+		},
+		inputStyle: {
+			type: Object,
+			default: void 0
+		},
+		activeStyle: {
+			type: Object,
+			default: void 0
+		},
+		matchStyle: {
+			type: Object,
+			default: void 0
+		},
+		autoFocus: {
+			type: Boolean,
+			default: false
+		},
+		showHidden: {
+			type: Boolean,
+			default: false
+		},
+		maxSuggestions: {
+			type: Number,
+			default: 50
+		},
+		provider: {
+			type: Object,
+			default: void 0
+		}
+	},
+	emits: [
+		"update:modelValue",
+		"select",
+		"invalid",
+		"keydown",
+		"focus",
+		"blur"
+	],
+	setup(props, { emit }) {
+		const { terminal, scheduler, defaultStyle } = useTerminal();
+		const layout = useLayout();
+		const { visible, rootProps } = useVisibility();
+		const injectedProvider = inject(TPathPickerProviderContextKey, null);
+		const parentEventZ = inject(EventZIndexContextKey, computed(() => 0));
+		const eventZ = computed(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0));
+		const provider = computed(() => props.provider ?? injectedProvider?.value ?? null);
+		const suggestions = ref([]);
+		const active = ref(0);
+		const scrollTop = ref(0);
+		const error = ref(null);
+		const inputH = 1;
+		const listH = computed(() => Math.max(0, Math.floor(props.h) - inputH));
+		const absListRect = computed(() => {
+			const raw = {
+				x: props.x,
+				y: props.y + inputH,
+				w: props.w,
+				h: listH.value
+			};
+			const translated = translateRect(raw, layout.originX, layout.originY);
+			if (!layout.clipRect) return translated;
+			return intersectRect(translated, layout.clipRect) ?? {
+				x: 0,
+				y: 0,
+				w: 0,
+				h: 0
+			};
+		});
+		function ensureActiveVisible() {
+			const h$1 = Math.max(0, listH.value);
+			if (h$1 <= 0) {
+				scrollTop.value = 0;
+				return;
+			}
+			const maxTop = Math.max(0, suggestions.value.length - h$1);
+			scrollTop.value = clamp$2(scrollTop.value, 0, maxTop);
+			if (active.value < scrollTop.value) scrollTop.value = active.value;
+			else if (active.value >= scrollTop.value + h$1) scrollTop.value = clamp$2(active.value - (h$1 - 1), 0, maxTop);
+		}
+		watch([
+			() => active.value,
+			() => suggestions.value.length,
+			() => listH.value
+		], () => {
+			ensureActiveVisible();
+		});
+		let refreshSeq = 0;
+		async function refresh(seq) {
+			const currentProvider = provider.value;
+			if (!currentProvider) {
+				if (seq !== refreshSeq) return;
+				suggestions.value = [];
+				active.value = 0;
+				scheduler.invalidate();
+				return;
+			}
+			const limit = Math.max(0, Math.floor(props.maxSuggestions));
+			const res = currentProvider.suggest ? await currentProvider.suggest({
+				workspaceAbs: props.workspace,
+				input: props.modelValue,
+				mode: props.mode,
+				max: limit,
+				showHidden: props.showHidden,
+				gitignore: "nonBlocking"
+			}) : await suggestPaths({
+				workspaceAbs: props.workspace,
+				input: props.modelValue,
+				mode: props.mode,
+				max: limit,
+				showHidden: props.showHidden,
+				listDir: currentProvider.listDir
+			});
+			if (seq !== refreshSeq) return;
+			suggestions.value = res.suggestions;
+			active.value = clamp$2(active.value, 0, Math.max(0, suggestions.value.length - 1));
+			ensureActiveVisible();
+			scheduler.invalidate();
+		}
+		watchEffect(() => {
+			if (!visible.value) return;
+			props.workspace;
+			props.mode;
+			props.showHidden;
+			props.modelValue;
+			listH.value;
+			error.value = null;
+			const seq = ++refreshSeq;
+			refresh(seq).catch((e) => {
+				if (seq !== refreshSeq) return;
+				suggestions.value = [];
+				error.value = e instanceof Error ? e.message : String(e);
+				scheduler.invalidate();
+			});
+		});
+		function setValue(next) {
+			const cleaned = next.replace(/\r/g, "").replace(/\n/g, " ");
+			emit("update:modelValue", cleaned);
+		}
+		function moveActive(delta) {
+			const len = suggestions.value.length;
+			if (len <= 0) return;
+			const next = clamp$2(active.value + delta, 0, len - 1);
+			if (next !== active.value) {
+				active.value = next;
+				ensureActiveVisible();
+				scheduler.invalidate();
+			}
+		}
+		function applyCompletion() {
+			const s = suggestions.value[active.value];
+			if (!s) return;
+			setValue(s.completion);
+		}
+		async function trySelect(absPath) {
+			const currentProvider = provider.value;
+			if (!currentProvider) {
+				error.value = "Path provider unavailable";
+				emit("invalid", {
+					reason: "provider_missing",
+					absPath
+				});
+				scheduler.invalidate();
+				return;
+			}
+			const stat = await currentProvider.stat(absPath);
+			if (!stat.exists) {
+				error.value = "Not found";
+				emit("invalid", {
+					reason: "not_found",
+					absPath
+				});
+				scheduler.invalidate();
+				return;
+			}
+			if (props.mode === "file" && stat.kind === "directory") {
+				const abs = normalizePath(absPath);
+				const workspaceAbs = normalizePath(props.workspace);
+				const rel = abs === workspaceAbs ? "" : abs.startsWith(`${workspaceAbs}/`) ? abs.slice(workspaceAbs.length + 1) : abs;
+				setValue(rel ? `${rel}/` : "");
+				error.value = null;
+				scheduler.invalidate();
+				return;
+			}
+			if (props.mode === "file" && stat.kind !== "file") {
+				error.value = "Not a file";
+				emit("invalid", {
+					reason: "not_file",
+					absPath
+				});
+				scheduler.invalidate();
+				return;
+			}
+			if (props.mode === "directory" && stat.kind !== "directory") {
+				error.value = "Not a directory";
+				emit("invalid", {
+					reason: "not_directory",
+					absPath
+				});
+				scheduler.invalidate();
+				return;
+			}
+			emit("select", stripTrailingSlash(absPath));
+		}
+		async function onCommit() {
+			const currentProvider = provider.value;
+			const typedAbs = currentProvider?.resolvePath ? await currentProvider.resolvePath(props.workspace, props.modelValue) : resolveUserPath(props.workspace, props.modelValue);
+			if (!currentProvider) {
+				error.value = "Path provider unavailable";
+				emit("invalid", {
+					reason: "provider_missing",
+					absPath: typedAbs
+				});
+				scheduler.invalidate();
+				return;
+			}
+			const typedStat = await currentProvider.stat(typedAbs);
+			if (typedStat.exists) {
+				if (props.mode === "file" && typedStat.kind === "directory") {
+					const base = props.modelValue.replace(/\r/g, "").replace(/\\/g, "/");
+					const next = base.endsWith("/") ? base : `${base}/`;
+					setValue(next);
+					error.value = null;
+					scheduler.invalidate();
+					return;
+				}
+				await trySelect(typedAbs);
+				return;
+			}
+			const s = suggestions.value[active.value];
+			if (s) {
+				if (props.mode === "file" && s.kind === "directory") {
+					setValue(s.completion);
+					error.value = null;
+					scheduler.invalidate();
+					return;
+				}
+				await trySelect(s.absPath);
+				return;
+			}
+			error.value = "Not found";
+			emit("invalid", {
+				reason: "not_found",
+				absPath: typedAbs
+			});
+			scheduler.invalidate();
+		}
+		function onKeydown(e) {
+			emit("keydown", e);
+			if (e.key === "Tab") {
+				e.preventDefault();
+				applyCompletion();
+				return;
+			}
+			if (e.key === "ArrowUp") {
+				e.preventDefault();
+				moveActive(-1);
+				return;
+			}
+			if (e.key === "ArrowDown") {
+				e.preventDefault();
+				moveActive(1);
+				return;
+			}
+			if (isCtrlLike(e) && (e.key === "p" || e.key === "P")) {
+				e.preventDefault();
+				moveActive(-1);
+				return;
+			}
+			if (isCtrlLike(e) && (e.key === "n" || e.key === "N")) {
+				e.preventDefault();
+				moveActive(1);
+			}
+		}
+		const wheelState = createWheelScrollState();
+		useTerminalNode(() => ({
+			rect: absListRect.value,
+			zIndex: eventZ.value,
+			visible: visible.value,
+			focusable: false,
+			handlers: {
+				click: (e) => {
+					const r = absListRect.value;
+					const idx = scrollTop.value + (e.cellY - r.y);
+					if (idx >= 0 && idx < suggestions.value.length) {
+						active.value = idx;
+						ensureActiveVisible();
+						scheduler.invalidate();
+					}
+				},
+				dblclick: async (e) => {
+					const r = absListRect.value;
+					const idx = scrollTop.value + (e.cellY - r.y);
+					const s = suggestions.value[idx];
+					if (!s) return;
+					if (props.mode === "file" && s.kind === "directory") {
+						setValue(s.completion);
+						error.value = null;
+						scheduler.invalidate();
+						return;
+					}
+					await trySelect(s.absPath);
+				},
+				wheel: (e) => {
+					const { deltaY, mode } = getWheelScrollInput(e);
+					const delta = deltaY;
+					if (!delta) return;
+					const h$1 = Math.max(0, listH.value);
+					const maxTop = Math.max(0, suggestions.value.length - h$1);
+					const { nextTop, dir } = applyWheelScroll(wheelState, delta, scrollTop.value, maxTop, Date.now(), mode, { disableAcceleration: mode === "pixel" });
+					if (!dir || nextTop === scrollTop.value) return;
+					scrollTop.value = nextTop;
+					const visibleStart = nextTop;
+					const visibleEnd = nextTop + h$1 - 1;
+					if (active.value < visibleStart || active.value > visibleEnd) {
+						const newActive = dir > 0 ? visibleEnd : visibleStart;
+						active.value = clamp$2(newActive, 0, Math.max(0, suggestions.value.length - 1));
+					}
+					scheduler.invalidate({ reason: "scroll" });
+				}
+			}
+		}));
+		useRenderNode(() => ({
+			zIndex: props.zIndex,
+			rect: visible.value ? absListRect.value : {
+				x: 0,
+				y: 0,
+				w: 0,
+				h: 0
+			},
+			deps: [
+				visible.value,
+				absListRect.value,
+				props.w,
+				listH.value,
+				props.style,
+				props.activeStyle,
+				props.matchStyle,
+				defaultStyle.value,
+				suggestions.value,
+				active.value,
+				scrollTop.value,
+				error.value
+			],
+			paint: () => {
+				if (!visible.value) return;
+				const r = absListRect.value;
+				if (r.w <= 0 || r.h <= 0) return;
+				const base = props.style ?? defaultStyle.value;
+				const query = parsePathQuery(String(props.modelValue ?? "")).query;
+				const top = clamp$2(scrollTop.value, 0, Math.max(0, suggestions.value.length - r.h));
+				for (let i = 0; i < r.h; i++) {
+					const idx = top + i;
+					const s = suggestions.value[idx];
+					const raw = s ? sanitizeInlineText(s.display) : "";
+					const clipped = sliceByCells(raw, r.w);
+					const rowStyle = idx === active.value ? {
+						...base,
+						...props.activeStyle ?? { inverse: true }
+					} : base;
+					const rowMatchStyle = {
+						...rowStyle,
+						...props.matchStyle ?? {
+							bold: true,
+							dim: false,
+							underline: true
+						}
+					};
+					const ranges = query ? computeHighlightRanges(raw, query) : [];
+					const used = writeHighlightedText({
+						text: clipped,
+						ranges,
+						x: r.x,
+						y: r.y + i,
+						maxCells: r.w,
+						baseStyle: rowStyle,
+						highlightStyle: rowMatchStyle,
+						terminal
+					});
+					if (used < r.w) terminal.write(spaces(r.w - used), {
+						x: r.x + used,
+						y: r.y + i,
+						style: rowStyle
+					});
+				}
+				if (suggestions.value.length === 0 && r.h > 0) {
+					const msg = error.value ? `(${sanitizeInlineText(error.value)})` : "(no matches)";
+					terminal.write(padEndByCells(sliceByCells(msg, r.w), r.w), {
+						x: r.x,
+						y: r.y,
+						style: {
+							...base,
+							dim: true
+						}
+					});
+				}
+			}
+		}));
+		return () => h("span", rootProps, [h(TInput, {
+			x: props.x,
+			y: props.y,
+			w: props.w,
+			h: inputH,
+			zIndex: props.zIndex,
+			modelValue: props.modelValue,
+			"onUpdate:modelValue": (v) => setValue(v),
+			cursorToEndOnExternalUpdate: true,
+			placeholder: props.placeholder,
+			style: props.inputStyle ?? props.style,
+			autoFocus: props.autoFocus,
+			onKeydown: (e) => onKeydown(e),
+			onChange: () => void onCommit(),
+			onFocus: () => emit("focus"),
+			onBlur: () => emit("blur")
+		})]);
+	}
+});
+
+//#endregion
+//#region src/vue/components/TRenderLayer.ts
+const TRenderLayer = defineComponent({
+	name: "TRenderLayer",
+	props: { zIndex: {
+		type: Number,
+		default: 0
+	} },
+	setup(props, { slots }) {
+		const { render } = useTerminal();
+		const parentStack = useRenderStack();
+		const stack = computed(() => render.createStack(parentStack.value, props.zIndex));
+		provide(RenderStackKey, stack);
+		return () => slots.default?.() ?? null;
+	}
+});
+
+//#endregion
+//#region src/vue/components/TTransition.ts
+const TTransition = defineComponent({
+	name: "TTransition",
+	props: {
+		show: {
+			type: Boolean,
+			required: true
+		},
+		duration: {
+			type: Number,
+			default: 200
+		},
+		beforeEnter: {
+			type: Function,
+			default: void 0
+		},
+		enter: {
+			type: Function,
+			default: void 0
+		},
+		afterEnter: {
+			type: Function,
+			default: void 0
+		},
+		beforeLeave: {
+			type: Function,
+			default: void 0
+		},
+		leave: {
+			type: Function,
+			default: void 0
+		},
+		afterLeave: {
+			type: Function,
+			default: void 0
+		}
+	},
+	setup(props, { slots }) {
+		const { scheduler } = useTerminal();
+		let raf = 0;
+		let runToken = 0;
+		const phase = ref("idle");
+		const progress = ref(props.show ? 1 : 0);
+		const rendered = ref(props.show);
+		const visible = ref(props.show);
+		provide(VisibilityContextKey, visible);
+		function cancel() {
+			if (raf > 0) {
+				cancelAnimationFrame(raf);
+				raf = 0;
+			}
+			runToken += 1;
+		}
+		async function runHook(hook, phaseName, p) {
+			if (!hook) return;
+			await hook({
+				phase: phaseName,
+				progress: p
+			});
+		}
+		function animate(from, to) {
+			const duration = Math.max(0, Math.floor(props.duration));
+			if (duration === 0) {
+				progress.value = to;
+				scheduler.invalidate();
+				return Promise.resolve();
+			}
+			const token = runToken;
+			const t0 = typeof performance !== "undefined" ? performance.now() : Date.now();
+			return new Promise((resolve) => {
+				const schedule = (fn) => {
+					raf = -1;
+					const id = requestAnimationFrame(fn);
+					if (raf === -1) raf = id;
+				};
+				const tick = () => {
+					if (token !== runToken) {
+						raf = 0;
+						resolve();
+						return;
+					}
+					const t = typeof performance !== "undefined" ? performance.now() : Date.now();
+					const p = Math.min(1, (t - t0) / duration);
+					progress.value = from + (to - from) * p;
+					scheduler.invalidate();
+					if (p >= 1) {
+						raf = 0;
+						resolve();
+						return;
+					}
+					schedule(tick);
+				};
+				schedule(tick);
+			});
+		}
+		async function enter() {
+			cancel();
+			rendered.value = true;
+			visible.value = true;
+			phase.value = "enter";
+			progress.value = 0;
+			scheduler.invalidate();
+			await runHook(props.beforeEnter, "enter", 0);
+			await runHook(props.enter, "enter", 0);
+			await animate(0, 1);
+			progress.value = 1;
+			phase.value = "idle";
+			scheduler.invalidate();
+			await runHook(props.afterEnter, "enter", 1);
+		}
+		async function leave() {
+			cancel();
+			rendered.value = true;
+			visible.value = true;
+			phase.value = "leave";
+			progress.value = 1;
+			scheduler.invalidate();
+			await runHook(props.beforeLeave, "leave", 1);
+			await runHook(props.leave, "leave", 1);
+			await animate(1, 0);
+			progress.value = 0;
+			phase.value = "idle";
+			visible.value = false;
+			rendered.value = false;
+			scheduler.invalidate();
+			await runHook(props.afterLeave, "leave", 0);
+		}
+		watch(() => props.show, (next, prev) => {
+			if (next === prev) return;
+			next ? enter() : leave();
+		});
+		onBeforeUnmount(() => cancel());
+		return () => {
+			if (!rendered.value) return null;
+			return slots.default?.({
+				phase: phase.value,
+				progress: progress.value
+			}) ?? null;
+		};
+	}
+});
+
+//#endregion
+//#region src/vue/composables/use-runtime.ts
+function useTerminalRuntime() {
+	return useTerminal().runtime;
+}
+
+//#endregion
+//#region src/vue/router/context.ts
+const TerminalRouterKey = injectionKey("TerminalRouter");
+const TerminalRouteKey = injectionKey("TerminalRoute");
+
+//#endregion
+//#region src/vue/router/composables.ts
+function useRouter() {
+	const r = inject(TerminalRouterKey, null);
+	if (!r) throw new Error("TerminalRouter is missing");
+	return r;
+}
+function useRoute() {
+	const route = inject(TerminalRouteKey, null);
+	if (!route) throw new Error("TerminalRoute is missing");
+	return computed(() => route.value);
+}
+
+//#endregion
+//#region src/vue/router/router.ts
+function normalize(to, records) {
+	const raw = typeof to === "string" ? { name: to } : to;
+	const record = records.get(raw.name);
+	return {
+		name: raw.name,
+		params: raw.params,
+		meta: record?.meta
+	};
+}
+function isRedirect(v) {
+	return typeof v === "string" || typeof v === "object" && v != null && "name" in v;
+}
+function createTerminalRouter(options) {
+	const records = new Map(options.routes.map((r) => [r.name, r]));
+	const currentRoute = ref(normalize(options.initialRoute, records));
+	const history = [currentRoute.value];
+	let index = 0;
+	const befores = [];
+	const resolves = [];
+	const afters = [];
+	async function runGuards(list, to, from) {
+		for (const guard of list) {
+			const r = await guard(to, from);
+			if (r === false) return false;
+			if (isRedirect(r)) return r;
+		}
+		return true;
+	}
+	async function navigate(toRaw, mode) {
+		const from = currentRoute.value;
+		const to = normalize(toRaw, records);
+		const fromRecord = records.get(from.name) ?? null;
+		const toRecord = records.get(to.name) ?? null;
+		const r1 = await runGuards(befores, to, from);
+		if (r1 === false) return;
+		if (isRedirect(r1)) return navigate(r1, mode);
+		const r2 = await runGuards(resolves, to, from);
+		if (r2 === false) return;
+		if (isRedirect(r2)) return navigate(r2, mode);
+		if (fromRecord?.onLeave) await fromRecord.onLeave(to, from);
+		currentRoute.value = to;
+		if (mode === "replace") history[index] = to;
+		else if (mode === "push") {
+			history.splice(index + 1);
+			history.push(to);
+			index = history.length - 1;
+		}
+		if (toRecord?.onEnter) await toRecord.onEnter(to, from);
+		for (const hook of afters) hook(to, from);
+	}
+	const router = {
+		currentRoute,
+		async push(to) {
+			await navigate(to, "push");
+		},
+		async replace(to) {
+			await navigate(to, "replace");
+		},
+		async back() {
+			if (index <= 0) return;
+			const from = currentRoute.value;
+			const to = history[index - 1];
+			const fromRecord = records.get(from.name) ?? null;
+			const toRecord = records.get(to.name) ?? null;
+			const r1 = await runGuards(befores, to, from);
+			if (r1 === false) return;
+			if (isRedirect(r1)) return navigate(r1, "push");
+			const r2 = await runGuards(resolves, to, from);
+			if (r2 === false) return;
+			if (isRedirect(r2)) return navigate(r2, "push");
+			if (fromRecord?.onLeave) await fromRecord.onLeave(to, from);
+			index -= 1;
+			currentRoute.value = to;
+			if (toRecord?.onEnter) await toRecord.onEnter(to, from);
+			for (const hook of afters) hook(to, from);
+		},
+		beforeEach(guard) {
+			befores.push(guard);
+			return () => {
+				const idx = befores.indexOf(guard);
+				if (idx >= 0) befores.splice(idx, 1);
+			};
+		},
+		beforeResolve(guard) {
+			resolves.push(guard);
+			return () => {
+				const idx = resolves.indexOf(guard);
+				if (idx >= 0) resolves.splice(idx, 1);
+			};
+		},
+		afterEach(hook) {
+			afters.push(hook);
+			return () => {
+				const idx = afters.indexOf(hook);
+				if (idx >= 0) afters.splice(idx, 1);
+			};
+		},
+		install(app) {
+			app.provide(TerminalRouterKey, router);
+			app.provide(TerminalRouteKey, currentRoute);
+		}
+	};
+	return router;
+}
+function resolveTerminalRouteComponent(router, routes) {
+	const cur = router.currentRoute.value;
+	const rec = routes.find((r) => r.name === cur.name);
+	return rec?.component ?? null;
+}
+
+//#endregion
+//#region src/vue/router/RouterView.ts
+const TRouterView = defineComponent({
+	name: "TRouterView",
+	props: {
+		routes: {
+			type: Array,
+			required: true
+		},
+		forceRemount: {
+			type: Boolean,
+			default: true
+		}
+	},
+	setup(props) {
+		const router = inject(TerminalRouterKey, null);
+		if (!router) throw new Error("TerminalRouter is missing (did you forget to app.use(router)?)");
+		const key = ref(0);
+		watch(() => router.currentRoute.value, () => {
+			if (props.forceRemount) key.value++;
+		}, { deep: true });
+		const component = computed(() => resolveTerminalRouteComponent(router, props.routes));
+		return () => {
+			const C = component.value;
+			return C ? h(C, { key: props.forceRemount ? key.value : void 0 }) : null;
+		};
+	}
+});
+
+//#endregion
+export { TAnchor, TAutocompleteInput, TBadge, TBox, TBreadcrumb, TCheckbox, TCode, TCommandPalette, TContextMenu, TDataTable, TDebugOverlay, TDialog, TDivider, TFlow, TForm, TFormContextKey, TFormField, TInput, TInputBox, TInputPluginsContextKey, TJsonEditor, TKeyHint, TLink, TLinkifyText, TList, TMultilineModal, TPasswordInput, TPathPicker, TPopover, TProgress, TRadioGroup, TRenderLayer, TRenderPlane, TRouterView, TSelect, TSlider, TSpinner, TSplitPane, TStatusBar, TSwitch, TTable, TTabs, TTag, TText, TToastViewport, TTooltip, TTransition, TTree, TView, TerminalProvider, computeCommandPaletteMatchRanges, createOverlayFocusStack, createPromptMentionPlugin, createTInputHostPlugin, createTerminalRouter, createTextRestrictionPlugin, createTheme, linkifyTextSegments, lintJsonText, padEndByCells, resolveOverlayPlacement, sliceByCells, sliceByCellsRange, spaces, textCellWidth, tuiDefaultTheme, useLayout, useRenderNode, useRoute, useRouter, useTForm, useTerminal, useTerminalNode, useTerminalRuntime, useVisibility, wrapByCells };