API Reference Raxol v#2.6.1

TEA module source templates for mix raxol.new.

Boilerplate content generators for mix raxol.new.

File creation orchestration for mix raxol.new.

Template descriptions and previews for mix raxol.new.

Mock terminal for testing plugins

Mock plugin runner for testing

Multi-surface application runtime for Elixir, built on OTP.

Records pilot interactions as time-series events.

Tracks pilot accept/reject decisions on layout recommendations.

Rule-based layout recommendation engine.

Pure functional layout interpolation between two layouts.

Axon MLP for layout recommendation inference and training.

Supervisor for the adaptive UI subsystem.

Pure functional trend detection across aggregate windows.

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.

Time source for the animation system.

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.

Sequence and animation compilation for the Animation DSL.

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

Transform calculation functions for the Animation DSL.

Provides standard easing functions for animations.

Coordinates the lifecycle of animations within Raxol.

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

GenServer implementation for Animation Gestures state management.

View DSL helpers for attaching animation hints to elements.

Declarative animation hint metadata attached to view elements.

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.

Authentication and session management for Raxol.

Result persistence, regression detection, comparison, and HTML dashboard for mix raxol.bench.

Test data generators for Raxol benchmarks.

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

Fixture TEA applications for benchmarking render throughput, input latency, and memory usage. Each app has known complexity and pure implementations (no subscriptions, no side effects).

Mixed 3-panel dashboard with text, table rows, and progress indicators.

Minimal TEA app: empty model, empty view.

Nested row > column > box > text, depth 3.

10 lines of text in a column.

100-row, 5-column table.

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.

Formats benchmark results as console tables, JSON, or Markdown.

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.

Static competitor reference numbers for context.

Benchmarks the event -> update -> view -> layout -> cells pipeline.

Benchmarks the view -> layout -> cells render pipeline at 5 complexity levels.

Benchmarks Lifecycle startup time from start_link to initialized state.

Benchmarks per-widget and composite memory usage.

Centralized color palette for consistent CLI styling.

CLI command for managing Raxol updates.

Enhanced error display for CLI output with intelligent suggestions.

Formats ErrorExperience suggestions for CLI output.

Animated progress spinners for CLI operations.

Cloud integration system for Raxol applications.

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

Pure functional in-memory virtual file system.

Compliance reporting utilities for Raxol.

Thin wrapper around Raxol.UI.Components.Base.Component.

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.

Schema definitions for all Raxol configuration sections.

Documentation generation for Raxol configuration schemas.

Validation logic for Raxol configuration values.

Centralized defaults for the Raxol framework.

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

Manages the integration between accessibility settings and the active theme.

Box drawing utilities for Raxol.Core.Buffer.

Compatibility layer for legacy Raxol.Core.Buffer references.

Circuit breaker implementation for external API calls.

Behaviour for clipboard operations.

Core color system for Raxol.

Thread-safe ETS table management for Raxol's plugin command registry.

Generic connection pooling implementation for external services.

Enhanced error experience system for Raxol applications.

Error Pattern Learning System - Error Experience

Load, save, import, and export functions for ErrorPatternLearner. All I/O is isolated here; the GenServer delegates persistence work to this module.

Prediction and suggestion enhancement for ErrorPatternLearner. All functions are pure and operate on the learner state map.

Manages context preservation across process restarts.

Manages dependency relationships between components for intelligent recovery.

Enhanced supervisor with intelligent error recovery strategies.

Wrapper module that adds recovery capabilities to any GenServer process.

Automatic error report generation system for Error Experience.

Enhanced error message templates for Error Experience.

Provides functions for generating unique identifiers.

Core metrics module for Raxol framework.

Metric aggregation system for the Raxol metrics.

Alert management system for the Raxol metrics.

Cloud export for the Raxol metrics system.

Configuration management for the Raxol metrics system.

ETS-backed metrics collection for high-throughput metric recording.

Visualization system for the Raxol metrics.

Performance monitoring facade for Raxol.Core.

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.

Rendering utilities for Raxol.Core.Buffer.

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.

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.

Constructs :box-tagged View DSL nodes (new/1) with content, padding, border, and margin metadata for the box model.

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.

Constructors for :flex-tagged View DSL nodes (row/1, column/1, container/1), consumed by Raxol.Core.Renderer.View's row/column/ flex macros and, transitively, Raxol.UI.Layout.Flexbox -- the live layout engine.

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).

Refactored component manager with functional error handling patterns.

Debug logging functionality for the Raxol runtime.

Lightweight, package-neutral pub/sub for TEA runtime events.

Implements capture and bubbling event dispatch through the view tree.

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.

Pure-function hooks extracted from Dispatcher for mouse hit testing, time-travel debugging, cycle profiling, and session recording.

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.

Component startup sequence for the Raxol application lifecycle. Extracted from Lifecycle to reduce file size.

Shutdown, cleanup, and registry management helpers for Lifecycle. Extracted from Lifecycle to reduce file size.

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

A GenServer wrapping a single component module for crash isolation.

Rendering backend implementations for different output targets.

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.

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

ETS-backed state operations for StateManager. All functions operate on a named ETS table.

Process-based state management strategy for StateManager. Each managed state ID corresponds to a named GenServer process.

Style utilities for Raxol.Core.Buffer.

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.

Unified theme registry - single source of truth for all Raxol themes.

Refactored UX refinement module that uses GenUxServer for state management.

GenServer for managing UX refinement state.

Cryptographic utilities for Raxol.

Debug mode utilities and detailed logging for Raxol terminal emulator.

Interactive debugger UI for time-travel debugging -- "React DevTools for the terminal."

Pure functions for formatting Snapshot changes into styled display lines.

Pure functions for rendering a map/struct as an expandable tree.

A single point-in-time capture of a TEA update cycle.

Time-travel debugger for TEA applications.

Animated demos for the terminal showcase. Supports both SSH (direct IO) and web (message-based) output.

Command registry for demo terminal. Only whitelisted commands are executed. Validates input and blocks anything not explicitly registered.

Simple counter demo for mix raxol.demo counter.

Live BEAM dashboard demo for mix raxol.demo dashboard.

Generates demo content for the terminal showcase. Produces ANSI-formatted output demonstrating Raxol's capabilities.

Reusable visual effect helpers for demo animations.

Conway's Game of Life implementation for the demo showcase. Features age-based coloring where newer cells are brighter.

Self-driving 80x24 hero scene for the axol.io landing page (and X/GIF export).

Particle system for animated demo effects. Supports sparkles, explosions, trails, and floating elements.

GenServer managing demo terminal sessions. Enforces session limits and handles automatic cleanup.

Interactive component showcase for mix raxol.demo showcase.

ASCII text particle formation for demo effects. Uses 5x7 bitmap font to create particle target positions.

Task list demo for mix raxol.demo todo.

Watches lib/ for file changes and triggers recompilation + re-render.

House prose rules for Markdown, as pure functions over file contents.

A dynamic supervisor for starting Raxol application processes.

Animated border beam effect for terminal interfaces.

LiveView CSS generation for the BorderBeam effect.

Dispatches BorderBeam animation hints to the effect implementation selected by opts[:type] and applies the result to a flat cell list.

Color palettes and gradient logic for the BorderBeam effect.

Contract + shared helpers for border-effect implementations.

A soft, non-directional shimmer along the entire perimeter.

Bright sparks flash at random perimeter positions. Each spark is a jagged character (+ * # \ / x) painted in a vivid palette color and bold. Position + char are deterministic from the time bucket, so a given now_ms always produces the same crackle pattern.

Flickering flames climb the bottom edge of the box, with weaker echoes on the left and right edges near the bottom. Per-cell character + color choices come from bucket_hash/3 over a ~100ms time bucket, so the effect looks chaotic but stays reproducible per tick.

The whole border breathes in unison: every perimeter cell shares the same fg color and intensity at any moment, both varying as a smooth cosine wave over the period.

A long bright comet sweeps clockwise around the border. The head is always the brightest palette color (bold); the trail fades through the palette and dims via terminal attrs.

Visual cursor trail for terminal interfaces.

Visual hover feedback for terminal widgets.

Dev-only Phoenix endpoint for Tidewave MCP integration.

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.

EXPERIMENTAL -- HEEx template integration for Raxol.

Terminal-specific Phoenix function components for HEEx templates.

The streaming-flush cadence policy: a pure decision function that tells a caller whether to paint now, wait, or stand aside for input.

Pure scrollable window over a full-screen diff render: the state behind the harness surface's "expand the focused diff block" feature.

The THIN impure runner for the composer's external-editor handoff: drives Raxol.Harness.EditorSuspend's pure state machine and interprets each step against the real device / stty / reader gate / editor process. All sequencing, ordering, and failure-recovery policy lives in the pure machine; this module only performs effects.

The PURE side of the composer's external-editor handoff: editor resolution policy, the draft round-trip discipline, the temp-file naming policy, and -- the load-bearing part -- the suspend/resume state machine with per-step compensation.

The live-session security seam: converts a live agent contract event (atom-keyed struct/map, atom payload keys AND atom payload values -- e.g. payload: %{item_type: :tool_use}) into the fixture wire shape Raxol.Harness.Projection.project/2 and the stall detector already consume (atom top-level fields; payload with STRING keys and JSON-shaped values -- exactly what Jason.encode!/1 |> Jason.decode!/1 would produce).

Loader + decode shim for versioned JSONL harness fixtures.

Regenerates <name>.blocks.json snapshots by running a pluggable projector over each golden fixture session in a directory.

Typed decode error for a malformed harness fixture line.

One decoded fixture line beyond the header — the %Envelope{} wire shape from harness-spec-protocol.md §2, with body decoded into a Raxol.Harness.Fixture.Event.

The decoded body of a fixture Envelope — one observable step of an agent run, per harness-spec-protocol.md §3.

Line 1 of a harness fixture JSONL file: schema + provenance tags for the whole recorded session (FI-2: every transcript version-tagged).

Behaviour for a fixture-session projection function, pluggable into mix raxol.harness.fixtures.bless.

Trivial identity-shaped projector: one summary row per envelope, in offset (line-number) order. Stand-in for the real journal-fold projection (roadmap T7) so mix raxol.harness.fixtures.bless is testable before that projection lands. Deterministic and pure — no fold/tier routing, no block model, just enough shape to exercise the bless task's round trip.

A fully-loaded fixture: header + the ordered, upcasted envelope list. Helpers here are read-only projections over that list — the real journal-fold projection (T7) is a separate, not-yet-built module; these helpers exist so tests (and the bless task) don't hand-roll Enum pipelines over envelopes everywhere.

Upcast-on-read: fills absent newer fields with declared defaults, never mutates the bytes on disk (06-projection §1.2, methodology R6 "contract-only-grows"). Operates purely on the already-decoded struct.

The live-session unit's DRIVER: a plain-process loop supervising ONE live agent session end-to-end, from an injected Raxol.Harness.SessionLane subscription through Raxol.Harness.StreamCadence and into a Raxol.Harness.Surface, and back out through the lane's :interrupt/:steer dispatch.

Pure read-model fold over extract meta events, for the harness's worktracks/memory/plan overlay panels.

The journal-fold projection: durable events -> an ordered block list; ephemeral item_delta -> a live-tail state, never a durable block.

Folds one turn's family: :loop events into %Block{}s.

Cross-cutting recovery mechanics shared by Raxol.Harness.Projection: the global id-monotonic filter (N-ADV-02/03/forward-gap), family partitioning (loop vs meta vs untyped, N-DORM-04), turn bucketing in first-seen order (N-ADV-05), and the single diagnostic-emission seam every recovered condition goes through.

Turn recency -> per-block prominence: the policy that decides WHICH prominence (0.0..1.0) a transcript block gets, based purely on how many turns behind the current one its own turn is. This module is pure turn-identity arithmetic -- no processes, no clocks, no config reads, no rendering. It feeds context[:prominence] into Raxol.UI.Components.Harness.Block.render/2 (Raxol.UI.Harness.Prominence.resolve/3 underneath), but never calls either.

The shared classifier for "which blocks may seal (commit) this frame" -- the one piece of logic every consumer that needs to answer that question goes through, instead of each restating its own walk.

The seam between the harness surface (this package, which must NEVER depend on raxol_agent) and a live agent session lane. A concrete lane implementation lives on the agent side (e.g. Raxol.Agent.Harness.SessionLane in packages/raxol_agent) or in a test double -- never here.

The stall / doom-loop detector: a pure supervision instrument that tells the human "the agent you're watching has wedged" instead of letting a lying spinner run.

One detector verdict. class is the four-state answer; evidence is nil exactly when class is :ok (the honesty floor), otherwise a map always carrying :reason and a human-readable :summary plus reason-specific detail. standing_by: true marks a verdict that is NOT a fresh escalation: either a repeat of an already-reported alarm, or an alarm raised after the escalation budget was spent.

Roadmap unit T10 (docs/proposals/in-flight/harness-ui-roadmap.md, "Construction -- chrome" section): the pinned status strip, as a pure projection state -> [footer_line].

The streaming render cadence layer: decouples token ingest (network rate, unbounded) from render egress (cadence-throttled, bounded per flush) so a live agent's token stream never floods the terminal or starves input.

The assembled harness (golden-fixture assembly): the HarnessSurface app composed end-to-end against a replayed fixture session. This is the first assembled, visually-demoable harness -- no agent lane, fixture events only.

Byte-golden snapshot matrix for the harness degradation ladder: renders each fixed fixture session, end-to-end, through Raxol.Harness.Surface in each of the three render modes (:inline_log, :tmux_conservative, :flat) at fixed geometry, and blesses/checks the raw emitted byte stream against a checked-in golden file per fixture x mode pair.

A pure, small diff formatter for the byte-golden snapshot tests (test/harness/golden_snapshot_test.exs). Golden byte streams are tens of kilobytes; a raw assert rendered == golden on a mismatch would dump the whole binary into the test failure message. This module exists so a divergence reports exactly one thing: the first byte offset the two streams disagree at, plus a small, escaped context window around it -- never the full streams.

Multi-surface parity matrix: renders each fixture session through all four surface projections and pins each one, so "one TEA module renders to terminal, browser, SSH, and MCP" is a checked claim rather than a README sentence.

The assembled harness's small view-map -> plain-text-lines bridge.

The pure unread-divider policy: when the harness surface's operator looks away (blur/2) and completed blocks keep arriving, on return (focus/2, or the keystroke fallback input_activity/2) exactly one "N new since you looked" span is recorded, for the caller to render as a full-width rule (line/2) in the repaintable footer LIVE region -- never in sealed history. Every guarantee documented below corresponds to a named test in test/harness/unread_divider_test.exs (the policy suite) or test/harness/unread_divider_surface_test.exs (the Raxol.Harness.Surface integration).

Manages headless Raxol application sessions for non-interactive use.

Exposes the Raxol documentation tree as MCP resources under raxol://docs/....

Builds Raxol.Core.Events.Event structs from simple inputs.

MCP tool definitions for Raxol headless sessions.

Converts a Raxol.Terminal.ScreenBuffer into a plain text string.

Phoenix LiveView integration for Raxol.

Memory data collection for the memory debug tool.

Text, JSON, and Markdown output formatting for memory debug reports.

Memory leak detection and trend analysis.

Memory optimization analysis and recommendations.

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.

Analyzes performance metrics and generates insights for AI analysis.

Automated performance monitoring system for Raxol.

Cache behavior and utilities for Raxol performance optimization.

Shared cache get-or-compute pattern and telemetry for performance caches.

High-performance cache for component rendering results.

High-performance cache for font metrics calculations.

Profiles TEA update/view/render cycle timings.

Pure functions for computing statistics from cycle profiler timing data.

Performance hints system for development mode.

Development-mode profiler for detailed performance analysis.

Shared helpers for ETS-backed LRU and simple caches.

Shared utilities for ETS table lifecycle management.

High-performance ETS cache manager for Raxol hot paths.

Flame graph generation for performance profiling.

Thin wrapper around :fprof that isolates apply/3 calls.

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.

Terminal playground for Raxol widgets.

Single source of truth for Raxol's widget catalog.

Shared helpers for playground demo TEA apps.

Playground demo: block-character bar chart with orientation toggle.

Playground demo: interactive button with click handling.

Playground demo: toggle checkboxes with keyboard navigation.

Playground demo: Raxol.UI.Components.CodeBlock — real component using Raxol.UI.SyntaxHighlighter (same token path as Pierre DiffViewer).

Playground demo: scrollable container with viewport controls.

Playground demo: animated cursor trail with presets.

Playground demo: animated easing function showcase.

Playground demo: the section-9.7 flex engine.

Playground demo: accessibility focus ring indicators.

Playground demo: the agent-harness approval gate.

Playground demo: pre-apply diff viewer for a proposed file edit.

Playground demo: harness projection panels (worktracks / rules / memory / residual) laid out as one dashboard.

Playground demo: harness status bar, context/spend meters, activity indicator, advisory feed, drift indicator, and a toast -- the status/observability surface of an agent harness (docs/proposals/in-flight/harness-spec-frontend.md).

Playground demo: agent-harness tool-call/tool-result blocks + taint badge.

Playground demo: an agent-harness transcript rendered from real protocol event payloads -- a completed message, collapsible reasoning, and a fault.

Playground demo: 2D heatmap with color scale cycling.

Playground demo: streaming braille-resolution line chart.

Playground demo: full Markdown feature surface via Raxol.UI.Components.MarkdownRenderer.

Playground demo: selectable menu with keyboard navigation.

Playground demo: modal dialog with confirm and cancel actions.

Playground demo: OSC 9 desktop notification, OSC 9;4 taskbar/dock progress, and OSC 22 pointer shape.

Playground demo: panel focus highlighting with border styles.

Playground demo: password input with visibility toggle and strength meter.

Playground demo: progress bar with value tracking.

Playground demo: grouped radio buttons with h/l switching.

Playground demo: interactive Elixir REPL with sandboxed evaluation.

Playground demo: H-K salience colour solver.

Playground demo: braille scatter plot with animated clusters.

Playground demo: Viewport's overflow_anchor follow-tail scrolling.

Playground demo: dropdown select list with keyboard navigation.

Playground demo: compact sparkline with live data.

Playground demo: resizable split pane with direction toggle.

Playground demo: status bar with live-updating fields.

Playground demo: Raxol.UI.Components.Table — real component with the three border modes

Playground demo: tab bar with keyboard switching and content panels.

Playground demo: multi-line text editor with insert and normal modes.

Playground demo: text rendering with style variations, plus the Raxol.UI.Components.Display.Text wrapping/truncation affordances documented in docs/core/LAYOUT.md section 4 (text_overflow: :ellipsis, line_clamp, text_wrap: :pretty).

Playground demo: single-line text input with character counting.

Playground demo: expandable tree view with keyboard navigation.

Playground demo: in-memory virtual file system with shell-like commands.

Test helpers 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.

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

File system entry structure for the file browser.

Git Integration Plugin for Raxol Terminal

Example plugin demonstrating the Plugin System v2.0 capabilities.

Internal state for the rainbow theme plugin.

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

Status Line Plugin for Raxol Terminal

Command routing for the TerminalMultiplexerPlugin.

Pane operations for the TerminalMultiplexerPlugin.

Layout rendering for the TerminalMultiplexerPlugin.

Window operations for the TerminalMultiplexerPlugin.

Terminal Multiplexer Plugin for Raxol Terminal

Terminal pane within a multiplexer window.

Multiplexer session containing multiple windows.

Window containing multiple panes.

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.

Dependency validation, cycle detection, and load-order resolution for plugins.

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.

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.

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.

Plugin for text search functionality.

Assertion helpers for plugin testing

Benchmarking utilities for plugin performance testing

Custom assertions for plugin testing

Test helper functions for common plugin testing scenarios. Note: This module provides additional helpers specific to the PluginTestFramework. For basic test helpers, see Raxol.Plugins.Testing.Helpers.

Helper functions for plugin testing

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.

Policy definition framework for Raxol.

Exception raised when authorization fails.

Privacy and GDPR compliance utilities for Raxol.

Compatibility layer for performance profiling.

Defines protocols for the Raxol framework.

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.

Protocol for handling events in a polymorphic way.

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

Event bus for protocol-aware event handling.

Enhanced event structure with protocol support.

Integration layer for the plugin system with protocol support.

Registry for managing plugins and their capabilities.

Protocol-aware plugin structure.

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.

PubSub system for Raxol.

Safe query building utilities for Raxol.

RATE: Raxol Automated Testing Environment (golden render harness).

Role-Based Access Control for Raxol.

Elixir code evaluator with timeout protection, IO capture, and persistent bindings.

AST-based safety checker for REPL code evaluation.

Shell-like helper functions for the virtual filesystem in REPL sessions.

Rate limiting utilities for Raxol.

Serializes and deserializes asciinema v2 .cast files.

Replays recorded terminal sessions from .cast files.

GenServer that captures terminal output and input during a live Raxol session.

Data structure for a recorded terminal session.

Video render target: turn a Raxol screen buffer into a rasterized frame.

Encodes a directory of PNG frames into a video file via FFmpeg.

Behaviour for turning a standalone HTML document into a single PNG frame.

Rasterizer backend backed by ChromicPDF's warm headless-Chrome session pool.

Rasterizer backend that shells out to an installed headless Chrome/Chromium.

Release entrypoints for the raxol OTP release.

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

SSH app serving for Raxol TEA applications.

I/O adapter for SSH sessions.

Serves a Raxol TEA application over SSH.

Manages a single SSH connection's TEA application lifecycle.

Sandbox execution environment for untrusted code.

Search system with fuzzy, exact, and regex matching.

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

GenServer implementation for Security User Context management.

Version-stable string quoting for golden artifacts.

Defines style properties for terminal UI elements.

Defines border properties for terminal UI elements.

Provides utilities for color accessibility, focusing on WCAG contrast.

Generates and validates accessible color palettes based on WCAG contrast requirements.

Suggests accessible color alternatives based on WCAG contrast requirements.

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.

Behaviour for convergent replicated data types (CRDTs).

Last-Writer-Wins Register CRDT.

Observed-Remove Set CRDT.

Bandwidth-aware synchronization manager.

Automatic node discovery via libcluster.

Health and latency tracking for cluster nodes.

Composites multi-node state into cell tuples for rendering.

libcluster strategy that discovers BEAM nodes via Tailscale.

Supervisor for the distributed swarm subsystem.

CRDT-backed shared state visible to all nodes.

Manages node roles and handles promotion/demotion on failure.

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.

Utility for running external commands with stdin input via Port.

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.

Theme management system for Raxol terminal.

Internal multi-framework adapter layer.

Handles border rendering logic and border character definitions.

Cell-level color dimming for content sitting behind an active modal dialog.

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

Block-character bar chart with sub-character precision.

A dot-addressable canvas that renders to Unicode braille characters.

Shared utilities for chart rendering: scaling, range computation, axis/legend cell generation, and data normalization.

2D heatmap with background-color intensity mapping.

Braille-resolution line chart with multicolor multi-series support.

Braille-resolution scatter plot for 2D {x, y} data.

Converts chart cell tuples to View DSL elements for use in TEA view/1.

A color intent — (hue, chroma, prominence), not a literal color — that rides the same fg:/bg: slots literal colors occupy in a style map or a cell tuple. Resolved to bytes exactly once, at the render choke point (Raxol.UI.ColorResolver), against the ground that is actually known at that point (terminal background, capability tier, region/focus state).

The single whole-list resolution pass that turns Raxol.UI.ColorIntent structs (and the {:fixed, color} wrapper) surviving in a cell list's fg/bg slots into concrete literal colors -- hex strings, {r, g, b} tuples, ANSI atoms, or 256-palette integers -- exactly once, as close to the terminal writer as this codebase gets.

Test utilities for Raxol UI components.

Absolute / overlay layer primitive for terminal chrome.

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.

Renders a block of code with structured syntax highlighting for the terminal.

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 non-interactive status bar that displays key-value pairs separated by a configurable delimiter.

Styled text rendering with wrapping, alignment, and truncation.

A tree view component with expand/collapse and keyboard navigation.

A scrollable container that displays a windowed view of content that may exceed its visible bounds.

Focus ring component for accessibility and keyboard navigation.

Working / idle / hung indicator for one harness turn.

Advisory side-channel feed: renders gate_decision / verdict / research meta events from probes running alongside the primary transcript.

The agent-harness approval gate: shows what an action wants to do, its blast radius, and a keyboard-driven choice of how far to trust it.

The axol face ≡··≡ — the harness identity/status layer.

Renders the blast radius of an agent-harness action: everything it will touch, grouped by effect kind, with destructive/irreversible effects made impossible to miss.

The projection unit of the harness transcript: one sealed-or-live chunk of a session, folded from journal events into a renderable shape.

T5's fold-aware entry point: renders a %Raxol.UI.Components.Harness.Block{} as its real, merged per-kind component when expanded, and as Block's own proven one-line-summary-plus-outcome-row when folded.

The T5 seam: an explicit per-kind content-map contract, plus the mapping from a %Raxol.UI.Components.Harness.Block{}'s kind to the merged component (or pair of components) that renders its EXPANDED body.

Harness prompt composer: wraps Raxol.UI.Components.Input.MultiLineInput with harness-specific submit semantics, input history recall, bracketed paste fidelity, and a queued-steer banner. Does not reimplement multi-line editing -- cursor movement, selection, and text mutation stay entirely in MultiLineInput; this module only decides when those primitives fire and adds one banner above the prompt.

Compaction-proximity gauge: how much of the context window is used.

Pre-apply file diff viewer.

Cross-family drift verdict gauge: how far this run has drifted from its originating agent family, on a 0 (identical) to 100 (fully drifted) scale.

Renders a fault: error{where, reason}.

Shared id-fallback helper for harness components.

Line-based diff between two blocks of text.

Renders a message/reasoning block's Markdown content for the harness transcript.

A read-only panel over the harness's session memory projection.

Renders a completed transcript message: item_completed{item_type: :message, content}.

Overlay picker primitive (AD-U3): prompt + ranked list + async cancelable preview -- the fzf-shape that serves every "pick one of N" (sessions, runs, tool-calls, command palette, file mentions). One primitive, many projections (T15's job); this unit builds the component itself.

Renders reasoning/thinking content: item_completed{item_type: :reasoning, content}.

A read-only indicator for the harness's residual projection.

A read-only panel over the harness's active when->then rules projection.

Spend-vs-cap gauge: agent spend as a bar toward its session/lifetime cap, colored green -> yellow -> red as spend approaches the cap.

Harness status line: model, turn-state, context budget, and running cost for one agent turn.

A tiny inline badge marking untrusted, tool-derived content.

Display-width-aware text truncation and control-byte sanitization shared by harness components that ultimately hand model-supplied text to Components.text().

Transient notification: a small floating notice with a level-appropriate glyph and color. The glyph carries the meaning too (not color alone), so the toast stays legible for colorblind users and on no-color terminals.

Renders one tool invocation from the harness protocol stream.

Renders one tool result from the harness protocol stream.

Intra-line word diff for a paired deletion/addition line.

A read-only kanban board over the harness's worktracks projection.

Hint display component for contextual help and tooltips.

Button component for user input.

Checkbox component for toggling boolean values.

A nested menu component with keyboard navigation.

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.

A tab bar component with keyboard navigation.

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.

Shared text editing operations for input components.

A text field component for single-line text input.

A text input component for the Raxol UI system.

Utility functions for text wrapping.

Renders Markdown text into styled Raxol elements for terminal display.

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.

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

Progress bar component for terminal UIs.

Circular progress indicator component.

Indeterminate progress indicator component.

Animated spinner component for terminal UIs.

Table component for displaying and interacting with tabular data.

A terminal emulator component that wraps EmulatorLite to display a fully functional terminal within the UI.

Terminal emulator component wrapping the core emulator logic.

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.

Helpers for widgets to determine focus state from the render context.

Canonical input-event normalization for harness components.

Harness keybind layer: canonical input event + mode context → typed command, or :passthrough. T12 in harness-ui-roadmap.md.

Pure, read-only footer-region content panel: a fixed-height scrollable block of pre-formatted lines, driven entirely by Raxol.UI.Harness.InputEvent-normalized events. No process, no I/O -- state is a plain map, and every function here is (t(), ...) -> t() | result, exactly Raxol.UI.Harness.OverlayPicker's style.

Pure footer-region overlay picker primitive: a filterable list rendered as a fixed-height block of Raxol.Harness.Surface.ViewText-shaped view maps, driven entirely by Raxol.UI.Harness.InputEvent-normalized events. No process, no I/O, no device -- state is a plain map (matching Raxol.Harness.Surface's own plain-map style, not a struct), and every function here is (t(), ...) -> t() | result.

Maps a continuous prominence (0.0..1.0) attribute onto a resolved hex color through the Raxol.UI.Theming.Salience H-K solver.

Integration testing utilities for Raxol applications.

Universal drag and drop system for all Raxol UI components.

CSS Grid layout system for Raxol UI components.

Grid cell definition specifying position and span.

Grid item with placement information.

Handles grid item placement: explicit placement via grid-area / grid-row / grid-column, occupancy-grid construction, and auto-placement (grid-auto-flow).

Calculates final pixel positions for placed grid items given sized tracks.

Track sizing for CSS Grid: resolves auto, fr, min-content, max-content, and minmax() tracks based on item content and available space.

Grid track (row or column) definition.

Parses CSS Grid track definitions (grid-template-columns / grid-template-rows).

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

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

A flex child resolved into the inputs the flexible-length solver needs.

Modern Flexbox layout system for Raxol UI components.

Container sizing and the legacy calculate_layout/distribute_flex API.

Main-axis and cross-axis positioning for flex items, including justify-content and align-items logic.

Resolve flexible lengths per CSS Flexbox spec section 9.7, on resolved Raxol.UI.Layout.FlexItems. Called from Flexbox.calculate_single_line_layout/5 for every flex line.

Line-breaking logic for flex-wrap containers, and multi-line layout orchestration.

Grid layout utility functions.

Handles measurement of input elements like buttons and text inputs.

Shared utilities for layout calculations.

Default ScrollContent adapter that wraps a plain list.

Min-content inline (width) measurement: the smallest width an element can occupy without losing content (longest unbreakable text segment, declared width for fixed boxes, aggregates for containers).

Handles layout calculations for panel UI elements.

An element with pre-computed text measurements.

Walks an element tree and produces PreparedElements with cached text measurements.

Responsive layout system with breakpoint support for terminal UI components.

Behaviour for content sources that support cursor-based streaming.

Layout processor for split pane elements.

Helpers for interactive split pane resize in TEA applications.

ScrollContent adapter for lazy/streaming data sources.

Shared style inheritance logic for layout containers.

Table layout operations for the UI system.

General-purpose fuzzy list scorer: (list, query, key_fn) -> ranked.

Performance testing utilities for Raxol UI components.

UI Renderer for Raxol terminal applications.

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.

The single seam both inline-render emit paths go through: the printed- history append path and the pinned-viewport repaint path.

Neutralizes control bytes inside agent/LLM-originated content before it reaches PaintAuthority.InlineAuthority.seal/2 -- seal/2/ append_sealed/2 previously wrote iodata verbatim, so an embedded \e[2J/\e[3J/CUP inside model output could wipe native scrollback or repaint an already-sealed row FROM INSIDE THE CONTENT, defeating every invariant the append path exists to hold, no matter how correct the fill-down/seal-once machinery around it is.

The single home of the wire vocabulary shared by every PaintAuthority implementation: the cursor-save dialect and the scroll-region set. The cursor-save dialect choice (DECSC \e7/\e8 vs SCO \e[s/\e[u) changes exactly the two constants below and nothing else; implementations and oracles must reference this module rather than embedding the bytes.

The degradation ladder's :flat tier: the append-only, zero-region, zero-cursor-jump PaintAuthority implementation. Picked by Raxol.UI.Rendering.PaintAuthority.ModeSelect.select/3 for TERM=dumb, non-tty, CI-without-tty, and degenerate-geometry sessions — the screen-reader answer, the CI/pipe answer, the block-hater answer.

Minimal production PaintAuthority stub: writes every emit straight to IO.write/1 and otherwise just tracks dimensions. This is deliberately NOT a full implementation — no scroll-region (DECSTBM) lifecycle, no D-PA-scoped resize policy, no real cursor-save dialect wiring. It exists so Raxol.UI.Rendering.PaintAuthority has at least one non-test implementation to compile against, and so the "tag layer costs nothing in prod" claim in the module doc is checkable: this module emits the same bytes Raxol.Harness.Test.CaptureAuthority records, minus the tags.

The real (production) PaintAuthority implementation: the printed- history append path.

The degradation ladder's startup mode-pick decision: caps + env -> which PaintAuthority profile a session renders through.

The FULL-VIEWPORT paint substrate: the alternate-screen, full-frame repaint sibling of InlineAuthority (append + pinned footer) and FlatAuthority (append-only).

Handles painting of UI components to the terminal.

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.

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.

Pure cursor-follow scroll windowing for vertical selection lists.

React-style Context API for Raxol UI components.

Definition structure for a context.

Context provider that supplies values to descendant components.

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.

Action structure for state changes.

Internal state structure for the Store.

Subscription to state changes in the Store.

Shared style/theme merging for UI components.

Handles style processing, merging, inheritance, and flattening.

Structured-token syntax highlighting for terminal rendering.

A terminal UI rendering module for Raxol.

Canonical text-wrapping entry point implementing the CSS white-space property (CSS Text Module Level 3) for monospace/terminal text. Call wrap/3 with one of the five values below instead of hand-rolling collapsing/wrapping logic.

text-wrap: pretty -- a Knuth-Plass-style dynamic program for the monospace grid.

Single source of truth for text display width measurement, and for converting between the three units text is counted in.

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

Polarity-preserving 16-color (ANSI16) degradation table for semantic salience roles.

Color management utilities for theme handling.

Single canonical home for Raxol's palette PRIMITIVES: the color VALUES that theming, terminal rendering, and UI components pull from -- as opposed to the color-manipulation ALGORITHMS (HSL conversion, harmony, gradients, accessibility suggestion, contrast calculation), which stay where they are (Raxol.Style.Colors.*, Raxol.UI.Theming.Salience).

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

Salience-tier color solver: OKLCH colors leveled through a two-lobe Helmholtz-Kohlrausch apparent-lightness model.

Builds a Raxol.UI.Theming.Theme from salience-tier seeds solved against the terminal's actual background.

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.

Visual regression testing utilities for Raxol applications.

Utility functions for color conversions between hex and RGB formats.

Shared formatting utilities for human-readable output.

Common utility functions for map operations.

Utility functions for formatting memory values.

Main view module for Raxol.

Basic view components for Raxol UI rendering.

Backward-compatibility shim for view elements.

Top-level interrupt/resume API for Raxol.Workflow.*.

Asynchronous execution surface for Raxol.Workflow.Compiled graphs.

Typed reducer declaration for a state-map key.

An append-only snapshot of a workflow run's state at a specific step.

Behaviour for Raxol.Workflow.Checkpoint persistence.

DETS-backed Raxol.Workflow.Checkpoint.Saver adapter.

ETS-backed Raxol.Workflow.Checkpoint.Saver adapter.

Postgrex-backed Raxol.Workflow.Checkpoint.Saver adapter.

Frozen, validated workflow ready for execution.

Edge descriptors for Raxol.Workflow.Graph.

Edge whose chooser.(state) returns the next node id, or a list of node ids for parallel fan-out.

Static edge from from to to.

Edge that is taken only when guard.(state) returns truthy.

Barrier descriptor for a join node.

Per-task execution state for workflow runs that use interrupt / resume.

Immutable graph builder for Raxol.Workflow.

Node descriptors for Raxol.Workflow.Graph.

A node backed by a module implementing Raxol.Workflow.Node.

Protocol for executing Raxol.Workflow.Node.TypedNode structs.

A node backed by a 1-arity function.

A node backed by a struct implementing Raxol.Workflow.Node.Executor. Used by external packages to register semantically-named nodes with custom telemetry.

Execution runtime for Raxol.Workflow.Compiled graphs.

Merges the terminal states of fan-out branches at a join.

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.

Run comprehensive quality checks on the Raxol codebase.

Validate documentation against the code and the house prose rules.

Converts GenServer modules to use BaseManager behavior.

Interactive debugger for time-travel debugging Raxol TEA applications.

Runs built-in Raxol demo applications.

Generate flame graphs for performance analysis.

Generates a new Raxol TEA component module and test.

Automatically generates type specs for private functions in Raxol modules.

Runs a projector over every golden harness fixture session and writes <name>.blocks.json beside it — the regenerable snapshot half of the fixture toolchain (06-projection §1.2).

Runs Raxol.Harness.Surface.Golden.run/1 over the fixtures x degradation-tier matrix, writing one checked-in golden byte file per fixture x tier pair (test/fixtures/harness/goldens/<fixture>.<mode>.golden).

Renders every harness fixture through all four surface projections (:cells, :liveview_dom, :ssh_ansi, :structured_json), writing one reviewable artifact per fixture x surface under test/fixtures/harness/parity/ plus the hash refs file priv/harness/parity.refs.

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.

Generates a new Raxol application.

Performance analysis and optimization tools for development.

Automated performance monitoring task for Raxol.

Interactive terminal playground for browsing Raxol widgets.

Render the fixture corpus and compare each hash against priv/rate/golden.refs.

Records a Raxol application session to an asciicast (.cast) file.

Render a TEA module (or .exs file path) to a video file or a single image.

Interactive Elixir REPL powered by Raxol's terminal UI.

Replays a recorded Raxol session from an asciicast (.cast) file.

Enhanced test runner for the Raxol project.

Drives real macOS GUI terminals (iTerm2, Terminal.app, WezTerm, kitty) through AppleScript/CLI device control, judges the T0 keystone claims (C1/C2/C3/C4/N06/N07) programmatically against each capture, writes the results into scripts/harness/t0/t0-verdict.json via append_result.sh, and prints the D-PA resolver's output.