@navios/commander-tui 1.3.0 → 1.4.0

package/lib/index.cjs

@@ -1,7 +1,589 @@
-const require_filter_engine = require('./filter_engine-DXqu9Vaq.cjs');
-let _opentui_core = require("@opentui/core");
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
 let _navios_core = require("@navios/core");
+let node_events = require("node:events");
+let node_readline = require("node:readline");
+node_readline = __toESM(node_readline);
+
+//#region src/types/screen.types.ts
+/**
+* Render mode determines how the TUI operates.
+* This is set during bind() and affects prompts, screen printing, and exit behavior.
+*/ var RenderMode = /* @__PURE__ */ function(RenderMode$1) {
+	/** bind() never called - screens print on completion, prompts return defaults */ RenderMode$1["UNBOUND"] = "unbound";
+	/** bind() called with useOpenTUI: false - stdout mode with readline prompts */ RenderMode$1["STDOUT_INTERACTIVE"] = "stdout";
+	/** bind() called with useOpenTUI: true but adapter unavailable - fallback to stdout with warning */ RenderMode$1["STDOUT_FALLBACK"] = "fallback";
+	/** Full TUI rendering active with adapter */ RenderMode$1["TUI_ACTIVE"] = "tui";
+	return RenderMode$1;
+}({});
+
+//#endregion
+//#region src/types/filter.types.ts
+/**
+* All log levels in order.
+*/ const ALL_LOG_LEVELS = [
+	"verbose",
+	"debug",
+	"log",
+	"warn",
+	"error",
+	"fatal"
+];
+/**
+* Create a default filter state.
+*/ function createDefaultFilterState() {
+	return {
+		enabledLevels: new Set(ALL_LOG_LEVELS),
+		searchQuery: "",
+		isVisible: false,
+		focusedField: "search"
+	};
+}
+/**
+* Check if any filtering is active.
+*/ function hasActiveFilter(filter) {
+	return filter.searchQuery !== "" || filter.enabledLevels.size < ALL_LOG_LEVELS.length;
+}
+
+//#endregion
+//#region src/types/events.types.ts
+/**
+* All manager events that adapters typically subscribe to for re-renders.
+*/ const MANAGER_EVENTS = [
+	"screen:added",
+	"screen:removed",
+	"screen:reordered",
+	"activeScreen:changed",
+	"focus:changed",
+	"sidebar:indexChanged",
+	"mode:changed"
+];
+/**
+* All screen events that adapters typically subscribe to for re-renders.
+*/ const SCREEN_EVENTS = [
+	"message:added",
+	"message:updated",
+	"messages:cleared",
+	"status:changed",
+	"visibility:changed",
+	"badge:changed",
+	"prompt:activated",
+	"prompt:updated",
+	"prompt:resolved"
+];
+/**
+* Sidebar-specific events that require re-render.
+*/ const SIDEBAR_EVENTS = [
+	"screen:added",
+	"screen:removed",
+	"screen:reordered",
+	"sidebar:indexChanged",
+	"focus:changed",
+	"activeScreen:changed"
+];
+/**
+* Content area events that affect active screen changes.
+*/ const CONTENT_MANAGER_EVENTS = ["activeScreen:changed", "focus:changed"];
+
+//#endregion
+//#region src/utils/colors/log-colors.ts
+/**
+* Default color scheme for all log levels.
+* Each level has a prominent border color and a subtle background tint.
+*/ const DEFAULT_LOG_LEVEL_COLORS = {
+	verbose: {
+		border: "#6B7280",
+		background: "#6B728015"
+	},
+	debug: {
+		border: "#8B5CF6",
+		background: "#8B5CF615"
+	},
+	log: {
+		border: "#3B82F6",
+		background: "#3B82F615"
+	},
+	warn: {
+		border: "#F59E0B",
+		background: "#F59E0B15"
+	},
+	error: {
+		border: "#EF4444",
+		background: "#EF444415"
+	},
+	fatal: {
+		border: "#DC2626",
+		background: "#DC262625",
+		text: "#FCA5A5"
+	}
+};
+/**
+* Colors for semantic variants (override level colors when variant is set).
+*/ const VARIANT_COLORS = {
+	success: {
+		border: "#22C55E",
+		background: "#22C55E15"
+	},
+	trace: {
+		border: "#6B7280",
+		background: "#6B728015"
+	}
+};
+/**
+* Error highlighting colors.
+*/ const ERROR_HIGHLIGHT_COLORS = {
+	background: "#EF444425",
+	border: "#EF4444",
+	gutterBackground: "#EF444440"
+};
+
+//#endregion
+//#region src/utils/colors/sidebar-colors.ts
+/**
+* Sidebar colors.
+*/ const SIDEBAR_COLORS = {
+	background: void 0,
+	selectedBackground: "#1F293780",
+	hoverBackground: "#374151",
+	text: "#E5E7EB",
+	textDim: "#6B7280",
+	border: "#374151",
+	badge: "#3B82F6",
+	focusBorder: "#3B82F6"
+};
+/**
+* Screen header colors.
+*/ const HEADER_COLORS = {
+	background: void 0,
+	text: "#F9FAFB",
+	border: "#374151"
+};
+/**
+* Screen status indicator colors and icons.
+*/ const STATUS_INDICATORS = {
+	waiting: {
+		icon: "○",
+		color: "#6B7280"
+	},
+	pending: {
+		icon: "◐",
+		color: "#F59E0B"
+	},
+	success: {
+		icon: "✓",
+		color: "#22C55E"
+	},
+	fail: {
+		icon: "✗",
+		color: "#EF4444"
+	}
+};
+/**
+* Separator colors for sidebar sections.
+*/ const SEPARATOR_COLORS = {
+	line: "#374151",
+	text: "#6B7280"
+};
+
+//#endregion
+//#region src/utils/colors/progress-colors.ts
+/**
+* Progress bar colors.
+*/ const PROGRESS_COLORS = {
+	border: "#3B82F6",
+	background: "#3B82F615",
+	barFilled: "#3B82F6",
+	barEmpty: "#374151",
+	text: "#E5E7EB",
+	textDim: "#9CA3AF",
+	complete: "#22C55E",
+	completeBackground: "#22C55E15",
+	failed: "#EF4444",
+	failedBackground: "#EF444415"
+};
+/**
+* Group colors for collapsible log groups.
+*/ const GROUP_COLORS = {
+	border: "#6B7280",
+	background: "#6B728010",
+	headerText: "#E5E7EB",
+	icon: "#9CA3AF"
+};
+
+//#endregion
+//#region src/utils/colors/table-colors.ts
+/**
+* Table colors (uses info/blue scheme).
+*/ const TABLE_COLORS = {
+	border: "#3B82F6",
+	background: "#3B82F615",
+	headerText: "#F9FAFB",
+	cellText: "#E5E7EB",
+	title: "#F9FAFB",
+	separator: "#3B82F650"
+};
+
+//#endregion
+//#region src/utils/colors/file-colors.ts
+/**
+* File display colors (uses info/blue scheme).
+*/ const FILE_COLORS = {
+	border: "#3B82F6",
+	background: "#3B82F615",
+	headerText: "#F9FAFB",
+	headerBackground: "#3B82F625"
+};
+
+//#endregion
+//#region src/utils/colors/prompt-colors.ts
+/**
+* Prompt colors for interactive prompts.
+*/ const PROMPT_COLORS = {
+	question: "#F9FAFB",
+	optionText: "#E5E7EB",
+	optionTextDim: "#9CA3AF",
+	optionSelected: "#3B82F6",
+	optionSelectedBackground: "#1E3A5F",
+	confirmButton: "#22C55E",
+	cancelButton: "#EF4444",
+	buttonBackground: "#374151",
+	buttonSelectedBackground: "#1F2937",
+	inputBorder: "#3B82F6",
+	inputBackground: "#1F2937",
+	inputText: "#F9FAFB",
+	inputPlaceholder: "#6B7280",
+	inputCursor: "#3B82F6",
+	border: "#374151",
+	focusBorder: "#3B82F6"
+};
 
+//#endregion
+//#region src/utils/colors/helpers.ts
+/**
+* Gets colors for a specific log level.
+*
+* @param level - The log level
+* @param customColors - Optional custom color map
+*/ function getLogLevelColors(level, customColors) {
+	const defaultColors = DEFAULT_LOG_LEVEL_COLORS[level];
+	const custom = customColors?.[level];
+	return {
+		border: custom?.border ?? defaultColors.border,
+		background: custom?.background ?? defaultColors.background,
+		text: custom?.text ?? defaultColors.text
+	};
+}
+
+//#endregion
+//#region src/utils/filetype.ts
+/**
+* Common file extension to filetype mapping for syntax highlighting.
+*/ const COMMON_FILETYPES = {
+	ts: "typescript",
+	tsx: "tsx",
+	js: "javascript",
+	jsx: "javascript",
+	json: "json",
+	md: "markdown",
+	py: "python",
+	rs: "rust",
+	go: "go",
+	java: "java",
+	c: "c",
+	cpp: "cpp",
+	h: "c",
+	hpp: "cpp",
+	css: "css",
+	html: "html",
+	yaml: "yaml",
+	yml: "yaml",
+	sh: "bash",
+	bash: "bash",
+	zsh: "bash",
+	toml: "toml",
+	xml: "xml",
+	sql: "sql",
+	rb: "ruby",
+	php: "php",
+	swift: "swift",
+	kt: "kotlin",
+	scala: "scala",
+	hs: "haskell",
+	elm: "elm",
+	vue: "vue",
+	svelte: "svelte"
+};
+/**
+* Resolves filetype from file path for syntax highlighting.
+*
+* @param filePath - Full file path or just filename
+* @returns Filetype string for tree-sitter, or undefined
+*/ function resolveFiletype(filePath) {
+	const lastDot = filePath.lastIndexOf(".");
+	if (lastDot === -1) return void 0;
+	return COMMON_FILETYPES[filePath.slice(lastDot + 1).toLowerCase()];
+}
+/**
+* Gets the filename from a full path.
+*
+* @param filePath - Full file path
+* @returns Just the filename
+*/ function getFileName(filePath) {
+	const lastSlash = Math.max(filePath.lastIndexOf("/"), filePath.lastIndexOf("\\"));
+	return lastSlash === -1 ? filePath : filePath.slice(lastSlash + 1);
+}
+
+//#endregion
+//#region src/utils/stdout-printer.ts
+const RESET = "\x1B[0m";
+const BOLD = "\x1B[1m";
+const DIM = "\x1B[2m";
+function hexToAnsi(hex, isForeground = true) {
+	const cleanHex = hex.replace("#", "").slice(0, 6);
+	if (!/^[0-9A-Fa-f]{6}$/.test(cleanHex)) return "";
+	const r = parseInt(cleanHex.slice(0, 2), 16);
+	const g = parseInt(cleanHex.slice(2, 4), 16);
+	const b = parseInt(cleanHex.slice(4, 6), 16);
+	return `\x1b[${isForeground ? 38 : 48};2;${r};${g};${b}m`;
+}
+function getLogLevelAnsiColor(level, variant) {
+	return hexToAnsi((variant ? VARIANT_COLORS[variant] : DEFAULT_LOG_LEVEL_COLORS[level]).border, true);
+}
+function formatLevel(level, variant) {
+	return `${getLogLevelAnsiColor(level, variant)}${BOLD}[${(variant ?? level).toUpperCase().padEnd(7)}]${RESET}`;
+}
+function formatTimestamp(date$2) {
+	return `${DIM}${date$2.toLocaleTimeString()}${RESET}`;
+}
+function printMessage(message, stream) {
+	switch (message.type) {
+		case "log": {
+			const logMessage = message;
+			const timestamp = formatTimestamp(message.timestamp);
+			const level = formatLevel(logMessage.level, logMessage.variant);
+			const label = logMessage.label ? ` ${DIM}[${logMessage.label}]${RESET}` : "";
+			stream.write(`${timestamp} ${level}${label} ${logMessage.content}\n`);
+			break;
+		}
+		case "file": {
+			const header = `${DIM}─── ${message.filePath} ───${RESET}`;
+			stream.write(`${header}\n${message.content}\n`);
+			break;
+		}
+		case "diff": {
+			const header = `${DIM}─── ${message.filePath} (diff) ───${RESET}`;
+			const coloredDiff = message.diff.split("\n").map((line) => {
+				if (line.startsWith("+") && !line.startsWith("+++")) return `\x1b[32m${line}${RESET}`;
+				else if (line.startsWith("-") && !line.startsWith("---")) return `\x1b[31m${line}${RESET}`;
+				else if (line.startsWith("@@")) return `\x1b[36m${line}${RESET}`;
+				return line;
+			}).join("\n");
+			stream.write(`${header}\n${coloredDiff}\n`);
+			break;
+		}
+		case "fileError": {
+			const header = `${DIM}─── ${message.filePath} ───${RESET}`;
+			const errorLineSet = new Set(message.errorLines);
+			const startLine = message.startLine ?? 1;
+			const numberedLines = message.content.split("\n").map((line, index) => {
+				const lineNum = startLine + index;
+				const numStr = String(lineNum).padStart(4);
+				if (errorLineSet.has(lineNum)) return `\x1b[31m${numStr} │ ${line}${RESET}`;
+				return `${DIM}${numStr}${RESET} │ ${line}`;
+			});
+			stream.write(`${header}\n${numberedLines.join("\n")}\n`);
+			break;
+		}
+		case "loading": {
+			const loadingMessage = message;
+			const status = loadingMessage.status;
+			const content = loadingMessage.resolvedContent ?? loadingMessage.content;
+			let level = "log";
+			let variant;
+			if (status === "success") {
+				level = "log";
+				variant = "success";
+			} else if (status === "fail") level = "error";
+			const timestamp = formatTimestamp(message.timestamp);
+			const levelStr = formatLevel(level, variant);
+			const prefix = status === "loading" ? "... " : "";
+			stream.write(`${timestamp} ${levelStr} ${prefix}${content}\n`);
+			break;
+		}
+		case "progress": {
+			const { label, current, total, status, resolvedContent } = message;
+			const percentage = total > 0 ? Math.round(current / total * 100) : 0;
+			const barWidth = 20;
+			const filledWidth = Math.round(percentage / 100 * barWidth);
+			const emptyWidth = barWidth - filledWidth;
+			const progressColor = hexToAnsi(PROGRESS_COLORS.barFilled);
+			const emptyColor = hexToAnsi(PROGRESS_COLORS.barEmpty);
+			const filledBar = "█".repeat(filledWidth);
+			const emptyBar = "░".repeat(emptyWidth);
+			let statusIcon = "";
+			let statusColor = "";
+			if (status === "complete") {
+				statusIcon = "✓";
+				statusColor = hexToAnsi(PROGRESS_COLORS.complete);
+			} else if (status === "failed") {
+				statusIcon = "✗";
+				statusColor = hexToAnsi(PROGRESS_COLORS.failed);
+			}
+			const displayLabel = resolvedContent ?? label;
+			const progressBar = `${progressColor}${filledBar}${RESET}${emptyColor}${emptyBar}${RESET}`;
+			const percentStr = `${String(percentage).padStart(3)}%`;
+			if (statusIcon) stream.write(`${statusColor}${statusIcon}${RESET} ${displayLabel} [${progressBar}] ${percentStr}\n`);
+			else stream.write(`  ${displayLabel} [${progressBar}] ${percentStr} (${current}/${total})\n`);
+			break;
+		}
+		case "group": {
+			const { label, collapsed, isEnd } = message;
+			const groupColor = hexToAnsi(GROUP_COLORS.border);
+			const iconColor = hexToAnsi(GROUP_COLORS.icon);
+			if (isEnd) stream.write(`${groupColor}└─${RESET} ${DIM}end ${label}${RESET}\n`);
+			else {
+				const icon = collapsed ? "▶" : "▼";
+				stream.write(`${groupColor}┌─${RESET} ${iconColor}${icon}${RESET} ${BOLD}${label}${RESET}\n`);
+			}
+			break;
+		}
+		case "table": {
+			const { headers, rows, title } = message;
+			const tableColor = hexToAnsi(TABLE_COLORS.border);
+			const headerColor = hexToAnsi(TABLE_COLORS.headerText);
+			const cellColor = hexToAnsi(TABLE_COLORS.cellText);
+			const colWidths = headers.map((h, i) => {
+				const maxRowWidth = rows.reduce((max, row) => Math.max(max, (row[i] ?? "").length), 0);
+				return Math.max(h.length, maxRowWidth);
+			});
+			const separator = `${tableColor}├${colWidths.map((w) => "─".repeat(w + 2)).join("┼")}┤${RESET}`;
+			const topBorder = `${tableColor}┌${colWidths.map((w) => "─".repeat(w + 2)).join("┬")}┐${RESET}`;
+			const bottomBorder = `${tableColor}└${colWidths.map((w) => "─".repeat(w + 2)).join("┴")}┘${RESET}`;
+			if (title) stream.write(`${BOLD}${title}${RESET}\n`);
+			stream.write(`${topBorder}\n`);
+			const headerRow = headers.map((h, i) => ` ${h.padEnd(colWidths[i])} `).join(`${tableColor}│${RESET}`);
+			stream.write(`${tableColor}│${RESET}${headerColor}${headerRow}${RESET}${tableColor}│${RESET}\n`);
+			stream.write(`${separator}\n`);
+			for (const row of rows) {
+				const rowStr = headers.map((_, i) => ` ${(row[i] ?? "").padEnd(colWidths[i])} `).join(`${tableColor}│${RESET}`);
+				stream.write(`${tableColor}│${RESET}${cellColor}${rowStr}${RESET}${tableColor}│${RESET}\n`);
+			}
+			stream.write(`${bottomBorder}\n`);
+			break;
+		}
+	}
+}
+/**
+* Print a single message to stdout with optional screen name prefix.
+* Used for immediate output in stdout mode (when OpenTUI is not active).
+*/ function printSingleMessage(message, screenName, isError = false) {
+	const stream = isError ? process.stderr : process.stdout;
+	if (screenName) stream.write(`${DIM}[${screenName}]${RESET} `);
+	printMessage(message, stream);
+}
+/**
+* Print all messages to stdout (or stderr if isError)
+*/ function printMessagesToStdout(messages, screenName, isError = false) {
+	const stream = isError ? process.stderr : process.stdout;
+	const headerColor = isError ? "\x1B[31m" : "\x1B[32m";
+	const status = isError ? "FAILED" : "COMPLETED";
+	stream.write(`\n${headerColor}${BOLD}═══ ${screenName} [${status}] ═══${RESET}\n\n`);
+	for (const message of messages) printMessage(message, stream);
+	stream.write("\n");
+}
+
+//#endregion
+//#region src/utils/format.ts
+/**
+* Format an object for display with configurable depth
+*/ function formatObject(obj, depth = 2, currentDepth = 0) {
+	if (currentDepth >= depth) {
+		if (Array.isArray(obj)) return "[Array]";
+		if (typeof obj === "object" && obj !== null) return `[${obj.constructor?.name ?? "Object"}]`;
+		return String(obj);
+	}
+	if (obj === null) return "null";
+	if (obj === void 0) return "undefined";
+	if (typeof obj === "string") return `"${obj}"`;
+	if (typeof obj === "number" || typeof obj === "boolean") return String(obj);
+	if (typeof obj === "function") return "[Function]";
+	if (obj instanceof Date) return obj.toISOString();
+	if (obj instanceof Error) return `${obj.name}: ${obj.message}`;
+	const indent = "  ".repeat(currentDepth);
+	const childIndent = "  ".repeat(currentDepth + 1);
+	if (Array.isArray(obj)) {
+		if (obj.length === 0) return "[]";
+		return `[\n${childIndent}${obj.map((item) => formatObject(item, depth, currentDepth + 1)).join(`,\n${childIndent}`)}\n${indent}]`;
+	}
+	if (typeof obj === "object") {
+		const entries = Object.entries(obj);
+		if (entries.length === 0) return "{}";
+		return `{\n${childIndent}${entries.map(([key, value]) => `${key}: ${formatObject(value, depth, currentDepth + 1)}`).join(`,\n${childIndent}`)}\n${indent}}`;
+	}
+	return String(obj);
+}
+/**
+* Capture a stack trace, filtering out internal frames
+*/ function captureTrace(offset = 0) {
+	const lines = ((/* @__PURE__ */ new Error()).stack ?? "").split("\n");
+	const begin = lines.findIndex((line) => line.includes("captureTrace"));
+	return lines.slice(begin !== -1 ? begin + 1 + offset : 4).join("\n");
+}
+
+//#endregion
+//#region src/utils/runtime.ts
+/**
+* Detect if running in Bun environment (OpenTUI is not supported in Bun)
+*/ function isBunRuntime() {
+	return typeof globalThis.Bun !== "undefined";
+}
+/**
+* Dynamic import that bypasses bundler static analysis.
+* Uses Function constructor to prevent bundlers from resolving the import at build time.
+*/ function dynamicImport(modulePath) {
+	return new Function("modulePath", "return import(modulePath)")(modulePath);
+}
+
+//#endregion
+//#region src/utils/prompt.ts
+/**
+* Get the default value for a prompt based on its type.
+* Used for resolving prompts when no interaction is possible.
+*/ function getPromptDefaultValue(prompt) {
+	switch (prompt.type) {
+		case "choice": return prompt.defaultChoice;
+		case "confirm": return prompt.defaultValue;
+		case "input": return prompt.defaultValue;
+		case "multiChoice": return prompt.choices.filter((_, i) => prompt.selectedIndices.has(i)).map((c) => c.value);
+	}
+}
+
+//#endregion
 //#region ../../node_modules/zod/v4/core/core.js
 /** A special constant with type `never` */
 const NEVER = Object.freeze({ status: "aborted" });
@@ -2628,7 +3210,7 @@ function initializeContext(params) {
 		external: params?.external ?? void 0
 	};
 }
-function process(schema, ctx, _params = {
+function process$1(schema, ctx, _params = {
 	path: [],
 	schemaPath: []
 }) {
@@ -2665,7 +3247,7 @@ function process(schema, ctx, _params = {
 		const parent = schema._zod.parent;
 		if (parent) {
 			if (!result.ref) result.ref = parent;
-			process(parent, ctx, params);
+			process$1(parent, ctx, params);
 			ctx.seen.get(parent).isParent = true;
 		}
 	}
@@ -2877,7 +3459,7 @@ const createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
 		...params,
 		processors
 	});
-	process(schema, ctx);
+	process$1(schema, ctx);
 	extractDefs(ctx, schema);
 	return finalize(ctx, schema);
 };
@@ -2889,7 +3471,7 @@ const createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params)
 		io,
 		processors
 	});
-	process(schema, ctx);
+	process$1(schema, ctx);
 	extractDefs(ctx, schema);
 	return finalize(ctx, schema);
 };
@@ -2976,7 +3558,7 @@ const arrayProcessor = (schema, ctx, _json, params) => {
 	if (typeof minimum === "number") json.minItems = minimum;
 	if (typeof maximum === "number") json.maxItems = maximum;
 	json.type = "array";
-	json.items = process(def.element, ctx, {
+	json.items = process$1(def.element, ctx, {
 		...params,
 		path: [...params.path, "items"]
 	});
@@ -2987,7 +3569,7 @@ const objectProcessor = (schema, ctx, _json, params) => {
 	json.type = "object";
 	json.properties = {};
 	const shape = def.shape;
-	for (const key in shape) json.properties[key] = process(shape[key], ctx, {
+	for (const key in shape) json.properties[key] = process$1(shape[key], ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -3005,7 +3587,7 @@ const objectProcessor = (schema, ctx, _json, params) => {
 	if (def.catchall?._zod.def.type === "never") json.additionalProperties = false;
 	else if (!def.catchall) {
 		if (ctx.io === "output") json.additionalProperties = false;
-	} else if (def.catchall) json.additionalProperties = process(def.catchall, ctx, {
+	} else if (def.catchall) json.additionalProperties = process$1(def.catchall, ctx, {
 		...params,
 		path: [...params.path, "additionalProperties"]
 	});
@@ -3013,7 +3595,7 @@ const objectProcessor = (schema, ctx, _json, params) => {
 const unionProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
 	const isExclusive = def.inclusive === false;
-	const options = def.options.map((x, i) => process(x, ctx, {
+	const options = def.options.map((x, i) => process$1(x, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -3026,7 +3608,7 @@ const unionProcessor = (schema, ctx, json, params) => {
 };
 const intersectionProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	const a = process(def.left, ctx, {
+	const a = process$1(def.left, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -3034,7 +3616,7 @@ const intersectionProcessor = (schema, ctx, json, params) => {
 			0
 		]
 	});
-	const b = process(def.right, ctx, {
+	const b = process$1(def.right, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -3047,7 +3629,7 @@ const intersectionProcessor = (schema, ctx, json, params) => {
 };
 const nullableProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	const inner = process(def.innerType, ctx, params);
+	const inner = process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	if (ctx.target === "openapi-3.0") {
 		seen.ref = def.innerType;
@@ -3056,27 +3638,27 @@ const nullableProcessor = (schema, ctx, json, params) => {
 };
 const nonoptionalProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
-	process(def.innerType, ctx, params);
+	process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 };
 const defaultProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	process(def.innerType, ctx, params);
+	process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	json.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
 const prefaultProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	process(def.innerType, ctx, params);
+	process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	if (ctx.io === "input") json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
 };
 const catchProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	process(def.innerType, ctx, params);
+	process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	let catchValue;
@@ -3090,20 +3672,20 @@ const catchProcessor = (schema, ctx, json, params) => {
 const pipeProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
 	const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
-	process(innerType, ctx, params);
+	process$1(innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = innerType;
 };
 const readonlyProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	process(def.innerType, ctx, params);
+	process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	json.readOnly = true;
 };
 const optionalProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
-	process(def.innerType, ctx, params);
+	process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 };
@@ -3759,7 +4341,7 @@ const ScreenOptionsSchema = object({
 const LoggerOptionsSchema = object({
 	screen: ScreenOptionsSchema.or(string()).optional().default("default"),
 	context: string().optional(),
-	enabledLevels: array(_enum(require_filter_engine.ALL_LOG_LEVELS)).default(require_filter_engine.ALL_LOG_LEVELS)
+	enabledLevels: array(_enum(ALL_LOG_LEVELS)).default(ALL_LOG_LEVELS)
 });
 
 //#endregion
@@ -3782,6 +4364,14 @@ const ScreenLogger = _navios_core.InjectionToken.create("ScreenLoggerInstance",
 //#region src/tokens/prompt.ts
 const Prompt = _navios_core.InjectionToken.create("Prompt", PromptOptionsSchema);
 
+//#endregion
+//#region src/tokens/adapter.ts
+/**
+* Injection token for the TUI rendering adapter.
+* Import the specific adapter (e.g., '@navios/commander-tui/adapters/react')
+* to register an implementation.
+*/ const Adapter = _navios_core.InjectionToken.create("Adapter");
+
 //#endregion
 //#region src/tokens/screen-manager.ts
 /**
@@ -4681,7 +5271,7 @@ function overrideConsoleLogger(hidden = false) {
 			static: true
 		} });
 		setup(options) {
-			this.logger.setLogLevels(options.logLevels ?? require_filter_engine.ALL_LOG_LEVELS);
+			this.logger.setLogLevels(options.logLevels ?? ALL_LOG_LEVELS);
 		}
 		log(message) {
 			this.logger.log(message);
@@ -4991,29 +5581,708 @@ function _apply_decs_2203_r$3(targetClass, memberDecs, classDecs, parentClass) {
 	return (_apply_decs_2203_r$3 = applyDecs2203RFactory$3())(targetClass, memberDecs, classDecs, parentClass);
 }
 var _dec$3, _initClass$3;
+const MISSING_ADAPTER_ERROR = "Adapter not registered, add import statement for @navios/tui-adapter-react, @navios/tui-adapter-ink or @navios/tui-adapter-solid to your module";
 let _MissingAdapterOverride;
 _dec$3 = (0, _navios_core.Injectable)({
-	token: require_filter_engine.Adapter,
+	token: Adapter,
 	priority: -100
 });
 var MissingAdapterOverride = class {
 	static {
 		({c: [_MissingAdapterOverride, _initClass$3]} = _apply_decs_2203_r$3(this, [], [_dec$3]));
 	}
+	/**
+	* Marker property to identify this as the missing adapter fallback.
+	* Used by ScreenManager.bind() to detect and handle graceful fallback.
+	*/ isMissingAdapter = true;
 	createRoot() {
-		throw new Error("Adapter not registered, add import statement for @navios/commander-tui/adapters/react or @navios/commander-tui/adapters/solid to your module");
+		throw new Error(MISSING_ADAPTER_ERROR);
 	}
 	renderToRoot() {
-		throw new Error("Adapter not registered, add import statement for @navios/commander-tui/adapters/react or @navios/commander-tui/adapters/solid to your module");
+		throw new Error(MISSING_ADAPTER_ERROR);
 	}
 	static {
 		_initClass$3();
 	}
 };
 
+//#endregion
+//#region src/themes/dark.ts
+/**
+* Default dark theme.
+* Migrated from the scattered color files in utils/colors/.
+*/ const darkTheme = {
+	name: "dark",
+	logLevels: {
+		verbose: {
+			border: "#6B7280",
+			background: "#6B728015"
+		},
+		debug: {
+			border: "#8B5CF6",
+			background: "#8B5CF615"
+		},
+		log: {
+			border: "#3B82F6",
+			background: "#3B82F615"
+		},
+		warn: {
+			border: "#F59E0B",
+			background: "#F59E0B15"
+		},
+		error: {
+			border: "#EF4444",
+			background: "#EF444415"
+		},
+		fatal: {
+			border: "#DC2626",
+			background: "#DC262625",
+			text: "#FCA5A5"
+		}
+	},
+	sidebar: {
+		background: void 0,
+		selectedBackground: "#1F293780",
+		hoverBackground: "#374151",
+		text: "#E5E7EB",
+		textDim: "#6B7280",
+		border: "#374151",
+		badge: "#3B82F6",
+		focusBorder: "#3B82F6"
+	},
+	header: {
+		background: void 0,
+		text: "#F9FAFB",
+		border: "#374151"
+	},
+	statusIndicators: {
+		waiting: {
+			icon: "○",
+			color: "#6B7280"
+		},
+		pending: {
+			icon: "◐",
+			color: "#F59E0B"
+		},
+		success: {
+			icon: "✓",
+			color: "#22C55E"
+		},
+		fail: {
+			icon: "✗",
+			color: "#EF4444"
+		},
+		static: {
+			icon: "●",
+			color: "#3B82F6"
+		}
+	},
+	separator: {
+		line: "#374151",
+		text: "#6B7280"
+	},
+	progress: {
+		border: "#3B82F6",
+		background: "#3B82F615",
+		barFilled: "#3B82F6",
+		barEmpty: "#374151",
+		text: "#E5E7EB",
+		textDim: "#9CA3AF",
+		complete: "#22C55E",
+		completeBackground: "#22C55E15",
+		failed: "#EF4444",
+		failedBackground: "#EF444415"
+	},
+	group: {
+		border: "#6B7280",
+		background: "#6B728010",
+		headerText: "#E5E7EB",
+		icon: "#9CA3AF"
+	},
+	table: {
+		border: "#3B82F6",
+		background: "#3B82F615",
+		headerText: "#F9FAFB",
+		cellText: "#E5E7EB",
+		title: "#F9FAFB",
+		separator: "#3B82F650"
+	},
+	file: {
+		border: "#3B82F6",
+		background: "#3B82F615",
+		headerText: "#F9FAFB",
+		headerBackground: "#3B82F625"
+	},
+	prompt: {
+		question: "#F9FAFB",
+		optionText: "#E5E7EB",
+		optionTextDim: "#9CA3AF",
+		optionSelected: "#3B82F6",
+		optionSelectedBackground: "#1E3A5F",
+		confirmButton: "#22C55E",
+		cancelButton: "#EF4444",
+		buttonBackground: "#374151",
+		buttonSelectedBackground: "#1F2937",
+		inputBorder: "#3B82F6",
+		inputBackground: "#1F2937",
+		inputText: "#F9FAFB",
+		inputPlaceholder: "#6B7280",
+		inputCursor: "#3B82F6",
+		border: "#374151",
+		focusBorder: "#3B82F6"
+	},
+	errorHighlight: {
+		background: "#EF444425",
+		border: "#EF4444",
+		gutterBackground: "#EF444440"
+	},
+	filter: {
+		background: "#1F293780",
+		border: "#3B82F6",
+		text: "#E5E7EB",
+		textDim: "#6B7280",
+		inputBackground: "#1F2937",
+		inputText: "#F9FAFB",
+		inputPlaceholder: "#6B7280",
+		cursor: "#3B82F6",
+		activeLevel: "#3B82F6",
+		inactiveLevel: "#4B5563"
+	},
+	help: {
+		background: "#1F2937",
+		border: "#3B82F6",
+		title: "#F9FAFB",
+		category: "#3B82F6",
+		key: "#F59E0B",
+		description: "#E5E7EB",
+		hint: "#6B7280"
+	},
+	colors: {
+		primary: "#3B82F6",
+		secondary: "#8B5CF6",
+		success: "#22C55E",
+		warning: "#F59E0B",
+		error: "#EF4444",
+		muted: "#6B7280",
+		background: "#111827",
+		foreground: "#F9FAFB"
+	}
+};
+
+//#endregion
+//#region src/themes/light.ts
+/**
+* Light theme for terminals with light backgrounds.
+*/ const lightTheme = {
+	name: "light",
+	logLevels: {
+		verbose: {
+			border: "#9CA3AF",
+			background: "#F3F4F6"
+		},
+		debug: {
+			border: "#7C3AED",
+			background: "#EDE9FE"
+		},
+		log: {
+			border: "#2563EB",
+			background: "#DBEAFE"
+		},
+		warn: {
+			border: "#D97706",
+			background: "#FEF3C7"
+		},
+		error: {
+			border: "#DC2626",
+			background: "#FEE2E2"
+		},
+		fatal: {
+			border: "#991B1B",
+			background: "#FECACA",
+			text: "#7F1D1D"
+		}
+	},
+	sidebar: {
+		background: "#F9FAFB",
+		selectedBackground: "#E5E7EB",
+		hoverBackground: "#F3F4F6",
+		text: "#1F2937",
+		textDim: "#6B7280",
+		border: "#D1D5DB",
+		badge: "#2563EB",
+		focusBorder: "#2563EB"
+	},
+	header: {
+		background: "#F9FAFB",
+		text: "#111827",
+		border: "#D1D5DB"
+	},
+	statusIndicators: {
+		waiting: {
+			icon: "○",
+			color: "#9CA3AF"
+		},
+		pending: {
+			icon: "◐",
+			color: "#D97706"
+		},
+		success: {
+			icon: "✓",
+			color: "#16A34A"
+		},
+		fail: {
+			icon: "✗",
+			color: "#DC2626"
+		},
+		static: {
+			icon: "●",
+			color: "#2563EB"
+		}
+	},
+	separator: {
+		line: "#D1D5DB",
+		text: "#6B7280"
+	},
+	progress: {
+		border: "#2563EB",
+		background: "#DBEAFE",
+		barFilled: "#2563EB",
+		barEmpty: "#E5E7EB",
+		text: "#1F2937",
+		textDim: "#6B7280",
+		complete: "#16A34A",
+		completeBackground: "#DCFCE7",
+		failed: "#DC2626",
+		failedBackground: "#FEE2E2"
+	},
+	group: {
+		border: "#9CA3AF",
+		background: "#F3F4F6",
+		headerText: "#1F2937",
+		icon: "#6B7280"
+	},
+	table: {
+		border: "#2563EB",
+		background: "#DBEAFE",
+		headerText: "#111827",
+		cellText: "#1F2937",
+		title: "#111827",
+		separator: "#93C5FD"
+	},
+	file: {
+		border: "#2563EB",
+		background: "#DBEAFE",
+		headerText: "#111827",
+		headerBackground: "#BFDBFE"
+	},
+	prompt: {
+		question: "#111827",
+		optionText: "#1F2937",
+		optionTextDim: "#6B7280",
+		optionSelected: "#2563EB",
+		optionSelectedBackground: "#DBEAFE",
+		confirmButton: "#16A34A",
+		cancelButton: "#DC2626",
+		buttonBackground: "#E5E7EB",
+		buttonSelectedBackground: "#D1D5DB",
+		inputBorder: "#2563EB",
+		inputBackground: "#FFFFFF",
+		inputText: "#111827",
+		inputPlaceholder: "#9CA3AF",
+		inputCursor: "#2563EB",
+		border: "#D1D5DB",
+		focusBorder: "#2563EB"
+	},
+	errorHighlight: {
+		background: "#FEE2E2",
+		border: "#DC2626",
+		gutterBackground: "#FECACA"
+	},
+	filter: {
+		background: "#F3F4F6",
+		border: "#2563EB",
+		text: "#1F2937",
+		textDim: "#6B7280",
+		inputBackground: "#FFFFFF",
+		inputText: "#111827",
+		inputPlaceholder: "#9CA3AF",
+		cursor: "#2563EB",
+		activeLevel: "#2563EB",
+		inactiveLevel: "#D1D5DB"
+	},
+	help: {
+		background: "#FFFFFF",
+		border: "#2563EB",
+		title: "#111827",
+		category: "#2563EB",
+		key: "#D97706",
+		description: "#1F2937",
+		hint: "#6B7280"
+	},
+	colors: {
+		primary: "#2563EB",
+		secondary: "#7C3AED",
+		success: "#16A34A",
+		warning: "#D97706",
+		error: "#DC2626",
+		muted: "#6B7280",
+		background: "#FFFFFF",
+		foreground: "#111827"
+	}
+};
+
+//#endregion
+//#region src/themes/high-contrast.ts
+/**
+* High contrast theme for accessibility.
+* Uses pure black/white with saturated colors for maximum visibility.
+*/ const highContrastTheme = {
+	name: "high-contrast",
+	logLevels: {
+		verbose: {
+			border: "#FFFFFF",
+			background: "#1A1A1A",
+			text: "#FFFFFF"
+		},
+		debug: {
+			border: "#A855F7",
+			background: "#1A1A1A",
+			text: "#E9D5FF"
+		},
+		log: {
+			border: "#3B82F6",
+			background: "#1A1A1A",
+			text: "#BFDBFE"
+		},
+		warn: {
+			border: "#FBBF24",
+			background: "#1A1A1A",
+			text: "#FEF08A"
+		},
+		error: {
+			border: "#EF4444",
+			background: "#1A1A1A",
+			text: "#FECACA"
+		},
+		fatal: {
+			border: "#FF0000",
+			background: "#330000",
+			text: "#FFFFFF"
+		}
+	},
+	sidebar: {
+		background: "#000000",
+		selectedBackground: "#333333",
+		hoverBackground: "#1A1A1A",
+		text: "#FFFFFF",
+		textDim: "#AAAAAA",
+		border: "#FFFFFF",
+		badge: "#FFFF00",
+		focusBorder: "#FFFF00"
+	},
+	header: {
+		background: "#000000",
+		text: "#FFFFFF",
+		border: "#FFFFFF"
+	},
+	statusIndicators: {
+		waiting: {
+			icon: "○",
+			color: "#AAAAAA"
+		},
+		pending: {
+			icon: "◐",
+			color: "#FBBF24"
+		},
+		success: {
+			icon: "✓",
+			color: "#22C55E"
+		},
+		fail: {
+			icon: "✗",
+			color: "#EF4444"
+		},
+		static: {
+			icon: "●",
+			color: "#00FFFF"
+		}
+	},
+	separator: {
+		line: "#FFFFFF",
+		text: "#AAAAAA"
+	},
+	progress: {
+		border: "#3B82F6",
+		background: "#1A1A1A",
+		barFilled: "#3B82F6",
+		barEmpty: "#333333",
+		text: "#FFFFFF",
+		textDim: "#AAAAAA",
+		complete: "#22C55E",
+		completeBackground: "#1A1A1A",
+		failed: "#EF4444",
+		failedBackground: "#1A1A1A"
+	},
+	group: {
+		border: "#FFFFFF",
+		background: "#1A1A1A",
+		headerText: "#FFFFFF",
+		icon: "#AAAAAA"
+	},
+	table: {
+		border: "#FFFFFF",
+		background: "#1A1A1A",
+		headerText: "#FFFFFF",
+		cellText: "#FFFFFF",
+		title: "#FFFFFF",
+		separator: "#666666"
+	},
+	file: {
+		border: "#FFFFFF",
+		background: "#1A1A1A",
+		headerText: "#FFFFFF",
+		headerBackground: "#333333"
+	},
+	prompt: {
+		question: "#FFFFFF",
+		optionText: "#FFFFFF",
+		optionTextDim: "#AAAAAA",
+		optionSelected: "#FFFF00",
+		optionSelectedBackground: "#333333",
+		confirmButton: "#22C55E",
+		cancelButton: "#EF4444",
+		buttonBackground: "#333333",
+		buttonSelectedBackground: "#1A1A1A",
+		inputBorder: "#FFFF00",
+		inputBackground: "#1A1A1A",
+		inputText: "#FFFFFF",
+		inputPlaceholder: "#666666",
+		inputCursor: "#FFFF00",
+		border: "#FFFFFF",
+		focusBorder: "#FFFF00"
+	},
+	errorHighlight: {
+		background: "#330000",
+		border: "#FF0000",
+		gutterBackground: "#660000"
+	},
+	filter: {
+		background: "#1A1A1A",
+		border: "#FFFF00",
+		text: "#FFFFFF",
+		textDim: "#AAAAAA",
+		inputBackground: "#000000",
+		inputText: "#FFFFFF",
+		inputPlaceholder: "#666666",
+		cursor: "#FFFF00",
+		activeLevel: "#FFFF00",
+		inactiveLevel: "#666666"
+	},
+	help: {
+		background: "#000000",
+		border: "#FFFFFF",
+		title: "#FFFFFF",
+		category: "#FFFF00",
+		key: "#00FFFF",
+		description: "#FFFFFF",
+		hint: "#AAAAAA"
+	},
+	colors: {
+		primary: "#3B82F6",
+		secondary: "#A855F7",
+		success: "#22C55E",
+		warning: "#FBBF24",
+		error: "#EF4444",
+		muted: "#AAAAAA",
+		background: "#000000",
+		foreground: "#FFFFFF"
+	}
+};
+
+//#endregion
+//#region src/themes/utils.ts
+/**
+* Deep merge two objects, with source taking precedence.
+*/ function deepMerge(target, source) {
+	const result = { ...target };
+	for (const key in source) if (Object.prototype.hasOwnProperty.call(source, key)) {
+		const sourceValue = source[key];
+		const targetValue = target[key];
+		if (sourceValue !== void 0 && typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue) && typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue)) result[key] = deepMerge(targetValue, sourceValue);
+		else if (sourceValue !== void 0) result[key] = sourceValue;
+	}
+	return result;
+}
+/**
+* Get a theme by preset name.
+*/ function getThemePreset(preset) {
+	switch (preset) {
+		case "dark": return darkTheme;
+		case "light": return lightTheme;
+		case "high-contrast": return highContrastTheme;
+		default: return darkTheme;
+	}
+}
+/**
+* Merge a base theme with partial overrides.
+*/ function mergeThemes(base, overrides) {
+	return deepMerge(base, overrides);
+}
+/**
+* Create a custom theme by extending the dark theme with overrides.
+*/ function createTheme(overrides) {
+	return mergeThemes(darkTheme, overrides);
+}
+/**
+* Create a custom theme by extending a specific base theme.
+*/ function createThemeFrom(base, overrides) {
+	return mergeThemes(typeof base === "string" ? getThemePreset(base) : base, overrides);
+}
+/**
+* Resolve a theme value which can be a Theme object or a preset name.
+*/ function resolveTheme(theme) {
+	return typeof theme === "string" ? getThemePreset(theme) : theme;
+}
+
+//#endregion
+//#region src/services/readline_prompt.ts
+/**
+* Readline-based prompt service for stdout mode.
+* Provides basic interactive prompts when TUI adapter is not available.
+*/ var ReadlinePromptService = class {
+	rl = null;
+	promptQueue = [];
+	isProcessing = false;
+	ensureInterface() {
+		if (!this.rl) this.rl = node_readline.createInterface({
+			input: process.stdin,
+			output: process.stdout
+		});
+		return this.rl;
+	}
+	/**
+	* Handle a prompt interactively via readline.
+	* Prompts are queued and processed sequentially.
+	*/ async handlePrompt(prompt) {
+		return new Promise((resolve) => {
+			this.promptQueue.push({
+				prompt,
+				resolve
+			});
+			this.processQueue();
+		});
+	}
+	async processQueue() {
+		if (this.isProcessing || this.promptQueue.length === 0) return;
+		this.isProcessing = true;
+		while (this.promptQueue.length > 0) {
+			const { prompt, resolve } = this.promptQueue.shift();
+			resolve(await this.processPrompt(prompt));
+		}
+		this.isProcessing = false;
+	}
+	async processPrompt(prompt) {
+		switch (prompt.type) {
+			case "choice": return this.handleChoice(prompt);
+			case "confirm": return this.handleConfirm(prompt);
+			case "input": return this.handleInput(prompt);
+			case "multiChoice": return this.handleMultiChoice(prompt);
+		}
+	}
+	async handleChoice(prompt) {
+		const rl = this.ensureInterface();
+		console.log(`\n${prompt.question}`);
+		prompt.choices.forEach((choice, index) => {
+			const marker = choice.value === prompt.defaultChoice ? "*" : " ";
+			const inputHint = choice.input ? " (allows custom input)" : "";
+			console.log(`  ${marker} ${index + 1}. ${choice.label}${inputHint}`);
+		});
+		return new Promise((resolve) => {
+			rl.question("Enter number (or press Enter for default): ", (answer) => {
+				const trimmed = answer.trim();
+				if (!trimmed) {
+					resolve(prompt.defaultChoice);
+					return;
+				}
+				const num = parseInt(trimmed, 10);
+				if (num >= 1 && num <= prompt.choices.length) {
+					const choice = prompt.choices[num - 1];
+					if (choice.input) rl.question(`Enter value for "${choice.label}": `, (inputValue) => {
+						resolve(inputValue.trim() || choice.value);
+					});
+					else resolve(choice.value);
+				} else resolve(prompt.defaultChoice);
+			});
+		});
+	}
+	async handleConfirm(prompt) {
+		const rl = this.ensureInterface();
+		const defaultText = prompt.defaultValue ? "Y/n" : "y/N";
+		return new Promise((resolve) => {
+			rl.question(`${prompt.question} [${defaultText}]: `, (answer) => {
+				const trimmed = answer.trim().toLowerCase();
+				if (!trimmed) {
+					resolve(prompt.defaultValue);
+					return;
+				}
+				resolve(trimmed === "y" || trimmed === "yes");
+			});
+		});
+	}
+	async handleInput(prompt) {
+		const rl = this.ensureInterface();
+		const defaultHint = prompt.defaultValue ? ` (default: ${prompt.defaultValue})` : "";
+		const placeholderHint = prompt.placeholder ? ` [${prompt.placeholder}]` : "";
+		return new Promise((resolve) => {
+			rl.question(`${prompt.question}${placeholderHint}${defaultHint}: `, (answer) => {
+				resolve(answer.trim() || prompt.defaultValue);
+			});
+		});
+	}
+	async handleMultiChoice(prompt) {
+		const rl = this.ensureInterface();
+		console.log(`\n${prompt.question}`);
+		console.log(`(Select ${prompt.minSelect}-${prompt.maxSelect} options, enter comma-separated numbers)`);
+		prompt.choices.forEach((choice, index) => {
+			const selected = prompt.selectedIndices.has(index) ? "[x]" : "[ ]";
+			console.log(`  ${selected} ${index + 1}. ${choice.label}`);
+		});
+		return new Promise((resolve) => {
+			rl.question("Enter numbers (e.g., 1,3,5): ", (answer) => {
+				const trimmed = answer.trim();
+				if (!trimmed) {
+					resolve(prompt.choices.filter((_, i) => prompt.selectedIndices.has(i)).map((c) => c.value));
+					return;
+				}
+				const indices = trimmed.split(",").map((s) => parseInt(s.trim(), 10) - 1).filter((n) => n >= 0 && n < prompt.choices.length);
+				if (indices.length < prompt.minSelect) {
+					console.log(`Minimum ${prompt.minSelect} selections required. Using defaults.`);
+					resolve(prompt.choices.filter((_, i) => prompt.selectedIndices.has(i)).map((c) => c.value));
+					return;
+				}
+				if (indices.length > prompt.maxSelect) {
+					console.log(`Maximum ${prompt.maxSelect} selections allowed. Taking first ${prompt.maxSelect}.`);
+					indices.splice(prompt.maxSelect);
+				}
+				resolve(indices.map((i) => prompt.choices[i].value));
+			});
+		});
+	}
+	/**
+	* Cleanup readline interface
+	*/ destroy() {
+		if (this.rl) {
+			this.rl.close();
+			this.rl = null;
+		}
+		this.promptQueue = [];
+		this.isProcessing = false;
+	}
+};
+
 //#endregion
 //#region src/services/screen.ts
-var ScreenInstance = class {
+var ScreenInstance = class extends node_events.EventEmitter {
 	id;
 	name;
 	icon;
@@ -5022,13 +6291,13 @@ var ScreenInstance = class {
 	hidden = false;
 	messages = [];
 	manager = null;
-	changeListeners = /* @__PURE__ */ new Set();
 	printFn = null;
 	hasPrinted = false;
 	version = 0;
 	promptQueue = [];
 	activePrompt = null;
 	constructor(id, options) {
+		super();
 		this.id = id;
 		this.name = options.name;
 		this.icon = options.icon;
@@ -5066,7 +6335,7 @@ var ScreenInstance = class {
 	}
 	setBadgeCount(count) {
 		this.badgeCount = count;
-		this.notifyChange();
+		this.emit("badge:changed", count);
 		return this;
 	}
 	isHidden() {
@@ -5075,7 +6344,7 @@ var ScreenInstance = class {
 	setHidden(hidden) {
 		this.hidden = hidden;
 		this.manager?.onScreenVisibilityChanged(this);
-		this.notifyChange();
+		this.emit("visibility:changed", hidden);
 		return this;
 	}
 	show() {
@@ -5088,15 +6357,22 @@ var ScreenInstance = class {
 		return this.status;
 	}
 	/**
-	* Set screen status. When success/fail and TUI is not bound, prints to stdout/stderr
+	* Check if a log level is enabled globally via the ScreenManager.
+	* Returns true if no manager is set or if the level is allowed.
+	*/ isLogLevelEnabled(level) {
+		if (!this.manager) return true;
+		return this.manager.isLogLevelEnabled(level);
+	}
+	/**
+	* Set screen status. When success/fail and not in TUI mode, prints to stdout/stderr
 	*/ setStatus(status) {
 		const wasComplete = this.status === "success" || this.status === "fail";
 		this.status = status;
 		if (!wasComplete && (status === "success" || status === "fail")) {
-			if (!this.manager?.isTuiBound()) this.printToConsole();
+			if (!this.manager?.hasTuiRenderer()) this.printToConsole();
 			this.manager?.onScreenCompleted(this);
 		}
-		this.notifyChange();
+		this.emit("status:changed", status);
 		return this;
 	}
 	/**
@@ -5105,9 +6381,12 @@ var ScreenInstance = class {
 		return this.status === "success" || this.status === "fail";
 	}
 	/**
-	* Check if this screen has been printed to console
+	* Check if this screen has been printed to console.
+	* Static screens in non-TUI modes are considered printed as they print incrementally.
 	*/ hasPrintedToConsole() {
-		return this.hasPrinted;
+		if (this.hasPrinted) return true;
+		if (this.status === "static" && !this.manager?.hasTuiRenderer()) return true;
+		return false;
 	}
 	/**
 	* Force print to console (called when TUI unbinds)
@@ -5124,19 +6403,25 @@ var ScreenInstance = class {
 	*/ addMessage(message) {
 		this.messages.push(message);
 		this.incrementVersion();
-		this.notifyChange();
+		if (this.status === "static" && !this.manager?.hasTuiRenderer()) this.printSingleMessageToConsole(message);
+		this.emit("message:added", message.id);
 	}
 	/**
 	* Update a loading message (internal use by Logger)
 	*/ updateMessage(id, updates) {
 		const index = this.messages.findIndex((m) => m.id === id);
 		if (index !== -1) {
+			const oldMessage = this.messages[index];
 			this.messages[index] = {
 				...this.messages[index],
 				...updates
 			};
 			this.incrementVersion();
-			this.notifyChange();
+			if (this.status === "static" && !this.manager?.hasTuiRenderer()) {
+				const newMessage = this.messages[index];
+				if (newMessage.status !== "loading" && oldMessage.status === "loading") this.printSingleMessageToConsole(newMessage);
+			}
+			this.emit("message:updated", id);
 		}
 	}
 	/**
@@ -5144,12 +6429,17 @@ var ScreenInstance = class {
 	*/ updateProgressMessage(id, updates) {
 		const index = this.messages.findIndex((m) => m.id === id);
 		if (index !== -1) {
+			const oldMessage = this.messages[index];
 			this.messages[index] = {
 				...this.messages[index],
 				...updates
 			};
 			this.incrementVersion();
-			this.notifyChange();
+			if (this.status === "static" && !this.manager?.hasTuiRenderer()) {
+				const newMessage = this.messages[index];
+				if ((newMessage.status === "complete" || newMessage.status === "failed") && oldMessage.status !== "complete" && oldMessage.status !== "failed") this.printSingleMessageToConsole(newMessage);
+			}
+			this.emit("message:updated", id);
 		}
 	}
 	/**
@@ -5157,7 +6447,7 @@ var ScreenInstance = class {
 	*/ clear() {
 		this.messages = [];
 		this.incrementVersion();
-		this.notifyChange();
+		this.emit("messages:cleared");
 		return this;
 	}
 	/**
@@ -5165,21 +6455,26 @@ var ScreenInstance = class {
 	* Returns a promise that resolves when the user responds
 	*/ _addPrompt(prompt) {
 		return new Promise((resolve) => {
+			const mode = this.manager?.getRenderMode() ?? RenderMode.UNBOUND;
+			if (mode === RenderMode.UNBOUND) {
+				this.resolvePromptWithDefault(prompt, resolve);
+				return;
+			}
+			if (mode === RenderMode.STDOUT_INTERACTIVE || mode === RenderMode.STDOUT_FALLBACK) {
+				this.manager?.handleReadlinePrompt(prompt).then(resolve);
+				return;
+			}
 			const pending = {
 				data: prompt,
 				resolve
 			};
-			if (!this.manager?.isTuiBound()) {
-				this.resolvePromptWithDefault(prompt, resolve);
-				return;
-			}
 			if (prompt.timeout && prompt.timeoutStarted) pending.timeoutId = setTimeout(() => {
 				if (this.activePrompt === pending) {
 					this.resolvePromptWithDefault(prompt, resolve);
 					this.activePrompt = null;
 					this.activateNextPrompt();
 					this.incrementVersion();
-					this.notifyChange();
+					this.emit("prompt:resolved");
 				} else {
 					const idx = this.promptQueue.indexOf(pending);
 					if (idx !== -1) {
@@ -5196,20 +6491,7 @@ var ScreenInstance = class {
 	/**
 	* Resolve a prompt with its default value
 	*/ resolvePromptWithDefault(prompt, resolve) {
-		switch (prompt.type) {
-			case "choice":
-				resolve(prompt.defaultChoice);
-				break;
-			case "confirm":
-				resolve(prompt.defaultValue);
-				break;
-			case "input":
-				resolve(prompt.defaultValue);
-				break;
-			case "multiChoice":
-				resolve(prompt.choices.filter((_, i) => prompt.selectedIndices.has(i)).map((c) => c.value));
-				break;
-		}
+		resolve(getPromptDefaultValue(prompt));
 	}
 	/**
 	* Get the currently active prompt (for rendering)
@@ -5233,7 +6515,7 @@ var ScreenInstance = class {
 			const maxIndex = prompt.choices.length - 1;
 			prompt.focusedIndex = Math.max(0, Math.min(index, maxIndex));
 		} else if (prompt.type === "confirm") prompt.selectedValue = index === 0;
-		this.notifyChange();
+		this.emit("prompt:updated");
 	}
 	/**
 	* Navigate prompt selection up
@@ -5260,7 +6542,7 @@ var ScreenInstance = class {
 		const prompt = this.activePrompt.data;
 		if (prompt.type === "confirm") {
 			prompt.selectedValue = true;
-			this.notifyChange();
+			this.emit("prompt:updated");
 		}
 	}
 	promptNavigateRight() {
@@ -5268,7 +6550,7 @@ var ScreenInstance = class {
 		const prompt = this.activePrompt.data;
 		if (prompt.type === "confirm") {
 			prompt.selectedValue = false;
-			this.notifyChange();
+			this.emit("prompt:updated");
 		}
 	}
 	/**
@@ -5280,7 +6562,7 @@ var ScreenInstance = class {
 			const p = prompt;
 			if (p.selectedIndices.has(p.focusedIndex)) p.selectedIndices.delete(p.focusedIndex);
 			else if (p.selectedIndices.size < p.maxSelect) p.selectedIndices.add(p.focusedIndex);
-			this.notifyChange();
+			this.emit("prompt:updated");
 		}
 	}
 	/**
@@ -5292,7 +6574,7 @@ var ScreenInstance = class {
 		if (prompt.type === "choice") {
 			if (prompt.choices[prompt.selectedIndex]?.input) {
 				prompt.inputMode = true;
-				this.notifyChange();
+				this.emit("prompt:updated");
 				return true;
 			}
 		} else if (prompt.type === "input") return true;
@@ -5305,7 +6587,7 @@ var ScreenInstance = class {
 		const prompt = this.activePrompt.data;
 		if (prompt.type === "choice" && prompt.inputMode) {
 			prompt.inputMode = false;
-			this.notifyChange();
+			this.emit("prompt:updated");
 		}
 	}
 	/**
@@ -5324,10 +6606,10 @@ var ScreenInstance = class {
 		const prompt = this.activePrompt.data;
 		if (prompt.type === "choice" && prompt.inputMode) {
 			prompt.inputValue = value;
-			this.notifyChange();
+			this.emit("prompt:updated");
 		} else if (prompt.type === "input") {
 			prompt.value = value;
-			this.notifyChange();
+			this.emit("prompt:updated");
 		}
 	}
 	/**
@@ -5337,10 +6619,10 @@ var ScreenInstance = class {
 		const prompt = this.activePrompt.data;
 		if (prompt.type === "choice" && prompt.inputMode) {
 			prompt.inputValue += char;
-			this.notifyChange();
+			this.emit("prompt:updated");
 		} else if (prompt.type === "input") {
 			prompt.value += char;
-			this.notifyChange();
+			this.emit("prompt:updated");
 		}
 	}
 	/**
@@ -5350,10 +6632,10 @@ var ScreenInstance = class {
 		const prompt = this.activePrompt.data;
 		if (prompt.type === "choice" && prompt.inputMode) {
 			prompt.inputValue = prompt.inputValue.slice(0, -1);
-			this.notifyChange();
+			this.emit("prompt:updated");
 		} else if (prompt.type === "input") {
 			prompt.value = prompt.value.slice(0, -1);
-			this.notifyChange();
+			this.emit("prompt:updated");
 		}
 	}
 	/**
@@ -5398,7 +6680,7 @@ var ScreenInstance = class {
 		this.activePrompt = null;
 		this.activateNextPrompt();
 		this.incrementVersion();
-		this.notifyChange();
+		this.emit("prompt:resolved");
 	}
 	/**
 	* Activate the next prompt in the queue
@@ -5407,17 +6689,13 @@ var ScreenInstance = class {
 			this.activePrompt = this.promptQueue.shift();
 			this.manager?.onScreenPromptActivated(this);
 			this.incrementVersion();
-			this.notifyChange();
+			this.emit("prompt:activated");
 		}
 	}
 	/**
-	* Register a change listener for re-renders
-	*/ onChange(listener) {
-		this.changeListeners.add(listener);
-		return () => this.changeListeners.delete(listener);
-	}
-	notifyChange() {
-		this.changeListeners.forEach((listener) => listener());
+	* Print a single message immediately to stdout (for static screens in stdout mode)
+	*/ printSingleMessageToConsole(message) {
+		printSingleMessage(message, this.name, false);
 	}
 	/**
 	* Print all messages to stdout/stderr with ANSI colors
@@ -5710,24 +6988,29 @@ function applyDecs2203RFactory$2() {
 function _apply_decs_2203_r$2(targetClass, memberDecs, classDecs, parentClass) {
 	return (_apply_decs_2203_r$2 = applyDecs2203RFactory$2())(targetClass, memberDecs, classDecs, parentClass);
 }
-var _dec$2, _initClass$2;
+var _dec$2, _initClass$2, _EventEmitter;
 let _ScreenManagerInstance;
 _dec$2 = (0, _navios_core.Injectable)({ token: ScreenManager });
-var ScreenManagerInstance = class {
+var ScreenManagerInstance = class extends (_EventEmitter = node_events.EventEmitter) {
 	static {
-		({c: [_ScreenManagerInstance, _initClass$2]} = _apply_decs_2203_r$2(this, [], [_dec$2]));
+		({c: [_ScreenManagerInstance, _initClass$2]} = _apply_decs_2203_r$2(this, [], [_dec$2], _EventEmitter));
+	}
+	constructor() {
+		super();
 	}
 	screens = /* @__PURE__ */ new Map();
 	screenOrder = [];
 	activeScreenId = null;
 	renderer = null;
 	root = null;
-	adapter = (0, _navios_core.inject)(require_filter_engine.Adapter);
-	isBound = false;
-	changeListeners = /* @__PURE__ */ new Set();
+	adapter = null;
+	container = (0, _navios_core.inject)(_navios_core.Container);
+	mode = RenderMode.UNBOUND;
+	readlinePromptService = null;
 	bindOptions = {};
 	autoCloseTimer = null;
 	theme;
+	globalLogLevels = null;
 	focusArea = "content";
 	selectedIndex = 0;
 	/**
@@ -5736,12 +7019,12 @@ var ScreenManagerInstance = class {
 		const id = `screen-${Date.now()}-${Math.random().toString(36).slice(2)}`;
 		const screen = new ScreenInstance(id, options);
 		screen._setManager(this);
-		screen._setPrintFn(require_filter_engine.printMessagesToStdout);
-		screen.onChange(() => this.notifyChange());
+		screen._setPrintFn(printMessagesToStdout);
 		this.screens.set(id, screen);
 		this.screenOrder.push(id);
 		if (!this.activeScreenId && !screen.isHidden()) this.activeScreenId = id;
-		this.notifyChange();
+		this.checkAutoClose();
+		this.emit("screen:added", id);
 		return screen;
 	}
 	getScreenByName(name) {
@@ -5755,71 +7038,190 @@ var ScreenManagerInstance = class {
 		if (!this.screens.has(id)) return;
 		this.screens.delete(id);
 		this.screenOrder = this.screenOrder.filter((sid) => sid !== id);
-		if (this.activeScreenId === id) this.activeScreenId = this.getScreens()[0]?.getId() ?? null;
+		if (this.activeScreenId === id) {
+			this.activeScreenId = this.getScreens()[0]?.getId() ?? null;
+			this.emit("activeScreen:changed", this.activeScreenId);
+		}
 		const visibleScreens = this.getScreens();
-		if (this.selectedIndex >= visibleScreens.length) this.selectedIndex = Math.max(0, visibleScreens.length - 1);
-		this.notifyChange();
+		if (this.selectedIndex >= visibleScreens.length) {
+			const newIndex = Math.max(0, visibleScreens.length - 1);
+			if (newIndex !== this.selectedIndex) {
+				this.selectedIndex = newIndex;
+				this.emit("sidebar:indexChanged", this.selectedIndex);
+			}
+		}
+		this.checkAutoClose();
+		this.emit("screen:removed", id);
 	}
 	/**
 	* Non-blocking bind - starts TUI rendering in background
 	*/ async bind(options) {
-		if (this.isBound) return;
+		if (this.mode !== RenderMode.UNBOUND) return;
 		this.bindOptions = options ?? {};
-		if (options?.theme) this.theme = typeof options.theme === "string" ? require_filter_engine.getThemePreset(options.theme) : options.theme;
-		this.renderer = await (0, _opentui_core.createCliRenderer)({
-			exitOnCtrlC: options?.exitOnCtrlC ?? true,
-			useAlternateScreen: true,
-			useMouse: options?.useMouse ?? true
-		});
-		this.root = await this.adapter.createRoot(this.renderer);
-		this.isBound = true;
-		this.render();
+		if (options?.theme) this.theme = typeof options.theme === "string" ? getThemePreset(options.theme) : options.theme;
+		if (!(options?.useOpenTUI ?? !isBunRuntime())) {
+			this.mode = RenderMode.STDOUT_INTERACTIVE;
+			this.readlinePromptService = new ReadlinePromptService();
+			this.emit("mode:changed", this.mode);
+			return;
+		}
+		try {
+			this.adapter = await this.container.get(Adapter);
+			if (this.adapter.isMissingAdapter) throw new Error("No adapter registered");
+			if (this.adapter.handlesOwnRenderer) this.root = await this.adapter.createRoot();
+			else {
+				const { createCliRenderer } = await dynamicImport("@opentui/core");
+				this.renderer = await createCliRenderer({
+					exitOnCtrlC: options?.exitOnCtrlC ?? true,
+					useAlternateScreen: true,
+					useMouse: options?.useMouse ?? true
+				});
+				this.root = await this.adapter.createRoot(this.renderer);
+			}
+			this.mode = RenderMode.TUI_ACTIVE;
+			this.emit("mode:changed", this.mode);
+			this.render();
+		} catch {
+			console.warn("[commander-tui] TUI adapter not available, falling back to stdout mode. To enable TUI, import a TUI adapter: @navios/tui-adapter-react, @navios/tui-adapter-ink, or @navios/tui-adapter-solid");
+			this.mode = RenderMode.STDOUT_FALLBACK;
+			this.readlinePromptService = new ReadlinePromptService();
+			this.adapter = null;
+			this.renderer = null;
+			this.root = null;
+			this.emit("mode:changed", this.mode);
+		}
+	}
+	/**
+	* Get the current render mode
+	*/ getRenderMode() {
+		return this.mode;
+	}
+	/**
+	* Check if TUI is interactive (any mode except UNBOUND).
+	* In interactive modes, prompts can be handled via readline or TUI.
+	*/ isInteractive() {
+		return this.mode !== RenderMode.UNBOUND;
+	}
+	/**
+	* Check if TUI rendering is active (TUI_ACTIVE mode).
+	* When true, screens are rendered in the TUI and not printed to stdout.
+	*/ hasTuiRenderer() {
+		return this.mode === RenderMode.TUI_ACTIVE;
+	}
+	/**
+	* Handle a prompt via readline (for stdout modes)
+	*/ handleReadlinePrompt(prompt) {
+		if (!this.readlinePromptService) return Promise.resolve(getPromptDefaultValue(prompt));
+		return this.readlinePromptService.handlePrompt(prompt);
 	}
 	/**
 	* Get the configured theme
 	*/ getTheme() {
 		return this.theme;
 	}
+	/**
+	* Setup global configuration for the screen manager.
+	* Can be called before or after bind() to configure theme and log levels.
+	*/ setup(options) {
+		if (options.theme) this.theme = typeof options.theme === "string" ? getThemePreset(options.theme) : options.theme;
+		if (options.logLevels) this.globalLogLevels = new Set(options.logLevels);
+	}
+	/**
+	* Check if a log level is enabled globally.
+	* Returns true if no global filter is set, or if the level is in the allowed set.
+	*/ isLogLevelEnabled(level) {
+		if (this.globalLogLevels === null) return true;
+		return this.globalLogLevels.has(level);
+	}
+	/**
+	* Get the current global log levels filter.
+	* Returns null if no filter is set (all levels allowed).
+	*/ getGlobalLogLevels() {
+		return this.globalLogLevels ? Array.from(this.globalLogLevels) : null;
+	}
 	onServiceDestroy() {
 		this.unbind();
 	}
 	/**
 	* Stop TUI rendering and cleanup
-	* Flushes all completed screens to stdout/stderr
+	* Flushes screens to stdout/stderr based on mode
 	*/ unbind() {
-		if (!this.isBound) return;
+		if (this.mode === RenderMode.UNBOUND) {
+			this.flushRemainingScreens();
+			return;
+		}
+		const previousMode = this.mode;
 		if (this.autoCloseTimer) {
 			clearTimeout(this.autoCloseTimer);
 			this.autoCloseTimer = null;
 		}
-		this.root?.unmount();
-		if (this.renderer && "disableMouse" in this.renderer) this.renderer.disableMouse();
-		this.renderer?.destroy();
+		if (previousMode === RenderMode.TUI_ACTIVE) {
+			if (this.root) this.root.unmount();
+			if (this.renderer) {
+				if ("disableMouse" in this.renderer) this.renderer.disableMouse();
+				this.renderer.destroy();
+			}
+		}
+		if (this.readlinePromptService) {
+			this.readlinePromptService.destroy();
+			this.readlinePromptService = null;
+		}
+		this.flushScreensOnExit(previousMode);
+		this.mode = RenderMode.UNBOUND;
 		this.renderer = null;
 		this.root = null;
-		this.isBound = false;
-		this.flushCompletedScreens();
+		this.adapter = null;
+		this.emit("mode:changed", this.mode);
+	}
+	/**
+	* Flush screens on exit based on the mode we're exiting from
+	*/ flushScreensOnExit(previousMode) {
+		for (const id of this.screenOrder) {
+			const screen = this.screens.get(id);
+			if (!screen || screen.isHidden()) continue;
+			if (previousMode === RenderMode.TUI_ACTIVE) screen._flushToConsole(true);
+			else if (!screen.hasPrintedToConsole()) screen._flushToConsole(true);
+		}
 	}
 	/**
-	* Print all completed screens that haven't been printed yet
-	*/ flushCompletedScreens() {
+	* Flush any remaining non-hidden screens that haven't been printed.
+	* Called on destroy even in UNBOUND mode to handle forgotten completions.
+	*/ flushRemainingScreens() {
 		for (const id of this.screenOrder) {
 			const screen = this.screens.get(id);
-			if (screen && !screen.hasPrintedToConsole()) screen._flushToConsole(true);
+			if (!screen || screen.isHidden()) continue;
+			if (!screen.hasPrintedToConsole()) screen._flushToConsole(true);
 		}
 	}
 	/**
 	* Check if TUI is currently bound
+	* @deprecated Use isInteractive() instead
 	*/ isTuiBound() {
-		return this.isBound;
+		return this.isInteractive();
+	}
+	/**
+	* Check if TUI rendering is active (has renderer or self-rendering adapter).
+	* @deprecated Use hasTuiRenderer() instead
+	*/ isTuiRendererActive() {
+		return this.hasTuiRenderer();
+	}
+	/**
+	* Check if OpenTUI rendering is active (has renderer).
+	* @deprecated Use hasTuiRenderer() instead
+	*/ isOpenTUIActive() {
+		return this.hasTuiRenderer();
 	}
 	/**
 	* Called by Screen when a prompt becomes active
 	* Focuses the screen and switches to content area
 	*/ onScreenPromptActivated(screen) {
-		this.setActiveScreen(screen);
-		this.focusArea = "content";
-		this.notifyChange();
+		const prevActiveId = this.activeScreenId;
+		this.activeScreenId = screen.getId();
+		if (prevActiveId !== this.activeScreenId) this.emit("activeScreen:changed", this.activeScreenId);
+		if (this.focusArea !== "content") {
+			this.focusArea = "content";
+			this.emit("focus:changed", this.focusArea);
+		}
 	}
 	/**
 	* Check if any screen has an active prompt
@@ -5840,10 +7242,18 @@ var ScreenManagerInstance = class {
 		if (screen.isHidden() && this.activeScreenId === screen.getId()) {
 			this.activeScreenId = this.getScreens()[0]?.getId() ?? null;
 			this.selectedIndex = 0;
+			this.emit("activeScreen:changed", this.activeScreenId);
+			this.emit("sidebar:indexChanged", this.selectedIndex);
 		}
 		const visibleScreens = this.getScreens();
-		if (this.selectedIndex >= visibleScreens.length) this.selectedIndex = Math.max(0, visibleScreens.length - 1);
-		this.notifyChange();
+		if (this.selectedIndex >= visibleScreens.length) {
+			const newIndex = Math.max(0, visibleScreens.length - 1);
+			if (newIndex !== this.selectedIndex) {
+				this.selectedIndex = newIndex;
+				this.emit("sidebar:indexChanged", this.selectedIndex);
+			}
+		}
+		this.checkAutoClose();
 	}
 	/**
 	* Called by Screen when status becomes success/fail
@@ -5855,9 +7265,16 @@ var ScreenManagerInstance = class {
 			this.screenOrder.splice(index, 1);
 			this.screenOrder.push(id);
 			const visibleScreens = this.getScreens();
-			if (this.selectedIndex >= visibleScreens.length) this.selectedIndex = Math.max(0, visibleScreens.length - 1);
+			if (this.selectedIndex >= visibleScreens.length) {
+				const newIndex = Math.max(0, visibleScreens.length - 1);
+				if (newIndex !== this.selectedIndex) {
+					this.selectedIndex = newIndex;
+					this.emit("sidebar:indexChanged", this.selectedIndex);
+				}
+			}
+			this.checkAutoClose();
+			this.emit("screen:reordered");
 		}
-		this.notifyChange();
 	}
 	/**
 	* Check if all screens are successful (or only static) and start auto-close timer if enabled.
@@ -5865,7 +7282,7 @@ var ScreenManagerInstance = class {
 	* If there are only static screens, the timer will trigger after the delay with no new activity.
 	*/ checkAutoClose() {
 		const autoClose = this.bindOptions.autoClose;
-		if (!autoClose || !this.isBound) return;
+		if (!autoClose || this.mode === RenderMode.UNBOUND) return;
 		if (this.autoCloseTimer) {
 			clearTimeout(this.autoCloseTimer);
 			this.autoCloseTimer = null;
@@ -5897,8 +7314,9 @@ var ScreenManagerInstance = class {
 	/**
 	* Set the active screen
 	*/ setActiveScreen(screen) {
+		const prevActiveId = this.activeScreenId;
 		this.activeScreenId = screen.getId();
-		this.notifyChange();
+		if (prevActiveId !== this.activeScreenId) this.emit("activeScreen:changed", this.activeScreenId);
 	}
 	/**
 	* Get bind options
@@ -5908,15 +7326,20 @@ var ScreenManagerInstance = class {
 	/**
 	* Set focus area (sidebar or content)
 	*/ setFocusArea(area) {
-		this.focusArea = area;
-		this.notifyChange();
+		if (this.focusArea !== area) {
+			this.focusArea = area;
+			this.emit("focus:changed", area);
+		}
 	}
 	/**
 	* Set selected index in sidebar
 	*/ setSelectedIndex(index) {
 		const visibleScreens = this.getScreens();
-		this.selectedIndex = Math.max(0, Math.min(index, visibleScreens.length - 1));
-		this.notifyChange();
+		const newIndex = Math.max(0, Math.min(index, visibleScreens.length - 1));
+		if (this.selectedIndex !== newIndex) {
+			this.selectedIndex = newIndex;
+			this.emit("sidebar:indexChanged", newIndex);
+		}
 	}
 	/**
 	* Navigate sidebar up
@@ -5938,20 +7361,10 @@ var ScreenManagerInstance = class {
 	* Toggle focus between sidebar and content
 	*/ toggleFocus() {
 		this.focusArea = this.focusArea === "sidebar" ? "content" : "sidebar";
-		this.notifyChange();
-	}
-	/**
-	* Register a change listener for re-renders
-	*/ onChange(listener) {
-		this.changeListeners.add(listener);
-		return () => this.changeListeners.delete(listener);
-	}
-	notifyChange() {
-		this.checkAutoClose();
-		this.changeListeners.forEach((listener) => listener());
+		this.emit("focus:changed", this.focusArea);
 	}
 	render() {
-		if (!this.root) return;
+		if (!this.root || !this.adapter) return;
 		this.adapter.renderToRoot(this.root, {
 			manager: this,
 			theme: this.theme
@@ -6253,7 +7666,10 @@ var ScreenLoggerInstance = class {
 		({c: [_ScreenLoggerInstance, _initClass$1]} = _apply_decs_2203_r$1(this, [], [_dec$1]));
 	}
 	constructor(options) {
-		this.screen = (0, _navios_core.inject)(Screen, typeof options.screen === "string" ? { name: options.screen } : options.screen);
+		this.screen = (0, _navios_core.inject)(Screen, typeof options.screen === "string" ? {
+			name: options.screen,
+			static: true
+		} : options.screen);
 		this.context = options.context;
 		this.enabledLevels = new Set(options.enabledLevels);
 	}
@@ -6261,7 +7677,8 @@ var ScreenLoggerInstance = class {
 	context;
 	enabledLevels;
 	isLevelEnabled(level) {
-		return this.enabledLevels.has(level);
+		if (!this.enabledLevels.has(level)) return false;
+		return this.screen.isLogLevelEnabled(level);
 	}
 	verbose(msg, label) {
 		return this.write("verbose", msg, label);
@@ -6271,7 +7688,7 @@ var ScreenLoggerInstance = class {
 		return this;
 	}
 	trace(msg, label) {
-		const trace = require_filter_engine.captureTrace(1);
+		const trace = captureTrace(1);
 		return this.write("verbose", msg, label, trace, "trace");
 	}
 	debug(msg, label) {
@@ -6294,7 +7711,7 @@ var ScreenLoggerInstance = class {
 	}
 	write(level, content, label, trace, variant) {
 		if (!this.isLevelEnabled(level)) return this;
-		const formattedContent = typeof content === "object" ? require_filter_engine.formatObject(content) : content;
+		const formattedContent = typeof content === "object" ? formatObject(content) : content;
 		const message = {
 			id: generateId(),
 			type: "log",
@@ -6877,15 +8294,590 @@ var PromptInstance = class {
 };
 
 //#endregion
-exports.ALL_LOG_LEVELS = require_filter_engine.ALL_LOG_LEVELS;
-exports.Adapter = require_filter_engine.Adapter;
-exports.COMMON_FILETYPES = require_filter_engine.COMMON_FILETYPES;
-exports.DEFAULT_LOG_LEVEL_COLORS = require_filter_engine.DEFAULT_LOG_LEVEL_COLORS;
-exports.ERROR_HIGHLIGHT_COLORS = require_filter_engine.ERROR_HIGHLIGHT_COLORS;
-exports.FILE_COLORS = require_filter_engine.FILE_COLORS;
-exports.FilterEngine = require_filter_engine.FilterEngine;
-exports.GROUP_COLORS = require_filter_engine.GROUP_COLORS;
-exports.HEADER_COLORS = require_filter_engine.HEADER_COLORS;
+//#region src/keyboard/keyboard_manager.ts
+/**
+* Manages keyboard bindings and dispatches key events to handlers.
+*/ var KeyboardManager = class {
+	bindings = [];
+	disabled = /* @__PURE__ */ new Set();
+	constructor(config$1) {
+		if (config$1?.bindings) this.bindings = [...config$1.bindings];
+		if (config$1?.disabled) this.disabled = new Set(config$1.disabled);
+		this.sortBindings();
+	}
+	/**
+	* Add bindings to the manager.
+	*/ addBindings(bindings) {
+		this.bindings.push(...bindings);
+		this.sortBindings();
+	}
+	/**
+	* Remove a binding by key name.
+	*/ removeBinding(key) {
+		this.bindings = this.bindings.filter((b) => {
+			return !(Array.isArray(b.key) ? b.key : [b.key]).includes(key);
+		});
+	}
+	/**
+	* Disable a key (prevents it from being matched).
+	*/ disableKey(key) {
+		this.disabled.add(key);
+	}
+	/**
+	* Enable a previously disabled key.
+	*/ enableKey(key) {
+		this.disabled.delete(key);
+	}
+	/**
+	* Handle a key event, dispatching to the appropriate handler.
+	* Returns true if a handler consumed the event.
+	*/ handleKey(key, context) {
+		const binding = this.findMatchingBinding(key, context);
+		if (binding) return binding.handler(key, context) !== false;
+		return false;
+	}
+	/**
+	* Get all bindings for display in help overlay.
+	*/ getBindingsForHelp() {
+		return this.bindings.filter((b) => b.description);
+	}
+	/**
+	* Get bindings grouped by category.
+	*/ getBindingsByCategory() {
+		const grouped = {
+			general: [],
+			navigation: [],
+			screen: [],
+			prompt: [],
+			filter: []
+		};
+		for (const binding of this.bindings) if (binding.description) grouped[binding.category].push(binding);
+		return grouped;
+	}
+	/**
+	* Find a matching binding for the given key and context.
+	*/ findMatchingBinding(key, context) {
+		for (const binding of this.bindings) if (this.keyMatches(key, binding) && this.conditionMatches(binding.when, context) && !this.isDisabled(binding)) return binding;
+		return null;
+	}
+	/**
+	* Check if a key event matches a binding's key specification.
+	*/ keyMatches(key, binding) {
+		const keys = Array.isArray(binding.key) ? binding.key : [binding.key];
+		if (!(keys.includes(key.name) || key.sequence && keys.includes(key.sequence))) return false;
+		const ctrlMatches = (binding.ctrl ?? false) === (key.ctrl ?? false);
+		const metaMatches = (binding.meta ?? false) === (key.meta ?? false);
+		const shiftMatches = (binding.shift ?? false) === (key.shift ?? false);
+		return ctrlMatches && metaMatches && shiftMatches;
+	}
+	/**
+	* Check if context matches a binding's condition.
+	*/ conditionMatches(condition, context) {
+		if (!condition) return true;
+		if (condition.hasPrompt !== void 0 && condition.hasPrompt !== context.hasPrompt) return false;
+		if (condition.inInputMode !== void 0 && condition.inInputMode !== context.inInputMode) return false;
+		if (condition.focusArea !== void 0 && condition.focusArea !== context.focusArea) return false;
+		if (condition.isFilterActive !== void 0 && condition.isFilterActive !== context.isFilterActive) return false;
+		if (condition.isHelpVisible !== void 0 && condition.isHelpVisible !== context.isHelpVisible) return false;
+		if (condition.hasSidebar !== void 0 && condition.hasSidebar !== context.hasSidebar) return false;
+		return true;
+	}
+	/**
+	* Check if a binding is disabled.
+	*/ isDisabled(binding) {
+		return (Array.isArray(binding.key) ? binding.key : [binding.key]).some((k) => this.disabled.has(k));
+	}
+	/**
+	* Sort bindings by priority (higher first).
+	*/ sortBindings() {
+		this.bindings.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+	}
+};
+/**
+* Format a key binding for display.
+*/ function formatKeyBinding(binding) {
+	const keys = Array.isArray(binding.key) ? binding.key : [binding.key];
+	const parts = [];
+	if (binding.ctrl) parts.push("Ctrl");
+	if (binding.meta) parts.push("Cmd");
+	if (binding.shift) parts.push("Shift");
+	const keyDisplay = keys.map((k) => {
+		switch (k) {
+			case "up": return "↑";
+			case "down": return "↓";
+			case "left": return "←";
+			case "right": return "→";
+			case "return": return "Enter";
+			case "escape": return "Esc";
+			case "space": return "Space";
+			case "tab": return "Tab";
+			case "\\": return "\\";
+			default: return k;
+		}
+	}).join("/");
+	parts.push(keyDisplay);
+	return parts.join("+");
+}
+
+//#endregion
+//#region src/keyboard/create_bindings.ts
+/**
+* Create the default keybindings with access to manager and screens.
+*/ function createDefaultBindings(handlers) {
+	const { manager, getActiveScreen, toggleHelp, toggleFilter, closeFilter } = handlers;
+	const bindings = [];
+	bindings.push({
+		key: "escape",
+		handler: () => {
+			const screen = getActiveScreen();
+			if (screen?.isPromptInInputMode()) {
+				screen.promptExitInputMode();
+				return true;
+			}
+		},
+		description: "Exit input mode",
+		category: "prompt",
+		when: {
+			hasPrompt: true,
+			inInputMode: true
+		},
+		priority: 100
+	});
+	bindings.push({
+		key: "return",
+		handler: () => {
+			const screen = getActiveScreen();
+			if (screen?.isPromptInInputMode()) {
+				screen.promptSubmit();
+				return true;
+			}
+		},
+		description: "Submit input",
+		category: "prompt",
+		when: {
+			hasPrompt: true,
+			inInputMode: true
+		},
+		priority: 100
+	});
+	bindings.push({
+		key: "backspace",
+		handler: () => {
+			const screen = getActiveScreen();
+			if (screen?.isPromptInInputMode()) {
+				screen.promptDeleteLastChar();
+				return true;
+			}
+		},
+		description: "Delete character",
+		category: "prompt",
+		when: {
+			hasPrompt: true,
+			inInputMode: true
+		},
+		priority: 100
+	});
+	bindings.push({
+		key: ["up", "k"],
+		handler: () => {
+			const screen = getActiveScreen();
+			const prompt = screen?.getActivePrompt();
+			if (prompt?.type === "choice" || prompt?.type === "multiChoice") {
+				screen?.promptNavigateUp();
+				return true;
+			}
+		},
+		description: "Navigate up",
+		category: "prompt",
+		when: {
+			hasPrompt: true,
+			inInputMode: false
+		},
+		priority: 90
+	});
+	bindings.push({
+		key: ["down", "j"],
+		handler: () => {
+			const screen = getActiveScreen();
+			const prompt = screen?.getActivePrompt();
+			if (prompt?.type === "choice" || prompt?.type === "multiChoice") {
+				screen?.promptNavigateDown();
+				return true;
+			}
+		},
+		description: "Navigate down",
+		category: "prompt",
+		when: {
+			hasPrompt: true,
+			inInputMode: false
+		},
+		priority: 90
+	});
+	bindings.push({
+		key: ["left", "h"],
+		handler: () => {
+			const screen = getActiveScreen();
+			if ((screen?.getActivePrompt())?.type === "confirm") {
+				screen?.promptNavigateLeft();
+				return true;
+			}
+		},
+		description: "Select confirm",
+		category: "prompt",
+		when: {
+			hasPrompt: true,
+			inInputMode: false
+		},
+		priority: 90
+	});
+	bindings.push({
+		key: ["right", "l"],
+		handler: () => {
+			const screen = getActiveScreen();
+			if ((screen?.getActivePrompt())?.type === "confirm") {
+				screen?.promptNavigateRight();
+				return true;
+			}
+		},
+		description: "Select cancel",
+		category: "prompt",
+		when: {
+			hasPrompt: true,
+			inInputMode: false
+		},
+		priority: 90
+	});
+	bindings.push({
+		key: "space",
+		handler: () => {
+			const screen = getActiveScreen();
+			if ((screen?.getActivePrompt())?.type === "multiChoice") {
+				screen?.promptToggleSelection();
+				return true;
+			}
+		},
+		description: "Toggle selection",
+		category: "prompt",
+		when: {
+			hasPrompt: true,
+			inInputMode: false
+		},
+		priority: 90
+	});
+	bindings.push({
+		key: "return",
+		handler: () => {
+			const screen = getActiveScreen();
+			const prompt = screen?.getActivePrompt();
+			if (!prompt) return false;
+			if (prompt.type === "choice") {
+				if (!screen?.promptEnterInputMode()) screen?.promptSubmit();
+				return true;
+			} else if (prompt.type === "confirm") {
+				screen?.promptSubmit();
+				return true;
+			} else if (prompt.type === "multiChoice") {
+				if (screen?.canSubmitPrompt()) screen.promptSubmit();
+				return true;
+			}
+		},
+		description: "Submit selection",
+		category: "prompt",
+		when: {
+			hasPrompt: true,
+			inInputMode: false
+		},
+		priority: 90
+	});
+	bindings.push({
+		key: "?",
+		handler: () => {
+			toggleHelp();
+			return true;
+		},
+		description: "Toggle help",
+		category: "general",
+		when: {
+			hasPrompt: false,
+			isFilterActive: false
+		},
+		priority: 50
+	});
+	bindings.push({
+		key: "escape",
+		handler: () => {
+			toggleHelp();
+			return true;
+		},
+		description: "Close help",
+		category: "general",
+		when: { isHelpVisible: true },
+		priority: 80
+	});
+	bindings.push({
+		key: "/",
+		handler: () => {
+			toggleFilter();
+			return true;
+		},
+		description: "Toggle filter",
+		category: "filter",
+		when: {
+			hasPrompt: false,
+			isHelpVisible: false
+		},
+		priority: 50
+	});
+	bindings.push({
+		key: "escape",
+		handler: () => {
+			closeFilter();
+			return true;
+		},
+		description: "Close filter",
+		category: "filter",
+		when: { isFilterActive: true },
+		priority: 70
+	});
+	bindings.push({
+		key: "tab",
+		handler: () => {
+			handlers.filterCycleField();
+			return true;
+		},
+		description: "Cycle filter fields",
+		category: "filter",
+		when: { isFilterActive: true },
+		priority: 70
+	});
+	bindings.push({
+		key: "backspace",
+		handler: () => {
+			handlers.filterDeleteChar();
+			return true;
+		},
+		description: "Delete character",
+		category: "filter",
+		when: { isFilterActive: true },
+		priority: 70
+	});
+	for (let i = 1; i <= 7; i++) bindings.push({
+		key: String(i),
+		handler: () => {
+			handlers.filterToggleLevel(i - 1);
+			return true;
+		},
+		description: `Toggle level ${i}`,
+		category: "filter",
+		when: { isFilterActive: true },
+		priority: 70
+	});
+	bindings.push({
+		key: "q",
+		handler: () => {
+			manager.unbind();
+			return true;
+		},
+		description: "Exit",
+		category: "general",
+		when: {
+			hasPrompt: false,
+			isFilterActive: false,
+			isHelpVisible: false
+		},
+		priority: 10
+	});
+	bindings.push({
+		key: "tab",
+		handler: (_, ctx) => {
+			if (ctx.hasSidebar) {
+				manager.toggleFocus();
+				return true;
+			}
+		},
+		description: "Toggle focus",
+		category: "navigation",
+		when: {
+			hasPrompt: false,
+			isFilterActive: false
+		},
+		priority: 20
+	});
+	bindings.push({
+		key: "\\",
+		handler: (_, ctx) => {
+			if (ctx.hasSidebar) {
+				manager.toggleFocus();
+				return true;
+			}
+		},
+		description: "Toggle focus",
+		category: "navigation",
+		when: {
+			hasPrompt: false,
+			isFilterActive: false
+		},
+		priority: 20
+	});
+	bindings.push({
+		key: ["up", "k"],
+		handler: () => {
+			manager.navigateUp();
+			return true;
+		},
+		description: "Navigate up",
+		category: "navigation",
+		when: {
+			focusArea: "sidebar",
+			hasPrompt: false
+		},
+		priority: 30
+	});
+	bindings.push({
+		key: ["down", "j"],
+		handler: () => {
+			manager.navigateDown();
+			return true;
+		},
+		description: "Navigate down",
+		category: "navigation",
+		when: {
+			focusArea: "sidebar",
+			hasPrompt: false
+		},
+		priority: 30
+	});
+	bindings.push({
+		key: "return",
+		handler: () => {
+			manager.selectCurrent();
+			return true;
+		},
+		description: "Select screen",
+		category: "navigation",
+		when: {
+			focusArea: "sidebar",
+			hasPrompt: false
+		},
+		priority: 30
+	});
+	for (let i = 1; i <= 9; i++) bindings.push({
+		key: String(i),
+		handler: () => {
+			const screens = manager.getScreens();
+			if (i <= screens.length) {
+				manager.setActiveScreen(screens[i - 1]);
+				manager.setSelectedIndex(i - 1);
+				return true;
+			}
+		},
+		description: `Jump to screen ${i}`,
+		category: "screen",
+		when: {
+			hasPrompt: false,
+			isFilterActive: false
+		},
+		priority: 15
+	});
+	bindings.push({
+		key: "c",
+		handler: () => {
+			getActiveScreen()?.clear();
+			return true;
+		},
+		description: "Clear screen",
+		category: "screen",
+		when: {
+			focusArea: "content",
+			hasPrompt: false,
+			isFilterActive: false
+		},
+		priority: 15
+	});
+	return bindings;
+}
+/**
+* Handle printable character input for prompts and filter.
+* This should be called for any key not handled by bindings.
+*/ function handlePrintableInput(key, context, handlers) {
+	if (!key.sequence || key.sequence.length !== 1 || key.ctrl || key.meta) return false;
+	const charCode = key.sequence.charCodeAt(0);
+	if (charCode < 32 || charCode > 126) return false;
+	if (context.isFilterActive) {
+		handlers.filterAppendChar(key.sequence);
+		return true;
+	}
+	if (context.hasPrompt && context.inInputMode) {
+		handlers.getActiveScreen()?.promptAppendInput(key.sequence);
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+//#region src/filter/filter_engine.ts
+/**
+* Filter engine for filtering log messages.
+*/ var FilterEngine = class {
+	/**
+	* Apply filter to messages array.
+	*/ static filterMessages(messages, filter) {
+		if (filter.searchQuery === "" && filter.enabledLevels.size === ALL_LOG_LEVELS.length) return messages;
+		return messages.filter((msg) => {
+			if (msg.type !== "log") {
+				if (filter.searchQuery) return this.messageMatchesSearch(msg, filter.searchQuery);
+				if (msg.type === "group") return true;
+				return true;
+			}
+			const logMsg = msg;
+			if (!filter.enabledLevels.has(logMsg.level)) return false;
+			if (filter.searchQuery && !this.messageMatchesSearch(logMsg, filter.searchQuery)) return false;
+			return true;
+		});
+	}
+	/**
+	* Check if a message matches the search query.
+	*/ static messageMatchesSearch(msg, query) {
+		const lowerQuery = query.toLowerCase();
+		switch (msg.type) {
+			case "log": return msg.content.toLowerCase().includes(lowerQuery) || (msg.label?.toLowerCase().includes(lowerQuery) ?? false);
+			case "file":
+			case "fileError": return msg.filePath.toLowerCase().includes(lowerQuery) || msg.content.toLowerCase().includes(lowerQuery);
+			case "diff": return msg.filePath.toLowerCase().includes(lowerQuery) || msg.diff.toLowerCase().includes(lowerQuery);
+			case "loading": return msg.content.toLowerCase().includes(lowerQuery) || (msg.resolvedContent?.toLowerCase().includes(lowerQuery) ?? false);
+			case "progress": return msg.label.toLowerCase().includes(lowerQuery);
+			case "group": return msg.label.toLowerCase().includes(lowerQuery);
+			case "table": return (msg.title?.toLowerCase().includes(lowerQuery) ?? false) || msg.headers.some((h) => h.toLowerCase().includes(lowerQuery)) || msg.rows.some((row) => row.some((cell) => cell.toLowerCase().includes(lowerQuery)));
+			default: return false;
+		}
+	}
+	/**
+	* Count messages by log level.
+	*/ static countByLevel(messages) {
+		const counts = {
+			debug: 0,
+			log: 0,
+			verbose: 0,
+			error: 0,
+			fatal: 0,
+			warn: 0
+		};
+		for (const msg of messages) if (msg.type === "log") counts[msg.level]++;
+		return counts;
+	}
+};
+
+//#endregion
+exports.ALL_LOG_LEVELS = ALL_LOG_LEVELS;
+exports.Adapter = Adapter;
+exports.COMMON_FILETYPES = COMMON_FILETYPES;
+exports.CONTENT_MANAGER_EVENTS = CONTENT_MANAGER_EVENTS;
+exports.DEFAULT_LOG_LEVEL_COLORS = DEFAULT_LOG_LEVEL_COLORS;
+exports.ERROR_HIGHLIGHT_COLORS = ERROR_HIGHLIGHT_COLORS;
+exports.FILE_COLORS = FILE_COLORS;
+exports.FilterEngine = FilterEngine;
+exports.GROUP_COLORS = GROUP_COLORS;
+exports.HEADER_COLORS = HEADER_COLORS;
 exports.IsomorphicLogger = IsomorphicLogger;
 Object.defineProperty(exports, 'IsomorphicLoggerFactory', {
   enumerable: true,
@@ -6893,16 +8885,17 @@ Object.defineProperty(exports, 'IsomorphicLoggerFactory', {
     return _IsomorphicLoggerFactory;
   }
 });
-exports.KeyboardManager = require_filter_engine.KeyboardManager;
+exports.KeyboardManager = KeyboardManager;
 exports.LoggerOptionsSchema = LoggerOptionsSchema;
+exports.MANAGER_EVENTS = MANAGER_EVENTS;
 Object.defineProperty(exports, 'MissingAdapterOverride', {
   enumerable: true,
   get: function () {
     return _MissingAdapterOverride;
   }
 });
-exports.PROGRESS_COLORS = require_filter_engine.PROGRESS_COLORS;
-exports.PROMPT_COLORS = require_filter_engine.PROMPT_COLORS;
+exports.PROGRESS_COLORS = PROGRESS_COLORS;
+exports.PROMPT_COLORS = PROMPT_COLORS;
 exports.Prompt = Prompt;
 Object.defineProperty(exports, 'PromptInstance', {
   enumerable: true,
@@ -6911,9 +8904,13 @@ Object.defineProperty(exports, 'PromptInstance', {
   }
 });
 exports.PromptOptionsSchema = PromptOptionsSchema;
-exports.SEPARATOR_COLORS = require_filter_engine.SEPARATOR_COLORS;
-exports.SIDEBAR_COLORS = require_filter_engine.SIDEBAR_COLORS;
-exports.STATUS_INDICATORS = require_filter_engine.STATUS_INDICATORS;
+exports.ReadlinePromptService = ReadlinePromptService;
+exports.RenderMode = RenderMode;
+exports.SCREEN_EVENTS = SCREEN_EVENTS;
+exports.SEPARATOR_COLORS = SEPARATOR_COLORS;
+exports.SIDEBAR_COLORS = SIDEBAR_COLORS;
+exports.SIDEBAR_EVENTS = SIDEBAR_EVENTS;
+exports.STATUS_INDICATORS = STATUS_INDICATORS;
 exports.Screen = Screen;
 Object.defineProperty(exports, 'ScreenFactory', {
   enumerable: true,
@@ -6937,28 +8934,30 @@ Object.defineProperty(exports, 'ScreenManagerInstance', {
   }
 });
 exports.ScreenOptionsSchema = ScreenOptionsSchema;
-exports.TABLE_COLORS = require_filter_engine.TABLE_COLORS;
-exports.VARIANT_COLORS = require_filter_engine.VARIANT_COLORS;
-exports.captureTrace = require_filter_engine.captureTrace;
-exports.createBorderColor = require_filter_engine.createBorderColor;
-exports.createDefaultBindings = require_filter_engine.createDefaultBindings;
-exports.createDefaultFilterState = require_filter_engine.createDefaultFilterState;
-exports.createTheme = require_filter_engine.createTheme;
-exports.createThemeFrom = require_filter_engine.createThemeFrom;
-exports.createTintedColor = require_filter_engine.createTintedColor;
-exports.darkTheme = require_filter_engine.darkTheme;
-exports.formatKeyBinding = require_filter_engine.formatKeyBinding;
-exports.formatObject = require_filter_engine.formatObject;
-exports.getFileName = require_filter_engine.getFileName;
-exports.getLogLevelColors = require_filter_engine.getLogLevelColors;
-exports.getThemePreset = require_filter_engine.getThemePreset;
-exports.handlePrintableInput = require_filter_engine.handlePrintableInput;
-exports.hasActiveFilter = require_filter_engine.hasActiveFilter;
-exports.highContrastTheme = require_filter_engine.highContrastTheme;
-exports.lightTheme = require_filter_engine.lightTheme;
-exports.mergeThemes = require_filter_engine.mergeThemes;
+exports.TABLE_COLORS = TABLE_COLORS;
+exports.VARIANT_COLORS = VARIANT_COLORS;
+exports.captureTrace = captureTrace;
+exports.createDefaultBindings = createDefaultBindings;
+exports.createDefaultFilterState = createDefaultFilterState;
+exports.createTheme = createTheme;
+exports.createThemeFrom = createThemeFrom;
+exports.darkTheme = darkTheme;
+exports.dynamicImport = dynamicImport;
+exports.formatKeyBinding = formatKeyBinding;
+exports.formatObject = formatObject;
+exports.getFileName = getFileName;
+exports.getLogLevelColors = getLogLevelColors;
+exports.getPromptDefaultValue = getPromptDefaultValue;
+exports.getThemePreset = getThemePreset;
+exports.handlePrintableInput = handlePrintableInput;
+exports.hasActiveFilter = hasActiveFilter;
+exports.highContrastTheme = highContrastTheme;
+exports.isBunRuntime = isBunRuntime;
+exports.lightTheme = lightTheme;
+exports.mergeThemes = mergeThemes;
 exports.overrideConsoleLogger = overrideConsoleLogger;
-exports.printMessagesToStdout = require_filter_engine.printMessagesToStdout;
-exports.resolveFiletype = require_filter_engine.resolveFiletype;
-exports.resolveTheme = require_filter_engine.resolveTheme;
+exports.printMessagesToStdout = printMessagesToStdout;
+exports.printSingleMessage = printSingleMessage;
+exports.resolveFiletype = resolveFiletype;
+exports.resolveTheme = resolveTheme;
 //# sourceMappingURL=index.cjs.map