API Reference Raxol v#2.0.1

Termbox2 NIF for Elixir - A terminal UI library.

Simple CSV encoding functionality. This is a minimal implementation for basic CSV export needs.

The behaviour for downloader modules.

The behaviour for precompiler modules.

Root-level EventHandler module that delegates to the unified event system. Provides backward compatibility for existing code.

Plugin lifecycle manager - delegates to the core plugin manager. This module exists for backwards compatibility with tests that expect a bare "Manager" module.

Mock terminal for testing plugins

Mock plugin runner for testing

Raxol is a world-class terminal UI framework for Elixir.

Handles accessibility concerns for the Animation Framework, specifically adapting animations for reduced motion preferences.

Handles animation adaptation based on user preferences and accessibility settings.

Animation framework stub for test compatibility.

Handles the processing of active animations and their application to state.

CSS-like declarative animation syntax for Raxol components.

Declarative animation DSL for composing complex animation sequences.

Defines an animation with name, type, parameters, conditions and metadata.

Manages complex multi-stage animations with stages, options and context.

Represents an animation sequence with type, animations, options, conditions and context.

Provides standard easing functions for animations.

Enhanced animation transitions with advanced effects and performance optimizations.

Coordinates the lifecycle of animations within Raxol.

Refactored gesture-driven interactions with GenServer-based state management.

GenServer implementation for Animation Gestures state management.

Provides interpolation functions for different data types.

Manages the lifecycle of animations including starting, stopping, and completion handling.

Manages animation target paths and state structure utilities.

Force field implementation for physics simulations.

Physics engine for Raxol animations.

3D vector implementation for physics simulations.

Refactored StateManager that delegates to GenServer implementation.

GenServer implementation for animation state management in Raxol.

Main application module for Raxol terminal emulator.

Base command module for CQRS pattern implementation in Raxol.

Command dispatcher for CQRS pattern implementation.

Command handler behaviour for CQRS pattern implementation in Raxol.

Setup and initialization for CQRS and Event Sourcing components.

Event structure for event sourcing implementation in Raxol.

Event store implementation for event sourcing pattern.

Represents a stream of events for a specific aggregate.

Represents a snapshot of aggregate state at a specific version.

Analyzes audit events in real-time to detect security threats, anomalies, and compliance violations.

Audit event definitions for compliance and security tracking.

Base audit event structure with common fields for all audit events.

Audit event for authentication attempts.

Audit event for authorization decisions.

Audit event for compliance-related activities.

Audit event for system configuration changes.

Audit event for data access operations.

Audit event for GDPR and privacy-related operations.

Audit event for security-related incidents.

Audit event specific to terminal operations.

Exports audit logs in various formats for compliance reporting and SIEM integration.

Integration module for hooking audit logging into terminal operations.

Centralized audit logging system for compliance and security tracking.

Functional version of the specialized storage backend for audit logs with indexing and search capabilities.

Benchmarking utilities for Raxol.

Legacy analyzer module for backward compatibility. Delegates to the new modular benchmark analysis system.

Benchmark suite for comparing Raxol against competitor terminal emulators.

Configuration and utilities for Raxol performance benchmarking. Centralizes benchmark settings, performance targets, and reporting configuration.

Domain-specific language for defining benchmarks in an idiomatic Elixir way.

Enhanced custom formatter for Benchee that provides better insights, performance analysis, and visual reporting for Raxol benchmarks.

Advanced memory pattern analysis for Raxol benchmarks.

Enhanced DSL for memory benchmarking with advanced assertions.

Advanced memory benchmarking dashboard and reporting system.

Detects performance regressions by comparing current results with baselines. Uses statistical methods to determine significant performance changes.

Generates comprehensive performance reports from benchmark results.

Comprehensive benchmarking suite for Raxol performance testing.

Test plugin for benchmark runner testing.

Generates realistic test scenarios and data for benchmarking. Includes real-world terminal sequences, user interactions, edge cases, and visualization data for comprehensive benchmark testing.

Advanced statistical analysis for benchmark results. Provides percentiles, distributions, outlier detection, and statistical significance testing.

Common statistical functions for benchmark analysis.

Handles storage and retrieval of benchmark results for historical analysis.

Central registry for all benchmark suites. Manages suite discovery, registration, and execution.

Performance benchmarking module.

Animation performance benchmarking.

Event handling performance benchmarking.

Memory usage benchmarking.

Rendering performance benchmarking.

Performance report generation.

CLI command for managing Raxol updates.

Handles clipboard operations across different platforms. Provides a unified interface for copy/paste functionality.

Cloud integration system for Raxol applications.

Command parser with tab completion, history, and argument parsing.

Command to apply a theme to a terminal.

Command to close a terminal and clean up resources.

Command to create a new terminal instance.

Virtual file system for terminal navigation and content display.

Command to send input to a terminal.

Command to update terminal settings.

Foundation for building reusable, stateful terminal UI components.

Unified TOML-based configuration management for Raxol.

Generates configuration files and templates.

Configuration loading utilities for various formats and sources.

Configuration schema definitions and validation.

Raxol Core - The main entry point and coordination layer for the Raxol framework.

Refactored Accessibility module that delegates to the unified GenAccessibilityServer.

Unified GenServer implementation for accessibility features in Raxol.

Handles screen reader announcements and announcement queue management.

Behaviour for accessibility implementations.

Handles accessibility-related events and notifications.

Handles accessibility metadata for UI elements and component styles.

Manages accessibility preferences and settings.

Manages the integration between accessibility settings and the active theme.

Base behavior for manager GenServers to reduce code duplication. Provides common patterns for state management, lifecycle, and error handling.

Base behavior for registry GenServers to reduce code duplication. Provides common patterns for registering, unregistering, and looking up resources.

Base behavior for general-purpose GenServers to reduce code duplication. Provides common patterns for server lifecycle, error handling, and state management.

Common behavior for lifecycle management across different components.

Common behavior for metrics collection and reporting.

Behaviour for state management systems.

Circuit breaker implementation for external API calls.

Behaviour for clipboard operations.

Core color system for Raxol.

Thread-safe ETS table management for parallel compilation.

Unified configuration management system for Raxol. Consolidates configuration from multiple specialized config modules

Generic connection pooling implementation for external services.

Enhanced error experience system for Raxol applications.

Centralized error handling module for the Raxol application.

Functional error handling patterns for Raxol.

Standardized error handling patterns for the Raxol application.

Error Pattern Learning System - Phase 4.3 Error Experience

Error recovery strategies for the Raxol application.

Manages context preservation across process restarts.

Manages dependency relationships between components for intelligent recovery.

Enhanced error pattern learning specifically for recovery scenarios.

Enhanced supervisor with intelligent error recovery strategies.

Wrapper module that adds recovery capabilities to any GenServer process.

Automatic error report generation system for Phase 4.3 Error Experience.

Enhanced error message templates for Phase 4.3 Error Experience.

Defines the structure for events in the Raxol system, providing a standardized format for key presses, mouse actions, and other UI events that components need to process.

Event management system that wraps :telemetry for backward compatibility.

GenServer implementation for event management in Raxol applications.

Alias module for Raxol.Core.Events.EventManager.

Provides helpers for managing event subscriptions.

Adapter to migrate from EventManager to :telemetry.

Converts rrex_termbox v2.0.1 NIF events to Raxol.Core.Events.Event structs.

Refactored FocusManager that delegates to GenServer implementation.

Defines the behaviour for focus management services.

GenServer implementation for focus management.

Unified registry interface consolidating different registry patterns across Raxol.

Behaviour for unified registry operations.

Refactored internationalization module using GenServer for state management.

GenServer-based internationalization server.

Provides functions for generating unique identifiers.

Refactored KeyboardNavigator that delegates to GenServer implementation.

BaseManager implementation for keyboard navigation in Raxol terminal UI applications.

Refactored KeyboardShortcuts that delegates to GenServer implementation.

GenServer implementation for keyboard shortcuts management.

Behavior for KeyboardShortcuts implementation.

Core metrics module for Raxol framework.

Metric aggregation system for the Raxol metrics.

Alert management system for the Raxol metrics.

Cloud integration for the Raxol metrics system.

Configuration management for the Raxol metrics system.

Manages unified metrics collection across the application.

Visualization system for the Raxol metrics.

Shared utilities for navigation path management. Used by both KeyboardNavigator and WindowManager to avoid code duplication.

Core performance module for Raxol framework.

Handles AI-based analysis of performance metrics and generates optimization recommendations. This module integrates with an AI agent to provide deep insights and actionable suggestions.

AI integration module for performance analysis.

Analyzes performance metrics and generates insights for AI analysis.

High-performance cache for component rendering results.

High-performance cache for font metrics calculations.

Detects UI jank by analyzing frame timing.

GenServer implementation for function memoization cache.

Enhanced performance metrics collection system for Raxol.

Refactored Performance optimization strategies with GenServer-based memoization.

Performance profiling and optimization tools for Raxol.

Platform detection utilities for cross-platform compatibility.

Provides clipboard read/write commands and delegates to a configured system clipboard implementation.

Defines the behaviour for clipboard plugin operations.

Core plugin responsible for handling notifications (:notify). Relies on an implementation of Raxol.System.Interaction for OS interactions.

Manages user preferences and settings for the Raxol terminal UI.

Handles persistence (loading/saving) of user preferences to a file.

Handles storage and retrieval of user preferences.

Manages terminal buffer rendering with double buffering and damage tracking.

Provides comprehensive color support for terminal rendering.

Defines the core element structure for the rendering system.

Central layout coordinator for the Raxol renderer system.

Manages the rendering system for Raxol applications.

Provides view-related functionality for rendering UI components.

Border-related functions for the View module. Extracted from the main View module to improve maintainability.

Component creation functions for the View module. Extracted from the main View module to improve maintainability.

Handles box layout functionality for the Raxol view system. Provides box model layout with content, padding, border, and margin.

Handles scrollable views for the Raxol view system. Provides viewport management, scrollbar rendering, and content scrolling.

Handles text rendering for the Raxol view system. Provides text styling, wrapping, and alignment functionality.

Handles flex layout functionality for the Raxol view system. Provides row and column layouts with various alignment and justification options.

Handles grid-based layouts for the Raxol view system. Provides functionality for creating and managing grid layouts with customizable columns and rows.

Layout helper functions for the View module. Extracted from the main View module to improve maintainability.

Handles border rendering for the Raxol view system. Provides various border styles and rendering functionality.

Type definitions for the Raxol view system.

Provides utility functions for common view operations in the Raxol view system.

Validation functions for the View module. Extracted from the main View module to improve maintainability.

Chart view component for data visualization.

Table view component for displaying tabular data.

Defines the behaviour for Raxol applications following The Elm Architecture (TEA).

Provides a way to handle side effects in a pure functional way.

Refactored component manager with functional error handling patterns.

Debug logging functionality for the Raxol runtime.

Behaviour for implementing custom event sources for subscriptions.

A test implementation of an event source for testing purposes.

Handles conversion between different event formats in the Raxol system.

Manages the application state (model) and dispatches events to the application's update/2 function. It also handles commands returned by update/2.

Manages event handlers registration and execution in the Raxol system.

Handles keyboard event processing in the Raxol system.

Manages the application lifecycle, including startup, shutdown, and terminal interaction.

Centralized logging system for Raxol with structured context, performance tracking, and consistent formatting across all modules.

Public API for Raxol plugins to interact with the core system.

This module is responsible for processing cells in the Raxol runtime.

Handles plugin command registration and dispatch for the Plugin Manager. Uses functional patterns with proper error handling using with statements and Tasks.

Manages command registration and execution for plugins.

Handles plugin discovery and initialization. This module is responsible for

Handles event filtering for plugins. This module is responsible for

Handles file watching and plugin reloading functionality.

Behavior for file watcher plugins.

Defines the behaviour for plugin lifecycle management.

Helper functions for plugin lifecycle management.

Behavior for plugin lifecycle management.

Handles plugin lifecycle operations including loading, unloading, enabling, and disabling plugins.

Manages plugin loading operations.

Behavior for plugin loading functionality.

Defines the behaviour for Raxol plugins.

Behavior for plugin command handling.

Manages plugin command registration and dispatch. Coordinates between plugins and the command system.

Handles plugin error handling and logging.

Behavior for plugin event filtering.

Handles event processing through plugins.

Handles initialization of plugins, including state setup and command registration.

Handles plugin lifecycle callback implementations.

Manages the loading, initialization, and lifecycle of plugins in the Raxol runtime.

Defines the behaviour for plugins that provide metadata like ID, version, and dependencies.

Handles plugin reloading operations including reloading by ID and from disk.

Behaviour for plugin reloading operations.

Handles unloading of plugins, including command and state cleanup.

Comprehensive validation system for plugins before loading.

Defines the state struct for the plugin manager.

Plugin registry using GenServer for state management.

Enhanced version of LifecycleOperations with comprehensive error handling.

Namespaced alias for StateManager.

Handles timer management for plugin operations including periodic ticks and file event timers.

Replacement for Process dictionary usage. Provides a functional alternative using Agent for state storage.

Provides the core rendering functionality for Raxol applications with functional error handling.

Behavior for rendering engines.

Manages the rendering schedule based on frame rate.

Provides a way to subscribe to recurring updates and external events.

Supervises the core runtime processes of a Raxol application.

Centralized registry and supervisor for all Raxol GenServers.

Distributed session registry that manages sessions across multiple nodes.

Persistent storage layer for distributed session data.

Multiplexer session implementation for the unified session manager.

Security session implementation for the unified session manager.

Unified session management system for Raxol applications.

Handles session migration and failover scenarios in a distributed environment.

Handles session replication and synchronization across nodes in a distributed cluster.

Terminal session implementation for the unified session manager.

Web session implementation for the unified session manager.

Code generation templates following Raxol coding standards.

Defines and enforces code style standards across the Raxol codebase.

Automated code consistency checker for the Raxol codebase.

Consolidated state management module providing functional, process-based, and ETS-backed state handling.

Supervisor for all refactored GenServer-based modules.

Defines a behaviour for interacting with the operating system, allowing for mocking.

Handles OSC 4 (Color Palette Set/Query) commands.

Represents the core state of a terminal instance.

Handles text processing and formatting for UI elements.

Refactored UX refinement module that uses GenUxServer for state management.

GenServer for managing UX refinement state.

Manages user preferences for the terminal emulator.

Internal state for the UserPreferences GenServer.

Consolidated error handling patterns used throughout the Raxol codebase. Provides consistent error handling, logging, and recovery mechanisms.

Common GenServer patterns and utilities to reduce code duplication. Provides standardized handlers for common operations like state retrieval, metrics collection, and configuration management.

Centralized timer management utilities for consistent timer handling across the codebase.

Consolidated timer utilities for standardized timer management across Raxol.

Common validation utilities to reduce code duplication across the codebase. Provides standardized validation functions for dimensions, configs, and common patterns.

Debug mode utilities and detailed logging for Raxol terminal emulator.

A dynamic supervisor for starting Raxol application processes.

Visual cursor trail effects for terminal interfaces.

Unified event handler consolidating all event processing capabilities.

Event emitted when a terminal is closed.

Event emitted when terminal configuration is updated.

Event emitted when a new terminal is created.

Event emitted when an error occurs in a terminal.

Event emitted when input is received by a terminal.

Event emitted when terminal generates output.

Event emitted when a theme is applied to a terminal.

Demo showcasing accessibility features including screen reader support, high contrast mode, and keyboard navigation.

A simple form component for demonstrating button integration. This is a stub implementation for test compatibility.

Backend handler for the VS Code extension.

HEEx template integration for Raxol.

Handler for applying themes to terminal instances.

Handler for closing terminal instances.

Handler for creating new terminal instances.

Handler for sending input to terminal instances.

Handler for updating terminal configurations.

Phoenix LiveView integration for Raxol.

Core buffer-to-HTML rendering engine for Raxol web terminals.

Converts Raxol.Core buffers to HTML for Phoenix LiveView rendering.

A Phoenix LiveView component for rendering terminal buffers in web browsers.

Legacy Phoenix LiveComponent for embedding terminal buffers in LiveView.

Built-in theme system for Raxol web terminals.

Handles collection and management of system metrics with functional error handling.

Minimal Raxol terminal interface for ultra-fast startup.

VIM-style navigation for terminal buffers.

Adaptive performance optimizer that responds to real-world usage patterns.

Advanced alerting system for Raxol performance monitoring.

Automated performance monitoring system for Raxol.

Optimized cache configuration for Raxol performance subsystem.

Performance hints system for development mode.

Development-mode profiler for detailed performance analysis.

High-performance ETS cache manager for Raxol hot paths.

Central coordinator for automated performance monitoring in Raxol.

Predictive performance optimizer using telemetry data.

Telemetry instrumentation for Raxol hot paths.

Interactive component playground for Raxol.

Component catalog for the Raxol Playground.

Generates Elixir code for components with their current configuration.

Interactive examples and guided tours for the Raxol Playground.

Live preview generation for Raxol components.

Interactive property editor for the component playground.

State management for the Raxol Playground.

Behavior for Raxol plugins.

Handles the processing of rendered cells, allowing plugins to modify or replace them. Especially targets placeholder cells generated by the rendering pipeline.

Plugin for clipboard operations in Raxol.

Advanced dependency resolution system for Plugin System v2.0.

Handles events for plugin system.

Common utilities and helper functions for event handling across plugins.

Handles input-related events for plugins.

Handles mouse-related events for plugins.

Handles output-related events for plugins.

Command Palette Plugin for Raxol Terminal

File Browser Plugin for Raxol Terminal

Git Integration Plugin for Raxol Terminal

Example plugin demonstrating the Plugin System v2.0 capabilities.

Example tests for the Rainbow Theme Plugin. Demonstrates how to test plugins with the new system.

Status Line Plugin for Raxol Terminal

Terminal Multiplexer Plugin for Raxol Terminal

Advanced hot-reload system for Plugin System v2.0.

Plugin that detects URLs in terminal output and makes them clickable.

Plugin that enables displaying images in the terminal using the iTerm2 image protocol. Supports various image formats and provides options for image display.

Handles the lifecycle management of Raxol plugins.

Handles dependency validation, circular dependency checks, and load order resolution for plugin lifecycle management.

Handles error formatting, logging, and result handling for plugin lifecycle management.

Handles plugin initialization, config merging, struct creation, and compatibility checks for plugin lifecycle management.

Handles manager state updates, config persistence, and plugin state management for plugin lifecycle management.

Handles field and config validation helpers for plugin lifecycle management.

Behaviour for plugin lifecycle management.

Plugin manager for Raxol. Handles plugin lifecycle, registration, and state management.

Handles cell processing functionality. Provides functions for processing and transforming cells through plugins.

Core functionality for the plugin manager. Handles basic plugin management operations and state.

Handles plugin event processing. Provides functions for processing various types of events through plugins.

Handles plugin hook execution. Provides functions for running various plugin hooks and collecting their results.

Handles plugin state management and updates. Provides functions for updating plugin state and managing plugin lifecycle states.

Plugin Marketplace client for Plugin System v2.0.

Defines the behavior for Raxol terminal emulator plugins. Plugins can extend the terminal's functionality by implementing this behavior.

Handles persistence of plugin configurations. Stores and loads plugin configurations from disk.

Provides utilities for plugin dependency and API compatibility checks.

Sandbox security system for running untrusted plugins safely.

Plugin System v2.0 - Advanced plugin management with enhanced features.

Integration layer for Plugin System v2.0 - brings together all components.

Plugin for text search functionality.

Spotify integration plugin for Raxol.

Spotify Web API client.

Spotify OAuth 2.0 authentication handler.

Configuration validation for Spotify plugin.

Assertion helpers for plugin testing

Benchmarking utilities for plugin performance testing

Custom assertions for plugin testing

Test helper functions for common plugin testing scenarios

Mock terminal implementation for plugin testing

Plugin runner for test environments

Plugin Testing Framework for Raxol

Plugin that manages terminal themes and color schemes. Allows users to apply predefined themes or create custom color schemes.

Handles rendering logic for chart visualizations within the VisualizationPlugin.

Utility functions for drawing basic shapes and text onto a cell grid. Used by visualization renderers.

Handles rendering logic for image visualization within the VisualizationPlugin. Supports both sixel and kitty protocols for terminal image rendering.

Handles rendering logic for treemap visualizations within the VisualizationPlugin. Uses a squarified layout algorithm.

Plugin responsible for rendering visualization components like charts and treemaps. It receives data structures from the view rendering pipeline and outputs actual terminal cells.

Cache system for pre-commit checks to enable incremental checking.

Configuration system for Raxol pre-commit checks.

Formats error messages from pre-commit checks with helpful context and fix suggestions.

Optimized Git operations for pre-commit checks.

Performance metrics tracking for pre-commit checks.

Progress indicator for pre-commit checks.

Convenience module for importing all unified protocols.

Adapter module to help migrate from behaviours to protocols.

Wrapper for buffer modules to enable protocol dispatch.

Wrapper for event handler modules to enable protocol dispatch.

Wrapper for renderer modules to enable protocol dispatch.

Protocol implementations for buffer operations on existing buffer types.

Protocol for buffer operations in terminal emulation.

Protocol-based component framework for Raxol.

Represents an instance of a protocol-aware component.

Domain-specific language for defining protocol-aware components.

Unified protocol definitions for Raxol core functionality. Consolidates multiple protocol definitions to reduce duplication and improve consistency.

Protocol for buffer operations across different buffer types. Provides unified interface for screen buffers, text buffers, etc.

Protocol for renderable UI components. Combines functionality from Renderable, Styleable, and EventHandler protocols.

Protocol for configurable modules and components. Handles configuration loading, validation, and persistence.

Protocol for managing component/module lifecycle. Handles initialization, startup, shutdown, and cleanup.

Protocol for serializing and deserializing data structures. Handles conversion to/from various formats (JSON, TOML, binary).

Protocol for handling events in a polymorphic way.

Integration layer between the existing event system and the new EventHandler protocol.

Integration layer for the plugin system with protocol support.

Protocol module for handling protocol-related functionality.

Protocol for rendering data structures to terminal output.

Protocol implementations for terminal renderer types.

Protocol for serializing and deserializing data structures.

Protocol for applying styles to data structures.

Protocol implementations for theme-related structures.

Protocol implementations for UI components.

Repository module for Raxol. Currently a stub as Raxol doesn't use Ecto database operations.

Search system with fuzzy, exact, and regex matching.

Security auditing and validation module for Raxol.

Configuration and policy management for encryption system.

Provides transparent encryption for data at rest.

Manages encryption keys for at-rest data encryption.

Secure input validation and sanitization module.

Secure session management with built-in security features.

Refactored Security User Context module with GenServer-based state management.

GenServer implementation for Security User Context management.

Represents a sequence of commands for benchmarking and testing.

Executes sequences of commands and animations.

Storage interface for event sourcing system.

Disk-based event storage implementation for production use.

Distributed event storage implementation for high availability.

In-memory event storage implementation for development and testing.

Defines style properties for terminal UI elements.

Defines border properties for terminal UI elements.

Provides utilities for color accessibility, focusing on WCAG contrast.

Detects terminal capabilities and adapts color schemes accordingly.

Provides advanced color handling capabilities for the terminal.

Core color representation and manipulation module.

Color format conversion utilities.

Creates and manages color gradients for terminal applications.

Provides functions for HSL color space conversions and adjustments.

Provides functions for generating color harmonies based on a base color.

Provides hot-reloading capabilities for color themes.

Manages color palette generation and scale creation with accessibility considerations.

Handles persistence of color themes and user preferences.

Refactored Color System module with GenServer-based state management.

GenServer implementation for the color system in Raxol.

Shared color utilities for the Raxol color system.

Handles layout styling for Raxol components.

Provides consolidated access to the system clipboard across different operating systems.

Handles delta updates for the Raxol terminal emulator.

Behaviour for a system adapter used by DeltaUpdater.

System adapter implementation for delta updater.

A behaviour for abstracting system environment interactions.

Concrete implementation of EnvironmentAdapterBehaviour using Elixir's System module.

Behaviour for abstracting system interactions like running commands, finding executables, and getting OS type. Allows for easier testing.

Concrete implementation of the System.Interaction behaviour using standard Elixir/Erlang functions.

Platform-specific functionality and detection for Raxol.

Terminal-specific platform features and compatibility checks.

Provides version management and self-update functionality for Raxol.

Core update logic and GenServer callbacks for the Raxol System Updater.

Network operations for the Raxol System Updater including HTTP requests, GitHub API, file downloads, and archive operations.

Refactored System Updater State module with GenServer-based state management.

GenServer implementation for the System Updater state management.

Validation functions for the Raxol System Updater including version checking, platform detection, and settings validation.

This module serves as a documentation reference for the ANSI terminal functionality.

Consolidated ANSI behaviours for terminal functionality. Consolidates: SixelGraphics.Behaviour, TerminalStateBehaviour, TextFormattingBehaviour.

Behaviour for Sixel graphics support.

Behaviour for managing terminal state saving and restoring.

Defines the behaviour for text formatting in the terminal. This includes handling text attributes, colors, and special text modes.

Provides benchmarking capabilities for the ANSI handling system. Measures performance of parsing and processing ANSI sequences.

Optimized ANSI parser with caching for common sequences.

Consolidated character set management for the terminal emulator. Combines: Handler, StateManager, Translator, and core CharacterSets functionality. Supports G0, G1, G2, G3 character sets and their switching operations.

Handles character set control sequences and state changes.

Manages character set state and operations.

Handles character set translations and mappings.

Provides character translation tables for different character sets. Maps characters between different character sets according to ANSI standards.

Handles terminal state queries and device status reports. This includes cursor position reports, device status reports, and terminal identification queries.

Handles extended ANSI sequences and provides improved integration with the screen buffer. Functional Programming Version - All try/catch blocks replaced with with statements.

Provides monitoring capabilities for the ANSI handling system. Tracks performance metrics, errors, and sequence statistics.

Consolidated mouse handling for the terminal emulator. Combines MouseEvents and MouseTracking functionality. Supports various mouse tracking modes and event reporting.

Handles mouse event reporting for the terminal emulator.

Handles mouse tracking and focus tracking for the terminal.

ANSI escape sequence parser for terminal emulation.

Consolidated SGR (Select Graphic Rendition) handling for ANSI escape sequences. Combines: SGR formatting, SGRHandler, and SGRProcessor functionality.

SGR parameter formatting for the Raxol Terminal ANSI TextFormatting module. Handles SGR parameter parsing, formatting, and attribute handling.

Handles parsing of SGR (Select Graphic Rendition) ANSI escape sequences. Translates SGR codes into updates on a TextFormatting style map.

Optimized SGR (Select Graphic Rendition) processor for ANSI escape sequences. Uses compile-time optimizations and pattern matching for maximum performance.

Processes SGR (Select Graphic Rendition) ANSI escape sequences.

Handles parsing and processing of ANSI escape sequences. This module extracts the ANSI sequence parsing logic from the main emulator.

ANSI Color Sequence Handler.

ANSI Cursor Sequence Handler.

ANSI Terminal Modes Sequence Handler.

Complete Sixel graphics support for terminal rendering.

Handles Sixel color palette management.

Handles the parsing logic for Sixel graphics data streams within a DCS sequence.

Represents the state during the parsing of a Sixel graphics data stream. Tracks position, color, palette, and pixel buffer information.

Handles rendering Sixel graphics data from a pixel buffer.

A state machine for parsing ANSI escape sequences. This module provides a more efficient alternative to regex-based parsing.

Manages terminal state operations for ANSI escape sequences.

Consolidated text formatting module for the terminal emulator. Combines Core, Attributes, and Colors functionality. Handles advanced text formatting features including double-width/height, text attributes, and color management.

Text attribute handling for ANSI text formatting.

Color handling utilities for ANSI text formatting.

Core text formatting functionality.

SGR parameter formatting for text styles.

Consolidated ANSI utilities for terminal functionality. Combines: SixelPatternMap, AnsiProcessor, SequenceParser, AnsiParser, and Emitter.

Provides comprehensive parsing for ANSI escape sequences. Determines the type of sequence and extracts its parameters.

Processes ANSI escape sequences for terminal control.

ANSI escape sequence generation module.

Helper module for parsing ANSI escape sequences.

Provides a mapping from Sixel characters to their 6-bit pixel patterns.

Consolidated window handling for the terminal emulator. Combines WindowEvents and WindowManipulation functionality. Supports window events, resizing, positioning, and state management.

Handles window events for terminal control.

Handles window manipulation sequences for terminal control.

Implements advanced terminal features for modern terminal emulators.

Manages the terminal buffer state and operations.

Buffer manager for terminal operations.

Buffer server stub for test compatibility.

Manages terminal cell operations and attributes.

Manages terminal character editing operations.

Manages character set state and operations for the screen buffer. This module handles character set designations, G-sets, and single shifts.

A thread-safe buffer implementation using GenServer for concurrent access. Provides synchronous operations to ensure data integrity when multiple processes are reading/writing to the buffer simultaneously.

Compatibility adapter for buffer content operations. Forwards calls to Raxol.Terminal.ScreenBuffer.Operations.

Manages cursor state and operations for the screen buffer. This module handles cursor position, visibility, style, and blink state.

Tracks damage regions in a terminal buffer for efficient rendering. Damage regions indicate areas that have changed and need to be redrawn.

Compatibility adapter for buffer erasing operations. Forwards calls to Raxol.Terminal.ScreenBuffer.Operations.

Manages text formatting state and operations for the screen buffer. This module handles text attributes, colors, and style management.

Provides functionality for line editing operations in the terminal buffer.

Provides line-level operations for the screen buffer. This module handles operations like inserting, deleting, and manipulating lines.

Character-level operations for buffer lines. Handles character insertion, deletion, and manipulation within lines.

Line deletion operations for terminal buffers. Handles deletion of single and multiple lines, with support for scroll regions.

Line insertion operations for terminal buffers. Handles insertion of single and multiple lines with style support.

Line management operations for terminal buffers. Handles line creation, retrieval, and manipulation.

Shared utility functions for line operations. Extracted to eliminate code duplication between Deletion and Insertion modules.

Compatibility adapter for consolidated buffer operations. Forwards calls to Raxol.Terminal.ScreenBuffer.Operations.

Handles text pasting operations for terminal buffers.

Handles buffer state querying operations. This module provides functions for querying the state of the screen buffer, including dimensions, content, and selection state.

Safe buffer manager that handles buffer operations with error recovery.

Terminal scroll buffer module.

Handles scroll region operations for the screen buffer. This module manages the scroll region boundaries and provides functions for scrolling content within the defined region.

Handles scrollback buffer operations for the screen buffer. This module manages the history of lines that have scrolled off the screen, including adding, retrieving, and clearing scrollback content.

Handles scrolling operations for the terminal buffer.

Manages text selection operations for the terminal. This module handles all selection-related operations including

Manages terminal text formatting operations.

Handles writing characters and strings to the Raxol.Terminal.ScreenBuffer. Responsible for character width, bidirectional text segmentation, and cell creation.

Helper functions for cache eviction strategies. Provides shared implementations for LRU, LFU, and FIFO eviction policies.

Unified caching system for the Raxol terminal emulator. This module provides a centralized caching mechanism that consolidates all caching operations across the terminal system, including

Manages terminal capabilities including detection, negotiation, and caching.

Defines types and structures for terminal capabilities management.

Terminal character cell module.

Cached version of Cell operations for performance optimization.

Handles wide character and bidirectional text support for the terminal emulator.

Manages character sets for the terminal emulator.

Manages terminal character sets and encoding operations.

Provides character mapping functions for different character sets.

Provides operations for managing character sets and their state.

Defines types used across the charset modules.

Manages the terminal character sets.

Provides a high-level interface for clipboard operations.

Handles clipboard content formatting and filtering.

Manages clipboard history for the terminal.

Manages clipboard operations for the terminal, including copying and pasting text.

Manages clipboard content storage and retrieval.

Handles clipboard synchronization between different terminal instances.

Defines the behaviour for clipboard operations in the terminal.

Manages terminal colors and color operations.

True color (24-bit RGB) support for Raxol terminal applications.

Manages terminal colors and color-related operations.

Defines the structure for terminal commands.

Manages terminal command processing and execution. This module is responsible for handling command parsing, validation, and execution.

Handles command processing for the terminal emulator. This module is responsible for parsing, validating, and executing terminal commands.

Handlers for CSI (Control Sequence Introducer) commands. This is a simplified version that delegates to the available handler modules.

Handles cursor-related CSI sequences.

Handles cursor movement operations for CSI sequences.

Handles CSI mode commands (Set Mode/Reset Mode).

Handles screen-related CSI sequences.

Screen handling utilities for CSI commands.

Unified command handler that consolidates all terminal command processing.

Handles parsing of command parameters in terminal sequences.

Handles cursor movement related CSI commands.

Shared utility functions for cursor handling commands. Eliminates code duplication between CursorHandler and CSIHandler.

Handles device-specific terminal commands like Device Attributes (DA) and Device Status Report (DSR). This module provides direct implementations.

Handles editor-related terminal commands.

Handles terminal erase commands like Erase in Display (ED) and Erase in Line (EL). This module provides simple fallback implementations.

Consolidated OSC (Operating System Command) handler for terminal control sequences. Combines all OSC handler functionality including window, clipboard, color, and selection operations.

Handles clipboard-related OSC commands.

Handles color-related OSC commands.

Handles color palette OSC commands.

Parses color specifications from OSC commands.

Parses font specifications from OSC commands.

Parses hyperlink specifications from OSC 8 commands.

Handles selection-related OSC commands.

Parses selection specifications from OSC commands.

Handles window-related OSC commands.

Handles screen manipulation commands in the terminal.

Handles scrolling operations for the terminal screen buffer.

Handles window-related commands and operations for the terminal.

Handles terminal settings and behavior, including

Manages caching for terminal animations using the unified caching system.

Terminal configuration application.

Terminal capability detection and management.

Validates terminal configuration settings.

Default terminal configuration values.

Defines the behaviour for terminal environment configuration.

Manages terminal configuration including settings, preferences, and environment variables. This module is responsible for handling configuration operations and state.

Handles persistence and migration of terminal configurations.

Terminal configuration profile management.

Schema definitions for terminal configuration.

Utility functions for handling terminal configuration maps.

Validation logic for terminal configuration.

Handles C0 control codes and simple ESC sequences.

Provides cursor manipulation functions for the terminal emulator. This module handles operations like moving the cursor, setting its visibility, and managing cursor state.

Handles GenServer callbacks for the cursor manager. Extracted from Raxol.Terminal.Cursor.Manager to reduce file size.

Handles cursor state management operations for the terminal cursor. Extracted from Raxol.Terminal.Cursor.Manager to reduce file size.

Manages cursor state and operations in the terminal. Handles cursor position, visibility, style, and blinking state.

Handles cursor movement operations for the terminal cursor. Extracted from Raxol.Terminal.Cursor.Manager to reduce file size.

Optimized cursor manager using BaseManager behavior to reduce boilerplate. Demonstrates the performance benefits of our consolidated base behaviors.

Handles cursor style and visibility control for the terminal emulator.

Handles device status reporting and attributes for the terminal emulator.

ASCII art rendering system for the Raxol terminal emulator.

Handles raw terminal input/output and event generation.

Enterprise-grade terminal emulator with VT100/ANSI support and high-performance parsing.

Handles ANSI sequence processing for the terminal emulator.

Adapter module to make EmulatorLite compatible with existing code that expects the full Emulator struct.

Provides buffer management functionality for the terminal emulator.

Buffer operation functions extracted from the main emulator module. Handles active buffer management and buffer switching operations.

Handles CSI/ESC/SGR/OSC and related command logic for the terminal emulator. Extracted from the main emulator module for clarity and maintainability.

Handles emulator constructor functions. This module extracts the constructor logic from the main emulator.

Coordinates complex operations that require interaction between multiple terminal subsystems. This module handles the orchestration logic that was previously embedded in the main Emulator module.

Handles core emulator functionality including input processing and scrolling.

Cursor operation functions extracted from the main emulator module. Handles cursor movement, positioning, and blink operations.

Dimension and resize operation functions extracted from the main emulator module. Handles terminal resizing and dimension getters.

GenServer implementation for the Terminal Emulator.

Handles state management for the terminal emulator. Provides functions for managing terminal state, modes, and character sets.

Utility and helper functions for the terminal emulator. Extracted from the main emulator module for clarity and reuse.

Handles input processing for the terminal emulator. Provides functions for key event handling, command history, and input parsing.

Mode operation functions extracted from the main emulator module. Handles terminal mode setting and resetting operations.

Optimized input processing for the terminal emulator.

Handles output processing for the terminal emulator. Provides functions for output buffering, processing, and formatting.

Handles emulator reset and cleanup functions. This module extracts the reset logic from the main emulator.

Enhanced terminal emulator with comprehensive error handling. Refactored to use functional error handling patterns instead of try/catch.

Screen operation functions extracted from the main emulator module. Handles screen clearing and line clearing operations.

Scroll operation functions extracted from the main emulator module. Handles scroll region management and scroll positioning.

Provides terminal emulator structure and related functionality.

Handles text styling and formatting for the terminal emulator. Provides functions for managing character attributes, colors, and text formatting.

Defines the behaviour for terminal emulator style management. This includes handling text attributes, colors, and text formatting.

Telemetry instrumentation for the terminal emulator.

Text operation functions extracted from the main emulator module. Handles text writing with charset translation and cursor updates.

Defines the behaviour for the core Terminal Emulator.

Factory module for creating terminal emulator instances. This module is responsible for initializing and configuring new emulator instances.

Lightweight terminal emulator for performance-critical paths.

Base parser utilities for escape sequence parsers.

Parser for CSI (Control Sequence Introducer) escape sequences.

Cached version of CSI parser for performance optimization.

Parser for SCS (Select Character Set) escape sequences.

Handles parsing of ANSI escape sequences and other control sequences.

Defines the structure for terminal events.

Handles terminal events including input events, state changes, and notifications. This module is responsible for processing and dispatching events to appropriate handlers.

Handles various terminal events including mouse, keyboard, and focus events. This module is responsible for processing and responding to user interactions.

Optimized event processing pipeline for terminal events.

Global event management for terminal interactions.

Handles terminal events and dispatches them to appropriate handlers.

Manages terminal extensions, including loading, unloading, and executing extension commands.

Unified extension management GenServer that provides a single interface for loading, unloading, and managing terminal extensions.

Manages font operations and settings for the terminal, including font family, size, weight, and style.

Manages terminal text formatting and styling operations.

Manages the terminal text formatting.

Terminal graphics animation adapter that bridges the existing Raxol.Animation.Framework with terminal graphics capabilities.

Shared utilities for chart data processing and transformation.

Chart export and data processing functions extracted from DataVisualization. Handles chart data export, ASCII generation, and format conversion.

Chart operations and management functions extracted from DataVisualization. Contains streaming updates, data processing, and chart maintenance functions.

Chart rendering functions extracted from DataVisualization. Handles specific chart types: heatmaps, scatter plots, histograms.

Advanced data visualization component library for terminal graphics.

GPU acceleration specifically for terminal graphics operations.

Provides unified graphics capabilities for the terminal emulator with automatic protocol detection and fallback support.

iTerm2 inline images protocol implementation.

High-performance caching system for processed images and graphics data.

Comprehensive image processing pipeline for terminal graphics.

Kitty Graphics Protocol implementation for advanced terminal graphics.

Manages terminal graphics operations including

Advanced memory management system for terminal graphics operations.

Provides mouse interaction capabilities for terminal graphics elements.

Comprehensive performance monitoring system for terminal graphics operations.

Real-time data streaming system for terminal graphics visualizations.

Streaming chart management and state utilities extracted from DataVisualization. Handles streaming updates, scheduling, and chart state management.

Helper functions for data visualization extracted from DataVisualization. Contains utilities for chart management, updates, and common operations.

Manages terminal command history buffer operations. This module handles the storage and retrieval of command history.

Manages terminal command history operations including history storage, retrieval, and navigation. This module is responsible for handling all history-related operations in the terminal.

Unified input/output system for the terminal emulator.

Handles input processing for the terminal.

Manages input buffering for the terminal emulator.

Handles character processing, translation, and writing to the terminal buffer.

Handles clipboard operations for the terminal emulator.

Handles various control sequences for the terminal emulator. Includes CSI, OSC, DCS, PM, and APC sequence handling.

Core input handling functionality for the terminal emulator. Manages the main input buffer and cursor state.

Defines the base event struct and common types for input events.

Represents a keyboard input event.

Represents a mouse input event.

Handles file drag-and-drop operations for the terminal emulator.

A simple data structure for managing input buffer state.

Utility functions for Raxol.Terminal.Input.InputBuffer.

Handles input processing for the terminal emulator.

Processes input events for the terminal emulator.

Manages terminal input processing including character input, key events, and input mode handling. This module is responsible for processing all input events and converting them into appropriate terminal actions.

Comprehensive mouse event handling for terminal applications.

Handles special key combinations and their escape sequences.

Handles text input processing for the terminal emulator. This module extracts the text input handling logic from the main emulator.

Defines shared types for the Raxol terminal input subsystem.

Main input handler module that coordinates between different input handling components.

Coordinates terminal integration components and provides a unified interface for terminal operations.

Handles buffer and cursor management for the terminal.

Renders a list of cells to the terminal.

Manages configuration for the terminal integration.

Main integration module that provides a GenServer-based interface for terminal integration.

Handles terminal output rendering and display management using Termbox2.

Manages the state of the integrated terminal system.

Terminal manager module.

Behaviour for terminal manager event callbacks. Implement this behaviour to receive notifications for terminal events.

Handles terminal events and dispatches them to appropriate handlers.

Handles screen updates and batch operations.

Handles terminal session management.

Manages memory usage and limits for the terminal emulator.

Unified metrics collection and export module.

Manages terminal modes for the terminal emulator.

Handles terminal mode management functions. This module extracts the mode handling logic from the main emulator.

Manages terminal modes (DEC Private Modes, Standard Modes) and their effects.

Handles saved state operations for the mode manager. This includes saving and restoring cursor positions, screen states, and other terminal modes.

Manages terminal mode state and transitions.

Handles terminal modes and state transitions for the terminal emulator.

Handles DEC Private mode operations and their side effects. Manages the implementation of DEC private mode changes and their effects on the terminal.

Handles mouse mode operations and their side effects. Manages different mouse reporting modes and their effects on the terminal.

Handles screen buffer mode operations and their side effects. Manages alternate screen buffer switching and related functionality.

Handles standard mode operations and their side effects. Manages standard terminal modes like insert mode and line feed mode.

Manages the state of terminal modes, including transitions and validation. Handles mode dependencies, conflicts, and state persistence.

Defines types and constants for terminal modes. Provides a centralized registry of all terminal modes and their properties.

Manages mouse events and tracking in the terminal, including button clicks, movement, and wheel events.

Provides unified mouse handling functionality for the terminal emulator. This module handles mouse events, tracking, and state management.

Manages terminal notifications, telemetry events, and callbacks.

Implements cursor-related operations for the terminal emulator.

Implements screen-related operations for the terminal emulator.

Implements scroll-related operations for the terminal emulator.

Implements selection-related operations for the terminal emulator.

Implements state-related operations for the terminal emulator.

Implements text-related operations for the terminal emulator.

Defines the behaviour for core terminal operations.

Manages terminal output buffering, event processing, styling, and formatting. This module handles output events, applies styles and formatting rules, and tracks metrics.

Processes output events for the terminal emulator.

Simple output buffer implementation for terminal output.

Manages terminal output operations including writing, flushing, and output buffering. This module is responsible for handling all output-related operations in the terminal.

Parser state for the terminal emulator.

Manages the state of the terminal parser, including escape sequences, control sequences, and parser modes.

Refactored version of Terminal Parser State Manager using pattern matching instead of cond statements.

Defines the behaviour for parser states.

Behaviour for terminal parser state management.

Handles the CSI Entry state in the terminal parser. This state is entered after receiving an ESC [ sequence.

Handles the :csi_intermediate state of the terminal parser.

Handles the :csi_param state of the terminal parser.

Handles the :dcs_entry state of the terminal parser.

Handles the :dcs_passthrough_maybe_st state of the terminal parser.

Handles the :dcs_passthrough state of the terminal parser.

Handles the :designate_charset state of the terminal parser.

Handles the :escape state of the terminal parser.

Handles parsing in the ground state, the default state of the terminal.

Handles the :osc_string_maybe_st state of the terminal parser.

Handles the OSC String state in the terminal parser. This state is entered when an OSC sequence is initiated.

Alias module for parser state functionality. This module delegates to the actual implementation in Parser.ParserState.

Consolidated terminal parser state manager combining simple emulator operations with comprehensive parser state management.

Handles plugin dependency resolution for the terminal emulator. This module extracts the plugin dependency resolution logic from the main emulator.

Manages terminal plugins with advanced features

Unified plugin system for the Raxol terminal emulator. Handles themes, scripting, and extensions.

Core functionality for managing terminal plugins.

Registry for terminal processes and components.

Provides a unified interface for terminal rendering operations.

Terminal renderer module.

High-performance terminal renderer with style string caching.

GPU-accelerated terminal renderer.

Phase 3 optimized terminal renderer with efficient style handling.

Adaptive frame rate system for smart refresh optimization in Raxol terminals.

Behaviour definition for terminal rendering backends.

GPU-accelerated rendering backend for Raxol terminals using Metal (macOS) and Vulkan.

Programming font ligature rendering system for Raxol terminals.

SSH client stub - SSH support not available.

SSH session stub - SSH support not available.

Provides screen manipulation functions for the terminal emulator.

Manages the terminal's screen buffer state (grid, scrollback, selection). This module serves as the main interface for terminal buffer operations, delegating specific operations to specialized modules in Raxol.Terminal.Buffer.*.

Manages buffer attributes including formatting, charset, and cursor state. Consolidates: Formatting, TextFormatting, Charset, Cursor functionality.

Implements behaviour callbacks for the terminal screen buffer.

Handles CSI (Control Sequence Introducer) sequences for the screen buffer.

Handles character set operations for the screen buffer.

Manages cloud-related settings for the screen buffer.

Core functionality for screen buffer creation, initialization, and basic queries. Consolidates: Initializer, Common, Helpers, and basic state management.

Data structure adapter for ScreenBuffer operations.

Handles all erase operations for the terminal screen buffer.

Handles file system event monitoring for the terminal screen buffer. This module provides functions for processing file system events and managing debounced event handling.

Manages buffer lifecycle, memory tracking, damage regions, and buffer switching. Consolidates: Manager, UnifiedManager, SafeManager, EnhancedManager, DamageTracker.

Handles memory usage calculations for the terminal screen buffer.

Handles metrics collection and management for the terminal screen buffer. This module provides functions for recording and retrieving various metrics related to screen buffer performance, operations, and resource usage.

All buffer mutation operations. Consolidates: Operations, Ops, OperationsCached, Writer, Updater, CharEditor, LineOperations, Eraser, Content, Paste functionality.

Erasing operations for the screen buffer.

Handles output buffer operations for the terminal screen buffer. This module manages the output buffer state and provides functions for writing, flushing, and clearing the buffer.

Manages screen buffer preferences and settings.

Handles region operations for the terminal screen buffer.

Handles screen buffer operations for the terminal emulator. This module provides functions for managing the screen state, including clearing, erasing, and marking damaged regions.

Scrolling and scrollback operations for the buffer. Consolidates: Scroll, Scroller, ScrollRegion, Scrollback, and operations/scrolling.

Manages scroll region boundaries for the screen buffer.

Text selection operations for the screen buffer. Handles selection creation, updates, text extraction, and clipboard operations.

Shared operations for screen buffer modules to eliminate code duplication. This module contains common functionality used across different screen buffer implementations.

Manages system-related settings for the screen buffer.

Manages themes for the screen buffer.

Backward-compatible adapter that maps the old ScreenBuffer API to the new consolidated modules. This allows existing code to work without changes while we migrate to the consolidated architecture.

Defines the behaviour for screen buffer operations in the terminal. This module specifies the callbacks that must be implemented by any module that wants to act as a screen buffer.

Manages screen buffer operations for the terminal emulator. This module handles operations related to the main and alternate screen buffers, including buffer switching, initialization, and state management.

Handles screen update operations for the terminal.

Unified scripting system for the Raxol terminal emulator. Handles script execution, management, and integration with the terminal.

Manages terminal scrolling operations with advanced features.

Handles scroll optimization for better performance. Dynamically adjusts batch size based on recent scroll patterns and (optionally) performance metrics.

Shared utilities for analyzing scroll patterns.

Handles predictive scrolling operations for the terminal. Tracks recent scrolls and provides pattern analysis for smarter prediction.

Unified scroll management system for the terminal.

Handles scroll synchronization across terminal splits. Tracks recent sync events for analytics and smarter sync strategies.

Manages terminal scrollback buffer operations.

Manages search state, options, matches, and history for terminal search operations.

Manages terminal search operations including text search, pattern matching, and search history. This module is responsible for handling all search-related operations in the terminal.

Manages text selection operations in the terminal.

Terminal session module.

Handles serialization and deserialization of terminal session state.

Handles persistence of terminal sessions.

Terminal multiplexing system providing tmux-like session management for Raxol.

Helper functions for SessionManager operations.

Manages terminal split windows and panes.

Provides state management for the terminal emulator. This module handles operations like creating new states, saving and restoring states, and managing state transitions.

State manager for terminal emulator state. Provides functions for managing modes, attributes, and state stack.

Manages terminal state including modes, attributes, and state transitions. This module is responsible for maintaining and updating the terminal's state.

Manages terminal state transitions and state stack operations. This module is responsible for maintaining and manipulating the terminal's state.

Manages text styling and formatting for the terminal emulator. This module provides a clean interface for managing text styles, colors, and attributes.

Handles style management for the terminal emulator. This module extracts the style handling logic from the main emulator.

Manages terminal style state and operations. This module handles text attributes, colors, and formatting for terminal output.

Manages terminal style operations including colors, attributes, and formatting. This module is responsible for handling all style-related operations in the terminal.

Supervisor for terminal-related processes.

Defines the structure for synchronized components.

Manages synchronization between different terminal components (splits, windows, tabs). Provides a high-level interface for component synchronization and state management.

Defines the synchronization protocol for terminal components. Handles message formats, versioning, and conflict resolution strategies.

Unified synchronization system for the Raxol terminal emulator. This module provides centralized synchronization mechanisms for

Unified synchronization system for the terminal emulator. Handles synchronization between splits, windows, and tabs with different consistency levels.

Manages terminal tabs and their associated sessions. This module handles

Provides unified tab management functionality for the terminal emulator. This module handles tab creation, switching, state management, and configuration.

Integration module for managing tabs and their associated windows.

Logs all Raxol.Terminal telemetry events for observability and debugging.

Core state struct for the terminal emulator. This struct holds the main state fields used by the emulator state management functions.

Parses raw byte streams into terminal events and commands. Handles escape sequences (CSI, OSC, DCS, etc.) and plain text.

Individual terminal process implementation for event sourced architecture.

Registry for managing terminal instances.

Unified terminal management system that consolidates all terminal operations.

Manages terminal state operations for the terminal emulator. This module handles the state stack, saved states, and state transitions.

Utility functions for terminal operations, providing cross-platform and consistent handling of terminal capabilities and dimensions.

Alias module for Raxol.Terminal.ANSI.TextFormatting. This module re-exports the functionality from ANSI.TextFormatting to maintain compatibility.

Manages terminal themes with advanced features

Unified theme system for the Raxol terminal emulator. Handles theme management, preview, switching, and customization.

Tooltip display functionality for terminal UI.

Stub module for terminal input validation.

Represents a terminal window with its properties and state.

Refactored Window.Manager that delegates to GenServer implementation.

Operations module for window management functionality. Handles all the complex logic for window creation, updates, and hierarchy management.

GenServer implementation for terminal window management in Raxol.

Registry for managing multiple terminal windows.

A unified window manager for terminal applications.

Theme management system for Raxol terminal.

Unified UI framework adapter for Raxol.

High contrast mode system for improved visual accessibility in Raxol terminals.

Comprehensive screen reader support system for Raxol terminal applications.

Handles border rendering logic and border character definitions.

Handles cell operations, clipping, merging, and coordinate management.

Provides base functionality and utilities for Raxol components.

Defines the behavior for UI components in the Raxol system.

Provides component lifecycle hooks and management for UI components.

A customizable button component.

Renders a block of code with syntax highlighting.

Calculates layout bounds for widgets within a grid configuration. This module provides functions to determine the position and size of widgets based on a grid layout definition (columns, rows, gaps).

Handles saving and loading dashboard widget layouts to disk.

A progress bar component for displaying completion status.

A component for displaying tabular data with sorting, filtering, and pagination.

Focus ring component for accessibility and keyboard navigation.

Hint display component for contextual help and tooltips.

Button component for user input.

Checkbox component for toggling boolean values.

A multi-line input component for text editing, supporting line wrapping, scrolling, selection, and accessibility.

Clipboard operations for MultiLineInput component.

Event handler for MultiLineInput component. Handles keyboard input and navigation events.

Message routing for MultiLineInput component. Handles routing different message types to appropriate handler functions.

Navigation helper functions for MultiLineInput component cursor movement and selection operations.

Rendering helper functions for MultiLineInput component.

Text manipulation helper functions for MultiLineInput component.

Password field input component for secure user input. This is a thin wrapper around Raxol.UI.Components.Input.TextField, setting secret: true by default. All features, options, and behaviour are inherited from TextField.

A component that allows users to select an option from a list.

Navigation helper for SelectList component. Handles arrow key navigation, home/end, and page up/down.

Pagination helper for SelectList component. Handles page-based navigation and state management.

Rendering logic for SelectList component.

Search/filter functionality for SelectList component.

Selection management for SelectList component.

Shared utility functions for SelectList component modules. Eliminates code duplication between Navigation and Selection modules.

A simple single-line text input component.

Text area input component for multi-line user input. This is a thin wrapper around Raxol.UI.Components.Input.MultiLineInput for API compatibility. All features, options, and behaviour are inherited from MultiLineInput.

A text field component for single-line text input.

A text input component for the Raxol UI system.

Utility functions for text wrapping.

Cached version of text wrapping utilities with performance optimizations.

Renders Markdown text into Raxol elements or raw HTML.

A modal component for displaying overlay dialogs like alerts, prompts, confirmations, and forms.

Core state management and initialization for the Modal component.

Event handling and keyboard navigation for the Modal component.

Rendering logic and form field rendering for the Modal component.

State management and form validation for the Modal component.

Compound Components pattern for Raxol UI.

Higher-Order Components (HOCs) for Raxol UI.

Render Props pattern implementation for Raxol UI.

Provides components for displaying progress, like progress bars and spinners.

Progress bar component for terminal UIs.

Circular progress indicator component.

Core progress component implementation.

Indeterminate progress indicator component.

Animated spinner component for terminal UIs.

Table component for displaying and interacting with tabular data.

A terminal component that emulates a standard terminal within the UI.

Terminal emulator component wrapping the core emulator logic.

A text input component with editing capabilities.

Handles rendering of specific UI element types (box, text, table, panel).

Tracks keyboard events and provides accessibility support.

Tracks scroll events for virtual scrolling components.

Universal drag and drop system for all Raxol UI components.

CSS Grid layout system for Raxol UI components.

Handles layout calculations for container elements like rows and columns.

Handles measurement of basic UI elements like text, labels, boxes, and checkboxes.

Core layout engine that translates the logical view structure into absolute positions.

Modern Flexbox layout system for Raxol UI components.

Grid layout utility functions.

Handles measurement of input elements like buttons and text inputs.

Shared utilities for layout calculations.

Handles layout calculations for panel UI elements.

Responsive layout system with breakpoint support for terminal UI components.

Table layout operations for the UI system.

UI Renderer for Raxol terminal applications.

Cached version of the UI Renderer that leverages component caching.

Dynamically adjusts rendering frame rate based on system performance and content complexity.

High-performance cache for component rendering results.

Handles composition of UI rendering trees.

Tracks damaged/dirty regions in the UI tree to optimize rendering. Only re-renders areas that have actually changed, reducing unnecessary work.

Handles layout of UI components.

Cached version of the Layouter that uses ETSCacheManager for performance.

Performance-optimized rendering pipeline implementation.

Handles painting of UI components to the terminal.

Manages the rendering pipeline for the UI as a GenServer.

Defines and executes the rendering pipeline stages for UI components.

Maintains state for the rendering pipeline.

Batches multiple render requests within animation frames to optimize performance. Coalesces rapid UI updates into single render operations.

GenServer responsible for managing rendering state and applying animation settings. Receives commands from the rendering pipeline and coordinates rendering actions.

Fault-tolerant rendering pipeline with error recovery and performance monitoring.

Centralized timer management for the UI rendering pipeline.

Provides functions to compute the difference (diff) between two UI trees. This module is responsible for identifying changes, additions, removals, and reordering of nodes, supporting both keyed and non-keyed children.

React-style Context API for Raxol UI components.

Unified UI State Hooks with comprehensive functionality.

Unified GenServer for UI state management, handling both store operations and component hooks without Process dictionary usage.

Refactored UI State Store with GenServer-based state management.

Reactive streams system for real-time data flow in Raxol UI.

Handles style processing, merging, inheritance, and flattening.

A terminal UI rendering module for Raxol.

Consolidated theme resolution, color processing, and theme-related utilities.

Cached theme resolution module providing backward compatibility.

Color management utilities for theme handling.

Registry for custom color palettes used in the Raxol theming system.

A component for selecting and applying themes.

Theme management for Raxol UI components.

Defines the behaviour for Theme services.

Unified manager for themes and color palettes in the UI system. Consolidates ThemeManager and ColorManager functionality.

Universal features available across all UI frameworks in Raxol.

Utility functions for color conversions between hex and RGB formats.

Common utility functions for map operations.

Utility functions for formatting memory values.

Main view module for Raxol that provides view macros and sigils.

Basic view components for Raxol UI rendering.

Compatibility adapter for view elements. Provides the expected interface for UI components.

WebAssembly build system for Raxol.

Web supervisor for Raxol web interface components.

Web manager for Raxol web interface.

The entrypoint for defining your web interface, such as controllers, components, channels, and so on.

The endpoint for RaxolWeb.

A module providing Internationalization with a gettext-based API.

Router for RaxolWeb.

Plugin state management utilities with full functionality.

Runs make in the current project.

A task responsible for downloading the precompiled NIFs for a given module.

Precompiles the given project for all targets.

Main entry point for Raxol development tasks.

Enhanced benchmarking task for Raxol terminal emulator.

Advanced benchmarking commands leveraging the new world-class infrastructure.

Enhanced memory benchmarking task for Raxol terminal emulator.

Advanced memory analysis task demonstrating Phase 3 capabilities.

Run comprehensive quality checks on the Raxol codebase.

Converts GenServer modules to use BaseManager behavior.

Automatically generates type specs for private functions in Raxol modules.

Unified memory analysis and profiling tools.

Memory debugging tools for detecting leaks, hotspots, and optimization opportunities.

Memory performance gates for CI/CD integration.

Interactive memory profiler for real-time memory analysis.

Long-running memory stability tests for detecting memory leaks and performance degradation.

Custom mutation testing for Raxol using simplified approach.

Performance analysis and optimization tools for development.

Automated performance monitoring task for Raxol.

Enhanced test runner for the Raxol project.

Compiles Raxol to WebAssembly for web deployment.

Removes all WASM build artifacts.

Shows information about the current WASM build.