Inline driver profile (unit T2d).

A sibling of Raxol.Terminal.Driver, not a replacement: today's driver enters the alternate screen at init (\e[?1049h) and termbox owns the whole tty. This module never does either. It puts the tty in raw mode (no echo, no line buffering, no signal generation), runs T1's capability probe over the same input fd, and streams parsed key events to a subscriber -- all while leaving the terminal's native scrollback completely alone. T2b (printed-history append) and T2a (scroll-region manager) are separate units layered on top; this module sets no scroll region itself.

Constructor options

• :dispatcher_pid -- the default subscriber for parsed input events (see below). May be nil (headless use).
• :subscriber -- overrides :dispatcher_pid as the input-event target, for tests that want a separate collector.
• :raw_sink -- optional pid that receives every PRE-parse input chunk as {:inline_raw_input, binary()}, exactly as it arrived from the tty reader, before InputParser sees it. Debug/observability seam (byte-level input tracing); default nil -- when unset, nothing changes on the input path.
• :device -- output sink. Default :stdio. Accepts :stdio or any IO.device/0 (a StringIO pid works great in tests -- everything here is written via plain IO.write/2, never raw port writes). This is the suite design's hard requirement: the output device is a parameter, not a hardcoded :stdio write, so Tier A can capture bytes with no pty and no termbox.
• :stty -- module implementing save/0, raw!/0, restore/1 (default Raxol.Terminal.Driver.Stty). Inject a recording stub in tests so OS-level tty state is never touched by a pure test run. Note: raw!/0's termios flags include -isig, so once raw mode is entered the kernel stops generating SIGINT/SIGTSTP from Ctrl-C / Ctrl-Z -- interrupt delivery and job control become this driver's responsibility (or the app's) until teardown restores the saved settings.
• :tty? -- override real-tty detection (default Raxol.Terminal.TerminalUtils.has_terminal_device?/0). Drives the default of :install_reader? and :stty_enabled? below.
• :stty_enabled? -- whether to actually invoke the injected :stty module (default: same as :tty?). Kept independent of :tty? so a test can force the byte-emission path (tty?: true) while keeping stty_enabled?: false -- the real OS tty of whatever process is running the test suite is never touched by Tier A.
• :install_reader? -- whether to hook the prim_tty trace-based stdin reader (default: same as :tty?). Independent for the same reason.
• :rows -- terminal height used for the final teardown cursor move (default: detected via :io.rows/0, falling back to the injected :stty module's size/0, falling back to 24).
• :probe? -- whether to run the T1 capability probe at startup (default true). Tests that only care about teardown ordering can pass false to skip the (bounded, ~100ms local / ~1s SSH) wait.
• :capabilities -- a pre-computed %Raxol.Terminal.Capabilities{}. When given, the probe is skipped entirely and this record is cached directly -- the fastest test seam, and also useful for embedding contexts that already know the answer.
• :probe_opts -- forwarded verbatim to Raxol.Terminal.Capabilities.Probe.new/2 (:budget_ms, :extend_ms, :now_ms, :tmux_passthrough?, :platform).
• :probe_env -- the env map the probe seeds from (default System.get_env/0).

The output-device + teardown seam

emit_teardown/2 is the pure(-ish) seam the suite design calls for: it takes the output device and a driver state and writes the canonical teardown byte sequence (Raxol.Terminal.InlineDriver.Sequences), restores the OS tty via the injected stty module, and returns an updated state with torn_down?: true. It is idempotent -- a state that already has torn_down?: true is returned unchanged and nothing is written, so calling it twice (a signal handler AND terminate/2, say) can never double-emit \e[r or reposition the cursor twice (LC-N-DOUBLE).

terminate/2 is the only caller in this module. It runs whenever THIS process terminates for a reachable reason: a direct GenServer.stop/1 on the driver, or a crash inside any handle_manager_* callback (a raised error inside a GenServer callback still runs that same process's own terminate/2 -- orthogonal to trap_exit, which only gates external exit signals). System.halt and SIGKILL run no cleanup at all -- documented residual, not a gap in this module (kill -9 cannot be caught by anything running in the killed process).

Teardown-on-quit through Lifecycle: graceful stop FIXED (T28a), SIGTERM open (T28b)

The driver's teardown itself is correct and deterministic; whether Lifecycle invokes it on shutdown was unit T28's subject, since split into two facets with different fates:

• Raxol.stop/1 (in-process graceful stop): deterministic since T28a (merged). Lifecycle now traps exits and drives teardown from its own terminate/2, driver-first, so a dependent's :shutdown exit can no longer race back through the link and kill Lifecycle before this driver is stopped -- this terminate/2 runs by construction. (Pre-T28a this was a measured ~50% miss under ExUnit load.) Enforced by the now-unskipped graceful-stop test in test/harness/t2d_teardown_positive_test.exs.

• OTP default SIGTERM -> init:stop/0 (the real VM tree-unwind a production kill -TERM / container stop triggers): teardown is still never reached. The tree unwind does not route through Lifecycle at all, so this terminate/2 is skipped every time (measured under a real pty: no \e[r, no modes-off in the capture). This is the stdio-shutdown race the termbox driver.ex already flags (~line 494) surfacing as a total miss on the inline path. Tracked as unit T28b (the first SIGTERM handler attempt self-deadlocked in :erl_signal_server and was reworked). Until T28b lands, production SIGTERM teardown relies on the app arranging its own handler that calls Raxol.stop/1 (as the Tier B LC-P-SIGTERM test does); the gap stays pinned by the remaining skipped @tag :pending_t28b test. The driver's own teardown is meanwhile proven deterministically by stopping the driver process directly (LC-P-CLEAN).

Input contract

Parsed input events are sent to the subscriber as {:inline_input, %Raxol.Core.Events.Event{}} messages -- a simple pid/message contract, intentionally thin. Unit T13a wires the real Dispatcher; until then this seam is the whole contract.