refactor: harden color-aa CLI parsing and de-magic charset count

Make --color-aa a typed Option<AaStrength> via FromStr so clap rejects
invalid values with a helpful error instead of silently falling back to
Off; remove the hand-rolled parse-and-ignore paths in resolved_color_aa
and the runner.

Replace the duplicated [AaStrength; 7] literals with a NUM_CHARSETS const
tied to ALL_CHARSETS.len(), so per-charset arrays stay locked to the
charset count.

Drop two provably-dead per-cell bounds checks in the blur hot loop in
favor of a single debug_assert on the width*height invariant.

Author: tamirelazar

src/app/runner.rs

@@ -324,10 +324,8 @@ pub fn run_simulation(
     renderer.set_dither_mode(dither_mode);
 
     // Apply CLI --color-aa override to the launch charset (else the per-charset default stands).
-    if let Some(ref s) = args.color_aa {
-        if let Some(aa) = crate::render::antialiasing::AaStrength::parse_cli(s) {
-            runtime_state.apply_cli_color_aa(aa);
-        }
+    if let Some(aa) = args.color_aa {
+        runtime_state.apply_cli_color_aa(aa);
     }
     // Push the resolved launch AA (default or CLI override) to the renderer so the
     // FIRST frame already reflects it (renderer's color_aa otherwise inits to Off).

src/cli.rs

@@ -1715,7 +1715,7 @@ pub struct Args {
         help = "Color anti-aliasing for subcell charsets: off | subtle | strong (default: auto — strong for braille, off otherwise)"
     )]
     /// Color anti-aliasing mode for subcell charsets.
-    pub color_aa: Option<String>,
+    pub color_aa: Option<crate::render::antialiasing::AaStrength>,
 
     #[arg(
         long = "bg-color",
@@ -1870,8 +1870,8 @@ impl Args {
         charset: &crate::render::charset::Charset,
     ) -> crate::render::antialiasing::AaStrength {
         use crate::render::antialiasing::AaStrength;
-        if let Some(ref s) = self.color_aa {
-            return AaStrength::parse_cli(s).unwrap_or(AaStrength::Off);
+        if let Some(aa) = self.color_aa {
+            return aa;
         }
         if matches!(charset, crate::render::charset::Charset::Braille) {
             AaStrength::Strong

src/config_defaults.rs

@@ -488,7 +488,8 @@ pub mod rendering {
 /// Default per-charset color-AA strength, indexed by `ALL_CHARSETS` order:
 /// [HalfBlock, HalfBlockDual, Ascii, Braille, Quadrant, Shade, Points].
 /// Braille defaults to Strong; everything else Off.
-pub const DEFAULT_COLOR_AA: [crate::render::antialiasing::AaStrength; 7] = {
+pub const DEFAULT_COLOR_AA: [crate::render::antialiasing::AaStrength;
+    crate::render::charset::NUM_CHARSETS] = {
     use crate::render::antialiasing::AaStrength::{Off, Strong};
     [Off, Off, Off, Strong, Off, Off, Off]
 };

src/config_manager.rs

@@ -252,7 +252,7 @@ impl SavedConfig {
         palette_cycle: crate::render::palette::PaletteCycle,
         glyph: crate::render::charset::GlyphConfig,
         temporal_accent: Option<crate::render::palette::RgbColor>,
-        color_aa: [crate::render::antialiasing::AaStrength; 7],
+        color_aa: [crate::render::antialiasing::AaStrength; crate::render::charset::NUM_CHARSETS],
     ) -> Self {
         let diffusion_kernel_str = match sim_config.diffusion_kernel {
             DiffusionKernel::Mean3x3 => "mean3x3",

src/render/antialiasing.rs

@@ -60,6 +60,19 @@ impl AaStrength {
     }
 }
 
+impl std::str::FromStr for AaStrength {
+    type Err = String;
+
+    /// Parse a CLI token, rejecting unrecognized values with a helpful message
+    /// (used by clap so bad `--color-aa` input errors instead of silently
+    /// falling back).
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Self::parse_cli(s).ok_or_else(|| {
+            format!("invalid color-aa mode: {s}. Valid options: off, subtle, strong")
+        })
+    }
+}
+
 /// True for charsets whose shape resolution exceeds their color resolution and
 /// therefore benefit from color anti-aliasing.
 pub fn charset_aa_eligible(charset: &Charset) -> bool {
@@ -78,13 +91,18 @@ pub fn blur_field(src: &[f32], width: usize, height: usize, strength: AaStrength
     if strength == AaStrength::Off || width == 0 || height == 0 {
         return src.to_vec();
     }
+    // Invariant: src is exactly the row-major field. With it, idx = y*width+x and
+    // every in-range nidx are provably < src.len(), so the inner indexing needs no
+    // per-cell bounds check (debug builds catch a caller that violates this).
+    debug_assert_eq!(
+        src.len(),
+        width * height,
+        "blur_field: src must be width*height"
+    );
     let mut out = vec![0.0_f32; src.len()];
     for y in 0..height {
         for x in 0..width {
             let idx = y * width + x;
-            if idx >= src.len() {
-                continue;
-            }
             let center = src[idx];
             let mut neighbor_sum = 0.0_f32;
             let mut neighbor_count = 0u32;
@@ -97,10 +115,8 @@ pub fn blur_field(src: &[f32], width: usize, height: usize, strength: AaStrength
                     let ny = y as i32 + dy;
                     if nx >= 0 && nx < width as i32 && ny >= 0 && ny < height as i32 {
                         let nidx = ny as usize * width + nx as usize;
-                        if nidx < src.len() {
-                            neighbor_sum += src[nidx];
-                            neighbor_count += 1;
-                        }
+                        neighbor_sum += src[nidx];
+                        neighbor_count += 1;
                     }
                 }
             }

src/render/charset.rs

@@ -138,6 +138,10 @@ pub const ALL_CHARSETS: [Charset; 7] = [
     Charset::Points,
 ];
 
+/// Number of distinct charsets. Single source of truth for any per-charset
+/// array (e.g. color-AA strength) so they stay locked to [`ALL_CHARSETS`].
+pub const NUM_CHARSETS: usize = ALL_CHARSETS.len();
+
 const HALF_BLOCK_CHARS: [char; 9] = [
     ' ', '\u{2581}', '\u{2582}', '\u{2583}', '\u{2584}', '\u{2585}', '\u{2586}', '\u{2587}',
     '\u{2588}',

src/terminal/frame_buffer.rs

@@ -566,6 +566,10 @@ impl FrameBuffer {
         // Color anti-aliasing: when active for this (frame-uniform) charset,
         // pre-blur two per-cell color fields. The glyph/shape path below reads
         // raw quadrant data and is unaffected.
+        // PERF: when active this allocates ~3 Vec<f32> per frame (base, diff, and
+        // each blur_field output). Only runs for AA-eligible charsets (braille by
+        // default). Revisit with reusable scratch buffers if a frame-time profile
+        // shows braille-AA as hot; not worth the restructure unprofiled.
         use crate::render::antialiasing::{blur_field, charset_aa_eligible};
         let aa_active = aa_strength != crate::render::antialiasing::AaStrength::Off
             && charset_aa_eligible(&charset);

src/terminal/state.rs

@@ -387,7 +387,7 @@ pub struct ParameterState {
     /// Window frame display mode.
     pub window_frame: WindowFrame,
     /// Per-charset color-AA strength, indexed by `charset_index`.
-    pub color_aa: [crate::render::antialiasing::AaStrength; 7],
+    pub color_aa: [crate::render::antialiasing::AaStrength; crate::render::charset::NUM_CHARSETS],
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -487,7 +487,7 @@ pub struct RuntimeState {
     /// Index of current charset.
     pub charset_index: usize,
     /// Per-charset color-AA strength, indexed by `charset_index`.
-    pub color_aa: [crate::render::antialiasing::AaStrength; 7],
+    pub color_aa: [crate::render::antialiasing::AaStrength; crate::render::charset::NUM_CHARSETS],
     /// Random seed used for initialization.
     pub original_seed: u64,
     /// Initialization mode used.
@@ -586,7 +586,8 @@ pub struct RuntimeState {
     /// (`cli_overrides: SimConfig` covers sim-layer params; these cover the render layer.)
     initial_palette_index: usize,
     initial_charset_index: usize,
-    initial_color_aa: [crate::render::antialiasing::AaStrength; 7],
+    initial_color_aa:
+        [crate::render::antialiasing::AaStrength; crate::render::charset::NUM_CHARSETS],
     initial_intensity_mapping: IntensityMapping,
     initial_window_frame: WindowFrame,
     /// Undo history stack.