diff --git a/crates/ass-renderer/Cargo.toml b/crates/ass-renderer/Cargo.toml
index 77361c5..cb7dd21 100644
--- a/crates/ass-renderer/Cargo.toml
+++ b/crates/ass-renderer/Cargo.toml
@@ -66,13 +66,12 @@ pkg-config = "0.3"
 pretty_assertions = "1.4"
 
 [features]
-default = ["analysis-integration", "backend-probing", "simd", "image", "serde", "libass-compare"]
+default = ["analysis-integration", "backend-probing", "simd", "image", "serde"]
 
 minimal = ["nostd", "analysis-integration"]
-full = ["analysis-integration", "backend-probing", "simd", "image", "serde", "libass-compare"]
+full = ["analysis-integration", "backend-probing", "simd", "image", "serde",]
 
 analysis-integration = ["ass-core/analysis"]
-libass-compare = []
 backend-probing = []
 backend-metrics = []
 
diff --git a/crates/ass-renderer/build.rs b/crates/ass-renderer/build.rs
deleted file mode 100644
index 2c7bba1..0000000
--- a/crates/ass-renderer/build.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//! Build script for ass-renderer crate
-//!
-//! Handles linking libass when the libass-compare feature is enabled,
-//! with platform-specific fallbacks for macOS Homebrew installations.
-
-fn main() {
-    // Only link libass on native targets when the libass-compare feature is enabled
-    #[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-    {
-        // Use pkg-config to find libass
-        if let Err(e) = pkg_config::Config::new()
-            .atleast_version("0.14.0")
-            .probe("libass")
-        {
-            // Fallback to manual linking for macOS with Homebrew
-            #[cfg(target_os = "macos")]
-            {
-                println!("cargo:warning=pkg-config failed: {e}, trying homebrew paths");
-                println!("cargo:rustc-link-search=/opt/homebrew/lib");
-                println!("cargo:rustc-link-search=/usr/local/lib");
-                println!("cargo:rustc-link-lib=ass");
-            }
-
-            #[cfg(not(target_os = "macos"))]
-            {
-                panic!("Cannot find libass. Please install libass development files. Error: {e}");
-            }
-        }
-    }
-}
diff --git a/crates/ass-renderer/src/backends/software.rs b/crates/ass-renderer/src/backends/software.rs
index d97cda9..5d62a69 100644
--- a/crates/ass-renderer/src/backends/software.rs
+++ b/crates/ass-renderer/src/backends/software.rs
@@ -6,10 +6,10 @@
 // a separate implementation would be required.
 #[cfg(feature = "nostd")]
 compile_error!(
-    "The software backend (software.rs) is not compatible with the `nostd` feature. \
+    "The software backend is not compatible with the `nostd` feature. \
      It uses `bytes::BytesMut`, `std::sync::Mutex`, and `bumpalo`, which all require std. \
-     Either disable the software-backend feature when building with nostd, or contribute a \
-     no_std-compatible alternative."
+     To fix: use `bytes` with default-features disabled, swap Mutex<Bump> for RefCell<Bump> \
+     on nostd, and gate std::sync imports behind #[cfg(not(feature = \"nostd\"))]."
 );
 
 #[cfg(feature = "nostd")]
diff --git a/crates/ass-renderer/src/debug/analyzer.rs b/crates/ass-renderer/src/debug/analyzer.rs
deleted file mode 100644
index c952753..0000000
--- a/crates/ass-renderer/src/debug/analyzer.rs
+++ /dev/null
@@ -1,559 +0,0 @@
-//! Frame analysis tools for detailed debugging and profiling
-//!
-//! This module provides in-depth analysis capabilities for rendered frames,
-//! including pixel statistics, region detection, and text analysis.
-
-use crate::Frame;
-
-#[cfg(feature = "nostd")]
-use alloc::vec::Vec;
-
-/// Frame analyzer for detailed text-based debugging
-pub struct FrameAnalyzer {
-    enable_pixel_histogram: bool,
-    enable_region_analysis: bool,
-    enable_text_detection: bool,
-}
-
-impl Default for FrameAnalyzer {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl FrameAnalyzer {
-    /// Create a new frame analyzer with all analysis features enabled
-    pub fn new() -> Self {
-        Self {
-            enable_pixel_histogram: true,
-            enable_region_analysis: true,
-            enable_text_detection: true,
-        }
-    }
-
-    /// Analyze a frame and generate a detailed report
-    pub fn analyze(&self, frame: &Frame) -> AnalysisReport {
-        let mut report = AnalysisReport::new(frame.width(), frame.height());
-
-        if self.enable_pixel_histogram {
-            report.pixel_histogram = self.calculate_pixel_histogram(frame);
-        }
-
-        if self.enable_region_analysis {
-            report.regions = self.detect_regions(frame);
-        }
-
-        if self.enable_text_detection {
-            report.text_areas = self.detect_text_areas(frame);
-        }
-
-        report.calculate_statistics(frame);
-        report
-    }
-
-    fn calculate_pixel_histogram(&self, frame: &Frame) -> PixelHistogram {
-        let pixels = frame.pixels();
-        let mut histogram = PixelHistogram::default();
-
-        for chunk in pixels.chunks(4) {
-            if chunk.len() == 4 {
-                let r = chunk[0];
-                let g = chunk[1];
-                let b = chunk[2];
-                let a = chunk[3];
-
-                histogram.red[r as usize] += 1;
-                histogram.green[g as usize] += 1;
-                histogram.blue[b as usize] += 1;
-                histogram.alpha[a as usize] += 1;
-
-                if a > 0 {
-                    histogram.non_transparent_count += 1;
-
-                    // Classify pixel
-                    if r == g && g == b {
-                        if r > 200 {
-                            histogram.white_pixels += 1;
-                        } else if r < 50 {
-                            histogram.black_pixels += 1;
-                        } else {
-                            histogram.gray_pixels += 1;
-                        }
-                    } else {
-                        histogram.colored_pixels += 1;
-                    }
-                }
-            }
-        }
-
-        histogram
-    }
-
-    fn detect_regions(&self, frame: &Frame) -> Vec<Region> {
-        let mut regions = Vec::new();
-        let pixels = frame.pixels();
-        let width = frame.width() as usize;
-        let height = frame.height() as usize;
-
-        // Simple region detection using connected components
-        let mut visited = vec![false; width * height];
-
-        for y in 0..height {
-            for x in 0..width {
-                let idx = y * width + x;
-                let pixel_idx = idx * 4;
-
-                if !visited[idx] && pixel_idx + 3 < pixels.len() && pixels[pixel_idx + 3] > 0 {
-                    // Found a non-transparent, unvisited pixel
-                    let region = self.flood_fill(frame, &mut visited, x, y);
-                    if region.pixel_count > 10 {
-                        // Filter out tiny regions
-                        regions.push(region);
-                    }
-                }
-            }
-        }
-
-        regions
-    }
-
-    fn flood_fill(
-        &self,
-        frame: &Frame,
-        visited: &mut [bool],
-        start_x: usize,
-        start_y: usize,
-    ) -> Region {
-        let pixels = frame.pixels();
-        let width = frame.width() as usize;
-        let height = frame.height() as usize;
-
-        let mut region = Region {
-            min_x: start_x as u32,
-            min_y: start_y as u32,
-            max_x: start_x as u32,
-            max_y: start_y as u32,
-            pixel_count: 0,
-            avg_color: [0, 0, 0, 0],
-        };
-
-        let mut stack = vec![(start_x, start_y)];
-        let mut color_sum = [0u64; 4];
-
-        while let Some((x, y)) = stack.pop() {
-            if x >= width || y >= height {
-                continue;
-            }
-
-            let idx = y * width + x;
-            if visited[idx] {
-                continue;
-            }
-
-            let pixel_idx = idx * 4;
-            if pixel_idx + 3 >= pixels.len() || pixels[pixel_idx + 3] == 0 {
-                continue;
-            }
-
-            visited[idx] = true;
-            region.pixel_count += 1;
-
-            // Update bounds
-            region.min_x = region.min_x.min(x as u32);
-            region.min_y = region.min_y.min(y as u32);
-            region.max_x = region.max_x.max(x as u32);
-            region.max_y = region.max_y.max(y as u32);
-
-            // Accumulate color
-            for i in 0..4 {
-                color_sum[i] += pixels[pixel_idx + i] as u64;
-            }
-
-            // Add neighbors
-            if x > 0 {
-                stack.push((x - 1, y));
-            }
-            if x + 1 < width {
-                stack.push((x + 1, y));
-            }
-            if y > 0 {
-                stack.push((x, y - 1));
-            }
-            if y + 1 < height {
-                stack.push((x, y + 1));
-            }
-        }
-
-        // Calculate average color
-        if region.pixel_count > 0 {
-            for (i, sum) in color_sum.iter().enumerate() {
-                region.avg_color[i] = (sum / region.pixel_count as u64) as u8;
-            }
-        }
-
-        region
-    }
-
-    fn detect_text_areas(&self, frame: &Frame) -> Vec<TextArea> {
-        let regions = self.detect_regions(frame);
-        let mut text_areas = Vec::new();
-
-        for region in regions {
-            // Heuristics to identify text regions:
-            // - Aspect ratio typical of text lines
-            // - High contrast colors (usually white/yellow text)
-            // - Reasonable size
-
-            let width = region.max_x - region.min_x + 1;
-            let height = region.max_y - region.min_y + 1;
-            let aspect_ratio = width as f32 / height as f32;
-
-            // Text typically has aspect ratio > 2 for horizontal text
-            // and reasonable height (20-200 pixels for typical subtitles)
-            if aspect_ratio > 1.5 && (15..200).contains(&height) {
-                // Check if it's high contrast (likely text)
-                let is_bright = region.avg_color[0] > 200
-                    || region.avg_color[1] > 200
-                    || region.avg_color[2] > 200;
-
-                if is_bright {
-                    text_areas.push(TextArea {
-                        x: region.min_x,
-                        y: region.min_y,
-                        width,
-                        height,
-                        confidence: calculate_text_confidence(&region),
-                        estimated_font_size: estimate_font_size(height),
-                    });
-                }
-            }
-        }
-
-        text_areas
-    }
-}
-
-/// Detailed analysis report for a rendered frame
-#[derive(Debug, Clone)]
-pub struct AnalysisReport {
-    /// Frame width in pixels
-    pub width: u32,
-    /// Frame height in pixels
-    pub height: u32,
-    /// Total number of pixels in the frame
-    pub total_pixels: usize,
-    /// Number of non-transparent pixels
-    pub non_transparent_pixels: usize,
-    /// Percentage of transparent pixels
-    pub transparency_percentage: f32,
-    /// Histogram of pixel color distribution
-    pub pixel_histogram: PixelHistogram,
-    /// Detected regions in the frame
-    pub regions: Vec<Region>,
-    /// Detected text areas in the frame
-    pub text_areas: Vec<TextArea>,
-    /// Dominant color in the frame [R, G, B, A]
-    pub dominant_color: [u8; 4],
-    /// Estimated contrast ratio
-    pub contrast_ratio: f32,
-}
-
-impl AnalysisReport {
-    fn new(width: u32, height: u32) -> Self {
-        Self {
-            width,
-            height,
-            total_pixels: (width * height) as usize,
-            non_transparent_pixels: 0,
-            transparency_percentage: 0.0,
-            pixel_histogram: PixelHistogram::default(),
-            regions: Vec::new(),
-            text_areas: Vec::new(),
-            dominant_color: [0, 0, 0, 0],
-            contrast_ratio: 0.0,
-        }
-    }
-
-    fn calculate_statistics(&mut self, frame: &Frame) {
-        self.non_transparent_pixels = self.pixel_histogram.non_transparent_count;
-        self.transparency_percentage = ((self.total_pixels - self.non_transparent_pixels) as f32
-            / self.total_pixels as f32)
-            * 100.0;
-
-        // Calculate dominant color
-        self.dominant_color = self.calculate_dominant_color();
-
-        // Calculate contrast ratio (simplified)
-        self.contrast_ratio = self.calculate_contrast_ratio(frame);
-    }
-
-    fn calculate_dominant_color(&self) -> [u8; 4] {
-        let hist = &self.pixel_histogram;
-
-        // Find the peak in each channel
-        let mut dominant = [0u8; 4];
-
-        for (i, channel) in [&hist.red, &hist.green, &hist.blue, &hist.alpha]
-            .iter()
-            .enumerate()
-        {
-            let mut max_count = 0;
-            let mut max_value = 0;
-
-            for (value, &count) in channel.iter().enumerate() {
-                if count > max_count {
-                    max_count = count;
-                    max_value = value;
-                }
-            }
-
-            dominant[i] = max_value as u8;
-        }
-
-        dominant
-    }
-
-    fn calculate_contrast_ratio(&self, _frame: &Frame) -> f32 {
-        // Simplified contrast calculation
-        // In a real implementation, this would calculate Weber contrast or Michelson contrast
-        if self.pixel_histogram.white_pixels > 0 && self.pixel_histogram.black_pixels > 0 {
-            let white_ratio =
-                self.pixel_histogram.white_pixels as f32 / self.non_transparent_pixels as f32;
-            let black_ratio =
-                self.pixel_histogram.black_pixels as f32 / self.non_transparent_pixels as f32;
-
-            // High contrast if we have both bright and dark pixels
-            (white_ratio * black_ratio * 100.0).min(1.0)
-        } else {
-            0.0
-        }
-    }
-
-    pub fn print_summary(&self) {
-        println!("\n╔════════════════════════════════════════╗");
-        println!("║         Frame Analysis Report          ║");
-        println!("╚════════════════════════════════════════╝");
-
-        println!("\n📊 Basic Statistics:");
-        println!(
-            "  • Resolution: {width}x{height}",
-            width = self.width,
-            height = self.height
-        );
-        println!(
-            "  • Total Pixels: {total_pixels}",
-            total_pixels = self.total_pixels
-        );
-        println!(
-            "  • Non-transparent: {} ({:.1}%)",
-            self.non_transparent_pixels,
-            (self.non_transparent_pixels as f32 / self.total_pixels as f32) * 100.0
-        );
-        println!(
-            "  • Transparency: {transparency:.1}%",
-            transparency = self.transparency_percentage
-        );
-
-        println!("\n🎨 Color Distribution:");
-        println!(
-            "  • White pixels: {white_pixels}",
-            white_pixels = self.pixel_histogram.white_pixels
-        );
-        println!(
-            "  • Black pixels: {black_pixels}",
-            black_pixels = self.pixel_histogram.black_pixels
-        );
-        println!(
-            "  • Gray pixels: {gray_pixels}",
-            gray_pixels = self.pixel_histogram.gray_pixels
-        );
-        println!(
-            "  • Colored pixels: {colored_pixels}",
-            colored_pixels = self.pixel_histogram.colored_pixels
-        );
-        println!(
-            "  • Dominant color: RGBA({r}, {g}, {b}, {a})",
-            r = self.dominant_color[0],
-            g = self.dominant_color[1],
-            b = self.dominant_color[2],
-            a = self.dominant_color[3]
-        );
-
-        println!("\n🔍 Region Detection:");
-        println!(
-            "  • Detected regions: {regions_count}",
-            regions_count = self.regions.len()
-        );
-        for (i, region) in self.regions.iter().enumerate() {
-            println!(
-                "    {}. Box: ({}, {}) to ({}, {}) | Pixels: {} | Color: RGBA({}, {}, {}, {})",
-                i + 1,
-                region.min_x,
-                region.min_y,
-                region.max_x,
-                region.max_y,
-                region.pixel_count,
-                region.avg_color[0],
-                region.avg_color[1],
-                region.avg_color[2],
-                region.avg_color[3]
-            );
-        }
-
-        println!("\n📝 Text Detection:");
-        if self.text_areas.is_empty() {
-            println!("  • No text areas detected");
-        } else {
-            println!(
-                "  • Detected text areas: {text_areas_count}",
-                text_areas_count = self.text_areas.len()
-            );
-            for (i, area) in self.text_areas.iter().enumerate() {
-                println!(
-                    "    {}. Position: ({}, {}) | Size: {}x{} | Font: ~{}px | Confidence: {:.1}%",
-                    i + 1,
-                    area.x,
-                    area.y,
-                    area.width,
-                    area.height,
-                    area.estimated_font_size,
-                    area.confidence * 100.0
-                );
-            }
-        }
-
-        println!("\n⚡ Performance Indicators:");
-        println!(
-            "  • Contrast ratio: {contrast_ratio:.2}",
-            contrast_ratio = self.contrast_ratio
-        );
-        println!(
-            "  • Memory usage: {memory_kb} KB",
-            memory_kb = (self.total_pixels * 4) / 1024
-        );
-
-        println!("\n═══════════════════════════════════════");
-    }
-
-    pub fn to_json(&self) -> String {
-        format!(
-            r#"{{
-    "resolution": {{ "width": {}, "height": {} }},
-    "pixels": {{
-        "total": {},
-        "non_transparent": {},
-        "transparency_percentage": {:.2}
-    }},
-    "color_distribution": {{
-        "white": {},
-        "black": {},
-        "gray": {},
-        "colored": {}
-    }},
-    "regions": {},
-    "text_areas": {},
-    "dominant_color": [{}, {}, {}, {}],
-    "contrast_ratio": {:.2}
-}}"#,
-            self.width,
-            self.height,
-            self.total_pixels,
-            self.non_transparent_pixels,
-            self.transparency_percentage,
-            self.pixel_histogram.white_pixels,
-            self.pixel_histogram.black_pixels,
-            self.pixel_histogram.gray_pixels,
-            self.pixel_histogram.colored_pixels,
-            self.regions.len(),
-            self.text_areas.len(),
-            self.dominant_color[0],
-            self.dominant_color[1],
-            self.dominant_color[2],
-            self.dominant_color[3],
-            self.contrast_ratio
-        )
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct PixelHistogram {
-    pub red: [usize; 256],
-    pub green: [usize; 256],
-    pub blue: [usize; 256],
-    pub alpha: [usize; 256],
-    pub non_transparent_count: usize,
-    pub white_pixels: usize,
-    pub black_pixels: usize,
-    pub gray_pixels: usize,
-    pub colored_pixels: usize,
-}
-
-impl Default for PixelHistogram {
-    fn default() -> Self {
-        Self {
-            red: [0; 256],
-            green: [0; 256],
-            blue: [0; 256],
-            alpha: [0; 256],
-            non_transparent_count: 0,
-            white_pixels: 0,
-            black_pixels: 0,
-            gray_pixels: 0,
-            colored_pixels: 0,
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct Region {
-    pub min_x: u32,
-    pub min_y: u32,
-    pub max_x: u32,
-    pub max_y: u32,
-    pub pixel_count: usize,
-    pub avg_color: [u8; 4],
-}
-
-#[derive(Debug, Clone)]
-pub struct TextArea {
-    pub x: u32,
-    pub y: u32,
-    pub width: u32,
-    pub height: u32,
-    pub confidence: f32,
-    pub estimated_font_size: u32,
-}
-
-fn calculate_text_confidence(region: &Region) -> f32 {
-    // Simple heuristic for text confidence
-    let width = region.max_x - region.min_x + 1;
-    let height = region.max_y - region.min_y + 1;
-    let aspect = width as f32 / height as f32;
-
-    let mut confidence: f32 = 0.0;
-
-    // Good aspect ratio for text
-    if (2.0..20.0).contains(&aspect) {
-        confidence += 0.3;
-    }
-
-    // High brightness (typical for subtitles)
-    let brightness =
-        (region.avg_color[0] as f32 + region.avg_color[1] as f32 + region.avg_color[2] as f32)
-            / 3.0;
-    if brightness > 200.0 {
-        confidence += 0.4;
-    }
-
-    // Reasonable size
-    if (20..150).contains(&height) {
-        confidence += 0.3;
-    }
-
-    confidence.min(1.0)
-}
-
-fn estimate_font_size(height: u32) -> u32 {
-    // Rough estimation: font size is about 75% of bounding box height
-    (height as f32 * 0.75) as u32
-}
diff --git a/crates/ass-renderer/src/debug/benchmarking.rs b/crates/ass-renderer/src/debug/benchmarking.rs
deleted file mode 100644
index b6d2fdd..0000000
--- a/crates/ass-renderer/src/debug/benchmarking.rs
+++ /dev/null
@@ -1,623 +0,0 @@
-//! Benchmarking and performance analysis for compatibility testing
-
-#[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-use crate::debug::LibassRenderer;
-use crate::renderer::{RenderContext, Renderer};
-use crate::utils::RenderError;
-use ass_core::parser::Script;
-
-#[cfg(feature = "nostd")]
-use alloc::{format, string::String, vec::Vec};
-#[cfg(not(feature = "nostd"))]
-use std::{format, string::String, time::Instant, vec::Vec};
-
-/// Performance benchmarking system for renderer comparison
-pub struct PerformanceBenchmark {
-    /// Our renderer instance
-    our_renderer: Renderer,
-    /// Libass renderer for comparison
-    #[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-    libass_renderer: LibassRenderer,
-    /// Benchmark configuration
-    config: BenchmarkConfig,
-    /// Historical results for regression analysis
-    historical_results: Vec<BenchmarkResult>,
-}
-
-/// Configuration for performance benchmarking
-#[derive(Debug, Clone)]
-pub struct BenchmarkConfig {
-    /// Number of iterations per test
-    pub iterations: usize,
-    /// Warmup iterations before measuring
-    pub warmup_iterations: usize,
-    /// Include memory usage measurement
-    pub measure_memory: bool,
-    /// Include frame rate measurement for animations
-    pub measure_frame_rate: bool,
-    /// Test different video resolutions
-    pub test_resolutions: Vec<(u32, u32)>,
-    /// Animation duration for frame rate tests (in centiseconds)
-    pub animation_duration_cs: u32,
-}
-
-impl Default for BenchmarkConfig {
-    fn default() -> Self {
-        Self {
-            iterations: 10,
-            warmup_iterations: 3,
-            measure_memory: true,
-            measure_frame_rate: true,
-            test_resolutions: vec![
-                (1280, 720),  // 720p
-                (1920, 1080), // 1080p
-                (3840, 2160), // 4K
-            ],
-            animation_duration_cs: 1000, // 10 seconds
-        }
-    }
-}
-
-/// Result of performance benchmark
-#[derive(Debug, Clone)]
-pub struct BenchmarkResult {
-    /// Test identifier
-    pub test_name: String,
-    /// Video resolution used
-    pub resolution: (u32, u32),
-    /// Our renderer performance
-    pub our_performance: PerformanceMetrics,
-    /// libass performance for comparison
-    #[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-    pub libass_performance: Option<PerformanceMetrics>,
-    /// Performance ratio (our_time / libass_time)
-    pub performance_ratio: Option<f64>,
-    /// Memory usage comparison
-    pub memory_ratio: Option<f64>,
-    /// Compatibility score (0.0 = completely different, 1.0 = identical)
-    pub compatibility_score: f64,
-}
-
-/// Detailed performance metrics
-#[derive(Debug, Clone)]
-pub struct PerformanceMetrics {
-    /// Average rendering time per frame (milliseconds)
-    pub avg_render_time_ms: f64,
-    /// Minimum rendering time (milliseconds)
-    pub min_render_time_ms: f64,
-    /// Maximum rendering time (milliseconds)
-    pub max_render_time_ms: f64,
-    /// Standard deviation of render times
-    pub render_time_std_dev: f64,
-    /// Frames per second (for animation tests)
-    pub fps: Option<f64>,
-    /// Peak memory usage (bytes)
-    pub peak_memory_bytes: Option<usize>,
-    /// Average memory usage (bytes)
-    pub avg_memory_bytes: Option<usize>,
-    /// Cache hit rate (0.0 to 1.0)
-    pub cache_hit_rate: Option<f64>,
-}
-
-impl PerformanceBenchmark {
-    /// Create new performance benchmark
-    #[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-    pub fn new(context: RenderContext, config: BenchmarkConfig) -> Result<Self, RenderError> {
-        let our_renderer = Renderer::new(context.clone())?;
-        let libass_renderer = LibassRenderer::new(context.width(), context.height())?;
-
-        Ok(Self {
-            our_renderer,
-            libass_renderer,
-            config,
-            historical_results: Vec::new(),
-        })
-    }
-
-    /// Create benchmark without libass comparison (or when building for wasm32)
-    #[cfg(any(not(feature = "libass-compare"), target_arch = "wasm32"))]
-    pub fn new(context: RenderContext, config: BenchmarkConfig) -> Result<Self, RenderError> {
-        let our_renderer = Renderer::new(context)?;
-
-        Ok(Self {
-            our_renderer,
-            config,
-            historical_results: Vec::new(),
-        })
-    }
-
-    /// Run comprehensive benchmark on a script
-    pub fn benchmark_script(
-        &mut self,
-        script: &Script,
-        test_name: &str,
-    ) -> Result<Vec<BenchmarkResult>, RenderError> {
-        let mut results = Vec::new();
-        let test_resolutions = self.config.test_resolutions.clone();
-
-        for &resolution in &test_resolutions {
-            eprintln!(
-                "Benchmarking {test_name} at {}x{}",
-                resolution.0, resolution.1
-            );
-
-            // Update context resolution
-            let context = RenderContext::new(resolution.0, resolution.1);
-            self.our_renderer = Renderer::new(context)?;
-
-            #[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-            {
-                self.libass_renderer
-                    .set_frame_size(resolution.0, resolution.1);
-            }
-
-            let result = self.benchmark_single_resolution(script, test_name, resolution)?;
-            results.push(result);
-        }
-
-        // Store results for regression analysis
-        self.historical_results.extend(results.clone());
-
-        Ok(results)
-    }
-
-    /// Benchmark at a single resolution
-    fn benchmark_single_resolution(
-        &mut self,
-        script: &Script,
-        test_name: &str,
-        resolution: (u32, u32),
-    ) -> Result<BenchmarkResult, RenderError> {
-        let test_time_cs = self.find_representative_time(script);
-
-        // Benchmark our renderer
-        let our_performance = self.benchmark_our_renderer(script, test_time_cs)?;
-
-        // Benchmark libass if available
-        #[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-        let libass_performance = self.benchmark_libass_renderer(script, test_time_cs).ok();
-        #[cfg(any(not(feature = "libass-compare"), target_arch = "wasm32"))]
-        let libass_performance: Option<PerformanceMetrics> = None;
-
-        // Calculate ratios
-        let (performance_ratio, memory_ratio) = if let Some(ref libass_perf) = libass_performance {
-            let perf_ratio = our_performance.avg_render_time_ms / libass_perf.avg_render_time_ms;
-            let mem_ratio = match (
-                our_performance.avg_memory_bytes,
-                libass_perf.avg_memory_bytes,
-            ) {
-                (Some(our_mem), Some(libass_mem)) => Some(our_mem as f64 / libass_mem as f64),
-                _ => None,
-            };
-            (Some(perf_ratio), mem_ratio)
-        } else {
-            (None, None)
-        };
-
-        // Calculate compatibility score (simplified - would need actual pixel comparison)
-        let compatibility_score = 0.95; // Placeholder
-
-        Ok(BenchmarkResult {
-            test_name: format!("{test_name}_{}_{}x{}", "single", resolution.0, resolution.1),
-            resolution,
-            our_performance,
-            #[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-            libass_performance,
-            performance_ratio,
-            memory_ratio,
-            compatibility_score,
-        })
-    }
-
-    /// Benchmark our renderer performance
-    fn benchmark_our_renderer(
-        &mut self,
-        script: &Script,
-        time_cs: u32,
-    ) -> Result<PerformanceMetrics, RenderError> {
-        let mut render_times = Vec::new();
-        let mut memory_usage = Vec::new();
-
-        // Warmup
-        for _ in 0..self.config.warmup_iterations {
-            let _ = self.our_renderer.render_frame(script, time_cs)?;
-        }
-
-        // Actual measurements
-        for _ in 0..self.config.iterations {
-            let start_memory = self.measure_memory_usage();
-
-            #[cfg(not(feature = "nostd"))]
-            let start_time = Instant::now();
-
-            let _frame = self.our_renderer.render_frame(script, time_cs)?;
-
-            #[cfg(not(feature = "nostd"))]
-            let elapsed = start_time.elapsed();
-            #[cfg(feature = "nostd")]
-            let elapsed = std::time::Duration::from_millis(1); // Placeholder for no_std
-
-            let end_memory = self.measure_memory_usage();
-
-            render_times.push(elapsed.as_secs_f64() * 1000.0); // Convert to milliseconds
-
-            if let (Some(start), Some(end)) = (start_memory, end_memory) {
-                memory_usage.push(end.saturating_sub(start));
-            }
-        }
-
-        self.calculate_performance_metrics(render_times, memory_usage)
-    }
-
-    /// Benchmark libass renderer performance
-    #[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-    fn benchmark_libass_renderer(
-        &mut self,
-        script: &Script,
-        time_cs: u32,
-    ) -> Result<PerformanceMetrics, RenderError> {
-        let mut render_times = Vec::new();
-        let mut memory_usage = Vec::new();
-
-        // Warmup
-        for _ in 0..self.config.warmup_iterations {
-            let _ = self.libass_renderer.render_frame(script, time_cs)?;
-        }
-
-        // Actual measurements
-        for _ in 0..self.config.iterations {
-            let start_memory = self.measure_memory_usage();
-
-            #[cfg(not(feature = "nostd"))]
-            let start_time = Instant::now();
-
-            let _frame = self.libass_renderer.render_frame(script, time_cs)?;
-
-            #[cfg(not(feature = "nostd"))]
-            let elapsed = start_time.elapsed();
-            #[cfg(feature = "nostd")]
-            let elapsed = std::time::Duration::from_millis(1); // Placeholder for no_std
-
-            let end_memory = self.measure_memory_usage();
-
-            render_times.push(elapsed.as_secs_f64() * 1000.0);
-
-            if let (Some(start), Some(end)) = (start_memory, end_memory) {
-                memory_usage.push(end.saturating_sub(start));
-            }
-        }
-
-        self.calculate_performance_metrics(render_times, memory_usage)
-    }
-
-    /// Calculate performance metrics from raw measurements
-    fn calculate_performance_metrics(
-        &self,
-        render_times: Vec<f64>,
-        memory_usage: Vec<usize>,
-    ) -> Result<PerformanceMetrics, RenderError> {
-        if render_times.is_empty() {
-            return Err(RenderError::InvalidInput(
-                "No render time measurements".to_string(),
-            ));
-        }
-
-        let avg_render_time = render_times.iter().sum::<f64>() / render_times.len() as f64;
-        let min_render_time = render_times.iter().fold(f64::INFINITY, |a, &b| a.min(b));
-        let max_render_time = render_times
-            .iter()
-            .fold(f64::NEG_INFINITY, |a, &b| a.max(b));
-
-        // Calculate standard deviation
-        let variance = render_times
-            .iter()
-            .map(|&t| (t - avg_render_time).powi(2))
-            .sum::<f64>()
-            / render_times.len() as f64;
-        let std_dev = variance.sqrt();
-
-        // Calculate FPS (frames per second)
-        let fps = if avg_render_time > 0.0 {
-            Some(1000.0 / avg_render_time)
-        } else {
-            None
-        };
-
-        // Memory statistics
-        let (peak_memory, avg_memory) = if !memory_usage.is_empty() {
-            let peak = memory_usage.iter().max().copied();
-            let avg = Some(memory_usage.iter().sum::<usize>() / memory_usage.len());
-            (peak, avg)
-        } else {
-            (None, None)
-        };
-
-        Ok(PerformanceMetrics {
-            avg_render_time_ms: avg_render_time,
-            min_render_time_ms: min_render_time,
-            max_render_time_ms: max_render_time,
-            render_time_std_dev: std_dev,
-            fps,
-            peak_memory_bytes: peak_memory,
-            avg_memory_bytes: avg_memory,
-            cache_hit_rate: None, // TODO: Implement cache metrics
-        })
-    }
-
-    /// Measure current memory usage (simplified)
-    fn measure_memory_usage(&self) -> Option<usize> {
-        // This is a simplified implementation
-        // In practice, you'd want to use a proper memory profiler
-        #[cfg(not(feature = "nostd"))]
-        {
-            // Use system APIs to get memory usage
-            // This is a placeholder - actual implementation would vary by platform
-            None
-        }
-        #[cfg(feature = "nostd")]
-        {
-            None
-        }
-    }
-
-    /// Find representative time for testing
-    fn find_representative_time(&self, script: &Script) -> u32 {
-        // Find middle of first event with text
-        for section in script.sections() {
-            if let ass_core::parser::Section::Events(events) = section {
-                for event in events {
-                    if !event.text.trim().is_empty() {
-                        let start = event.start_time_cs().unwrap_or(0);
-                        let end = event.end_time_cs().unwrap_or(0);
-                        return start + (end - start) / 2;
-                    }
-                }
-            }
-        }
-        100 // Default to 1 second
-    }
-
-    /// Run frame rate benchmark for animations
-    pub fn benchmark_animation_framerate(
-        &mut self,
-        script: &Script,
-        test_name: &str,
-    ) -> Result<BenchmarkResult, RenderError> {
-        if !self.config.measure_frame_rate {
-            return Err(RenderError::UnsupportedOperation(
-                "Frame rate benchmarking disabled".to_string(),
-            ));
-        }
-
-        let (start_time, end_time) = self.find_animation_timerange(script);
-        let total_frames = ((end_time - start_time) / 4) as usize; // 25 FPS
-        let mut frame_times = Vec::new();
-
-        eprintln!("Benchmarking animation frame rate: {total_frames} frames");
-
-        #[cfg(not(feature = "nostd"))]
-        let start_benchmark = Instant::now();
-
-        // Render all frames
-        for frame_idx in 0..total_frames {
-            let time_cs = start_time + (frame_idx as u32 * 4); // 25 FPS
-
-            #[cfg(not(feature = "nostd"))]
-            let frame_start = Instant::now();
-
-            let _frame = self.our_renderer.render_frame(script, time_cs)?;
-
-            #[cfg(not(feature = "nostd"))]
-            let frame_time = frame_start.elapsed();
-            #[cfg(feature = "nostd")]
-            let frame_time = std::time::Duration::from_millis(1);
-
-            frame_times.push(frame_time.as_secs_f64() * 1000.0);
-        }
-
-        #[cfg(not(feature = "nostd"))]
-        let total_time = start_benchmark.elapsed().as_secs_f64();
-        #[cfg(feature = "nostd")]
-        let total_time = 1.0;
-
-        let avg_frame_time = frame_times.iter().sum::<f64>() / frame_times.len() as f64;
-        let fps = 1000.0 / avg_frame_time;
-        let realtime_fps = total_frames as f64 / total_time;
-
-        eprintln!("Animation benchmark results:");
-        eprintln!("  Average frame time: {avg_frame_time:.2}ms");
-        eprintln!("  Theoretical FPS: {fps:.1}");
-        eprintln!("  Actual FPS: {realtime_fps:.1}");
-
-        let our_performance = PerformanceMetrics {
-            avg_render_time_ms: avg_frame_time,
-            min_render_time_ms: frame_times.iter().fold(f64::INFINITY, |a, &b| a.min(b)),
-            max_render_time_ms: frame_times.iter().fold(f64::NEG_INFINITY, |a, &b| a.max(b)),
-            render_time_std_dev: {
-                let variance = frame_times
-                    .iter()
-                    .map(|&t| (t - avg_frame_time).powi(2))
-                    .sum::<f64>()
-                    / frame_times.len() as f64;
-                variance.sqrt()
-            },
-            fps: Some(fps),
-            peak_memory_bytes: None,
-            avg_memory_bytes: None,
-            cache_hit_rate: None,
-        };
-
-        Ok(BenchmarkResult {
-            test_name: format!("{test_name}_animation_fps"),
-            resolution: (
-                self.our_renderer.context().width(),
-                self.our_renderer.context().height(),
-            ),
-            our_performance,
-            #[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-            libass_performance: None, // TODO: Implement libass animation benchmark
-            performance_ratio: None,
-            memory_ratio: None,
-            compatibility_score: 1.0, // Placeholder
-        })
-    }
-
-    /// Find animation time range
-    fn find_animation_timerange(&self, script: &Script) -> (u32, u32) {
-        let mut min_time = u32::MAX;
-        let mut max_time = 0;
-
-        for section in script.sections() {
-            if let ass_core::parser::Section::Events(events) = section {
-                for event in events {
-                    let start = event.start_time_cs().unwrap_or(0);
-                    let end = event.end_time_cs().unwrap_or(0);
-                    min_time = min_time.min(start);
-                    max_time = max_time.max(end);
-                }
-            }
-        }
-
-        if min_time == u32::MAX {
-            (0, self.config.animation_duration_cs)
-        } else {
-            let duration = (max_time - min_time).min(self.config.animation_duration_cs);
-            (min_time, min_time + duration)
-        }
-    }
-
-    /// Generate performance report
-    pub fn generate_performance_report(&self) -> PerformanceReport {
-        PerformanceReport {
-            results: self.historical_results.clone(),
-            summary: self.calculate_performance_summary(),
-        }
-    }
-
-    /// Calculate performance summary statistics
-    fn calculate_performance_summary(&self) -> PerformanceSummary {
-        if self.historical_results.is_empty() {
-            return PerformanceSummary::default();
-        }
-
-        let total_tests = self.historical_results.len();
-        let performance_ratios: Vec<f64> = self
-            .historical_results
-            .iter()
-            .filter_map(|r| r.performance_ratio)
-            .collect();
-
-        let avg_performance_ratio = if !performance_ratios.is_empty() {
-            performance_ratios.iter().sum::<f64>() / performance_ratios.len() as f64
-        } else {
-            1.0
-        };
-
-        let avg_compatibility = self
-            .historical_results
-            .iter()
-            .map(|r| r.compatibility_score)
-            .sum::<f64>()
-            / total_tests as f64;
-
-        let avg_fps = self
-            .historical_results
-            .iter()
-            .filter_map(|r| r.our_performance.fps)
-            .sum::<f64>()
-            / total_tests as f64;
-
-        PerformanceSummary {
-            total_tests,
-            avg_performance_ratio,
-            avg_compatibility_score: avg_compatibility,
-            avg_fps,
-            fastest_test: self.find_fastest_test(),
-            slowest_test: self.find_slowest_test(),
-        }
-    }
-
-    /// Find fastest test
-    fn find_fastest_test(&self) -> Option<String> {
-        self.historical_results
-            .iter()
-            .min_by(|a, b| {
-                a.our_performance
-                    .avg_render_time_ms
-                    .partial_cmp(&b.our_performance.avg_render_time_ms)
-                    .unwrap_or(std::cmp::Ordering::Equal)
-            })
-            .map(|r| r.test_name.clone())
-    }
-
-    /// Find slowest test
-    fn find_slowest_test(&self) -> Option<String> {
-        self.historical_results
-            .iter()
-            .max_by(|a, b| {
-                a.our_performance
-                    .avg_render_time_ms
-                    .partial_cmp(&b.our_performance.avg_render_time_ms)
-                    .unwrap_or(std::cmp::Ordering::Equal)
-            })
-            .map(|r| r.test_name.clone())
-    }
-}
-
-/// Performance report containing all benchmark results
-#[derive(Debug, Clone)]
-pub struct PerformanceReport {
-    /// Individual test results
-    pub results: Vec<BenchmarkResult>,
-    /// Summary statistics
-    pub summary: PerformanceSummary,
-}
-
-/// Summary of performance characteristics
-#[derive(Debug, Clone)]
-pub struct PerformanceSummary {
-    /// Total number of tests run
-    pub total_tests: usize,
-    /// Average performance ratio vs libass
-    pub avg_performance_ratio: f64,
-    /// Average compatibility score
-    pub avg_compatibility_score: f64,
-    /// Average frames per second
-    pub avg_fps: f64,
-    /// Name of fastest test
-    pub fastest_test: Option<String>,
-    /// Name of slowest test
-    pub slowest_test: Option<String>,
-}
-
-impl Default for PerformanceSummary {
-    fn default() -> Self {
-        Self {
-            total_tests: 0,
-            avg_performance_ratio: 1.0,
-            avg_compatibility_score: 1.0,
-            avg_fps: 0.0,
-            fastest_test: None,
-            slowest_test: None,
-        }
-    }
-}
-
-/// Quick benchmark function for single script
-pub fn quick_benchmark(script: &Script, test_name: &str) -> Result<BenchmarkResult, RenderError> {
-    let context = RenderContext::new(1920, 1080);
-    let config = BenchmarkConfig {
-        iterations: 5,
-        warmup_iterations: 1,
-        test_resolutions: vec![(1920, 1080)],
-        ..Default::default()
-    };
-
-    let mut benchmark = PerformanceBenchmark::new(context, config)?;
-    let results = benchmark.benchmark_script(script, test_name)?;
-
-    results
-        .into_iter()
-        .next()
-        .ok_or_else(|| RenderError::InvalidState("No benchmark results".to_string()))
-}
diff --git a/crates/ass-renderer/src/debug/color_diagnostic.rs b/crates/ass-renderer/src/debug/color_diagnostic.rs
deleted file mode 100644
index ae80b27..0000000
--- a/crates/ass-renderer/src/debug/color_diagnostic.rs
+++ /dev/null
@@ -1,208 +0,0 @@
-//! Color diagnostic tool for debugging rendering issues
-
-use ass_core::parser::ast::{Section, SectionType};
-use ass_core::Script;
-
-/// Diagnose color issues in ASS scripts
-pub struct ColorDiagnostic;
-
-impl ColorDiagnostic {
-    /// Analyze colors in a script and report potential issues
-    pub fn analyze_script(script: &Script) -> ColorReport {
-        let mut report = ColorReport::default();
-
-        // Check styles section
-        if let Some(Section::Styles(styles)) = script.find_section(SectionType::Styles) {
-            for style in styles {
-                let name = style.name;
-                let primary = style.primary_colour;
-                let secondary = style.secondary_colour;
-                let outline = style.outline_colour;
-                let back = style.back_colour;
-
-                report.styles.push(StyleColors {
-                    name: name.to_string(),
-                    primary_raw: primary.to_string(),
-                    primary_parsed: parse_color_debug(primary),
-                    secondary_raw: secondary.to_string(),
-                    outline_raw: outline.to_string(),
-                    back_raw: back.to_string(),
-                });
-            }
-        }
-
-        // Check events for color overrides
-        if let Some(Section::Events(events)) = script.find_section(SectionType::Events) {
-            for event in events {
-                if event.text.contains("\\c") || event.text.contains("\\1c") {
-                    report.has_color_overrides = true;
-                }
-            }
-        }
-
-        report
-    }
-
-    /// Create a test script with white text
-    pub fn create_white_text_test() -> String {
-        r#"[Script Info]
-Title: White Text Test
-PlayResX: 640
-PlayResY: 480
-
-[V4+ Styles]
-Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: WhiteText,Arial,50,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,2,0,2,10,10,10,1
-
-[Events]
-Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-Dialogue: 0,0:00:00.00,0:00:05.00,WhiteText,,0,0,0,,This should be WHITE text"#.to_string()
-    }
-
-    /// Create a color reference test with multiple colors
-    pub fn create_color_reference_test() -> String {
-        r#"[Script Info]
-Title: Color Reference Test
-PlayResX: 640
-PlayResY: 480
-
-[V4+ Styles]
-Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: White,Arial,40,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,-1,0,0,0,100,100,0,0,1,2,0,2,10,10,10,1
-Style: Red,Arial,40,&H000000FF,&H000000FF,&H00000000,&H00000000,-1,0,0,0,100,100,0,0,1,2,0,2,10,10,10,1
-Style: Green,Arial,40,&H0000FF00,&H000000FF,&H00000000,&H00000000,-1,0,0,0,100,100,0,0,1,2,0,2,10,10,10,1
-Style: Blue,Arial,40,&H00FF0000,&H000000FF,&H00000000,&H00000000,-1,0,0,0,100,100,0,0,1,2,0,2,10,10,10,1
-Style: Yellow,Arial,40,&H0000FFFF,&H000000FF,&H00000000,&H00000000,-1,0,0,0,100,100,0,0,1,2,0,2,10,10,10,1
-Style: Cyan,Arial,40,&H00FFFF00,&H000000FF,&H00000000,&H00000000,-1,0,0,0,100,100,0,0,1,2,0,2,10,10,10,1
-Style: Magenta,Arial,40,&H00FF00FF,&H000000FF,&H00000000,&H00000000,-1,0,0,0,100,100,0,0,1,2,0,2,10,10,10,1
-
-[Events]
-Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-Dialogue: 0,0:00:00.00,0:00:10.00,White,,0,0,0,,WHITE
-Dialogue: 0,0:00:00.00,0:00:10.00,Red,,0,0,60,,RED
-Dialogue: 0,0:00:00.00,0:00:10.00,Green,,0,0,120,,GREEN
-Dialogue: 0,0:00:00.00,0:00:10.00,Blue,,0,0,180,,BLUE
-Dialogue: 0,0:00:00.00,0:00:10.00,Yellow,,0,0,240,,YELLOW
-Dialogue: 0,0:00:00.00,0:00:10.00,Cyan,,0,0,300,,CYAN
-Dialogue: 0,0:00:00.00,0:00:10.00,Magenta,,0,0,360,,MAGENTA"#.to_string()
-    }
-}
-
-#[derive(Debug, Default)]
-pub struct ColorReport {
-    pub styles: Vec<StyleColors>,
-    pub has_color_overrides: bool,
-}
-
-#[derive(Debug)]
-pub struct StyleColors {
-    pub name: String,
-    pub primary_raw: String,
-    pub primary_parsed: ColorDebugInfo,
-    pub secondary_raw: String,
-    pub outline_raw: String,
-    pub back_raw: String,
-}
-
-#[derive(Debug)]
-pub struct ColorDebugInfo {
-    pub hex_value: String,
-    pub has_alpha: bool,
-    pub alpha: u8,
-    pub red: u8,
-    pub green: u8,
-    pub blue: u8,
-    pub expected_color: String,
-}
-
-fn parse_color_debug(color: &str) -> ColorDebugInfo {
-    let color_trimmed = color.trim_end_matches('&');
-
-    if let Some(hex) = color_trimmed.strip_prefix("&H") {
-        let has_alpha = hex.len() >= 8;
-
-        if let Ok(value) = u32::from_str_radix(hex, 16) {
-            let (alpha, bgr_value) = if has_alpha {
-                let alpha = ((value >> 24) & 0xFF) as u8;
-                (alpha, value & 0xFFFFFF)
-            } else {
-                (0x00, value) // Default to opaque
-            };
-
-            let r = (bgr_value & 0xFF) as u8;
-            let g = ((bgr_value >> 8) & 0xFF) as u8;
-            let b = ((bgr_value >> 16) & 0xFF) as u8;
-
-            let expected = match (r, g, b) {
-                (255, 255, 255) => "WHITE",
-                (255, 0, 0) => "RED",
-                (0, 255, 0) => "GREEN",
-                (0, 0, 255) => "BLUE",
-                (255, 255, 0) => "YELLOW",
-                (0, 255, 255) => "CYAN",
-                (255, 0, 255) => "MAGENTA",
-                (0, 0, 0) => "BLACK",
-                _ => "CUSTOM",
-            };
-
-            return ColorDebugInfo {
-                hex_value: hex.to_string(),
-                has_alpha,
-                alpha,
-                red: r,
-                green: g,
-                blue: b,
-                expected_color: expected.to_string(),
-            };
-        }
-    }
-
-    ColorDebugInfo {
-        hex_value: "INVALID".to_string(),
-        has_alpha: false,
-        alpha: 0,
-        red: 0,
-        green: 0,
-        blue: 0,
-        expected_color: "ERROR".to_string(),
-    }
-}
-
-impl ColorReport {
-    pub fn print_diagnostic(&self) {
-        println!("=== ASS Color Diagnostic Report ===\n");
-
-        for style in &self.styles {
-            println!("Style: {}", style.name);
-            println!("  Primary Color: {}", style.primary_raw);
-            println!("    Hex: {}", style.primary_parsed.hex_value);
-            println!(
-                "    RGBA: ({}, {}, {}, {})",
-                style.primary_parsed.red,
-                style.primary_parsed.green,
-                style.primary_parsed.blue,
-                if style.primary_parsed.has_alpha {
-                    format!("{}", 255 - style.primary_parsed.alpha) // Convert ASS to RGBA alpha
-                } else {
-                    "255".to_string()
-                }
-            );
-            println!("    Expected: {}", style.primary_parsed.expected_color);
-
-            // Diagnostic for common issues
-            if style.primary_parsed.expected_color == "YELLOW" && style.name.contains("White") {
-                println!(
-                    "    ⚠️  WARNING: Style named '{}' is YELLOW but should probably be WHITE!",
-                    style.name
-                );
-                println!("       Correct white: &H00FFFFFF");
-                println!("       Current value might be: &H0000FFFF (yellow)");
-            }
-            println!();
-        }
-
-        if self.has_color_overrides {
-            println!("Note: Script contains color override tags (\\c or \\1c) in events");
-        }
-    }
-}
diff --git a/crates/ass-renderer/src/debug/inspector.rs b/crates/ass-renderer/src/debug/inspector.rs
deleted file mode 100644
index 4f5927f..0000000
--- a/crates/ass-renderer/src/debug/inspector.rs
+++ /dev/null
@@ -1,606 +0,0 @@
-use crate::Frame;
-
-#[cfg(not(feature = "nostd"))]
-use std::collections::HashSet;
-#[cfg(not(feature = "nostd"))]
-use std::fmt;
-
-#[cfg(feature = "nostd")]
-use alloc::collections::BTreeSet as HashSet;
-#[cfg(feature = "nostd")]
-use alloc::vec::Vec;
-#[cfg(feature = "nostd")]
-use core::fmt;
-
-/// Frame inspector for detailed pixel-level debugging
-pub struct FrameInspector {
-    frame: Option<Frame>,
-    cursor_x: u32,
-    cursor_y: u32,
-}
-
-impl Default for FrameInspector {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl FrameInspector {
-    pub fn new() -> Self {
-        Self {
-            frame: None,
-            cursor_x: 0,
-            cursor_y: 0,
-        }
-    }
-
-    pub fn load_frame(&mut self, frame: Frame) {
-        self.cursor_x = frame.width() / 2;
-        self.cursor_y = frame.height() / 2;
-        self.frame = Some(frame);
-    }
-
-    pub fn move_cursor(&mut self, dx: i32, dy: i32) {
-        if let Some(ref frame) = self.frame {
-            let new_x = (self.cursor_x as i32 + dx)
-                .max(0)
-                .min(frame.width() as i32 - 1) as u32;
-            let new_y = (self.cursor_y as i32 + dy)
-                .max(0)
-                .min(frame.height() as i32 - 1) as u32;
-            self.cursor_x = new_x;
-            self.cursor_y = new_y;
-        }
-    }
-
-    pub fn set_cursor(&mut self, x: u32, y: u32) {
-        if let Some(ref frame) = self.frame {
-            self.cursor_x = x.min(frame.width() - 1);
-            self.cursor_y = y.min(frame.height() - 1);
-        }
-    }
-
-    pub fn get_pixel_at_cursor(&self) -> Option<PixelInfo> {
-        self.get_pixel_at(self.cursor_x, self.cursor_y)
-    }
-
-    pub fn get_pixel_at(&self, x: u32, y: u32) -> Option<PixelInfo> {
-        let frame = self.frame.as_ref()?;
-
-        if x >= frame.width() || y >= frame.height() {
-            return None;
-        }
-
-        let idx = ((y * frame.width() + x) * 4) as usize;
-        let pixels = frame.pixels();
-
-        if idx + 3 >= pixels.len() {
-            return None;
-        }
-
-        Some(PixelInfo {
-            x,
-            y,
-            r: pixels[idx],
-            g: pixels[idx + 1],
-            b: pixels[idx + 2],
-            a: pixels[idx + 3],
-        })
-    }
-
-    pub fn get_region(&self, x: u32, y: u32, width: u32, height: u32) -> RegionInfo {
-        let frame = match self.frame.as_ref() {
-            Some(f) => f,
-            None => return RegionInfo::empty(),
-        };
-
-        let mut pixels = Vec::new();
-        let mut histogram = ColorHistogram::new();
-
-        let x_end = (x + width).min(frame.width());
-        let y_end = (y + height).min(frame.height());
-
-        for py in y..y_end {
-            for px in x..x_end {
-                if let Some(pixel) = self.get_pixel_at(px, py) {
-                    histogram.add_pixel(&pixel);
-                    pixels.push(pixel);
-                }
-            }
-        }
-
-        RegionInfo {
-            x,
-            y,
-            width: x_end - x,
-            height: y_end - y,
-            pixels,
-            histogram,
-        }
-    }
-
-    pub fn find_non_transparent_bounds(&self) -> Option<BoundsInfo> {
-        let frame = self.frame.as_ref()?;
-        let pixels = frame.pixels();
-
-        let mut min_x = frame.width();
-        let mut min_y = frame.height();
-        let mut max_x = 0u32;
-        let mut max_y = 0u32;
-        let mut found = false;
-
-        for y in 0..frame.height() {
-            for x in 0..frame.width() {
-                let idx = ((y * frame.width() + x) * 4) as usize;
-                if idx + 3 < pixels.len() && pixels[idx + 3] > 0 {
-                    found = true;
-                    min_x = min_x.min(x);
-                    min_y = min_y.min(y);
-                    max_x = max_x.max(x);
-                    max_y = max_y.max(y);
-                }
-            }
-        }
-
-        if !found {
-            return None;
-        }
-
-        Some(BoundsInfo {
-            min_x,
-            min_y,
-            max_x,
-            max_y,
-            width: max_x - min_x + 1,
-            height: max_y - min_y + 1,
-        })
-    }
-
-    pub fn scan_line(&self, y: u32) -> Vec<LineScanSegment> {
-        let frame = match self.frame.as_ref() {
-            Some(f) => f,
-            None => return Vec::new(),
-        };
-
-        if y >= frame.height() {
-            return Vec::new();
-        }
-
-        let mut segments = Vec::new();
-        let mut current_segment: Option<LineScanSegment> = None;
-
-        for x in 0..frame.width() {
-            if let Some(pixel) = self.get_pixel_at(x, y) {
-                if pixel.a > 0 {
-                    // Non-transparent pixel
-                    match current_segment.as_mut() {
-                        Some(seg) if seg.is_similar(&pixel) => {
-                            seg.end_x = x;
-                            seg.pixels.push(pixel);
-                        }
-                        _ => {
-                            if let Some(seg) = current_segment.take() {
-                                segments.push(seg);
-                            }
-                            current_segment = Some(LineScanSegment {
-                                y,
-                                start_x: x,
-                                end_x: x,
-                                pixels: vec![pixel],
-                                avg_color: [pixel.r, pixel.g, pixel.b, pixel.a],
-                            });
-                        }
-                    }
-                } else if let Some(seg) = current_segment.take() {
-                    segments.push(seg);
-                }
-            }
-        }
-
-        if let Some(mut seg) = current_segment {
-            seg.calculate_average();
-            segments.push(seg);
-        }
-
-        segments
-    }
-
-    pub fn compare_pixels(&self, x1: u32, y1: u32, x2: u32, y2: u32) -> Option<PixelComparison> {
-        let pixel1 = self.get_pixel_at(x1, y1)?;
-        let pixel2 = self.get_pixel_at(x2, y2)?;
-
-        Some(PixelComparison {
-            pixel1,
-            pixel2,
-            color_distance: pixel1.color_distance(&pixel2),
-            is_similar: pixel1.is_similar(&pixel2, 30),
-        })
-    }
-
-    pub fn print_cursor_info(&self) {
-        if let Some(pixel) = self.get_pixel_at_cursor() {
-            pixel.print_detailed();
-        } else {
-            println!("No frame loaded or cursor out of bounds");
-        }
-    }
-
-    pub fn print_ascii_preview(&self, width: u32, height: u32) {
-        let frame = match self.frame.as_ref() {
-            Some(f) => f,
-            None => {
-                println!("No frame loaded");
-                return;
-            }
-        };
-
-        let scale_x = frame.width() as f32 / width as f32;
-        let scale_y = frame.height() as f32 / height as f32;
-
-        println!(
-            "ASCII Preview ({}x{} -> {}x{}):",
-            frame.width(),
-            frame.height(),
-            width,
-            height
-        );
-        let border = "─".repeat(width as usize);
-        println!("┌{border}┐");
-
-        for y in 0..height {
-            print!("│");
-            for x in 0..width {
-                let sample_x = (x as f32 * scale_x) as u32;
-                let sample_y = (y as f32 * scale_y) as u32;
-
-                if let Some(pixel) = self.get_pixel_at(sample_x, sample_y) {
-                    print!("{}", pixel.to_ascii());
-                } else {
-                    print!(" ");
-                }
-            }
-            println!("│");
-        }
-
-        let border = "─".repeat(width as usize);
-        println!("└{border}┘");
-        println!("Legend: █=opaque ▓=semi ░=faint ·=trace  =transparent");
-    }
-}
-
-#[derive(Debug, Clone, Copy)]
-pub struct PixelInfo {
-    pub x: u32,
-    pub y: u32,
-    pub r: u8,
-    pub g: u8,
-    pub b: u8,
-    pub a: u8,
-}
-
-impl PixelInfo {
-    pub fn to_hex(&self) -> String {
-        format!(
-            "#{r:02X}{g:02X}{b:02X}{a:02X}",
-            r = self.r,
-            g = self.g,
-            b = self.b,
-            a = self.a
-        )
-    }
-
-    pub fn to_css(&self) -> String {
-        if self.a == 255 {
-            format!("rgb({r}, {g}, {b})", r = self.r, g = self.g, b = self.b)
-        } else {
-            format!(
-                "rgba({r}, {g}, {b}, {a:.2})",
-                r = self.r,
-                g = self.g,
-                b = self.b,
-                a = self.a as f32 / 255.0
-            )
-        }
-    }
-
-    pub fn luminance(&self) -> f32 {
-        // Relative luminance formula
-        0.2126 * (self.r as f32) + 0.7152 * (self.g as f32) + 0.0722 * (self.b as f32)
-    }
-
-    pub fn is_grayscale(&self) -> bool {
-        self.r == self.g && self.g == self.b
-    }
-
-    pub fn color_distance(&self, other: &PixelInfo) -> f32 {
-        let dr = (self.r as f32 - other.r as f32).powi(2);
-        let dg = (self.g as f32 - other.g as f32).powi(2);
-        let db = (self.b as f32 - other.b as f32).powi(2);
-        let da = (self.a as f32 - other.a as f32).powi(2);
-
-        (dr + dg + db + da).sqrt()
-    }
-
-    pub fn is_similar(&self, other: &PixelInfo, threshold: u8) -> bool {
-        let diff = |a: u8, b: u8| -> u8 { a.abs_diff(b) };
-
-        diff(self.r, other.r) <= threshold
-            && diff(self.g, other.g) <= threshold
-            && diff(self.b, other.b) <= threshold
-            && diff(self.a, other.a) <= threshold
-    }
-
-    pub fn to_ascii(&self) -> char {
-        if self.a == 0 {
-            ' '
-        } else if self.a > 200 {
-            '█'
-        } else if self.a > 150 {
-            '▓'
-        } else if self.a > 100 {
-            '▒'
-        } else if self.a > 50 {
-            '░'
-        } else {
-            '·'
-        }
-    }
-
-    pub fn print_detailed(&self) {
-        println!("╔════════════════════════════════════╗");
-        println!("║         Pixel Information          ║");
-        println!("╚════════════════════════════════════╝");
-        println!("Position: ({x}, {y})", x = self.x, y = self.y);
-        println!(
-            "RGBA: ({r}, {g}, {b}, {a})",
-            r = self.r,
-            g = self.g,
-            b = self.b,
-            a = self.a
-        );
-        println!("Hex: {hex}", hex = self.to_hex());
-        println!("CSS: {css}", css = self.to_css());
-        println!("Luminance: {luminance:.2}", luminance = self.luminance());
-        println!(
-            "Grayscale: {}",
-            if self.is_grayscale() { "Yes" } else { "No" }
-        );
-        println!(
-            "Opacity: {opacity:.1}%",
-            opacity = (self.a as f32 / 255.0) * 100.0
-        );
-
-        // Color classification
-        let color_name = if self.a == 0 {
-            "Transparent"
-        } else if self.is_grayscale() {
-            if self.r > 200 {
-                "White"
-            } else if self.r > 150 {
-                "Light Gray"
-            } else if self.r > 100 {
-                "Gray"
-            } else if self.r > 50 {
-                "Dark Gray"
-            } else {
-                "Black"
-            }
-        } else {
-            // Simple color classification
-            if self.r > self.g && self.r > self.b {
-                "Reddish"
-            } else if self.g > self.r && self.g > self.b {
-                "Greenish"
-            } else if self.b > self.r && self.b > self.g {
-                "Bluish"
-            } else {
-                "Mixed"
-            }
-        };
-
-        println!("Color: {color_name}");
-        println!("════════════════════════════════════");
-    }
-}
-
-#[derive(Debug)]
-pub struct RegionInfo {
-    pub x: u32,
-    pub y: u32,
-    pub width: u32,
-    pub height: u32,
-    pub pixels: Vec<PixelInfo>,
-    pub histogram: ColorHistogram,
-}
-
-impl RegionInfo {
-    fn empty() -> Self {
-        Self {
-            x: 0,
-            y: 0,
-            width: 0,
-            height: 0,
-            pixels: Vec::new(),
-            histogram: ColorHistogram::new(),
-        }
-    }
-
-    pub fn print_summary(&self) {
-        println!(
-            "Region: {}x{} at ({}, {})",
-            self.width, self.height, self.x, self.y
-        );
-        let pixel_count = self.pixels.len();
-        println!("Total pixels: {pixel_count}");
-
-        if !self.pixels.is_empty() {
-            let non_transparent = self.pixels.iter().filter(|p| p.a > 0).count();
-            println!(
-                "Non-transparent: {} ({:.1}%)",
-                non_transparent,
-                (non_transparent as f32 / self.pixels.len() as f32) * 100.0
-            );
-
-            self.histogram.print_summary();
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ColorHistogram {
-    pub red_sum: u64,
-    pub green_sum: u64,
-    pub blue_sum: u64,
-    pub alpha_sum: u64,
-    pub count: usize,
-    pub unique_colors: HashSet<(u8, u8, u8, u8)>,
-}
-
-impl ColorHistogram {
-    fn new() -> Self {
-        Self {
-            red_sum: 0,
-            green_sum: 0,
-            blue_sum: 0,
-            alpha_sum: 0,
-            count: 0,
-            unique_colors: HashSet::new(),
-        }
-    }
-
-    fn add_pixel(&mut self, pixel: &PixelInfo) {
-        self.red_sum += pixel.r as u64;
-        self.green_sum += pixel.g as u64;
-        self.blue_sum += pixel.b as u64;
-        self.alpha_sum += pixel.a as u64;
-        self.count += 1;
-        self.unique_colors
-            .insert((pixel.r, pixel.g, pixel.b, pixel.a));
-    }
-
-    pub fn average_color(&self) -> Option<[u8; 4]> {
-        if self.count == 0 {
-            return None;
-        }
-
-        Some([
-            (self.red_sum / self.count as u64) as u8,
-            (self.green_sum / self.count as u64) as u8,
-            (self.blue_sum / self.count as u64) as u8,
-            (self.alpha_sum / self.count as u64) as u8,
-        ])
-    }
-
-    fn print_summary(&self) {
-        if let Some(avg) = self.average_color() {
-            println!(
-                "Average color: RGBA({}, {}, {}, {})",
-                avg[0], avg[1], avg[2], avg[3]
-            );
-        }
-        let color_count = self.unique_colors.len();
-        println!("Unique colors: {color_count}");
-    }
-}
-
-#[derive(Debug)]
-pub struct BoundsInfo {
-    pub min_x: u32,
-    pub min_y: u32,
-    pub max_x: u32,
-    pub max_y: u32,
-    pub width: u32,
-    pub height: u32,
-}
-
-impl fmt::Display for BoundsInfo {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "Bounds: ({}, {}) to ({}, {}) [{}x{}]",
-            self.min_x, self.min_y, self.max_x, self.max_y, self.width, self.height
-        )
-    }
-}
-
-#[derive(Debug)]
-pub struct LineScanSegment {
-    pub y: u32,
-    pub start_x: u32,
-    pub end_x: u32,
-    pub pixels: Vec<PixelInfo>,
-    pub avg_color: [u8; 4],
-}
-
-impl LineScanSegment {
-    fn is_similar(&self, pixel: &PixelInfo) -> bool {
-        if self.pixels.is_empty() {
-            return false;
-        }
-
-        // Check if pixel is similar to average
-        let threshold = 30;
-        let diff = |a: u8, b: u8| -> u8 { a.abs_diff(b) };
-
-        diff(self.avg_color[0], pixel.r) <= threshold
-            && diff(self.avg_color[1], pixel.g) <= threshold
-            && diff(self.avg_color[2], pixel.b) <= threshold
-    }
-
-    fn calculate_average(&mut self) {
-        if self.pixels.is_empty() {
-            return;
-        }
-
-        let sum: (u64, u64, u64, u64) = self.pixels.iter().fold((0, 0, 0, 0), |acc, p| {
-            (
-                acc.0 + p.r as u64,
-                acc.1 + p.g as u64,
-                acc.2 + p.b as u64,
-                acc.3 + p.a as u64,
-            )
-        });
-
-        let count = self.pixels.len() as u64;
-        self.avg_color = [
-            (sum.0 / count) as u8,
-            (sum.1 / count) as u8,
-            (sum.2 / count) as u8,
-            (sum.3 / count) as u8,
-        ];
-    }
-
-    pub fn width(&self) -> u32 {
-        self.end_x - self.start_x + 1
-    }
-}
-
-#[derive(Debug)]
-pub struct PixelComparison {
-    pub pixel1: PixelInfo,
-    pub pixel2: PixelInfo,
-    pub color_distance: f32,
-    pub is_similar: bool,
-}
-
-impl fmt::Display for PixelComparison {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(
-            f,
-            "Pixel 1 @ ({}, {}): {}",
-            self.pixel1.x,
-            self.pixel1.y,
-            self.pixel1.to_hex()
-        )?;
-        writeln!(
-            f,
-            "Pixel 2 @ ({}, {}): {}",
-            self.pixel2.x,
-            self.pixel2.y,
-            self.pixel2.to_hex()
-        )?;
-        writeln!(f, "Distance: {:.2}", self.color_distance)?;
-        writeln!(f, "Similar: {}", if self.is_similar { "Yes" } else { "No" })?;
-        Ok(())
-    }
-}
diff --git a/crates/ass-renderer/src/debug/libass_compatibility.rs b/crates/ass-renderer/src/debug/libass_compatibility.rs
deleted file mode 100644
index a4d8332..0000000
--- a/crates/ass-renderer/src/debug/libass_compatibility.rs
+++ /dev/null
@@ -1,542 +0,0 @@
-//! Comprehensive libass compatibility testing framework
-//!
-//! This module provides tools for pixel-perfect comparison between our renderer
-//! and libass, including visual diff generation, animation testing, and regression detection.
-
-use crate::debug::{LibassRenderer, PixelPerfectComparison};
-use crate::renderer::{RenderContext, Renderer};
-use crate::utils::RenderError;
-use ass_core::parser::Script;
-
-#[cfg(feature = "nostd")]
-use alloc::{format, string::String, vec::Vec};
-#[cfg(not(feature = "nostd"))]
-use std::{collections::HashMap, string::String, time::Instant, vec::Vec};
-
-/// Compatibility test result
-#[derive(Debug, Clone)]
-pub struct CompatibilityResult {
-    /// Test name/identifier
-    pub test_name: String,
-    /// Whether the test passed (pixel-perfect match)
-    pub passed: bool,
-    /// Pixel difference percentage (0.0 = perfect match, 1.0 = completely different)
-    pub pixel_diff_percentage: f64,
-    /// Maximum pixel value difference (0-255)
-    pub max_pixel_diff: u8,
-    /// Areas where differences occur
-    pub diff_regions: Vec<DiffRegion>,
-    /// Rendering time comparison (ours vs libass)
-    pub performance_ratio: Option<f64>,
-    /// Memory usage comparison
-    pub memory_ratio: Option<f64>,
-}
-
-/// Region where pixel differences were detected
-#[derive(Debug, Clone)]
-pub struct DiffRegion {
-    /// Bounding box (x, y, width, height)
-    pub bounds: (u32, u32, u32, u32),
-    /// Average difference in this region
-    pub avg_diff: f64,
-    /// Maximum difference in this region
-    pub max_diff: u8,
-    /// Type of difference detected
-    pub diff_type: DiffType,
-}
-
-/// Types of differences that can be detected
-#[derive(Debug, Clone, PartialEq)]
-pub enum DiffType {
-    /// Color/pixel value differences
-    PixelValue,
-    /// Text positioning differences
-    TextPosition,
-    /// Animation timing differences
-    AnimationTiming,
-    /// Font rendering differences
-    FontRendering,
-    /// Effect application differences
-    Effects,
-    /// Geometric transformation differences
-    Transform,
-}
-
-/// Comprehensive compatibility tester
-pub struct CompatibilityTester {
-    /// Our renderer instance
-    our_renderer: Renderer,
-    /// Libass renderer for reference
-    libass_renderer: LibassRenderer,
-    /// Test configuration
-    config: TestConfig,
-    /// Results cache for regression testing
-    #[cfg(not(feature = "nostd"))]
-    #[allow(dead_code)]
-    // incomplete testing
-    results_cache: HashMap<String, CompatibilityResult>,
-}
-
-/// Configuration for compatibility testing
-#[derive(Debug, Clone)]
-pub struct TestConfig {
-    /// Tolerance for pixel differences (0-255)
-    pub pixel_tolerance: u8,
-    /// Minimum difference percentage to consider significant
-    pub significance_threshold: f64,
-    /// Whether to generate visual diff images
-    pub generate_visual_diffs: bool,
-    /// Output directory for test results
-    #[cfg(not(feature = "nostd"))]
-    pub output_dir: String,
-    /// Whether to test animations frame-by-frame
-    pub test_animations: bool,
-    /// Animation frame step (in centiseconds)
-    pub animation_step_cs: u32,
-    /// Maximum animation duration to test (in centiseconds)
-    pub max_animation_duration_cs: u32,
-    /// Whether to measure performance
-    pub measure_performance: bool,
-}
-
-impl Default for TestConfig {
-    fn default() -> Self {
-        Self {
-            pixel_tolerance: 1,            // Allow 1 pixel value difference
-            significance_threshold: 0.001, // 0.1% difference threshold
-            generate_visual_diffs: true,
-            #[cfg(not(feature = "nostd"))]
-            output_dir: "test_output/compatibility".to_string(),
-            test_animations: true,
-            animation_step_cs: 4,            // 40ms steps (25 FPS)
-            max_animation_duration_cs: 3000, // 30 seconds max
-            measure_performance: true,
-        }
-    }
-}
-
-impl CompatibilityTester {
-    /// Create new compatibility tester
-    pub fn new(context: RenderContext, config: TestConfig) -> Result<Self, RenderError> {
-        let our_renderer = Renderer::new(context.clone())?;
-        let libass_renderer = LibassRenderer::new(context.width(), context.height())?;
-
-        Ok(Self {
-            our_renderer,
-            libass_renderer,
-            config,
-            #[cfg(not(feature = "nostd"))]
-            results_cache: HashMap::new(),
-        })
-    }
-
-    /// Run comprehensive compatibility test on a script
-    pub fn test_script_compatibility(
-        &mut self,
-        script: &Script,
-        test_name: &str,
-    ) -> Result<CompatibilityResult, RenderError> {
-        // Test static frames first
-        let static_result = self.test_static_compatibility(script, test_name)?;
-
-        if !self.config.test_animations {
-            return Ok(static_result);
-        }
-
-        // Test animations if enabled
-        let animation_results = self.test_animation_compatibility(script, test_name)?;
-
-        // Combine results
-        Ok(self.combine_test_results(static_result, animation_results))
-    }
-
-    /// Test static frame compatibility
-    fn test_static_compatibility(
-        &mut self,
-        script: &Script,
-        test_name: &str,
-    ) -> Result<CompatibilityResult, RenderError> {
-        // Find a representative time to test (middle of first event)
-        let test_time = self.find_representative_time(script);
-
-        let start_time = Instant::now();
-        let our_frame = self.our_renderer.render_frame(script, test_time)?;
-        let our_render_time = start_time.elapsed();
-
-        let start_time = Instant::now();
-        let libass_frame = self.libass_renderer.render_frame(script, test_time)?;
-        let libass_render_time = start_time.elapsed();
-
-        // Compare frames pixel by pixel
-        let comparison = PixelPerfectComparison::compare_frames(
-            our_frame.data(),
-            libass_frame.data(),
-            our_frame.width(),
-            our_frame.height(),
-        );
-
-        let result = CompatibilityResult {
-            test_name: format!("{test_name}_static"),
-            passed: comparison.pixel_diff_percentage <= self.config.significance_threshold,
-            pixel_diff_percentage: comparison.pixel_diff_percentage,
-            max_pixel_diff: comparison.max_pixel_diff,
-            diff_regions: self.analyze_diff_regions(&comparison),
-            performance_ratio: Some(
-                our_render_time.as_nanos() as f64 / libass_render_time.as_nanos() as f64,
-            ),
-            memory_ratio: None, // TODO: Implement memory measurement
-        };
-
-        // Generate visual diff if requested
-        #[cfg(all(not(feature = "nostd"), feature = "image"))]
-        if self.config.generate_visual_diffs && !result.passed {
-            self.generate_visual_diff(&our_frame, &libass_frame, &comparison, test_name)?;
-        }
-
-        Ok(result)
-    }
-
-    /// Test animation compatibility frame by frame
-    fn test_animation_compatibility(
-        &mut self,
-        script: &Script,
-        test_name: &str,
-    ) -> Result<Vec<CompatibilityResult>, RenderError> {
-        let mut results = Vec::new();
-        let (start_time, end_time) = self.find_animation_timerange(script);
-
-        let end_time = end_time.min(start_time + self.config.max_animation_duration_cs);
-
-        for time_cs in (start_time..=end_time).step_by(self.config.animation_step_cs as usize) {
-            let frame_result = self.test_frame_at_time(script, time_cs, test_name)?;
-            results.push(frame_result);
-
-            // Early exit if we find major differences
-            if let Some(last_result) = results.last() {
-                if last_result.pixel_diff_percentage > 0.1 {
-                    eprintln!("Major difference detected at {time_cs}cs, stopping animation test");
-                    break;
-                }
-            }
-        }
-
-        Ok(results)
-    }
-
-    /// Test a single frame at specific time
-    fn test_frame_at_time(
-        &mut self,
-        script: &Script,
-        time_cs: u32,
-        test_name: &str,
-    ) -> Result<CompatibilityResult, RenderError> {
-        let our_frame = self.our_renderer.render_frame(script, time_cs)?;
-        let libass_frame = self.libass_renderer.render_frame(script, time_cs)?;
-
-        let comparison = PixelPerfectComparison::compare_frames(
-            our_frame.data(),
-            libass_frame.data(),
-            our_frame.width(),
-            our_frame.height(),
-        );
-
-        Ok(CompatibilityResult {
-            test_name: format!("{test_name}_frame_{time_cs}"),
-            passed: comparison.pixel_diff_percentage <= self.config.significance_threshold,
-            pixel_diff_percentage: comparison.pixel_diff_percentage,
-            max_pixel_diff: comparison.max_pixel_diff,
-            diff_regions: self.analyze_diff_regions(&comparison),
-            performance_ratio: None,
-            memory_ratio: None,
-        })
-    }
-
-    /// Analyze difference regions to categorize types of differences
-    fn analyze_diff_regions(&self, comparison: &PixelPerfectComparison) -> Vec<DiffRegion> {
-        let mut regions = Vec::new();
-
-        // Simple clustering of different pixels into regions
-        // TODO: Implement proper connected component analysis
-
-        if let Some(diff_map) = &comparison.difference_map {
-            // Find clusters of different pixels
-            let clusters = self.find_difference_clusters(diff_map);
-
-            for cluster in clusters {
-                let diff_type = self.classify_difference_type(&cluster);
-                regions.push(DiffRegion {
-                    bounds: cluster.bounds,
-                    avg_diff: cluster.avg_diff,
-                    max_diff: cluster.max_diff,
-                    diff_type,
-                });
-            }
-        }
-
-        regions
-    }
-
-    /// Find clusters of different pixels
-    fn find_difference_clusters(&self, _diff_map: &[u8]) -> Vec<DiffCluster> {
-        // TODO: Implement connected component analysis
-        // For now, return empty clusters
-        Vec::new()
-    }
-
-    /// Classify the type of difference in a cluster
-    fn classify_difference_type(&self, _cluster: &DiffCluster) -> DiffType {
-        // TODO: Implement heuristics to classify difference types
-        // - Text positioning: differences in glyph positions
-        // - Font rendering: differences in glyph shapes
-        // - Effects: differences in shadows, outlines, etc.
-        // - Transform: differences in rotation, scaling
-        // - Animation timing: differences that vary with time
-        DiffType::PixelValue
-    }
-
-    /// Generate visual diff image for debugging
-    #[cfg(all(not(feature = "nostd"), feature = "image"))]
-    fn generate_visual_diff(
-        &self,
-        our_frame: &crate::renderer::Frame,
-        libass_frame: &crate::renderer::Frame,
-        comparison: &PixelPerfectComparison,
-        test_name: &str,
-    ) -> Result<(), RenderError> {
-        // Create output directory
-        let output_dir = std::path::Path::new(&self.config.output_dir);
-        std::fs::create_dir_all(output_dir)
-            .map_err(|e| RenderError::IOError(format!("Failed to create output directory: {e}")))?;
-
-        // Save our frame
-        let our_path = output_dir.join(format!("{test_name}_ours.png"));
-        self.save_frame_as_image(our_frame, &our_path)?;
-
-        // Save libass frame
-        let libass_path = output_dir.join(format!("{test_name}_libass.png"));
-        self.save_frame_as_image(libass_frame, &libass_path)?;
-
-        // Generate and save diff visualization
-        if let Some(diff_map) = &comparison.difference_map {
-            let diff_path = output_dir.join(format!("{test_name}_diff.png"));
-            self.save_diff_visualization(
-                diff_map,
-                our_frame.width(),
-                our_frame.height(),
-                &diff_path,
-            )?;
-        }
-
-        Ok(())
-    }
-
-    /// Save frame data as PNG image
-    #[cfg(all(not(feature = "nostd"), feature = "image"))]
-    fn save_frame_as_image(
-        &self,
-        frame: &crate::renderer::Frame,
-        path: &std::path::Path,
-    ) -> Result<(), RenderError> {
-        use image::{ImageBuffer, RgbImage};
-
-        let width = frame.width();
-        let height = frame.height();
-        let data = frame.data();
-
-        // Convert RGBA to RGB
-        let mut rgb_data = Vec::with_capacity(width as usize * height as usize * 3);
-        for chunk in data.chunks(4) {
-            rgb_data.push(chunk[0]); // R
-            rgb_data.push(chunk[1]); // G
-            rgb_data.push(chunk[2]); // B
-                                     // Skip alpha channel
-        }
-
-        let img: RgbImage = ImageBuffer::from_raw(width, height, rgb_data).ok_or_else(|| {
-            RenderError::BackendError("Failed to create image buffer".to_string())
-        })?;
-
-        img.save(path)
-            .map_err(|e| RenderError::IOError(format!("Failed to save image: {e}")))?;
-
-        Ok(())
-    }
-
-    /// Save difference visualization
-    #[cfg(all(not(feature = "nostd"), feature = "image"))]
-    fn save_diff_visualization(
-        &self,
-        _diff_map: &[u8],
-        width: u32,
-        height: u32,
-        path: &std::path::Path,
-    ) -> Result<(), RenderError> {
-        use image::{ImageBuffer, RgbImage};
-
-        // Create heatmap visualization of differences
-        let mut rgb_data = Vec::with_capacity(width as usize * height as usize * 3);
-
-        for &diff_value in _diff_map {
-            if diff_value == 0 {
-                // No difference - black
-                rgb_data.extend_from_slice(&[0, 0, 0]);
-            } else {
-                // Difference - red intensity based on difference magnitude
-                rgb_data.extend_from_slice(&[diff_value, 0, 0]);
-            }
-        }
-
-        let img: RgbImage = ImageBuffer::from_raw(width, height, rgb_data).ok_or_else(|| {
-            RenderError::BackendError("Failed to create diff image buffer".to_string())
-        })?;
-
-        img.save(path)
-            .map_err(|e| RenderError::IOError(format!("Failed to save diff image: {e}")))?;
-
-        Ok(())
-    }
-
-    /// Combine multiple test results into a summary
-    fn combine_test_results(
-        &self,
-        static_result: CompatibilityResult,
-        animation_results: Vec<CompatibilityResult>,
-    ) -> CompatibilityResult {
-        let animation_passed = animation_results.iter().all(|r| r.passed);
-        let max_animation_diff = animation_results
-            .iter()
-            .map(|r| r.pixel_diff_percentage)
-            .fold(0.0, f64::max);
-
-        CompatibilityResult {
-            test_name: static_result.test_name.replace("_static", "_combined"),
-            passed: static_result.passed && animation_passed,
-            pixel_diff_percentage: static_result.pixel_diff_percentage.max(max_animation_diff),
-            max_pixel_diff: static_result.max_pixel_diff.max(
-                animation_results
-                    .iter()
-                    .map(|r| r.max_pixel_diff)
-                    .max()
-                    .unwrap_or(0),
-            ),
-            diff_regions: static_result.diff_regions, // TODO: Combine all diff regions
-            performance_ratio: static_result.performance_ratio,
-            memory_ratio: static_result.memory_ratio,
-        }
-    }
-
-    /// Find representative time for static testing
-    fn find_representative_time(&self, script: &Script) -> u32 {
-        // Find middle of first event that has visible text
-        for section in script.sections() {
-            if let ass_core::parser::Section::Events(events) = section {
-                for event in events {
-                    if !event.text.trim().is_empty() {
-                        let start = event.start_time_cs().unwrap_or(0);
-                        let end = event.end_time_cs().unwrap_or(0);
-                        return start + (end - start) / 2;
-                    }
-                }
-            }
-        }
-
-        // Default to 1 second
-        100
-    }
-
-    /// Find animation time range to test
-    fn find_animation_timerange(&self, script: &Script) -> (u32, u32) {
-        let mut min_time = u32::MAX;
-        let mut max_time = 0;
-
-        for section in script.sections() {
-            if let ass_core::parser::Section::Events(events) = section {
-                for event in events {
-                    let start = event.start_time_cs().unwrap_or(0);
-                    let end = event.end_time_cs().unwrap_or(0);
-                    min_time = min_time.min(start);
-                    max_time = max_time.max(end);
-                }
-            }
-        }
-
-        if min_time == u32::MAX {
-            (0, 1000) // Default 10 second range
-        } else {
-            (min_time, max_time)
-        }
-    }
-}
-
-/// Cluster of different pixels for analysis
-#[derive(Debug)]
-struct DiffCluster {
-    bounds: (u32, u32, u32, u32),
-    avg_diff: f64,
-    max_diff: u8,
-    #[allow(dead_code)]
-    pixel_count: usize,
-}
-
-/// Comprehensive test suite runner
-pub struct CompatibilityTestSuite {
-    tester: CompatibilityTester,
-    test_cases: Vec<TestCase>,
-}
-
-/// Individual test case
-#[derive(Debug, Clone)]
-pub struct TestCase {
-    pub name: String,
-    pub script_content: String,
-    pub expected_issues: Vec<DiffType>,
-    pub tolerance: Option<f64>,
-}
-
-impl CompatibilityTestSuite {
-    /// Create new test suite
-    pub fn new(context: RenderContext, config: TestConfig) -> Result<Self, RenderError> {
-        let tester = CompatibilityTester::new(context, config)?;
-        Ok(Self {
-            tester,
-            test_cases: Vec::new(),
-        })
-    }
-
-    /// Add test case from ASS content
-    pub fn add_test_case(&mut self, name: String, script_content: String) {
-        self.test_cases.push(TestCase {
-            name,
-            script_content,
-            expected_issues: Vec::new(),
-            tolerance: None,
-        });
-    }
-
-    /// Run all test cases
-    pub fn run_all_tests(&mut self) -> Result<Vec<CompatibilityResult>, RenderError> {
-        let mut results = Vec::new();
-
-        for test_case in &self.test_cases {
-            eprintln!("Running compatibility test: {}", test_case.name);
-
-            let script = ass_core::parser::Script::parse(&test_case.script_content)
-                .map_err(|e| RenderError::ParseError(format!("Failed to parse script: {e}")))?;
-
-            let result = self
-                .tester
-                .test_script_compatibility(&script, &test_case.name)?;
-
-            eprintln!(
-                "Test {} - Passed: {}, Diff: {:.3}%",
-                test_case.name,
-                result.passed,
-                result.pixel_diff_percentage * 100.0
-            );
-
-            results.push(result);
-        }
-
-        Ok(results)
-    }
-}
diff --git a/crates/ass-renderer/src/debug/libass_ffi.rs b/crates/ass-renderer/src/debug/libass_ffi.rs
deleted file mode 100644
index 0286583..0000000
--- a/crates/ass-renderer/src/debug/libass_ffi.rs
+++ /dev/null
@@ -1,313 +0,0 @@
-//! Direct FFI bindings to libass for debugging and comparison
-//!
-//! This module provides direct FFI bindings to libass library.
-//! It requires libass to be installed on the system:
-//! - macOS: brew install libass
-//! - Ubuntu/Debian: apt-get install libass-dev
-//! - Fedora: dnf install libass-devel
-
-#![allow(unsafe_code)] // Required for FFI
-
-use std::ffi::CString;
-use std::os::raw::{c_char, c_double, c_int, c_long};
-use std::ptr;
-
-#[repr(C)]
-pub struct ASS_Library {
-    _private: [u8; 0],
-}
-
-#[repr(C)]
-pub struct ASS_Renderer {
-    _private: [u8; 0],
-}
-
-#[repr(C)]
-pub struct ASS_Track {
-    _private: [u8; 0],
-}
-
-#[repr(C)]
-#[derive(Debug, Clone)]
-pub struct ASS_Image {
-    pub w: c_int,
-    pub h: c_int,
-    pub stride: c_int,
-    pub bitmap: *mut u8,
-    pub color: u32,
-    pub dst_x: c_int,
-    pub dst_y: c_int,
-    pub next: *mut ASS_Image,
-    pub type_: c_int,
-}
-
-#[link(name = "ass")]
-extern "C" {
-    // Library functions
-    pub fn ass_library_init() -> *mut ASS_Library;
-    pub fn ass_library_done(library: *mut ASS_Library);
-    pub fn ass_library_version() -> c_int;
-
-    // Renderer functions
-    pub fn ass_renderer_init(library: *mut ASS_Library) -> *mut ASS_Renderer;
-    pub fn ass_renderer_done(renderer: *mut ASS_Renderer);
-    pub fn ass_set_frame_size(renderer: *mut ASS_Renderer, w: c_int, h: c_int);
-    pub fn ass_set_storage_size(renderer: *mut ASS_Renderer, w: c_int, h: c_int);
-    pub fn ass_set_margins(renderer: *mut ASS_Renderer, t: c_int, b: c_int, l: c_int, r: c_int);
-    pub fn ass_set_use_margins(renderer: *mut ASS_Renderer, use_: c_int);
-    pub fn ass_set_pixel_aspect(renderer: *mut ASS_Renderer, par: c_double);
-    pub fn ass_set_font_scale(renderer: *mut ASS_Renderer, font_scale: c_double);
-    pub fn ass_set_hinting(renderer: *mut ASS_Renderer, ht: c_int);
-    pub fn ass_set_line_spacing(renderer: *mut ASS_Renderer, line_spacing: c_double);
-    pub fn ass_set_line_position(renderer: *mut ASS_Renderer, line_position: c_double);
-
-    // Font configuration
-    pub fn ass_set_fonts(
-        renderer: *mut ASS_Renderer,
-        default_font: *const c_char,
-        default_family: *const c_char,
-        dfp: c_int,
-        config: *const c_char,
-        update: c_int,
-    );
-
-    pub fn ass_fonts_update(renderer: *mut ASS_Renderer) -> c_int;
-    pub fn ass_set_fonts_dir(library: *mut ASS_Library, fonts_dir: *const c_char);
-
-    // Track functions
-    pub fn ass_new_track(library: *mut ASS_Library) -> *mut ASS_Track;
-    pub fn ass_free_track(track: *mut ASS_Track);
-    pub fn ass_process_data(track: *mut ASS_Track, data: *const c_char, size: c_int);
-    pub fn ass_process_chunk(
-        track: *mut ASS_Track,
-        data: *const c_char,
-        size: c_int,
-        timecode: c_long,
-        duration: c_long,
-    );
-    pub fn ass_read_file(
-        library: *mut ASS_Library,
-        fname: *const c_char,
-        codepage: *const c_char,
-    ) -> *mut ASS_Track;
-
-    // Rendering
-    pub fn ass_render_frame(
-        renderer: *mut ASS_Renderer,
-        track: *mut ASS_Track,
-        now: c_long,
-        detect_change: *mut c_int,
-    ) -> *mut ASS_Image;
-}
-
-/// Safe wrapper for libass library
-pub struct LibassLibrary {
-    ptr: *mut ASS_Library,
-}
-
-impl LibassLibrary {
-    pub fn new() -> Option<Self> {
-        unsafe {
-            let ptr = ass_library_init();
-            if ptr.is_null() {
-                None
-            } else {
-                Some(Self { ptr })
-            }
-        }
-    }
-
-    pub fn version() -> i32 {
-        unsafe { ass_library_version() as i32 }
-    }
-
-    pub fn as_ptr(&self) -> *mut ASS_Library {
-        self.ptr
-    }
-
-    pub fn set_fonts_dir(&mut self, path: &str) {
-        let c_path = CString::new(path).unwrap();
-        unsafe {
-            ass_set_fonts_dir(self.ptr, c_path.as_ptr());
-        }
-    }
-}
-
-impl Drop for LibassLibrary {
-    fn drop(&mut self) {
-        unsafe {
-            if !self.ptr.is_null() {
-                ass_library_done(self.ptr);
-            }
-        }
-    }
-}
-
-/// Safe wrapper for libass renderer
-pub struct LibassRenderer {
-    ptr: *mut ASS_Renderer,
-    _library: *mut ASS_Library, // Keep reference to prevent early drop
-}
-
-impl LibassRenderer {
-    pub fn new(library: &LibassLibrary) -> Option<Self> {
-        unsafe {
-            let ptr = ass_renderer_init(library.as_ptr());
-            if ptr.is_null() {
-                None
-            } else {
-                Some(Self {
-                    ptr,
-                    _library: library.as_ptr(),
-                })
-            }
-        }
-    }
-
-    pub fn set_frame_size(&mut self, width: i32, height: i32) {
-        unsafe {
-            ass_set_frame_size(self.ptr, width, height);
-        }
-    }
-
-    pub fn set_storage_size(&mut self, width: i32, height: i32) {
-        unsafe {
-            ass_set_storage_size(self.ptr, width, height);
-        }
-    }
-
-    pub fn set_margins(&mut self, top: i32, bottom: i32, left: i32, right: i32) {
-        unsafe {
-            ass_set_margins(self.ptr, top, bottom, left, right);
-        }
-    }
-
-    pub fn set_use_margins(&mut self, use_margins: bool) {
-        unsafe {
-            ass_set_use_margins(self.ptr, if use_margins { 1 } else { 0 });
-        }
-    }
-
-    pub fn set_pixel_aspect(&mut self, aspect: f64) {
-        unsafe {
-            ass_set_pixel_aspect(self.ptr, aspect);
-        }
-    }
-
-    pub fn set_font_scale(&mut self, scale: f64) {
-        unsafe {
-            ass_set_font_scale(self.ptr, scale);
-        }
-    }
-
-    pub fn set_fonts(&mut self, default_font: Option<&str>, default_family: Option<&str>) {
-        unsafe {
-            let font = default_font
-                .and_then(|s| CString::new(s).ok())
-                .map(|s| s.as_ptr())
-                .unwrap_or(ptr::null());
-
-            let default_family_cstr = CString::new("sans-serif").unwrap();
-            let family = default_family
-                .and_then(|s| CString::new(s).ok())
-                .map(|s| s.as_ptr())
-                .unwrap_or_else(|| default_family_cstr.as_ptr());
-
-            ass_set_fonts(self.ptr, font, family, 1, ptr::null(), 1);
-        }
-    }
-
-    pub fn render_frame(
-        &mut self,
-        track: &mut LibassTrack,
-        time_ms: i64,
-    ) -> Option<Vec<ASS_Image>> {
-        unsafe {
-            let mut change = 0;
-            let image_ptr = ass_render_frame(self.ptr, track.as_ptr(), time_ms, &mut change);
-
-            if image_ptr.is_null() {
-                return None;
-            }
-
-            let mut images = Vec::new();
-            let mut current = image_ptr;
-
-            while !current.is_null() {
-                images.push((*current).clone());
-                current = (*current).next;
-            }
-
-            Some(images)
-        }
-    }
-
-    pub fn as_ptr(&self) -> *mut ASS_Renderer {
-        self.ptr
-    }
-}
-
-impl Drop for LibassRenderer {
-    fn drop(&mut self) {
-        unsafe {
-            if !self.ptr.is_null() {
-                ass_renderer_done(self.ptr);
-            }
-        }
-    }
-}
-
-/// Safe wrapper for libass track
-pub struct LibassTrack {
-    ptr: *mut ASS_Track,
-}
-
-impl LibassTrack {
-    pub fn new(library: &LibassLibrary) -> Option<Self> {
-        unsafe {
-            let ptr = ass_new_track(library.as_ptr());
-            if ptr.is_null() {
-                None
-            } else {
-                Some(Self { ptr })
-            }
-        }
-    }
-
-    pub fn process_data(&mut self, data: &[u8]) {
-        unsafe {
-            ass_process_data(
-                self.ptr,
-                data.as_ptr() as *const c_char,
-                data.len() as c_int,
-            );
-        }
-    }
-
-    pub fn process_chunk(&mut self, data: &str, timecode: i64, duration: i64) {
-        let c_data = CString::new(data).unwrap();
-        unsafe {
-            ass_process_chunk(
-                self.ptr,
-                c_data.as_ptr(),
-                data.len() as c_int,
-                timecode,
-                duration,
-            );
-        }
-    }
-
-    pub fn as_ptr(&mut self) -> *mut ASS_Track {
-        self.ptr
-    }
-}
-
-impl Drop for LibassTrack {
-    fn drop(&mut self) {
-        unsafe {
-            if !self.ptr.is_null() {
-                ass_free_track(self.ptr);
-            }
-        }
-    }
-}
diff --git a/crates/ass-renderer/src/debug/libass_renderer.rs b/crates/ass-renderer/src/debug/libass_renderer.rs
deleted file mode 100644
index c4166f9..0000000
--- a/crates/ass-renderer/src/debug/libass_renderer.rs
+++ /dev/null
@@ -1,250 +0,0 @@
-//! Libass renderer for comparison and debugging
-//!
-//! This module provides a functional libass renderer that can be used
-//! to compare output with our ASS renderer implementation.
-
-#![allow(unsafe_code)] // Required for using FFI bindings
-
-#[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-use super::libass_ffi::{ASS_Image, LibassLibrary, LibassRenderer as FFIRenderer, LibassTrack};
-use crate::{Frame, RenderError};
-use std::path::Path;
-
-/// Libass renderer wrapper for debugging and comparison
-#[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-pub struct LibassRenderer {
-    library: LibassLibrary,
-    renderer: FFIRenderer,
-    track: Option<LibassTrack>,
-    width: u32,
-    height: u32,
-}
-
-#[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-impl LibassRenderer {
-    /// Create a new libass renderer
-    pub fn new(width: u32, height: u32) -> Result<Self, RenderError> {
-        let library = LibassLibrary::new().ok_or_else(|| {
-            RenderError::InitializationError("Failed to initialize libass library".into())
-        })?;
-
-        let mut renderer = FFIRenderer::new(&library).ok_or_else(|| {
-            RenderError::InitializationError("Failed to create libass renderer".into())
-        })?;
-
-        // Configure renderer
-        renderer.set_frame_size(width as i32, height as i32);
-        renderer.set_storage_size(width as i32, height as i32);
-        renderer.set_use_margins(true);
-        renderer.set_pixel_aspect(1.0);
-        renderer.set_font_scale(1.0);
-
-        // Load system fonts
-        renderer.set_fonts(None, Some("sans-serif"));
-
-        println!("Libass version: 0x{:08x}", LibassLibrary::version());
-
-        Ok(Self {
-            library,
-            renderer,
-            track: None,
-            width,
-            height,
-        })
-    }
-
-    /// Load ASS script from string
-    pub fn load_script(&mut self, script_content: &str) -> Result<(), RenderError> {
-        // Create new track
-        let mut track = LibassTrack::new(&self.library)
-            .ok_or_else(|| RenderError::ParseError("Failed to create libass track".into()))?;
-
-        // Process the script content
-        track.process_data(script_content.as_bytes());
-
-        self.track = Some(track);
-        Ok(())
-    }
-
-    /// Load ASS script from file
-    pub fn load_script_file(&mut self, path: &Path) -> Result<(), RenderError> {
-        let content =
-            std::fs::read_to_string(path).map_err(|e| RenderError::IOError(e.to_string()))?;
-        self.load_script(&content)
-    }
-
-    /// Render a frame at the given time (in centiseconds for compatibility)
-    pub fn render_frame(
-        &mut self,
-        script: &ass_core::parser::Script,
-        time_cs: u32,
-    ) -> Result<Frame, RenderError> {
-        // Convert our script to ASS format
-        let ass_content = script.to_ass_string();
-        self.load_script(&ass_content)?;
-
-        let track = self
-            .track
-            .as_mut()
-            .ok_or_else(|| RenderError::InvalidState("No script loaded".into()))?;
-
-        // Convert centiseconds to milliseconds
-        let time_ms = time_cs as i64 * 10;
-
-        // Create RGBA buffer
-        let mut buffer = vec![0u8; (self.width * self.height * 4) as usize];
-
-        // Render with libass
-        if let Some(images) = self.renderer.render_frame(track, time_ms) {
-            // Blend libass images onto buffer
-            for image in images {
-                self.blend_image(&mut buffer, &image);
-            }
-        }
-
-        Ok(Frame::new(buffer.into(), self.width, self.height, time_cs))
-    }
-
-    /// Render a frame at the given time (in milliseconds) - legacy method
-    pub fn render_frame_ms(&mut self, time_ms: i64) -> Result<Vec<u8>, RenderError> {
-        let track = self
-            .track
-            .as_mut()
-            .ok_or_else(|| RenderError::InvalidState("No script loaded".into()))?;
-
-        // Create RGBA buffer
-        let mut buffer = vec![0u8; (self.width * self.height * 4) as usize];
-
-        // Render with libass
-        if let Some(images) = self.renderer.render_frame(track, time_ms) {
-            // Blend libass images onto buffer
-            for image in images {
-                self.blend_image(&mut buffer, &image);
-            }
-        }
-
-        Ok(buffer)
-    }
-
-    /// Render and return as Frame - legacy method
-    pub fn render_to_frame(&mut self, time_ms: i64) -> Result<Frame, RenderError> {
-        let buffer = self.render_frame_ms(time_ms)?;
-        Ok(Frame::new(
-            buffer.into(),
-            self.width,
-            self.height,
-            (time_ms / 10) as u32,
-        ))
-    }
-
-    /// Blend a libass image onto the buffer
-    fn blend_image(&self, buffer: &mut [u8], image: &ASS_Image) {
-        let stride = self.width * 4;
-
-        // Get color from libass image (RGBA format in little-endian)
-        // In libass, color is stored as 0xRRGGBBAA where:
-        // - bits 0-7 (0xFF) = Alpha (0 = opaque, 255 = transparent, needs inversion)
-        // - bits 8-15 (0xFF00) = Blue
-        // - bits 16-23 (0xFF0000) = Green
-        // - bits 24-31 (0xFF000000) = Red
-        let libass_alpha = (image.color & 0xFF) as u8;
-        let a = 255 - libass_alpha; // Invert: libass uses 0=opaque, we need 255=opaque
-        let b = ((image.color >> 8) & 0xFF) as u8;
-        let g = ((image.color >> 16) & 0xFF) as u8;
-        let r = ((image.color >> 24) & 0xFF) as u8;
-
-        // Safety check for bitmap pointer
-        if image.bitmap.is_null() {
-            return;
-        }
-
-        // Get bitmap data
-        let bitmap =
-            unsafe { std::slice::from_raw_parts(image.bitmap, (image.stride * image.h) as usize) };
-
-        // Blend onto buffer
-        for y in 0..image.h {
-            let dst_y = (image.dst_y + y) as usize;
-            if dst_y >= self.height as usize {
-                continue;
-            }
-
-            for x in 0..image.w {
-                let dst_x = (image.dst_x + x) as usize;
-                if dst_x >= self.width as usize {
-                    continue;
-                }
-
-                let src_idx = (y * image.stride + x) as usize;
-                let dst_idx = dst_y * stride as usize + dst_x * 4;
-
-                if src_idx < bitmap.len() && dst_idx + 3 < buffer.len() {
-                    // Get alpha from bitmap (libass uses alpha channel for glyph coverage)
-                    let coverage = bitmap[src_idx] as f32 / 255.0;
-
-                    // Combine glyph coverage with color alpha
-                    let src_alpha = (a as f32 / 255.0) * coverage;
-                    let inv_alpha = 1.0 - src_alpha;
-
-                    // Composite over existing pixel using premultiplied alpha
-                    buffer[dst_idx] =
-                        (buffer[dst_idx] as f32 * inv_alpha + r as f32 * src_alpha) as u8;
-                    buffer[dst_idx + 1] =
-                        (buffer[dst_idx + 1] as f32 * inv_alpha + g as f32 * src_alpha) as u8;
-                    buffer[dst_idx + 2] =
-                        (buffer[dst_idx + 2] as f32 * inv_alpha + b as f32 * src_alpha) as u8;
-                    buffer[dst_idx + 3] = ((buffer[dst_idx + 3] as f32 * (1.0 - inv_alpha)
-                        + src_alpha * 255.0)
-                        .min(255.0)) as u8;
-                }
-            }
-        }
-    }
-
-    /// Update frame size
-    pub fn set_frame_size(&mut self, width: u32, height: u32) {
-        self.width = width;
-        self.height = height;
-        self.renderer.set_frame_size(width as i32, height as i32);
-        self.renderer.set_storage_size(width as i32, height as i32);
-    }
-}
-
-/// Stub implementation when libass-compare feature is disabled or when building for wasm32
-#[cfg(any(not(feature = "libass-compare"), target_arch = "wasm32"))]
-pub struct LibassRenderer;
-
-#[cfg(any(not(feature = "libass-compare"), target_arch = "wasm32"))]
-impl LibassRenderer {
-    pub fn new(_width: u32, _height: u32) -> Result<Self, RenderError> {
-        Err(RenderError::UnsupportedOperation(
-            "libass-compare feature not enabled. Install libass and enable the feature.".into(),
-        ))
-    }
-
-    pub fn load_script(&mut self, _script_content: &str) -> Result<(), RenderError> {
-        Err(RenderError::UnsupportedOperation(
-            "libass-compare feature not enabled".into(),
-        ))
-    }
-
-    pub fn load_script_file(&mut self, _path: &Path) -> Result<(), RenderError> {
-        Err(RenderError::UnsupportedOperation(
-            "libass-compare feature not enabled".into(),
-        ))
-    }
-
-    pub fn render_frame(&mut self, _time_ms: i64) -> Result<Vec<u8>, RenderError> {
-        Err(RenderError::UnsupportedOperation(
-            "libass-compare feature not enabled".into(),
-        ))
-    }
-
-    pub fn render_to_frame(&mut self, _time_ms: i64) -> Result<Frame, RenderError> {
-        Err(RenderError::UnsupportedOperation(
-            "libass-compare feature not enabled".into(),
-        ))
-    }
-
-    pub fn set_frame_size(&mut self, _width: u32, _height: u32) {}
-}
diff --git a/crates/ass-renderer/src/debug/mod.rs b/crates/ass-renderer/src/debug/mod.rs
deleted file mode 100644
index 433dc75..0000000
--- a/crates/ass-renderer/src/debug/mod.rs
+++ /dev/null
@@ -1,564 +0,0 @@
-//! Debug and analysis tools for ASS subtitle rendering
-//!
-//! This module provides comprehensive debugging capabilities including:
-//! - Frame analysis and benchmarking
-//! - Visual comparison tools
-//! - Performance profiling
-//! - Compatibility testing with libass
-
-#![allow(missing_docs)] // Debug module with many internal structures
-
-use crate::{Frame, RenderError};
-
-#[cfg(feature = "nostd")]
-extern crate alloc;
-#[cfg(feature = "nostd")]
-use alloc::collections::BTreeMap as HashMap;
-#[cfg(feature = "nostd")]
-use alloc::{format, string::String, vec::Vec};
-#[cfg(not(feature = "nostd"))]
-use std::format;
-
-/// Frame analysis and reporting tools
-pub mod analyzer;
-/// Color diagnostic utilities
-pub mod color_diagnostic;
-/// Frame inspection tools
-pub mod inspector;
-/// Debug player for subtitle playback
-pub mod player;
-/// Visual comparison utilities
-pub mod visual_comparison;
-
-/// Performance benchmarking tools
-pub mod benchmarking;
-/// libass compatibility testing (native only — requires C libass)
-#[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-pub mod libass_compatibility;
-/// libass FFI bindings (native only — requires C libass)
-#[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-pub mod libass_ffi;
-/// libass renderer wrapper (native only — requires C libass)
-#[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-pub mod libass_renderer;
-/// Pixel-perfect comparison tools (native only — requires C libass)
-#[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-pub mod pixel_perfect_comparison;
-/// Visual report generation (native only — requires C libass)
-#[cfg(all(not(feature = "nostd"), feature = "libass-compare", not(target_arch = "wasm32")))]
-pub mod visual_reporting;
-
-pub use analyzer::{AnalysisReport, FrameAnalyzer};
-pub use benchmarking::{
-    quick_benchmark, BenchmarkConfig, BenchmarkResult, PerformanceBenchmark, PerformanceMetrics,
-};
-pub use inspector::FrameInspector;
-#[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-pub use libass_compatibility::{
-    CompatibilityResult, CompatibilityTestSuite, CompatibilityTester, DiffRegion, DiffType,
-    TestConfig,
-};
-#[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-pub use libass_renderer::LibassRenderer;
-#[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-pub use pixel_perfect_comparison::PixelPerfectComparison;
-#[cfg(all(not(feature = "nostd"), feature = "libass-compare", not(target_arch = "wasm32")))]
-pub use visual_reporting::{generate_compatibility_report, ReportConfig, VisualReportGenerator};
-// #[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-// pub use pixel_perfect_comparison::{
-//     PixelPerfectComparator, PixelComparisonResult, ComparisonConfig,
-//     LibassCompatibilityTester, TestReport
-// };
-pub use player::{DebugPlayer, PlayerFrame};
-
-/// Debug information for a rendered frame
-#[derive(Debug, Clone)]
-pub struct FrameDebugInfo {
-    /// Frame timestamp in milliseconds
-    pub timestamp_ms: u32,
-    /// Number of active subtitle events
-    pub active_events: usize,
-    /// Dirty regions that need re-rendering
-    pub dirty_regions: Vec<DirtyRegionInfo>,
-    /// Time taken to render this frame in milliseconds
-    pub render_time_ms: f64,
-    /// Memory used by frame data in bytes
-    pub memory_usage_bytes: usize,
-    /// Number of cache hits during rendering
-    pub cache_hits: usize,
-    /// Number of cache misses during rendering
-    pub cache_misses: usize,
-    /// Name of the rendering backend used
-    pub backend_type: String,
-    /// Checksum of the frame data for comparison
-    pub frame_checksum: u64,
-    /// Number of non-transparent pixels
-    pub non_transparent_pixels: usize,
-    /// Bounding box of rendered content
-    pub bounding_box: Option<BoundingBoxInfo>,
-}
-
-/// Information about a dirty region that needs re-rendering
-#[derive(Debug, Clone)]
-pub struct DirtyRegionInfo {
-    /// X coordinate of the region
-    pub x: u32,
-    /// Y coordinate of the region
-    pub y: u32,
-    /// Width of the region
-    pub width: u32,
-    /// Height of the region
-    pub height: u32,
-    /// Reason why this region is dirty
-    pub reason: String,
-}
-
-/// Bounding box information for rendered content
-#[derive(Debug, Clone, PartialEq)]
-pub struct BoundingBoxInfo {
-    /// Minimum X coordinate
-    pub min_x: u32,
-    /// Minimum Y coordinate
-    pub min_y: u32,
-    /// Maximum X coordinate
-    pub max_x: u32,
-    /// Maximum Y coordinate
-    pub max_y: u32,
-}
-
-/// Debug renderer that wraps a normal renderer and provides additional debugging info
-pub struct DebugRenderer {
-    /// The wrapped renderer
-    inner: crate::Renderer,
-    /// History of rendered frames with debug info
-    frame_history: Vec<FrameDebugInfo>,
-    /// Whether to add visual debugging overlay
-    enable_visual_overlay: bool,
-    /// Whether to output debug text to console
-    enable_text_output: bool,
-    /// Directory to save debug output files
-    output_dir: Option<String>,
-}
-
-impl DebugRenderer {
-    /// Create a new debug renderer wrapping the given renderer
-    pub fn new(renderer: crate::Renderer) -> Self {
-        Self {
-            inner: renderer,
-            frame_history: Vec::new(),
-            enable_visual_overlay: false,
-            enable_text_output: true,
-            output_dir: None,
-        }
-    }
-
-    /// Enable or disable visual debugging overlay on rendered frames
-    pub fn enable_visual_overlay(&mut self, enable: bool) {
-        self.enable_visual_overlay = enable;
-    }
-
-    /// Enable or disable text debug output to console
-    pub fn enable_text_output(&mut self, enable: bool) {
-        self.enable_text_output = enable;
-    }
-
-    /// Set the directory where debug output files will be saved
-    pub fn set_output_dir(&mut self, dir: &str) {
-        self.output_dir = Some(dir.to_string());
-    }
-
-    /// Render a frame with full debug instrumentation
-    ///
-    /// Returns both the rendered frame and detailed debug information
-    pub fn render_frame_debug(
-        &mut self,
-        script: &ass_core::parser::Script,
-        time_ms: u32,
-    ) -> Result<(Frame, FrameDebugInfo), RenderError> {
-        let start = std::time::Instant::now();
-
-        // Render the frame
-        let frame = self.inner.render_frame(script, time_ms)?;
-
-        let render_time = start.elapsed().as_secs_f64() * 1000.0;
-
-        // Collect debug info
-        let debug_info = self.collect_debug_info(&frame, time_ms, render_time);
-
-        // Store in history
-        self.frame_history.push(debug_info.clone());
-
-        // Output debug info if enabled
-        if self.enable_text_output {
-            self.output_text_debug(&debug_info);
-        }
-
-        // Save visual debug if output dir is set
-        if let Some(ref dir) = self.output_dir {
-            self.save_visual_debug(&frame, &debug_info, dir, time_ms)?;
-        }
-
-        Ok((frame, debug_info))
-    }
-
-    fn collect_debug_info(&self, frame: &Frame, time_ms: u32, render_time: f64) -> FrameDebugInfo {
-        let pixels = frame.pixels();
-        let mut non_transparent = 0;
-        let mut min_x = frame.width();
-        let mut min_y = frame.height();
-        let mut max_x = 0u32;
-        let mut max_y = 0u32;
-
-        // Analyze pixels
-        for y in 0..frame.height() {
-            for x in 0..frame.width() {
-                let idx = ((y * frame.width() + x) * 4) as usize;
-                if idx + 3 < pixels.len() && pixels[idx + 3] > 0 {
-                    non_transparent += 1;
-                    min_x = min_x.min(x);
-                    min_y = min_y.min(y);
-                    max_x = max_x.max(x);
-                    max_y = max_y.max(y);
-                }
-            }
-        }
-
-        let bounding_box = if non_transparent > 0 {
-            Some(BoundingBoxInfo {
-                min_x,
-                min_y,
-                max_x,
-                max_y,
-            })
-        } else {
-            None
-        };
-
-        // Calculate checksum
-        let checksum = calculate_checksum(pixels);
-
-        FrameDebugInfo {
-            timestamp_ms: time_ms,
-            active_events: 0,          // TODO: Get from renderer
-            dirty_regions: Vec::new(), // TODO: Get from renderer
-            render_time_ms: render_time,
-            memory_usage_bytes: pixels.len(),
-            cache_hits: 0,                        // TODO: Get from renderer
-            cache_misses: 0,                      // TODO: Get from renderer
-            backend_type: "Software".to_string(), // TODO: Get from renderer
-            frame_checksum: checksum,
-            non_transparent_pixels: non_transparent,
-            bounding_box,
-        }
-    }
-
-    fn output_text_debug(&self, info: &FrameDebugInfo) {
-        println!("=== Frame Debug Info ===");
-        println!("Timestamp: {}ms", info.timestamp_ms);
-        println!("Render Time: {:.2}ms", info.render_time_ms);
-        println!("Backend: {}", info.backend_type);
-        println!("Active Events: {}", info.active_events);
-        println!("Non-transparent Pixels: {}", info.non_transparent_pixels);
-
-        if let Some(ref bbox) = info.bounding_box {
-            println!(
-                "Bounding Box: ({}, {}) to ({}, {})",
-                bbox.min_x, bbox.min_y, bbox.max_x, bbox.max_y
-            );
-            println!(
-                "  Size: {}x{}",
-                bbox.max_x - bbox.min_x + 1,
-                bbox.max_y - bbox.min_y + 1
-            );
-        }
-
-        println!("Memory: {} KB", info.memory_usage_bytes / 1024);
-        println!("Checksum: 0x{:016x}", info.frame_checksum);
-        println!(
-            "Cache: {} hits, {} misses",
-            info.cache_hits, info.cache_misses
-        );
-
-        if !info.dirty_regions.is_empty() {
-            println!("Dirty Regions:");
-            for region in &info.dirty_regions {
-                println!(
-                    "  - {}x{} at ({}, {}): {}",
-                    region.width, region.height, region.x, region.y, region.reason
-                );
-            }
-        }
-        println!("========================");
-    }
-
-    fn save_visual_debug(
-        &self,
-        frame: &Frame,
-        info: &FrameDebugInfo,
-        dir: &str,
-        time_ms: u32,
-    ) -> Result<(), RenderError> {
-        // Create directory if it doesn't exist
-        #[cfg(not(feature = "nostd"))]
-        std::fs::create_dir_all(dir)
-            .map_err(|e| RenderError::BackendError(format!("Failed to create debug dir: {e}")))?;
-        #[cfg(feature = "nostd")]
-        return Err(RenderError::BackendError(
-            "File operations not supported in no_std".into(),
-        ));
-
-        // Save frame as PNG with debug overlay if enabled
-        if self.enable_visual_overlay {
-            let debug_frame = self.create_debug_overlay(frame, info)?;
-            save_frame_as_png(&debug_frame, &format!("{dir}/frame_{time_ms:06}_debug.png"))?;
-        } else {
-            save_frame_as_png(frame, &format!("{dir}/frame_{time_ms:06}.png"))?;
-        }
-
-        // Save debug info as JSON
-        #[cfg(all(not(feature = "nostd"), feature = "serde"))]
-        {
-            let json_path = format!("{dir}/frame_{time_ms:06}_info.json");
-            let json = serde_json::to_string_pretty(&info).map_err(|e| {
-                RenderError::BackendError(format!("Failed to serialize debug info: {e}"))
-            })?;
-            std::fs::write(json_path, json).map_err(|e| {
-                RenderError::BackendError(format!("Failed to write debug info: {e}"))
-            })?;
-        }
-
-        Ok(())
-    }
-
-    fn create_debug_overlay(
-        &self,
-        frame: &Frame,
-        info: &FrameDebugInfo,
-    ) -> Result<Frame, RenderError> {
-        let mut debug_frame = frame.clone();
-
-        // Draw bounding box
-        if let Some(ref bbox) = info.bounding_box {
-            draw_rectangle(
-                &mut debug_frame,
-                bbox.min_x,
-                bbox.min_y,
-                bbox.max_x - bbox.min_x + 1,
-                bbox.max_y - bbox.min_y + 1,
-                [255, 0, 0, 128],
-            )?;
-        }
-
-        // Draw dirty regions
-        for region in &info.dirty_regions {
-            draw_rectangle(
-                &mut debug_frame,
-                region.x,
-                region.y,
-                region.width,
-                region.height,
-                [0, 255, 0, 128],
-            )?;
-        }
-
-        // Draw info text overlay
-        draw_text_overlay(
-            &mut debug_frame,
-            &format!(
-                "Time: {}ms | Events: {} | Render: {:.1}ms",
-                info.timestamp_ms, info.active_events, info.render_time_ms
-            ),
-            10,
-            10,
-        )?;
-
-        Ok(debug_frame)
-    }
-
-    /// Get the history of rendered frames with debug information
-    pub fn get_frame_history(&self) -> &[FrameDebugInfo] {
-        &self.frame_history
-    }
-
-    /// Clear the frame history
-    pub fn clear_history(&mut self) {
-        self.frame_history.clear();
-    }
-
-    /// Compare two frames from the history by their indices
-    ///
-    /// Returns `None` if either index is out of bounds
-    pub fn compare_frames(&self, idx1: usize, idx2: usize) -> Option<FrameComparison> {
-        if idx1 >= self.frame_history.len() || idx2 >= self.frame_history.len() {
-            return None;
-        }
-
-        let frame1 = &self.frame_history[idx1];
-        let frame2 = &self.frame_history[idx2];
-
-        Some(FrameComparison {
-            checksum_match: frame1.frame_checksum == frame2.frame_checksum,
-            pixel_diff: (frame1.non_transparent_pixels as i32
-                - frame2.non_transparent_pixels as i32)
-                .unsigned_abs(),
-            render_time_diff: frame1.render_time_ms - frame2.render_time_ms,
-            bbox_changed: frame1.bounding_box != frame2.bounding_box,
-        })
-    }
-}
-
-/// Result of comparing two frames
-#[derive(Debug)]
-pub struct FrameComparison {
-    /// Whether the frame checksums match
-    pub checksum_match: bool,
-    /// Difference in non-transparent pixel count
-    pub pixel_diff: u32,
-    /// Difference in render time (milliseconds)
-    pub render_time_diff: f64,
-    /// Whether the bounding boxes differ
-    pub bbox_changed: bool,
-}
-
-fn calculate_checksum(pixels: &[u8]) -> u64 {
-    #[cfg(not(feature = "nostd"))]
-    use std::collections::hash_map::DefaultHasher;
-    #[cfg(not(feature = "nostd"))]
-    use std::hash::{Hash, Hasher};
-
-    #[cfg(feature = "nostd")]
-    use core::hash::{Hash, Hasher};
-    #[cfg(feature = "nostd")]
-    struct DefaultHasher(u64);
-
-    #[cfg(feature = "nostd")]
-    impl DefaultHasher {
-        fn new() -> Self {
-            DefaultHasher(0)
-        }
-        fn finish(&self) -> u64 {
-            self.0
-        }
-    }
-
-    #[cfg(feature = "nostd")]
-    impl Hasher for DefaultHasher {
-        fn write(&mut self, bytes: &[u8]) {
-            for &b in bytes {
-                self.0 = self.0.wrapping_mul(31).wrapping_add(b as u64);
-            }
-        }
-
-        fn finish(&self) -> u64 {
-            self.0
-        }
-    }
-
-    let mut hasher = DefaultHasher::new();
-    pixels.hash(&mut hasher);
-    hasher.finish()
-}
-
-fn save_frame_as_png(frame: &Frame, path: &str) -> Result<(), RenderError> {
-    #[cfg(feature = "image")]
-    {
-        use image::{ImageBuffer, Rgba};
-
-        let img = ImageBuffer::<Rgba<u8>, Vec<u8>>::from_raw(
-            frame.width(),
-            frame.height(),
-            frame.pixels().to_vec(),
-        )
-        .ok_or_else(|| RenderError::BackendError("Failed to create image buffer".into()))?;
-
-        img.save(path)
-            .map_err(|e| RenderError::BackendError(format!("Failed to save PNG: {e}")))?;
-    }
-
-    #[cfg(not(feature = "image"))]
-    {
-        let _ = (frame, path);
-        // Silent no-op if image feature is not enabled
-    }
-
-    Ok(())
-}
-
-fn draw_rectangle(
-    frame: &mut Frame,
-    x: u32,
-    y: u32,
-    width: u32,
-    height: u32,
-    color: [u8; 4],
-) -> Result<(), RenderError> {
-    // TODO: Implement rectangle drawing
-    let _ = (frame, x, y, width, height, color);
-    Ok(())
-}
-
-fn draw_text_overlay(frame: &mut Frame, text: &str, x: u32, y: u32) -> Result<(), RenderError> {
-    // TODO: Implement text overlay
-    let _ = (frame, text, x, y);
-    Ok(())
-}
-
-// Make FrameDebugInfo serializable
-#[cfg(feature = "serde")]
-impl serde::Serialize for FrameDebugInfo {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-
-        let mut state = serializer.serialize_struct("FrameDebugInfo", 11)?;
-        state.serialize_field("timestamp_ms", &self.timestamp_ms)?;
-        state.serialize_field("active_events", &self.active_events)?;
-        state.serialize_field("dirty_regions", &self.dirty_regions)?;
-        state.serialize_field("render_time_ms", &self.render_time_ms)?;
-        state.serialize_field("memory_usage_bytes", &self.memory_usage_bytes)?;
-        state.serialize_field("cache_hits", &self.cache_hits)?;
-        state.serialize_field("cache_misses", &self.cache_misses)?;
-        state.serialize_field("backend_type", &self.backend_type)?;
-        state.serialize_field("frame_checksum", &format!("0x{:016x}", self.frame_checksum))?;
-        state.serialize_field("non_transparent_pixels", &self.non_transparent_pixels)?;
-        state.serialize_field("bounding_box", &self.bounding_box)?;
-        state.end()
-    }
-}
-
-#[cfg(feature = "serde")]
-impl serde::Serialize for DirtyRegionInfo {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-
-        let mut state = serializer.serialize_struct("DirtyRegionInfo", 5)?;
-        state.serialize_field("x", &self.x)?;
-        state.serialize_field("y", &self.y)?;
-        state.serialize_field("width", &self.width)?;
-        state.serialize_field("height", &self.height)?;
-        state.serialize_field("reason", &self.reason)?;
-        state.end()
-    }
-}
-
-#[cfg(feature = "serde")]
-impl serde::Serialize for BoundingBoxInfo {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-
-        let mut state = serializer.serialize_struct("BoundingBoxInfo", 4)?;
-        state.serialize_field("min_x", &self.min_x)?;
-        state.serialize_field("min_y", &self.min_y)?;
-        state.serialize_field("max_x", &self.max_x)?;
-        state.serialize_field("max_y", &self.max_y)?;
-        state.end()
-    }
-}
diff --git a/crates/ass-renderer/src/debug/pixel_perfect_comparison.rs b/crates/ass-renderer/src/debug/pixel_perfect_comparison.rs
deleted file mode 100644
index f61075b..0000000
--- a/crates/ass-renderer/src/debug/pixel_perfect_comparison.rs
+++ /dev/null
@@ -1,141 +0,0 @@
-//! Pixel-perfect comparison utilities for frame analysis
-
-#[cfg(feature = "nostd")]
-use alloc::vec::Vec;
-#[cfg(not(feature = "nostd"))]
-use std::vec::Vec;
-
-/// Result of pixel-perfect comparison between two frames
-#[derive(Debug, Clone)]
-pub struct PixelPerfectComparison {
-    /// Percentage of pixels that differ (0.0 = identical, 1.0 = completely different)
-    pub pixel_diff_percentage: f64,
-    /// Maximum difference in any pixel value (0-255)
-    pub max_pixel_diff: u8,
-    /// Average difference across all pixels
-    pub avg_pixel_diff: f64,
-    /// Total number of different pixels
-    pub different_pixels: usize,
-    /// Optional difference map (per-pixel difference values)
-    pub difference_map: Option<Vec<u8>>,
-}
-
-impl PixelPerfectComparison {
-    /// Compare two frames pixel by pixel
-    pub fn compare_frames(frame1_data: &[u8], frame2_data: &[u8], width: u32, height: u32) -> Self {
-        let total_pixels = (width * height) as usize;
-        let expected_len = total_pixels * 4; // RGBA
-
-        // Ensure both frames have the same size
-        if frame1_data.len() != expected_len || frame2_data.len() != expected_len {
-            return Self {
-                pixel_diff_percentage: 1.0, // Complete difference if sizes don't match
-                max_pixel_diff: 255,
-                avg_pixel_diff: 255.0,
-                different_pixels: total_pixels,
-                difference_map: None,
-            };
-        }
-
-        let mut different_pixels = 0;
-        let mut max_diff = 0u8;
-        let mut total_diff = 0u64;
-        let mut diff_map = Vec::with_capacity(total_pixels);
-
-        // Compare pixels
-        for pixel_idx in 0..total_pixels {
-            let base_idx = pixel_idx * 4;
-
-            // Calculate difference for this pixel (RGBA)
-            let r_diff = (frame1_data[base_idx] as i16 - frame2_data[base_idx] as i16).abs();
-            let g_diff =
-                (frame1_data[base_idx + 1] as i16 - frame2_data[base_idx + 1] as i16).abs();
-            let b_diff =
-                (frame1_data[base_idx + 2] as i16 - frame2_data[base_idx + 2] as i16).abs();
-            let a_diff =
-                (frame1_data[base_idx + 3] as i16 - frame2_data[base_idx + 3] as i16).abs();
-
-            // Use maximum component difference as pixel difference
-            let pixel_diff = r_diff.max(g_diff).max(b_diff).max(a_diff) as u8;
-            diff_map.push(pixel_diff);
-
-            if pixel_diff > 0 {
-                different_pixels += 1;
-                max_diff = max_diff.max(pixel_diff);
-                total_diff += pixel_diff as u64;
-            }
-        }
-
-        let pixel_diff_percentage = different_pixels as f64 / total_pixels as f64;
-        let avg_pixel_diff = if different_pixels > 0 {
-            total_diff as f64 / different_pixels as f64
-        } else {
-            0.0
-        };
-
-        Self {
-            pixel_diff_percentage,
-            max_pixel_diff: max_diff,
-            avg_pixel_diff,
-            different_pixels,
-            difference_map: Some(diff_map),
-        }
-    }
-
-    /// Compare frames with tolerance for small differences
-    pub fn compare_frames_with_tolerance(
-        frame1_data: &[u8],
-        frame2_data: &[u8],
-        width: u32,
-        height: u32,
-        tolerance: u8,
-    ) -> Self {
-        let mut comparison = Self::compare_frames(frame1_data, frame2_data, width, height);
-
-        // Apply tolerance - pixels within tolerance are considered identical
-        if let Some(ref mut diff_map) = comparison.difference_map {
-            let mut adjusted_different_pixels = 0;
-            let mut adjusted_total_diff = 0u64;
-            let mut adjusted_max_diff = 0u8;
-
-            for diff in diff_map.iter_mut() {
-                if *diff <= tolerance {
-                    *diff = 0; // Consider as identical
-                } else {
-                    adjusted_different_pixels += 1;
-                    adjusted_total_diff += *diff as u64;
-                    adjusted_max_diff = adjusted_max_diff.max(*diff);
-                }
-            }
-
-            let total_pixels = (width * height) as usize;
-            comparison.pixel_diff_percentage =
-                adjusted_different_pixels as f64 / total_pixels as f64;
-            comparison.different_pixels = adjusted_different_pixels;
-            comparison.max_pixel_diff = adjusted_max_diff;
-            comparison.avg_pixel_diff = if adjusted_different_pixels > 0 {
-                adjusted_total_diff as f64 / adjusted_different_pixels as f64
-            } else {
-                0.0
-            };
-        }
-
-        comparison
-    }
-
-    /// Check if frames are considered identical within given thresholds
-    pub fn are_frames_compatible(&self, max_diff_percentage: f64, max_pixel_diff: u8) -> bool {
-        self.pixel_diff_percentage <= max_diff_percentage && self.max_pixel_diff <= max_pixel_diff
-    }
-
-    /// Get a summary string of the comparison results
-    pub fn summary(&self) -> String {
-        format!(
-            "Diff: {:.3}% ({} pixels), Max: {}, Avg: {:.1}",
-            self.pixel_diff_percentage * 100.0,
-            self.different_pixels,
-            self.max_pixel_diff,
-            self.avg_pixel_diff
-        )
-    }
-}
diff --git a/crates/ass-renderer/src/debug/player.rs b/crates/ass-renderer/src/debug/player.rs
deleted file mode 100644
index 47981e8..0000000
--- a/crates/ass-renderer/src/debug/player.rs
+++ /dev/null
@@ -1,620 +0,0 @@
-use crate::{Frame, RenderContext, RenderError, Renderer};
-use ass_core::parser::Script;
-
-#[cfg(not(feature = "nostd"))]
-use std::collections::HashMap;
-#[cfg(not(feature = "nostd"))]
-use std::time::{Duration, Instant};
-
-#[cfg(feature = "nostd")]
-use alloc::collections::BTreeMap as HashMap;
-#[cfg(feature = "nostd")]
-use alloc::string::String;
-#[cfg(feature = "nostd")]
-use alloc::vec::Vec;
-
-/// Debug player for visual verification of subtitle rendering
-pub struct DebugPlayer {
-    renderer: Renderer,
-    script_content: Option<String>,
-    #[allow(dead_code)] // if we fix the debug stuff later, we'll use this
-    parsed_script: Option<Script<'static>>,
-    current_time_ms: u32,
-    playback_speed: f32,
-    is_playing: bool,
-    frame_interval_ms: u32,
-    output_dir: String,
-    save_frames: bool,
-    show_stats: bool,
-    loop_playback: bool,
-    start_time_ms: u32,
-    end_time_ms: u32,
-    frame_cache: HashMap<u32, Frame>,
-    cache_enabled: bool,
-    max_cache_size: usize,
-    // Timing fields for proper synchronization
-    playback_start_instant: Option<Instant>,
-    playback_start_time_ms: u32,
-    accumulated_time_ms: f32,
-    width: u32,
-    height: u32,
-}
-
-impl DebugPlayer {
-    pub fn new(width: u32, height: u32) -> Result<Self, RenderError> {
-        let context = RenderContext::new(width, height);
-
-        let renderer = Renderer::new(context)?;
-
-        Ok(Self {
-            renderer,
-            script_content: None,
-            parsed_script: None,
-            current_time_ms: 0,
-            playback_speed: 1.0,
-            is_playing: false,
-            frame_interval_ms: 40, // ~25 FPS for subtitle granularity
-            output_dir: "debug_player_output".to_string(),
-            save_frames: false,
-            show_stats: true,
-            loop_playback: false,
-            start_time_ms: 0,
-            end_time_ms: 0, // Default to 0, will be set when script is loaded
-            frame_cache: HashMap::new(),
-            cache_enabled: true,
-            max_cache_size: 100, // Cache up to 100 frames
-            playback_start_instant: None,
-            playback_start_time_ms: 0,
-            accumulated_time_ms: 0.0,
-            width,
-            height,
-        })
-    }
-
-    pub fn width(&self) -> u32 {
-        self.width
-    }
-
-    pub fn height(&self) -> u32 {
-        self.height
-    }
-
-    /// Check if a script is currently loaded
-    pub fn has_script(&self) -> bool {
-        self.script_content.is_some()
-    }
-
-    /// Get the current end time in milliseconds
-    pub fn duration_ms(&self) -> u32 {
-        self.end_time_ms
-    }
-
-    pub fn load_script(&mut self, script_content: &str) -> Result<(), RenderError> {
-        // Parse and store the script to avoid re-parsing on every frame
-        let owned_content = script_content.to_string();
-        let script = Script::parse(&owned_content)
-            .map_err(|e| RenderError::ParseError(format!("Failed to parse script: {e:?}")))?;
-
-        // Calculate actual end time from events
-        let mut max_time = 0u32;
-        let mut event_count = 0;
-        for section in script.sections() {
-            if let ass_core::parser::Section::Events(events) = section {
-                for event in events.iter() {
-                    event_count += 1;
-                    if let Ok(end) = event.end_time_cs() {
-                        max_time = max_time.max(end * 10); // Convert centiseconds to milliseconds
-                    }
-                }
-            }
-        }
-
-        if max_time > 0 {
-            self.end_time_ms = max_time;
-        } else {
-            // If no events found or all events have no end time,
-            // set a reasonable default duration (10 seconds)
-            self.end_time_ms = 10000;
-        }
-
-        // Clear cache when loading new script
-        self.frame_cache.clear();
-
-        // Store both the content and parsed script
-        self.script_content = Some(owned_content);
-        // Note: We can't store the parsed script due to lifetime issues
-        // We'll need to parse on demand but cache rendered frames
-
-        println!(
-            "Script loaded. Duration: {duration}ms, Events: {events}",
-            duration = self.end_time_ms,
-            events = event_count
-        );
-
-        Ok(())
-    }
-
-    pub fn set_cache_enabled(&mut self, enabled: bool) {
-        self.cache_enabled = enabled;
-        if !enabled {
-            self.frame_cache.clear();
-        }
-    }
-
-    pub fn set_max_cache_size(&mut self, size: usize) {
-        self.max_cache_size = size;
-        // Trim cache if needed
-        while self.frame_cache.len() > size {
-            // Remove oldest entries (not optimal but simple)
-            if let Some(&min_key) = self.frame_cache.keys().min() {
-                self.frame_cache.remove(&min_key);
-            }
-        }
-    }
-
-    pub fn play(&mut self) {
-        self.is_playing = true;
-        self.playback_start_instant = Some(Instant::now());
-        self.playback_start_time_ms = self.current_time_ms;
-        self.accumulated_time_ms = 0.0;
-        println!(
-            "▶️  Playback started at {current_time}ms",
-            current_time = self.current_time_ms
-        );
-    }
-
-    pub fn pause(&mut self) {
-        if self.is_playing {
-            // Save accumulated time
-            if let Some(start) = self.playback_start_instant {
-                let elapsed = start.elapsed().as_secs_f32() * 1000.0 * self.playback_speed;
-                self.accumulated_time_ms += elapsed;
-            }
-        }
-        self.is_playing = false;
-        self.playback_start_instant = None;
-        println!(
-            "⏸️  Playback paused at {current_time}ms",
-            current_time = self.current_time_ms
-        );
-    }
-
-    pub fn stop(&mut self) {
-        self.is_playing = false;
-        self.current_time_ms = self.start_time_ms;
-        self.playback_start_instant = None;
-        self.accumulated_time_ms = 0.0;
-        println!("⏹️  Playback stopped");
-    }
-
-    pub fn seek(&mut self, time_ms: u32) {
-        self.current_time_ms = time_ms.min(self.end_time_ms);
-        if self.is_playing {
-            self.playback_start_instant = Some(Instant::now());
-            self.playback_start_time_ms = self.current_time_ms;
-            self.accumulated_time_ms = 0.0;
-        }
-        println!(
-            "⏩ Seeked to {current_time}ms",
-            current_time = self.current_time_ms
-        );
-    }
-
-    pub fn set_speed(&mut self, speed: f32) {
-        // If playing, update the accumulated time before changing speed
-        if self.is_playing {
-            if let Some(start) = self.playback_start_instant {
-                let elapsed = start.elapsed().as_secs_f32() * 1000.0 * self.playback_speed;
-                self.accumulated_time_ms += elapsed;
-                self.playback_start_instant = Some(Instant::now());
-                self.playback_start_time_ms = self.current_time_ms;
-            }
-        }
-        self.playback_speed = speed.clamp(0.1, 10.0);
-        println!("🎚️  Playback speed: {speed}x", speed = self.playback_speed);
-    }
-
-    pub fn step_forward(&mut self) {
-        self.current_time_ms =
-            (self.current_time_ms + self.frame_interval_ms).min(self.end_time_ms);
-        if self.is_playing {
-            self.playback_start_instant = Some(Instant::now());
-            self.playback_start_time_ms = self.current_time_ms;
-            self.accumulated_time_ms = 0.0;
-        }
-        println!(
-            "⏭️  Step forward to {current_time}ms",
-            current_time = self.current_time_ms
-        );
-    }
-
-    pub fn step_backward(&mut self) {
-        self.current_time_ms = self.current_time_ms.saturating_sub(self.frame_interval_ms);
-        if self.is_playing {
-            self.playback_start_instant = Some(Instant::now());
-            self.playback_start_time_ms = self.current_time_ms;
-            self.accumulated_time_ms = 0.0;
-        }
-        println!(
-            "⏮️  Step backward to {current_time}ms",
-            current_time = self.current_time_ms
-        );
-    }
-
-    pub fn toggle_stats(&mut self) {
-        self.show_stats = !self.show_stats;
-        println!(
-            "📊 Stats display: {}",
-            if self.show_stats { "ON" } else { "OFF" }
-        );
-    }
-
-    pub fn toggle_frame_saving(&mut self) {
-        self.save_frames = !self.save_frames;
-        if self.save_frames {
-            #[cfg(not(feature = "nostd"))]
-            std::fs::create_dir_all(&self.output_dir).ok();
-            println!(
-                "💾 Frame saving: ON (to {output_dir})",
-                output_dir = self.output_dir
-            );
-        } else {
-            println!("💾 Frame saving: OFF");
-        }
-    }
-
-    pub fn set_loop(&mut self, enable: bool) {
-        self.loop_playback = enable;
-        println!(
-            "🔁 Loop playback: {status}",
-            status = if enable { "ON" } else { "OFF" }
-        );
-    }
-
-    pub fn set_output_dir(&mut self, dir: &str) {
-        self.output_dir = dir.to_string();
-        println!("📁 Output directory set to: {dir}");
-    }
-
-    pub fn is_playing(&self) -> bool {
-        self.is_playing
-    }
-
-    pub fn current_time(&self) -> u32 {
-        self.current_time_ms
-    }
-
-    pub fn toggle_loop(&mut self) {
-        self.loop_playback = !self.loop_playback;
-        let loop_status = if self.loop_playback { "ON" } else { "OFF" };
-        println!("🔁 Loop: {loop_status}");
-    }
-
-    pub fn increase_speed(&mut self) {
-        let new_speed = (self.playback_speed * 1.5).min(10.0);
-        self.set_speed(new_speed);
-    }
-
-    pub fn decrease_speed(&mut self) {
-        let new_speed = (self.playback_speed / 1.5).max(0.1);
-        self.set_speed(new_speed);
-    }
-
-    pub fn render_current_frame(&mut self) -> Result<PlayerFrame, RenderError> {
-        // Check cache first if enabled
-        if self.cache_enabled {
-            // Round to nearest frame interval for better cache hits
-            let cache_key =
-                (self.current_time_ms / self.frame_interval_ms) * self.frame_interval_ms;
-
-            if let Some(cached_frame) = self.frame_cache.get(&cache_key) {
-                let player_frame = PlayerFrame {
-                    frame: cached_frame.clone(),
-                    timestamp_ms: self.current_time_ms,
-                    render_time: Duration::from_micros(100), // Cached, so very fast
-                    frame_number: (self.current_time_ms / self.frame_interval_ms),
-                };
-
-                if self.show_stats {
-                    println!("📦 Using cached frame for {cache_key}ms");
-                }
-
-                return Ok(player_frame);
-            }
-        }
-
-        let script_content = self
-            .script_content
-            .as_ref()
-            .ok_or_else(|| RenderError::InvalidInput("No script loaded".into()))?;
-
-        let script = Script::parse(script_content)
-            .map_err(|e| RenderError::ParseError(format!("Failed to parse script: {e:?}")))?;
-
-        let start = Instant::now();
-        // Convert milliseconds to centiseconds for the renderer
-        let time_cs = self.current_time_ms / 10;
-        let frame = self.renderer.render_frame(&script, time_cs)?;
-        let render_time = start.elapsed();
-
-        // Cache the frame if enabled
-        if self.cache_enabled {
-            let cache_key =
-                (self.current_time_ms / self.frame_interval_ms) * self.frame_interval_ms;
-
-            // Maintain cache size limit
-            if self.frame_cache.len() >= self.max_cache_size {
-                // Remove oldest entry
-                if let Some(&min_key) = self.frame_cache.keys().min() {
-                    self.frame_cache.remove(&min_key);
-                }
-            }
-
-            self.frame_cache.insert(cache_key, frame.clone());
-        }
-
-        let player_frame = PlayerFrame {
-            frame: frame.clone(),
-            timestamp_ms: self.current_time_ms,
-            render_time,
-            frame_number: (self.current_time_ms / self.frame_interval_ms),
-        };
-
-        if self.show_stats {
-            self.print_frame_stats(&player_frame);
-        }
-
-        if self.save_frames {
-            self.save_frame(&player_frame)?;
-        }
-
-        Ok(player_frame)
-    }
-
-    pub fn update(&mut self, _delta_time: Duration) -> Result<Option<PlayerFrame>, RenderError> {
-        if !self.is_playing {
-            return Ok(None);
-        }
-
-        // Calculate the actual timeline position based on real elapsed time
-        if let Some(start_instant) = self.playback_start_instant {
-            let elapsed_ms = start_instant.elapsed().as_secs_f32() * 1000.0 * self.playback_speed;
-            self.current_time_ms =
-                self.playback_start_time_ms + (elapsed_ms + self.accumulated_time_ms) as u32;
-
-            if self.current_time_ms >= self.end_time_ms {
-                if self.loop_playback {
-                    self.current_time_ms = self.start_time_ms;
-                    self.playback_start_instant = Some(Instant::now());
-                    self.playback_start_time_ms = self.start_time_ms;
-                    self.accumulated_time_ms = 0.0;
-                    println!("🔁 Looping playback");
-                } else {
-                    self.is_playing = false;
-                    self.current_time_ms = self.end_time_ms;
-                    self.playback_start_instant = None;
-                    println!("✅ Playback finished");
-                    return Ok(None);
-                }
-            }
-        }
-
-        self.render_current_frame().map(Some)
-    }
-
-    fn print_frame_stats(&self, player_frame: &PlayerFrame) {
-        let pixels = player_frame.frame.pixels();
-        let mut non_transparent = 0;
-
-        for chunk in pixels.chunks(4) {
-            if chunk.len() == 4 && chunk[3] > 0 {
-                non_transparent += 1;
-            }
-        }
-
-        println!("┌────────────────────────────────────┐");
-        println!(
-            "│ Frame #{:06} @ {:02}:{:02}.{:03}        │",
-            player_frame.frame_number,
-            self.current_time_ms / 60000,
-            (self.current_time_ms / 1000) % 60,
-            self.current_time_ms % 1000
-        );
-        println!("├────────────────────────────────────┤");
-        println!(
-            "│ Render: {:.2}ms                    │",
-            player_frame.render_time.as_secs_f64() * 1000.0
-        );
-        println!("│ Visible pixels: {non_transparent:6}            │");
-        println!(
-            "│ Speed: {:.1}x | Progress: {:3.1}%    │",
-            self.playback_speed,
-            (self.current_time_ms as f32 / self.end_time_ms as f32) * 100.0
-        );
-        println!("└────────────────────────────────────┘");
-    }
-
-    fn save_frame(&self, player_frame: &PlayerFrame) -> Result<(), RenderError> {
-        #[cfg(feature = "image")]
-        {
-            let path = format!(
-                "{}/frame_{:06}_{:06}ms.png",
-                self.output_dir, player_frame.frame_number, player_frame.timestamp_ms
-            );
-
-            use image::{ImageBuffer, Rgba};
-
-            let img = ImageBuffer::<Rgba<u8>, Vec<u8>>::from_raw(
-                player_frame.frame.width(),
-                player_frame.frame.height(),
-                player_frame.frame.pixels().to_vec(),
-            )
-            .ok_or_else(|| RenderError::BackendError("Failed to create image buffer".into()))?;
-
-            img.save(&path)
-                .map_err(|e| RenderError::BackendError(format!("Failed to save frame: {e}")))?;
-        }
-
-        #[cfg(not(feature = "image"))]
-        {
-            let _ = player_frame;
-        }
-
-        Ok(())
-    }
-
-    pub fn run_automatic_test(&mut self, test_points: Vec<u32>) -> Result<TestReport, RenderError> {
-        let script_content = self
-            .script_content
-            .as_ref()
-            .ok_or_else(|| RenderError::InvalidInput("No script loaded".into()))?;
-
-        let script = Script::parse(script_content)
-            .map_err(|e| RenderError::ParseError(format!("Failed to parse script: {e:?}")))?;
-
-        let mut report = TestReport {
-            test_points: Vec::new(),
-            total_render_time: Duration::ZERO,
-            frames_with_content: 0,
-            frames_empty: 0,
-            average_render_time_ms: 0.0,
-        };
-
-        println!(
-            "\n🧪 Running automatic test at {} points",
-            test_points.len()
-        );
-
-        for time_ms in test_points {
-            println!("  Testing at {time_ms}ms...");
-
-            let start = Instant::now();
-            // Convert milliseconds to centiseconds for the renderer
-            let time_cs = time_ms / 10;
-            let frame = self.renderer.render_frame(&script, time_cs)?;
-            let render_time = start.elapsed();
-
-            let pixels = frame.pixels();
-            let mut has_content = false;
-
-            for chunk in pixels.chunks(4) {
-                if chunk.len() == 4 && chunk[3] > 0 {
-                    has_content = true;
-                    break;
-                }
-            }
-
-            if has_content {
-                report.frames_with_content += 1;
-            } else {
-                report.frames_empty += 1;
-            }
-
-            report.test_points.push(TestPoint {
-                timestamp_ms: time_ms,
-                render_time,
-                has_visible_content: has_content,
-            });
-
-            report.total_render_time += render_time;
-        }
-
-        if !report.test_points.is_empty() {
-            report.average_render_time_ms =
-                report.total_render_time.as_secs_f64() * 1000.0 / report.test_points.len() as f64;
-        }
-
-        report.print_summary();
-
-        Ok(report)
-    }
-}
-
-pub struct PlayerFrame {
-    pub frame: Frame,
-    pub timestamp_ms: u32,
-    pub render_time: Duration,
-    pub frame_number: u32,
-}
-
-#[derive(Debug)]
-pub struct TestReport {
-    pub test_points: Vec<TestPoint>,
-    pub total_render_time: Duration,
-    pub frames_with_content: usize,
-    pub frames_empty: usize,
-    pub average_render_time_ms: f64,
-}
-
-impl TestReport {
-    pub fn print_summary(&self) {
-        println!("\n╔════════════════════════════════════════╗");
-        println!("║         Test Report Summary            ║");
-        println!("╚════════════════════════════════════════╝");
-
-        println!("\n📈 Overall Statistics:");
-        let test_points_len = self.test_points.len();
-        println!("  • Test points: {test_points_len}");
-        println!(
-            "  • Frames with content: {} ({:.1}%)",
-            self.frames_with_content,
-            (self.frames_with_content as f32 / self.test_points.len() as f32) * 100.0
-        );
-        println!(
-            "  • Empty frames: {} ({:.1}%)",
-            self.frames_empty,
-            (self.frames_empty as f32 / self.test_points.len() as f32) * 100.0
-        );
-        println!(
-            "  • Average render time: {:.2}ms",
-            self.average_render_time_ms
-        );
-        println!(
-            "  • Total render time: {:.2}ms",
-            self.total_render_time.as_secs_f64() * 1000.0
-        );
-
-        println!("\n📊 Performance Distribution:");
-        let mut fast = 0;
-        let mut normal = 0;
-        let mut slow = 0;
-
-        for point in &self.test_points {
-            let ms = point.render_time.as_secs_f64() * 1000.0;
-            if ms < 5.0 {
-                fast += 1;
-            } else if ms < 15.0 {
-                normal += 1;
-            } else {
-                slow += 1;
-            }
-        }
-
-        println!("  • Fast (<5ms): {fast}");
-        println!("  • Normal (5-15ms): {normal}");
-        println!("  • Slow (>15ms): {slow}");
-
-        println!("\n🔍 Individual Test Points:");
-        for point in &self.test_points {
-            println!(
-                "  • {:6}ms: {:.2}ms render | {}",
-                point.timestamp_ms,
-                point.render_time.as_secs_f64() * 1000.0,
-                if point.has_visible_content {
-                    "✓ visible"
-                } else {
-                    "✗ empty"
-                }
-            );
-        }
-
-        println!("\n═══════════════════════════════════════");
-    }
-}
-
-#[derive(Debug)]
-pub struct TestPoint {
-    pub timestamp_ms: u32,
-    pub render_time: Duration,
-    pub has_visible_content: bool,
-}
diff --git a/crates/ass-renderer/src/debug/visual_comparison.rs b/crates/ass-renderer/src/debug/visual_comparison.rs
deleted file mode 100644
index fec194f..0000000
--- a/crates/ass-renderer/src/debug/visual_comparison.rs
+++ /dev/null
@@ -1,379 +0,0 @@
-//! Visual comparison and debugging tools for ASS rendering
-
-use crate::utils::RenderError;
-use ass_core::Script;
-use tiny_skia::{Color, Paint, Pixmap, Stroke, Transform};
-
-#[cfg(all(not(feature = "nostd"), feature = "serde"))]
-use std::{fs, path::Path};
-
-/// Visual debug info for rendering comparison
-#[derive(Debug, Clone)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize))]
-pub struct RenderDebugInfo {
-    /// Font size as calculated
-    pub calculated_font_size: f32,
-    /// Font size after PlayRes scaling
-    pub scaled_font_size: f32,
-    /// PlayResX value
-    pub play_res_x: u32,
-    /// PlayResY value
-    pub play_res_y: u32,
-    /// Render resolution
-    pub render_width: u32,
-    pub render_height: u32,
-    /// Color in BBGGRR format (as hex string)
-    pub color_bbggrr: String,
-    /// Converted RGBA values
-    pub color_rgba: [u8; 4],
-    /// Font metrics
-    pub font_metrics: FontMetricsDebug,
-    /// Text bounding box
-    pub text_bbox: BoundingBoxDebug,
-    /// Animation progress
-    pub animation_progress: Option<f32>,
-}
-
-#[derive(Debug, Clone)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize))]
-pub struct FontMetricsDebug {
-    pub ascender: f32,
-    pub descender: f32,
-    pub line_gap: f32,
-    pub units_per_em: f32,
-    pub scale_factor: f32,
-}
-
-#[derive(Debug, Clone)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize))]
-pub struct BoundingBoxDebug {
-    pub x: f32,
-    pub y: f32,
-    pub width: f32,
-    pub height: f32,
-}
-
-/// Visual comparison renderer
-pub struct VisualComparison {
-    width: u32,
-    height: u32,
-    debug_enabled: bool,
-    debug_info: Vec<RenderDebugInfo>,
-}
-
-impl VisualComparison {
-    pub fn new(width: u32, height: u32) -> Self {
-        Self {
-            width,
-            height,
-            debug_enabled: true,
-            debug_info: Vec::new(),
-        }
-    }
-
-    /// Enable/disable debug mode
-    pub fn set_debug(&mut self, enabled: bool) {
-        self.debug_enabled = enabled;
-    }
-
-    /// Render with debug overlay
-    pub fn render_with_debug(
-        &mut self,
-        script: &Script,
-        _time_ms: u32,
-    ) -> Result<Pixmap, RenderError> {
-        // Clear debug info
-        self.debug_info.clear();
-
-        // Get script info
-        use ass_core::parser::ast::SectionType;
-        let play_res_x = if let Some(ass_core::parser::ast::Section::ScriptInfo(info)) =
-            script.find_section(SectionType::ScriptInfo)
-        {
-            info.get_field("PlayResX")
-                .and_then(|v| v.parse::<u32>().ok())
-                .unwrap_or(384)
-        } else {
-            384
-        };
-        let play_res_y = if let Some(ass_core::parser::ast::Section::ScriptInfo(info)) =
-            script.find_section(SectionType::ScriptInfo)
-        {
-            info.get_field("PlayResY")
-                .and_then(|v| v.parse::<u32>().ok())
-                .unwrap_or(288)
-        } else {
-            288
-        };
-
-        // Create a basic pixmap for now - full rendering would require more setup
-        let mut pixmap = Pixmap::new(self.width, self.height).ok_or(RenderError::InvalidPixmap)?;
-
-        if self.debug_enabled {
-            // Add debug overlay
-            self.draw_debug_overlay(&mut pixmap, &self.debug_info)?;
-
-            // Add grid for alignment reference
-            self.draw_alignment_grid(&mut pixmap, play_res_x, play_res_y)?;
-
-            // Add color reference
-            self.draw_color_reference(&mut pixmap)?;
-        }
-
-        Ok(pixmap)
-    }
-
-    /// Draw debug overlay with rendering info
-    fn draw_debug_overlay(
-        &self,
-        pixmap: &mut Pixmap,
-        debug_info: &[RenderDebugInfo],
-    ) -> Result<(), RenderError> {
-        let mut paint = Paint::default();
-        paint.set_color(Color::from_rgba8(255, 255, 0, 180)); // Yellow for debug text
-
-        // Draw debug info in top-left corner
-        let mut y_offset = 20.0;
-        for (i, info) in debug_info.iter().enumerate() {
-            let text = format!(
-                "Event {}: Font: {:.1}pt (scaled: {:.1}pt), Color: {} -> RGBA({},{},{},{})",
-                i,
-                info.calculated_font_size,
-                info.scaled_font_size,
-                info.color_bbggrr,
-                info.color_rgba[0],
-                info.color_rgba[1],
-                info.color_rgba[2],
-                info.color_rgba[3],
-            );
-
-            // Draw text background for readability
-            let mut bg_paint = Paint::default();
-            bg_paint.set_color(Color::from_rgba8(0, 0, 0, 180));
-            pixmap.fill_rect(
-                tiny_skia::Rect::from_xywh(5.0, y_offset - 15.0, text.len() as f32 * 7.0, 20.0)
-                    .unwrap(),
-                &bg_paint,
-                Transform::identity(),
-                None,
-            );
-
-            // Would draw actual text here with a proper text renderer
-            // For now, just indicate where it would be
-            y_offset += 25.0;
-        }
-
-        Ok(())
-    }
-
-    /// Draw alignment grid for reference
-    fn draw_alignment_grid(
-        &self,
-        pixmap: &mut Pixmap,
-        _play_res_x: u32,
-        _play_res_y: u32,
-    ) -> Result<(), RenderError> {
-        let mut paint = Paint::default();
-        paint.set_color(Color::from_rgba8(100, 100, 100, 50)); // Semi-transparent gray
-
-        let width = pixmap.width() as f32;
-        let height = pixmap.height() as f32;
-
-        // Draw 3x3 grid for alignment positions
-        let h_third = width / 3.0;
-        let v_third = height / 3.0;
-
-        let stroke = Stroke {
-            width: 1.0,
-            ..Default::default()
-        };
-
-        // Vertical lines
-        for i in 1..3 {
-            let x = h_third * i as f32;
-            if let Some(rect) = tiny_skia::Rect::from_xywh(x, 0.0, 1.0, height) {
-                let path = tiny_skia::PathBuilder::from_rect(rect);
-                pixmap.stroke_path(&path, &paint, &stroke, Transform::identity(), None);
-            }
-        }
-
-        // Horizontal lines
-        for i in 1..3 {
-            let y = v_third * i as f32;
-            if let Some(rect) = tiny_skia::Rect::from_xywh(0.0, y, width, 1.0) {
-                let path = tiny_skia::PathBuilder::from_rect(rect);
-                pixmap.stroke_path(&path, &paint, &stroke, Transform::identity(), None);
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Draw color reference swatches
-    fn draw_color_reference(&self, pixmap: &mut Pixmap) -> Result<(), RenderError> {
-        // Draw common ASS colors for reference
-        let colors = [
-            ("White", [255, 255, 255, 255]),
-            ("Cyan", [255, 255, 0, 255]),   // In BBGGRR: &H00FFFF&
-            ("Yellow", [0, 255, 255, 255]), // In BBGGRR: &H00FFFF&
-            ("Red", [0, 0, 255, 255]),      // In BBGGRR: &H0000FF&
-            ("Blue", [255, 0, 0, 255]),     // In BBGGRR: &HFF0000&
-        ];
-
-        let mut x_offset = pixmap.width() as f32 - 250.0;
-        let y_offset = 10.0;
-
-        for (_name, rgba) in colors.iter() {
-            let mut paint = Paint::default();
-            paint.set_color(Color::from_rgba8(rgba[0], rgba[1], rgba[2], rgba[3]));
-
-            // Draw color swatch
-            pixmap.fill_rect(
-                tiny_skia::Rect::from_xywh(x_offset, y_offset, 40.0, 20.0).unwrap(),
-                &paint,
-                Transform::identity(),
-                None,
-            );
-
-            x_offset += 45.0;
-        }
-
-        Ok(())
-    }
-
-    /// Export debug info to file
-    #[cfg(all(not(feature = "nostd"), feature = "serde"))]
-    pub fn export_debug_info(&self, path: &Path) -> Result<(), RenderError> {
-        let json = serde_json::to_string_pretty(&self.debug_info)
-            .map_err(|e| RenderError::BackendError(format!("Serialization failed: {e}")))?;
-        fs::write(path, json).map_err(|e| RenderError::IOError(e.to_string()))?;
-        Ok(())
-    }
-
-    /// Compare with libass output
-    pub fn compare_with_libass(
-        &self,
-        our_output: &Pixmap,
-        libass_output: &Pixmap,
-    ) -> ComparisonResult {
-        let mut differences = Vec::new();
-        let mut total_diff = 0.0;
-        let mut max_diff = 0.0;
-
-        // Compare pixel by pixel
-        for y in 0..our_output.height().min(libass_output.height()) {
-            for x in 0..our_output.width().min(libass_output.width()) {
-                let our_pixel = our_output.pixel(x, y).unwrap();
-                let lib_pixel = libass_output.pixel(x, y).unwrap();
-
-                let r_diff = (our_pixel.red() as i32 - lib_pixel.red() as i32).abs() as f32;
-                let g_diff = (our_pixel.green() as i32 - lib_pixel.green() as i32).abs() as f32;
-                let b_diff = (our_pixel.blue() as i32 - lib_pixel.blue() as i32).abs() as f32;
-                let a_diff = (our_pixel.alpha() as i32 - lib_pixel.alpha() as i32).abs() as f32;
-
-                let pixel_diff = (r_diff + g_diff + b_diff + a_diff) / 4.0;
-
-                if pixel_diff > 10.0 {
-                    differences.push(PixelDifference {
-                        x,
-                        y,
-                        our_color: [
-                            our_pixel.red(),
-                            our_pixel.green(),
-                            our_pixel.blue(),
-                            our_pixel.alpha(),
-                        ],
-                        libass_color: [
-                            lib_pixel.red(),
-                            lib_pixel.green(),
-                            lib_pixel.blue(),
-                            lib_pixel.alpha(),
-                        ],
-                        difference: pixel_diff,
-                    });
-                }
-
-                total_diff += pixel_diff;
-                max_diff = if pixel_diff > max_diff {
-                    pixel_diff
-                } else {
-                    max_diff
-                };
-            }
-        }
-
-        let pixel_count = (our_output.width() * our_output.height()) as f32;
-
-        ComparisonResult {
-            average_difference: total_diff / pixel_count,
-            max_difference: max_diff,
-            different_pixels: differences.len(),
-            total_pixels: pixel_count as usize,
-            pixel_differences: differences,
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ComparisonResult {
-    pub average_difference: f32,
-    pub max_difference: f32,
-    pub different_pixels: usize,
-    pub total_pixels: usize,
-    pub pixel_differences: Vec<PixelDifference>,
-}
-
-#[derive(Debug)]
-pub struct PixelDifference {
-    pub x: u32,
-    pub y: u32,
-    pub our_color: [u8; 4],
-    pub libass_color: [u8; 4],
-    pub difference: f32,
-}
-
-/// Create side-by-side comparison image
-pub fn create_comparison_image(
-    our_output: &Pixmap,
-    libass_output: &Pixmap,
-    diff_map: Option<&Pixmap>,
-) -> Result<Pixmap, RenderError> {
-    let width = our_output.width() + libass_output.width() + diff_map.map_or(0, |d| d.width());
-    let height = our_output.height().max(libass_output.height());
-
-    let mut comparison = Pixmap::new(width, height).ok_or(RenderError::InvalidPixmap)?;
-
-    // Copy our output to left side
-    comparison.draw_pixmap(
-        0,
-        0,
-        our_output.as_ref(),
-        &tiny_skia::PixmapPaint::default(),
-        Transform::identity(),
-        None,
-    );
-
-    // Copy libass output to middle
-    comparison.draw_pixmap(
-        our_output.width() as i32,
-        0,
-        libass_output.as_ref(),
-        &tiny_skia::PixmapPaint::default(),
-        Transform::identity(),
-        None,
-    );
-
-    // Copy diff map to right side if provided
-    if let Some(diff) = diff_map {
-        comparison.draw_pixmap(
-            (our_output.width() + libass_output.width()) as i32,
-            0,
-            diff.as_ref(),
-            &tiny_skia::PixmapPaint::default(),
-            Transform::identity(),
-            None,
-        );
-    }
-
-    Ok(comparison)
-}
diff --git a/crates/ass-renderer/src/debug/visual_reporting.rs b/crates/ass-renderer/src/debug/visual_reporting.rs
deleted file mode 100644
index fc11fac..0000000
--- a/crates/ass-renderer/src/debug/visual_reporting.rs
+++ /dev/null
@@ -1,1254 +0,0 @@
-//! Visual reporting system for compatibility test results
-
-#[cfg(all(feature = "libass-compare", not(target_arch = "wasm32")))]
-use crate::debug::{CompatibilityResult, DiffRegion, DiffType};
-use crate::utils::RenderError;
-
-#[cfg(feature = "nostd")]
-use alloc::{format, string::String, vec::Vec};
-#[cfg(not(feature = "nostd"))]
-use std::{collections::HashMap, format, fs, path::Path, string::String, vec::Vec};
-
-/// HTML report generator for compatibility test results
-pub struct VisualReportGenerator {
-    /// Test results to include in report
-    results: Vec<CompatibilityResult>,
-    /// Output directory for report files
-    #[cfg(not(feature = "nostd"))]
-    output_dir: String,
-    /// Report configuration
-    config: ReportConfig,
-}
-
-/// Configuration for report generation
-#[derive(Debug, Clone)]
-pub struct ReportConfig {
-    /// Include thumbnail previews in report
-    pub include_thumbnails: bool,
-    /// Include detailed metrics
-    pub include_metrics: bool,
-    /// Include performance comparison
-    pub include_performance: bool,
-    /// Maximum number of results to show per page
-    pub max_results_per_page: usize,
-    /// Generate separate pages for different test categories
-    pub categorize_by_type: bool,
-}
-
-impl Default for ReportConfig {
-    fn default() -> Self {
-        Self {
-            include_thumbnails: true,
-            include_metrics: true,
-            include_performance: true,
-            max_results_per_page: 50,
-            categorize_by_type: true,
-        }
-    }
-}
-
-impl VisualReportGenerator {
-    /// Create new report generator
-    #[cfg(not(feature = "nostd"))]
-    pub fn new(output_dir: String, config: ReportConfig) -> Self {
-        Self {
-            results: Vec::new(),
-            output_dir,
-            config,
-        }
-    }
-
-    /// Add test result to report
-    pub fn add_result(&mut self, result: CompatibilityResult) {
-        self.results.push(result);
-    }
-
-    /// Add multiple test results
-    pub fn add_results(&mut self, results: Vec<CompatibilityResult>) {
-        self.results.extend(results);
-    }
-
-    /// Generate complete HTML report
-    #[cfg(not(feature = "nostd"))]
-    pub fn generate_report(&self) -> Result<String, RenderError> {
-        // Create output directory
-        fs::create_dir_all(&self.output_dir)
-            .map_err(|e| RenderError::IOError(format!("Failed to create output directory: {e}")))?;
-
-        // Generate main report
-        let report_path = Path::new(&self.output_dir).join("compatibility_report.html");
-        let html_content = self.generate_html_report()?;
-
-        fs::write(&report_path, html_content)
-            .map_err(|e| RenderError::IOError(format!("Failed to write report: {e}")))?;
-
-        // Generate CSS file
-        let css_path = Path::new(&self.output_dir).join("report.css");
-        fs::write(css_path, Self::generate_css())
-            .map_err(|e| RenderError::IOError(format!("Failed to write CSS: {e}")))?;
-
-        // Generate JavaScript file
-        let js_path = Path::new(&self.output_dir).join("report.js");
-        fs::write(js_path, Self::generate_javascript())
-            .map_err(|e| RenderError::IOError(format!("Failed to write JavaScript: {e}")))?;
-
-        // Generate summary JSON
-        if self.config.include_metrics {
-            let json_path = Path::new(&self.output_dir).join("summary.json");
-            let summary = self.generate_summary_json()?;
-            fs::write(json_path, summary)
-                .map_err(|e| RenderError::IOError(format!("Failed to write summary JSON: {e}")))?;
-        }
-
-        Ok(report_path.to_string_lossy().to_string())
-    }
-
-    /// Generate HTML report content
-    fn generate_html_report(&self) -> Result<String, RenderError> {
-        let mut html = String::new();
-
-        // HTML header
-        html.push_str(&Self::generate_html_header());
-
-        // Summary section
-        html.push_str(&self.generate_summary_section()?);
-
-        // Filter controls
-        html.push_str(&Self::generate_filter_controls());
-
-        // Results section
-        if self.config.categorize_by_type {
-            html.push_str(&self.generate_categorized_results()?);
-        } else {
-            html.push_str(&self.generate_flat_results()?);
-        }
-
-        // Footer
-        html.push_str(&Self::generate_html_footer());
-
-        Ok(html)
-    }
-
-    /// Generate HTML header
-    fn generate_html_header() -> String {
-        r#"<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>ASS Renderer Compatibility Report</title>
-    <link rel="stylesheet" href="report.css">
-    <script src="report.js"></script>
-</head>
-<body>
-    <div class="container">
-        <header>
-            <h1>ASS Renderer Compatibility Report</h1>
-            <p class="subtitle">Pixel-perfect comparison with libass reference implementation</p>
-        </header>
-"#
-        .to_string()
-    }
-
-    /// Generate summary section
-    fn generate_summary_section(&self) -> Result<String, RenderError> {
-        let total_tests = self.results.len();
-        let passed_tests = self.results.iter().filter(|r| r.passed).count();
-        let failed_tests = total_tests - passed_tests;
-
-        let avg_diff = if total_tests > 0 {
-            self.results
-                .iter()
-                .map(|r| r.pixel_diff_percentage)
-                .sum::<f64>()
-                / total_tests as f64
-        } else {
-            0.0
-        };
-
-        let max_diff = self
-            .results
-            .iter()
-            .map(|r| r.pixel_diff_percentage)
-            .fold(0.0, f64::max);
-
-        let avg_performance = if self.config.include_performance {
-            let performance_results: Vec<f64> = self
-                .results
-                .iter()
-                .filter_map(|r| r.performance_ratio)
-                .collect();
-
-            if !performance_results.is_empty() {
-                Some(performance_results.iter().sum::<f64>() / performance_results.len() as f64)
-            } else {
-                None
-            }
-        } else {
-            None
-        };
-
-        let mut html = String::new();
-        html.push_str(
-            r#"<section class="summary">
-            <h2>Test Summary</h2>
-            <div class="summary-grid">
-                <div class="summary-card">"#,
-        );
-
-        html.push_str(&format!(
-            r#"
-                    <h3>Total Tests</h3>
-                    <div class="metric-value">{}</div>
-                </div>
-                <div class="summary-card passed">
-                    <h3>Passed</h3>
-                    <div class="metric-value">{}</div>
-                    <div class="metric-percent">({:.1}%)</div>
-                </div>
-                <div class="summary-card failed">
-                    <h3>Failed</h3>
-                    <div class="metric-value">{}</div>
-                    <div class="metric-percent">({:.1}%)</div>
-                </div>"#,
-            total_tests,
-            passed_tests,
-            (passed_tests as f64 / total_tests as f64) * 100.0,
-            failed_tests,
-            (failed_tests as f64 / total_tests as f64) * 100.0
-        ));
-
-        html.push_str(&format!(
-            r#"
-                <div class="summary-card">
-                    <h3>Average Difference</h3>
-                    <div class="metric-value">{:.3}%</div>
-                </div>
-                <div class="summary-card">
-                    <h3>Maximum Difference</h3>
-                    <div class="metric-value">{:.3}%</div>
-                </div>"#,
-            avg_diff * 100.0,
-            max_diff * 100.0
-        ));
-
-        if let Some(perf) = avg_performance {
-            html.push_str(&format!(
-                r#"
-                <div class="summary-card">
-                    <h3>Performance Ratio</h3>
-                    <div class="metric-value">{perf:.2}x</div>
-                    <div class="metric-help">vs libass</div>
-                </div>"#
-            ));
-        }
-
-        html.push_str(
-            r#"
-            </div>
-        </section>"#,
-        );
-
-        Ok(html)
-    }
-
-    /// Generate filter controls
-    fn generate_filter_controls() -> String {
-        r#"<section class="filters">
-            <h2>Filters</h2>
-            <div class="filter-controls">
-                <label>
-                    <input type="checkbox" id="show-passed" checked> Show Passed Tests
-                </label>
-                <label>
-                    <input type="checkbox" id="show-failed" checked> Show Failed Tests
-                </label>
-                <label>
-                    Status: 
-                    <select id="status-filter">
-                        <option value="all">All</option>
-                        <option value="passed">Passed Only</option>
-                        <option value="failed">Failed Only</option>
-                    </select>
-                </label>
-                <label>
-                    Max Difference: 
-                    <input type="range" id="diff-threshold" min="0" max="10" step="0.1" value="10">
-                    <span id="diff-value">10.0%</span>
-                </label>
-                <button id="reset-filters">Reset Filters</button>
-            </div>
-        </section>"#
-            .to_string()
-    }
-
-    /// Generate categorized results
-    fn generate_categorized_results(&self) -> Result<String, RenderError> {
-        let mut categories: HashMap<String, Vec<&CompatibilityResult>> = HashMap::new();
-
-        // Categorize results by test name patterns
-        for result in &self.results {
-            let category = Self::categorize_test(&result.test_name);
-            categories.entry(category).or_default().push(result);
-        }
-
-        let mut html = String::new();
-        html.push_str(
-            r#"<section class="results">
-            <h2>Test Results by Category</h2>"#,
-        );
-
-        for (category, results) in categories {
-            html.push_str(&format!(
-                r#"
-                <div class="category">
-                    <h3 class="category-title">{category}</h3>
-                    <div class="results-grid">"#
-            ));
-
-            for result in results {
-                html.push_str(&self.generate_result_card(result)?);
-            }
-
-            html.push_str(
-                r#"
-                    </div>
-                </div>"#,
-            );
-        }
-
-        html.push_str(r#"</section>"#);
-        Ok(html)
-    }
-
-    /// Generate flat results list
-    fn generate_flat_results(&self) -> Result<String, RenderError> {
-        let mut html = String::new();
-        html.push_str(
-            r#"<section class="results">
-            <h2>All Test Results</h2>
-            <div class="results-grid">"#,
-        );
-
-        for result in &self.results {
-            html.push_str(&self.generate_result_card(result)?);
-        }
-
-        html.push_str(
-            r#"
-            </div>
-        </section>"#,
-        );
-        Ok(html)
-    }
-
-    /// Generate individual result card
-    fn generate_result_card(&self, result: &CompatibilityResult) -> Result<String, RenderError> {
-        let status_class = if result.passed { "passed" } else { "failed" };
-        let diff_percent = result.pixel_diff_percentage * 100.0;
-
-        let mut html = format!(
-            r#"
-            <div class="result-card {}" data-status="{}" data-diff="{}">
-                <h4 class="test-name">{}</h4>
-                <div class="test-status">
-                    <span class="status-badge">{}</span>
-                    <span class="diff-value">{:.3}% diff</span>
-                </div>"#,
-            status_class,
-            if result.passed { "passed" } else { "failed" },
-            diff_percent,
-            result.test_name,
-            if result.passed { "PASS" } else { "FAIL" },
-            diff_percent
-        );
-
-        // Add metrics
-        if self.config.include_metrics {
-            html.push_str(&format!(
-                r#"
-                <div class="metrics">
-                    <div class="metric">
-                        <span class="label">Max Pixel Diff:</span>
-                        <span class="value">{}</span>
-                    </div>"#,
-                result.max_pixel_diff
-            ));
-
-            if let Some(perf) = result.performance_ratio {
-                html.push_str(&format!(
-                    r#"
-                    <div class="metric">
-                        <span class="label">Performance:</span>
-                        <span class="value">{perf:.2}x</span>
-                    </div>"#
-                ));
-            }
-
-            if !result.diff_regions.is_empty() {
-                html.push_str(&format!(
-                    r#"
-                    <div class="metric">
-                        <span class="label">Diff Regions:</span>
-                        <span class="value">{}</span>
-                    </div>"#,
-                    result.diff_regions.len()
-                ));
-            }
-
-            html.push_str(r#"</div>"#);
-        }
-
-        // Add thumbnails if enabled and files exist
-        if self.config.include_thumbnails {
-            html.push_str(&self.generate_thumbnail_section(&result.test_name)?);
-        }
-
-        // Add diff regions details
-        if !result.diff_regions.is_empty() {
-            html.push_str(&self.generate_diff_regions_section(&result.diff_regions)?);
-        }
-
-        html.push_str(r#"</div>"#);
-        Ok(html)
-    }
-
-    /// Generate thumbnail section for a test
-    #[cfg(not(feature = "nostd"))]
-    fn generate_thumbnail_section(&self, test_name: &str) -> Result<String, RenderError> {
-        let mut html = String::new();
-
-        // Check if thumbnail files exist
-        let our_path = Path::new(&self.output_dir).join(format!("{test_name}_ours.png"));
-        let libass_path = Path::new(&self.output_dir).join(format!("{test_name}_libass.png"));
-        let diff_path = Path::new(&self.output_dir).join(format!("{test_name}_diff.png"));
-
-        if our_path.exists() || libass_path.exists() || diff_path.exists() {
-            html.push_str(
-                r#"
-                <div class="thumbnails">
-                    <div class="thumbnail-row">"#,
-            );
-
-            if our_path.exists() {
-                html.push_str(&format!(
-                    r#"
-                        <div class="thumbnail">
-                            <img src="{test_name}_ours.png" alt="Our Renderer" title="Our Renderer">
-                            <label>Ours</label>
-                        </div>"#
-                ));
-            }
-
-            if libass_path.exists() {
-                html.push_str(&format!(r#"
-                        <div class="thumbnail">
-                            <img src="{test_name}_libass.png" alt="libass Reference" title="libass Reference">
-                            <label>libass</label>
-                        </div>"#));
-            }
-
-            if diff_path.exists() {
-                html.push_str(&format!(
-                    r#"
-                        <div class="thumbnail">
-                            <img src="{test_name}_diff.png" alt="Difference Map" title="Difference Map">
-                            <label>Diff</label>
-                        </div>"#
-                ));
-            }
-
-            html.push_str(
-                r#"
-                    </div>
-                </div>"#,
-            );
-        }
-
-        Ok(html)
-    }
-
-    #[cfg(feature = "nostd")]
-    fn generate_thumbnail_section(&self, _test_name: &str) -> Result<String, RenderError> {
-        Ok(String::new())
-    }
-
-    /// Generate diff regions section
-    fn generate_diff_regions_section(&self, regions: &[DiffRegion]) -> Result<String, RenderError> {
-        if regions.is_empty() {
-            return Ok(String::new());
-        }
-
-        let mut html = String::new();
-        html.push_str(
-            r#"
-            <div class="diff-regions">
-                <h5>Difference Regions</h5>
-                <div class="regions-list">"#,
-        );
-
-        for (i, region) in regions.iter().enumerate().take(10) {
-            // Limit to first 10 regions
-            let region_type = match region.diff_type {
-                DiffType::PixelValue => "pixel",
-                DiffType::TextPosition => "position",
-                DiffType::AnimationTiming => "timing",
-                DiffType::FontRendering => "font",
-                DiffType::Effects => "effects",
-                DiffType::Transform => "transform",
-            };
-
-            html.push_str(&format!(
-                r#"
-                    <div class="region-item {} type-{}">
-                        <span class="region-bounds">{}x{} at ({}, {})</span>
-                        <span class="region-type">{}</span>
-                        <span class="region-diff">avg: {:.1}, max: {}</span>
-                    </div>"#,
-                if i % 2 == 0 { "even" } else { "odd" },
-                region_type,
-                region.bounds.2,
-                region.bounds.3,
-                region.bounds.0,
-                region.bounds.1,
-                region_type,
-                region.avg_diff,
-                region.max_diff
-            ));
-        }
-
-        if regions.len() > 10 {
-            html.push_str(&format!(
-                r#"
-                    <div class="region-item more">
-                        ... and {} more regions
-                    </div>"#,
-                regions.len() - 10
-            ));
-        }
-
-        html.push_str(
-            r#"
-                </div>
-            </div>"#,
-        );
-
-        Ok(html)
-    }
-
-    /// Generate CSS styles
-    fn generate_css() -> String {
-        r#"/* CSS styles for compatibility report */
-body {
-    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-    margin: 0;
-    padding: 20px;
-    background-color: #f5f5f5;
-    color: #333;
-}
-
-.container {
-    max-width: 1200px;
-    margin: 0 auto;
-    background: white;
-    border-radius: 8px;
-    box-shadow: 0 2px 10px rgba(0,0,0,0.1);
-    overflow: hidden;
-}
-
-header {
-    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-    color: white;
-    padding: 30px;
-    text-align: center;
-}
-
-header h1 {
-    margin: 0;
-    font-size: 2.5em;
-    font-weight: 300;
-}
-
-.subtitle {
-    margin: 10px 0 0 0;
-    opacity: 0.9;
-    font-size: 1.1em;
-}
-
-.summary {
-    padding: 30px;
-    border-bottom: 1px solid #eee;
-}
-
-.summary-grid {
-    display: grid;
-    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
-    gap: 20px;
-    margin-top: 20px;
-}
-
-.summary-card {
-    background: #f8f9fa;
-    padding: 20px;
-    border-radius: 6px;
-    text-align: center;
-    border-left: 4px solid #007bff;
-}
-
-.summary-card.passed {
-    border-left-color: #28a745;
-    background: #f8fff9;
-}
-
-.summary-card.failed {
-    border-left-color: #dc3545;
-    background: #fff8f8;
-}
-
-.summary-card h3 {
-    margin: 0 0 10px 0;
-    font-size: 0.9em;
-    text-transform: uppercase;
-    color: #666;
-    font-weight: 600;
-}
-
-.metric-value {
-    font-size: 2em;
-    font-weight: bold;
-    color: #333;
-}
-
-.metric-percent {
-    font-size: 0.9em;
-    color: #666;
-    margin-top: 5px;
-}
-
-.metric-help {
-    font-size: 0.8em;
-    color: #999;
-    margin-top: 5px;
-}
-
-.filters {
-    padding: 20px 30px;
-    background: #f8f9fa;
-    border-bottom: 1px solid #eee;
-}
-
-.filter-controls {
-    display: flex;
-    gap: 20px;
-    align-items: center;
-    flex-wrap: wrap;
-}
-
-.filter-controls label {
-    display: flex;
-    align-items: center;
-    gap: 5px;
-    font-size: 0.9em;
-}
-
-button {
-    background: #007bff;
-    color: white;
-    border: none;
-    padding: 8px 16px;
-    border-radius: 4px;
-    cursor: pointer;
-    font-size: 0.9em;
-}
-
-button:hover {
-    background: #0056b3;
-}
-
-.results {
-    padding: 30px;
-}
-
-.category {
-    margin-bottom: 40px;
-}
-
-.category-title {
-    color: #495057;
-    border-bottom: 2px solid #007bff;
-    padding-bottom: 10px;
-    margin-bottom: 20px;
-}
-
-.results-grid {
-    display: grid;
-    grid-template-columns: repeat(auto-fill, minmax(400px, 1fr));
-    gap: 20px;
-}
-
-.result-card {
-    background: white;
-    border: 1px solid #dee2e6;
-    border-radius: 6px;
-    padding: 20px;
-    transition: all 0.2s ease;
-}
-
-.result-card:hover {
-    box-shadow: 0 4px 12px rgba(0,0,0,0.1);
-    transform: translateY(-2px);
-}
-
-.result-card.passed {
-    border-left: 4px solid #28a745;
-}
-
-.result-card.failed {
-    border-left: 4px solid #dc3545;
-}
-
-.test-name {
-    margin: 0 0 10px 0;
-    font-size: 1.1em;
-    color: #333;
-}
-
-.test-status {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    margin-bottom: 15px;
-}
-
-.status-badge {
-    padding: 4px 8px;
-    border-radius: 4px;
-    font-size: 0.8em;
-    font-weight: bold;
-}
-
-.passed .status-badge {
-    background: #d4edda;
-    color: #155724;
-}
-
-.failed .status-badge {
-    background: #f8d7da;
-    color: #721c24;
-}
-
-.diff-value {
-    font-size: 0.9em;
-    color: #666;
-}
-
-.metrics {
-    margin-bottom: 15px;
-}
-
-.metric {
-    display: flex;
-    justify-content: space-between;
-    margin-bottom: 5px;
-    font-size: 0.9em;
-}
-
-.metric .label {
-    color: #666;
-}
-
-.metric .value {
-    font-weight: 500;
-}
-
-.thumbnails {
-    margin-top: 15px;
-    padding-top: 15px;
-    border-top: 1px solid #eee;
-}
-
-.thumbnail-row {
-    display: flex;
-    gap: 10px;
-    justify-content: space-around;
-}
-
-.thumbnail {
-    text-align: center;
-    flex: 1;
-}
-
-.thumbnail img {
-    max-width: 100%;
-    max-height: 120px;
-    border: 1px solid #ddd;
-    border-radius: 4px;
-    cursor: pointer;
-}
-
-.thumbnail img:hover {
-    border-color: #007bff;
-}
-
-.thumbnail label {
-    display: block;
-    margin-top: 5px;
-    font-size: 0.8em;
-    color: #666;
-}
-
-.diff-regions {
-    margin-top: 15px;
-    padding-top: 15px;
-    border-top: 1px solid #eee;
-}
-
-.diff-regions h5 {
-    margin: 0 0 10px 0;
-    font-size: 0.9em;
-    color: #666;
-    text-transform: uppercase;
-}
-
-.regions-list {
-    max-height: 150px;
-    overflow-y: auto;
-}
-
-.region-item {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    padding: 5px 0;
-    font-size: 0.8em;
-    border-bottom: 1px solid #f1f1f1;
-}
-
-.region-item.even {
-    background: #f8f9fa;
-}
-
-.region-bounds {
-    color: #333;
-    font-family: monospace;
-}
-
-.region-type {
-    padding: 2px 6px;
-    border-radius: 3px;
-    background: #e9ecef;
-    color: #495057;
-}
-
-.region-type.type-pixel { background: #fff3cd; color: #856404; }
-.region-type.type-position { background: #d4edda; color: #155724; }
-.region-type.type-timing { background: #cce7ff; color: #004085; }
-.region-type.type-font { background: #f8d7da; color: #721c24; }
-.region-type.type-effects { background: #e2e3e5; color: #383d41; }
-.region-type.type-transform { background: #ffeeba; color: #533f03; }
-
-.region-diff {
-    color: #666;
-    font-family: monospace;
-}
-
-.hidden {
-    display: none !important;
-}
-
-/* Responsive design */
-@media (max-width: 768px) {
-    .container {
-        margin: 10px;
-        border-radius: 0;
-    }
-    
-    .results-grid {
-        grid-template-columns: 1fr;
-    }
-    
-    .filter-controls {
-        flex-direction: column;
-        align-items: flex-start;
-    }
-    
-    .summary-grid {
-        grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
-    }
-}"#
-        .to_string()
-    }
-
-    /// Generate JavaScript for interactive features
-    fn generate_javascript() -> String {
-        r#"// JavaScript for interactive compatibility report
-document.addEventListener('DOMContentLoaded', function() {
-    // Filter controls
-    const showPassed = document.getElementById('show-passed');
-    const showFailed = document.getElementById('show-failed');
-    const statusFilter = document.getElementById('status-filter');
-    const diffThreshold = document.getElementById('diff-threshold');
-    const diffValue = document.getElementById('diff-value');
-    const resetFilters = document.getElementById('reset-filters');
-
-    // Update diff threshold display
-    if (diffThreshold && diffValue) {
-        diffThreshold.addEventListener('input', function() {
-            diffValue.textContent = this.value + '%';
-            applyFilters();
-        });
-    }
-
-    // Apply filters
-    function applyFilters() {
-        const cards = document.querySelectorAll('.result-card');
-        const showPassedChecked = showPassed ? showPassed.checked : true;
-        const showFailedChecked = showFailed ? showFailed.checked : true;
-        const statusFilterValue = statusFilter ? statusFilter.value : 'all';
-        const maxDiff = diffThreshold ? parseFloat(diffThreshold.value) : 100;
-
-        cards.forEach(card => {
-            const status = card.dataset.status;
-            const diff = parseFloat(card.dataset.diff) || 0;
-            
-            let visible = true;
-            
-            // Status filter
-            if (statusFilterValue === 'passed' && status !== 'passed') {
-                visible = false;
-            } else if (statusFilterValue === 'failed' && status !== 'failed') {
-                visible = false;
-            }
-            
-            // Checkbox filters
-            if (status === 'passed' && !showPassedChecked) {
-                visible = false;
-            } else if (status === 'failed' && !showFailedChecked) {
-                visible = false;
-            }
-            
-            // Difference threshold
-            if (diff > maxDiff) {
-                visible = false;
-            }
-            
-            card.classList.toggle('hidden', !visible);
-        });
-
-        updateResultsCount();
-    }
-
-    // Update visible results count
-    function updateResultsCount() {
-        const visibleCards = document.querySelectorAll('.result-card:not(.hidden)');
-        const totalCards = document.querySelectorAll('.result-card');
-        
-        // Update summary if exists
-        const summaryElement = document.querySelector('.results h2');
-        if (summaryElement) {
-            summaryElement.textContent = `Test Results (${visibleCards.length} of ${totalCards.length} shown)`;
-        }
-    }
-
-    // Event listeners
-    if (showPassed) {
-        showPassed.addEventListener('change', applyFilters);
-    }
-    if (showFailed) {
-        showFailed.addEventListener('change', applyFilters);
-    }
-    if (statusFilter) {
-        statusFilter.addEventListener('change', applyFilters);
-    }
-    if (resetFilters) {
-        resetFilters.addEventListener('click', function() {
-            if (showPassed) showPassed.checked = true;
-            if (showFailed) showFailed.checked = true;
-            if (statusFilter) statusFilter.value = 'all';
-            if (diffThreshold) {
-                diffThreshold.value = '10';
-                diffValue.textContent = '10.0%';
-            }
-            applyFilters();
-        });
-    }
-
-    // Image modal functionality
-    const images = document.querySelectorAll('.thumbnail img');
-    images.forEach(img => {
-        img.addEventListener('click', function() {
-            showImageModal(this.src, this.alt);
-        });
-    });
-
-    function showImageModal(src, alt) {
-        // Create modal
-        const modal = document.createElement('div');
-        modal.className = 'image-modal';
-        modal.innerHTML = `
-            <div class="modal-backdrop">
-                <div class="modal-content">
-                    <img src="${src}" alt="${alt}">
-                    <div class="modal-caption">${alt}</div>
-                    <button class="modal-close">&times;</button>
-                </div>
-            </div>
-        `;
-
-        // Add modal styles
-        modal.style.cssText = `
-            position: fixed;
-            top: 0;
-            left: 0;
-            width: 100%;
-            height: 100%;
-            background: rgba(0,0,0,0.8);
-            display: flex;
-            justify-content: center;
-            align-items: center;
-            z-index: 1000;
-        `;
-
-        const content = modal.querySelector('.modal-content');
-        content.style.cssText = `
-            position: relative;
-            max-width: 90%;
-            max-height: 90%;
-            background: white;
-            border-radius: 8px;
-            padding: 20px;
-            text-align: center;
-        `;
-
-        const image = modal.querySelector('img');
-        image.style.cssText = `
-            max-width: 100%;
-            max-height: 70vh;
-            border-radius: 4px;
-        `;
-
-        const closeBtn = modal.querySelector('.modal-close');
-        closeBtn.style.cssText = `
-            position: absolute;
-            top: 10px;
-            right: 15px;
-            background: none;
-            border: none;
-            font-size: 24px;
-            cursor: pointer;
-            color: #666;
-        `;
-
-        // Close modal handlers
-        closeBtn.addEventListener('click', () => modal.remove());
-        modal.addEventListener('click', (e) => {
-            if (e.target === modal || e.target.className === 'modal-backdrop') {
-                modal.remove();
-            }
-        });
-
-        document.addEventListener('keydown', function escHandler(e) {
-            if (e.key === 'Escape') {
-                modal.remove();
-                document.removeEventListener('keydown', escHandler);
-            }
-        });
-
-        document.body.appendChild(modal);
-    }
-
-    // Initialize filters
-    applyFilters();
-
-    // Sort functionality
-    addSortControls();
-
-    function addSortControls() {
-        const resultsSection = document.querySelector('.results');
-        if (!resultsSection) return;
-
-        const sortControls = document.createElement('div');
-        sortControls.className = 'sort-controls';
-        sortControls.innerHTML = `
-            <label>
-                Sort by:
-                <select id="sort-by">
-                    <option value="name">Test Name</option>
-                    <option value="status">Status</option>
-                    <option value="diff">Difference</option>
-                    <option value="performance">Performance</option>
-                </select>
-            </label>
-            <label>
-                <input type="checkbox" id="sort-reverse"> Reverse Order
-            </label>
-        `;
-
-        sortControls.style.cssText = `
-            margin-bottom: 20px;
-            padding: 15px;
-            background: #f8f9fa;
-            border-radius: 6px;
-            display: flex;
-            gap: 20px;
-            align-items: center;
-        `;
-
-        const h2 = resultsSection.querySelector('h2');
-        if (h2) {
-            h2.insertAdjacentElement('afterend', sortControls);
-        }
-
-        const sortBy = document.getElementById('sort-by');
-        const sortReverse = document.getElementById('sort-reverse');
-
-        function applySorting() {
-            const grids = document.querySelectorAll('.results-grid');
-            grids.forEach(grid => {
-                const cards = Array.from(grid.querySelectorAll('.result-card'));
-                
-                cards.sort((a, b) => {
-                    let aValue, bValue;
-                    
-                    switch (sortBy.value) {
-                        case 'name':
-                            aValue = a.querySelector('.test-name').textContent;
-                            bValue = b.querySelector('.test-name').textContent;
-                            break;
-                        case 'status':
-                            aValue = a.dataset.status;
-                            bValue = b.dataset.status;
-                            break;
-                        case 'diff':
-                            aValue = parseFloat(a.dataset.diff) || 0;
-                            bValue = parseFloat(b.dataset.diff) || 0;
-                            break;
-                        case 'performance':
-                            aValue = parseFloat(a.querySelector('.metric .value')?.textContent) || 0;
-                            bValue = parseFloat(b.querySelector('.metric .value')?.textContent) || 0;
-                            break;
-                        default:
-                            return 0;
-                    }
-                    
-                    let result;
-                    if (typeof aValue === 'string') {
-                        result = aValue.localeCompare(bValue);
-                    } else {
-                        result = aValue - bValue;
-                    }
-                    
-                    return sortReverse.checked ? -result : result;
-                });
-                
-                // Re-append sorted cards
-                cards.forEach(card => grid.appendChild(card));
-            });
-        }
-
-        sortBy.addEventListener('change', applySorting);
-        sortReverse.addEventListener('change', applySorting);
-    }
-});
-"#.to_string()
-    }
-
-    /// Generate HTML footer
-    fn generate_html_footer() -> String {
-        {
-            #[cfg(not(feature = "nostd"))]
-            let timestamp = std::time::SystemTime::now()
-                .duration_since(std::time::UNIX_EPOCH)
-                .map(|d| format!("{} seconds since epoch", d.as_secs()))
-                .unwrap_or_else(|_| "unknown time".to_string());
-            #[cfg(feature = "nostd")]
-            let timestamp = "unknown time".to_string();
-
-            format!(
-                r#"
-        <footer style="padding: 20px 30px; background: #f8f9fa; border-top: 1px solid #eee; text-align: center; color: #666;">
-            <p>Report generated on {timestamp} by ASS Renderer Compatibility Testing Framework</p>
-            <p>Compare with libass reference implementation for pixel-perfect subtitle rendering</p>
-        </footer>
-    </div>
-</body>
-</html>"#
-            )
-        }
-    }
-
-    /// Generate summary JSON for programmatic access
-    #[cfg(feature = "serde")]
-    fn generate_summary_json(&self) -> Result<String, RenderError> {
-        let total_tests = self.results.len();
-        let passed_tests = self.results.iter().filter(|r| r.passed).count();
-
-        let summary = serde_json::json!({
-            "summary": {
-                "total_tests": total_tests,
-                "passed_tests": passed_tests,
-                "failed_tests": total_tests - passed_tests,
-                "pass_rate": if total_tests > 0 { passed_tests as f64 / total_tests as f64 } else { 0.0 },
-                "average_difference": if total_tests > 0 {
-                    self.results.iter().map(|r| r.pixel_diff_percentage).sum::<f64>() / total_tests as f64
-                } else { 0.0 },
-                "maximum_difference": self.results.iter().map(|r| r.pixel_diff_percentage).fold(0.0, f64::max)
-            },
-            "results": self.results.iter().map(|r| {
-                serde_json::json!({
-                    "test_name": r.test_name,
-                    "passed": r.passed,
-                    "pixel_diff_percentage": r.pixel_diff_percentage,
-                    "max_pixel_diff": r.max_pixel_diff,
-                    "performance_ratio": r.performance_ratio,
-                    "diff_regions_count": r.diff_regions.len()
-                })
-            }).collect::<Vec<_>>()
-        });
-
-        serde_json::to_string_pretty(&summary)
-            .map_err(|e| RenderError::BackendError(format!("Failed to serialize summary: {e}")))
-    }
-
-    /// Categorize test by name pattern
-    fn categorize_test(test_name: &str) -> String {
-        if test_name.contains("basic") || test_name.contains("text") {
-            "Basic Text Rendering".to_string()
-        } else if test_name.contains("animation")
-            || test_name.contains("move")
-            || test_name.contains("fade")
-        {
-            "Animations".to_string()
-        } else if test_name.contains("transform")
-            || test_name.contains("rotation")
-            || test_name.contains("scale")
-        {
-            "Transformations".to_string()
-        } else if test_name.contains("karaoke") {
-            "Karaoke Effects".to_string()
-        } else if test_name.contains("drawing") || test_name.contains("clip") {
-            "Drawing Commands".to_string()
-        } else if test_name.contains("effect")
-            || test_name.contains("blur")
-            || test_name.contains("shadow")
-        {
-            "Visual Effects".to_string()
-        } else if test_name.contains("edge") || test_name.contains("error") {
-            "Edge Cases".to_string()
-        } else {
-            "Other".to_string()
-        }
-    }
-}
-
-/// Quick function to generate a basic report from results
-#[cfg(not(feature = "nostd"))]
-pub fn generate_compatibility_report(
-    results: Vec<CompatibilityResult>,
-    output_dir: &str,
-) -> Result<String, RenderError> {
-    let config = ReportConfig::default();
-    let mut generator = VisualReportGenerator::new(output_dir.to_string(), config);
-    generator.add_results(results);
-    generator.generate_report()
-}
diff --git a/crates/ass-renderer/src/lib.rs b/crates/ass-renderer/src/lib.rs
index b262309..1700fc0 100644
--- a/crates/ass-renderer/src/lib.rs
+++ b/crates/ass-renderer/src/lib.rs
@@ -15,18 +15,11 @@ pub mod animation;
 pub mod backends;
 pub mod cache;
 pub mod collision;
-#[cfg(not(feature = "nostd"))]
-/// Debug and analysis tools for subtitle rendering
-pub mod debug;
 pub mod layout;
 pub mod pipeline;
 pub mod renderer;
 pub mod utils;
 
-#[cfg(all(not(feature = "nostd"), feature = "libass-compare", not(target_arch = "wasm32")))]
-pub use debug::LibassRenderer;
-#[cfg(not(feature = "nostd"))]
-pub use debug::{DebugPlayer, FrameAnalyzer, FrameInspector, PlayerFrame};
 pub use pipeline::PipelineStage;
 pub use renderer::{Frame, RenderContext, Renderer};
 pub use utils::{FontDb, RenderError};
diff --git a/crates/ass-renderer/tests/README.md b/crates/ass-renderer/tests/README.md
deleted file mode 100644
index fa6c546..0000000
--- a/crates/ass-renderer/tests/README.md
+++ /dev/null
@@ -1,309 +0,0 @@
-# Compatibility Testing Guide
-
-This document explains how to run comprehensive compatibility tests between our ass-renderer and libass.
-
-## Prerequisites
-
-### Install libass
-
-**macOS (Homebrew):**
-```bash
-brew install libass
-```
-
-**Ubuntu/Debian:**
-```bash
-sudo apt-get install libass-dev
-```
-
-**Fedora/RHEL:**
-```bash
-sudo dnf install libass-devel
-```
-
-**Windows:**
-```bash
-# Using vcpkg
-vcpkg install libass
-```
-
-### Install Dependencies
-
-```bash
-# Add image support for visual diffs
-cargo add image --features png
-
-# Optional: serde for JSON output
-cargo add serde --features derive
-cargo add serde_json
-```
-
-## Running Tests
-
-### Basic Compatibility Tests
-
-Run all compatibility tests:
-```bash
-cargo test --features libass-compare
-```
-
-Run specific test categories:
-```bash
-# Basic text rendering
-cargo test test_basic_text_compatibility --features libass-compare
-
-# Animation tests  
-cargo test test_animation_compatibility --features libass-compare
-
-# Transform tests
-cargo test test_transform_compatibility --features libass-compare
-```
-
-### With Visual Diff Generation
-
-Enable visual diff output:
-```bash
-GENERATE_VISUAL_DIFFS=1 cargo test --features libass-compare,image
-```
-
-This will create PNG files in `test_output/compatibility/` showing:
-- `{test_name}_ours.png` - Our renderer output
-- `{test_name}_libass.png` - libass reference output  
-- `{test_name}_diff.png` - Difference heatmap
-
-### Performance Benchmarking
-
-Run with performance measurement:
-```bash
-cargo test --features libass-compare --release -- --nocapture
-```
-
-### Custom Test Configuration
-
-Create a custom test with specific tolerance:
-```rust
-let config = TestConfig {
-    pixel_tolerance: 3,           // Allow 3 pixel value difference
-    significance_threshold: 0.01, // 1% difference threshold
-    generate_visual_diffs: true,
-    test_animations: true,
-    animation_step_cs: 5,         // 50ms animation steps
-    ..Default::default()
-};
-```
-
-## Test Categories
-
-### 1. Basic Text Rendering
-- Simple dialogue lines
-- Font styling (bold, italic, underline)
-- Color changes
-- Font size variations
-
-### 2. Text Effects
-- Outlines and shadows
-- Blur effects
-- Color overrides
-- Spacing adjustments
-
-### 3. Animations
-- Movement (`\move`)
-- Fading (`\fad`, `\fade`)
-- Transforms (`\t`)
-- Karaoke effects (`\k`, `\kf`)
-
-### 4. Transformations
-- Rotation (`\frx`, `\fry`, `\frz`)
-- Scaling (`\fscx`, `\fscy`)
-- Shearing (`\fax`, `\fay`)
-- Origin points (`\org`)
-
-### 5. Drawing Commands
-- Vector paths (`\p`)
-- Bezier curves
-- Clipping regions (`\clip`)
-
-### 6. Edge Cases
-- Empty events
-- Invalid parameters
-- Off-screen content
-- Malformed tags
-
-## Interpreting Results
-
-### Compatibility Metrics
-
-**Pixel Difference Percentage:**
-- `0.000%` - Perfect match (pixel identical)
-- `< 0.001%` - Excellent (sub-pixel differences)
-- `< 0.01%` - Good (minor rasterization differences)
-- `< 0.1%` - Acceptable (visible but minor differences)
-- `> 0.1%` - Poor (significant visual differences)
-
-**Maximum Pixel Difference:**
-- `0-2` - Excellent (imperceptible)
-- `3-5` - Good (very minor)
-- `6-15` - Acceptable (minor)
-- `16+` - Poor (noticeable)
-
-### Common Difference Sources
-
-1. **Font Rasterization:** Different font rendering engines
-2. **Antialiasing:** Slight differences in edge smoothing
-3. **Color Blending:** Alpha blending precision differences
-4. **Animation Timing:** Frame timing precision differences
-5. **Coordinate Precision:** Sub-pixel positioning differences
-
-## Continuous Integration
-
-### GitHub Actions Example
-
-```yaml
-name: Compatibility Tests
-
-on: [push, pull_request]
-
-jobs:
-  compatibility:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-    
-    - name: Install libass
-      run: sudo apt-get install libass-dev
-      
-    - name: Install Rust
-      uses: actions-rs/toolchain@v1
-      with:
-        toolchain: stable
-        
-    - name: Run compatibility tests
-      run: cargo test --features libass-compare
-      
-    - name: Upload visual diffs
-      if: failure()
-      uses: actions/upload-artifact@v3
-      with:
-        name: visual-diffs
-        path: test_output/
-```
-
-## Debugging Failed Tests
-
-### 1. Visual Inspection
-Check the generated PNG files to see visual differences:
-```bash
-open test_output/compatibility/{test_name}_diff.png
-```
-
-### 2. Increase Tolerance
-For minor differences, adjust tolerance:
-```rust
-let config = TestConfig {
-    pixel_tolerance: 5,  // Increase from default
-    significance_threshold: 0.02, // Increase from 1% to 2%
-    ..Default::default()
-};
-```
-
-### 3. Animation Analysis
-For animation tests, check individual frames:
-```bash
-# Run with detailed output
-RUST_LOG=debug cargo test test_animation_compatibility --features libass-compare -- --nocapture
-```
-
-### 4. Performance Analysis
-Compare rendering performance:
-```bash
-cargo test --features libass-compare --release -- --nocapture | grep "render time"
-```
-
-## Adding New Tests
-
-### Create Test Script
-```rust
-fn create_custom_test_script() -> String {
-    r#"[Script Info]
-Title: Custom Test
-PlayResX: 1920
-PlayResY: 1080
-
-[V4+ Styles]
-Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: Default,Arial,48,&H00FFFFFF,&H000000FF,&H00000000,&H80000000,0,0,0,0,100,100,0,0,1,2,1,2,50,50,50,1
-
-[Events]
-Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,Your test content here"#.to_string()
-}
-```
-
-### Add to Test Suite
-```rust
-#[test]
-#[cfg(feature = "libass-compare")]
-fn test_custom_feature() {
-    let context = RenderContext::new(TEST_WIDTH, TEST_HEIGHT);
-    let config = TestConfig::default();
-    let mut tester = CompatibilityTester::new(context, config).unwrap();
-    
-    let script_content = create_custom_test_script();
-    let script = Script::parse(&script_content).unwrap();
-    let result = tester.test_script_compatibility(&script, "custom_feature").unwrap();
-    
-    assert!(result.passed, "Custom test failed with {}% difference", 
-           result.pixel_diff_percentage * 100.0);
-}
-```
-
-## Performance Targets
-
-### Rendering Speed
-- **Target:** Our renderer within 150% of libass speed
-- **Acceptable:** Within 200% of libass speed
-- **Poor:** More than 300% of libass speed
-
-### Memory Usage  
-- **Target:** Within 120% of libass memory usage
-- **Acceptable:** Within 150% of libass memory usage
-- **Poor:** More than 200% of libass memory usage
-
-### Compatibility
-- **Target:** 95%+ tests pass with <0.01% difference
-- **Acceptable:** 90%+ tests pass with <0.05% difference
-- **Poor:** <85% tests pass or >0.1% average difference
-
-## Troubleshooting
-
-### libass Not Found
-```bash
-# Check if libass is installed
-pkg-config --modversion libass
-
-# macOS specific
-brew list libass
-
-# Ubuntu/Debian
-dpkg -l | grep libass
-```
-
-### Build Errors
-```bash
-# Clean rebuild
-cargo clean
-cargo build --features libass-compare
-
-# Check feature flags
-cargo build --features libass-compare --verbose
-```
-
-### Test Failures
-```bash
-# Run with maximum output
-RUST_LOG=trace cargo test test_name --features libass-compare -- --nocapture
-
-# Generate visual diffs for debugging
-mkdir -p test_output/compatibility
-cargo test --features libass-compare,image
-```
\ No newline at end of file
diff --git a/crates/ass-renderer/tests/compatibility_tests.rs b/crates/ass-renderer/tests/compatibility_tests.rs
deleted file mode 100644
index a75962d..0000000
--- a/crates/ass-renderer/tests/compatibility_tests.rs
+++ /dev/null
@@ -1,443 +0,0 @@
-//! Comprehensive libass compatibility tests
-//!
-//! This test suite verifies pixel-perfect compatibility with libass
-//! using a variety of ASS features and edge cases.
-
-#[cfg(all(feature = "libass-compare", not(feature = "nostd")))]
-use ass_core::parser::Script;
-#[cfg(all(feature = "libass-compare", not(feature = "nostd")))]
-use ass_renderer::debug::{CompatibilityTestSuite, CompatibilityTester, TestConfig};
-#[cfg(all(feature = "libass-compare", not(feature = "nostd")))]
-use ass_renderer::renderer::RenderContext;
-
-#[cfg(all(feature = "libass-compare", not(feature = "nostd")))]
-const TEST_WIDTH: u32 = 1920;
-#[cfg(all(feature = "libass-compare", not(feature = "nostd")))]
-const TEST_HEIGHT: u32 = 1080;
-
-/// Test basic text rendering compatibility
-#[test]
-#[cfg(all(feature = "libass-compare", not(feature = "nostd")))]
-fn test_basic_text_compatibility() {
-    let context = RenderContext::new(TEST_WIDTH, TEST_HEIGHT);
-    let config = TestConfig {
-        pixel_tolerance: 2, // Allow slight differences due to different rasterizers
-        significance_threshold: 0.005, // 0.5% threshold
-        ..Default::default()
-    };
-
-    let mut tester = CompatibilityTester::new(context, config).expect("Failed to create tester");
-
-    let script_content = r#"[Script Info]
-Title: Basic Text Test
-PlayResX: 1920
-PlayResY: 1080
-
-[V4+ Styles]
-Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: Default,Arial,48,&H00FFFFFF,&H000000FF,&H00000000,&H80000000,0,0,0,0,100,100,0,0,1,2,1,2,50,50,50,1
-
-[Events]
-Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,Hello World!"#;
-
-    let script = Script::parse(script_content).expect("Failed to parse script");
-    let result = tester
-        .test_script_compatibility(&script, "basic_text")
-        .expect("Test failed");
-
-    assert!(
-        result.passed,
-        "Basic text test failed with {}% difference",
-        result.pixel_diff_percentage * 100.0
-    );
-}
-
-/// Test various text effects and formatting
-#[test]
-#[cfg(all(feature = "libass-compare", not(feature = "nostd")))]
-fn test_text_effects_compatibility() {
-    let context = RenderContext::new(TEST_WIDTH, TEST_HEIGHT);
-    let config = TestConfig::default();
-
-    let mut tester = CompatibilityTester::new(context, config).expect("Failed to create tester");
-
-    let script_content = r#"[Script Info]
-Title: Text Effects Test
-PlayResX: 1920
-PlayResY: 1080
-
-[V4+ Styles]
-Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: Default,Arial,48,&H00FFFFFF,&H000000FF,&H00000000,&H80000000,0,0,0,0,100,100,0,0,1,2,1,2,50,50,50,1
-
-[Events]
-Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,{\b1}Bold text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,{\i1}Italic text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,{\u1}Underlined text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,{\s1}Strikethrough text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,{\c&H00FF00&}Green text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,{\fs72}Large text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,{\fsp10}Spaced text"#;
-
-    let script = Script::parse(script_content).expect("Failed to parse script");
-    let result = tester
-        .test_script_compatibility(&script, "text_effects")
-        .expect("Test failed");
-
-    // Text effects might have more differences due to implementation differences
-    assert!(
-        result.pixel_diff_percentage < 0.05,
-        "Text effects test failed with {}% difference",
-        result.pixel_diff_percentage * 100.0
-    );
-}
-
-/// Test animation and movement
-#[test]
-#[cfg(all(feature = "libass-compare", not(feature = "nostd")))]
-fn test_animation_compatibility() {
-    let context = RenderContext::new(TEST_WIDTH, TEST_HEIGHT);
-    let config = TestConfig {
-        test_animations: true,
-        animation_step_cs: 10,          // 100ms steps
-        max_animation_duration_cs: 500, // 5 seconds
-        ..Default::default()
-    };
-
-    let mut tester = CompatibilityTester::new(context, config).expect("Failed to create tester");
-
-    let script_content = r#"[Script Info]
-Title: Animation Test
-PlayResX: 1920
-PlayResY: 1080
-
-[V4+ Styles]
-Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: Default,Arial,48,&H00FFFFFF,&H000000FF,&H00000000,&H80000000,0,0,0,0,100,100,0,0,1,2,1,2,50,50,50,1
-
-[Events]
-Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-Dialogue: 0,0:00:00.00,0:00:05.00,Default,,0,0,0,,{\move(100,500,1800,500,0,5000)}Moving text
-Dialogue: 0,0:00:00.00,0:00:05.00,Default,,0,0,0,,{\fad(500,500)}Fading text
-Dialogue: 0,0:00:00.00,0:00:05.00,Default,,0,0,0,,{\t(0,2000,\fs72)}Growing text"#;
-
-    let script = Script::parse(script_content).expect("Failed to parse script");
-    let result = tester
-        .test_script_compatibility(&script, "animation")
-        .expect("Test failed");
-
-    // Animation might have timing differences, allow more tolerance
-    assert!(
-        result.pixel_diff_percentage < 0.1,
-        "Animation test failed with {}% difference",
-        result.pixel_diff_percentage * 100.0
-    );
-}
-
-/// Test complex transformations
-#[test]
-#[cfg(all(feature = "libass-compare", not(feature = "nostd")))]
-fn test_transform_compatibility() {
-    let context = RenderContext::new(TEST_WIDTH, TEST_HEIGHT);
-    let config = TestConfig::default();
-
-    let mut tester = CompatibilityTester::new(context, config).expect("Failed to create tester");
-
-    let script_content = r#"[Script Info]
-Title: Transform Test
-PlayResX: 1920
-PlayResY: 1080
-
-[V4+ Styles]
-Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: Default,Arial,48,&H00FFFFFF,&H000000FF,&H00000000,&H80000000,0,0,0,0,100,100,0,0,1,2,1,2,50,50,50,1
-
-[Events]
-Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,{\frz45}Rotated text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,{\fscx150\fscy75}Scaled text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,{\fax0.3}Sheared text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,{\org(960,540)\frz90}Rotated around center"#;
-
-    let script = Script::parse(script_content).expect("Failed to parse script");
-    let result = tester
-        .test_script_compatibility(&script, "transforms")
-        .expect("Test failed");
-
-    // Transforms are complex and may have implementation differences
-    assert!(
-        result.pixel_diff_percentage < 0.08,
-        "Transform test failed with {}% difference",
-        result.pixel_diff_percentage * 100.0
-    );
-}
-
-/// Test karaoke effects
-#[test]
-#[cfg(all(feature = "libass-compare", not(feature = "nostd")))]
-fn test_karaoke_compatibility() {
-    let context = RenderContext::new(TEST_WIDTH, TEST_HEIGHT);
-    let config = TestConfig {
-        test_animations: true,
-        animation_step_cs: 5,            // 50ms steps for karaoke
-        max_animation_duration_cs: 1000, // 10 seconds
-        ..Default::default()
-    };
-
-    let mut tester = CompatibilityTester::new(context, config).expect("Failed to create tester");
-
-    let script_content = r#"[Script Info]
-Title: Karaoke Test
-PlayResX: 1920
-PlayResY: 1080
-
-[V4+ Styles]
-Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: Default,Arial,48,&H00FFFFFF,&H000000FF,&H00FF0000,&H80000000,0,0,0,0,100,100,0,0,1,2,1,2,50,50,50,1
-
-[Events]
-Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,karaoke,{\k30}Ka{\k30}ra{\k30}o{\k30}ke {\k30}test
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,{\kf50}Smooth {\kf50}karaoke"#;
-
-    let script = Script::parse(script_content).expect("Failed to parse script");
-    let result = tester
-        .test_script_compatibility(&script, "karaoke")
-        .expect("Test failed");
-
-    // Karaoke timing is complex, allow higher tolerance
-    assert!(
-        result.pixel_diff_percentage < 0.15,
-        "Karaoke test failed with {}% difference",
-        result.pixel_diff_percentage * 100.0
-    );
-}
-
-/// Test drawing commands
-#[test]
-#[cfg(all(feature = "libass-compare", not(feature = "nostd")))]
-fn test_drawing_compatibility() {
-    let context = RenderContext::new(TEST_WIDTH, TEST_HEIGHT);
-    let config = TestConfig::default();
-
-    let mut tester = CompatibilityTester::new(context, config).expect("Failed to create tester");
-
-    let script_content = r#"[Script Info]
-Title: Drawing Test
-PlayResX: 1920
-PlayResY: 1080
-
-[V4+ Styles]
-Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: Default,Arial,48,&H00FFFFFF,&H000000FF,&H00000000,&H80000000,0,0,0,0,100,100,0,0,1,2,1,2,50,50,50,1
-
-[Events]
-Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,{\p1}m 100 100 l 200 100 200 200 100 200{\p0}
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,{\p1}m 300 300 b 400 250 500 350 600 300{\p0}"#;
-
-    let script = Script::parse(script_content).expect("Failed to parse script");
-    let result = tester
-        .test_script_compatibility(&script, "drawing")
-        .expect("Test failed");
-
-    // Drawing commands might have differences in curve rendering
-    assert!(
-        result.pixel_diff_percentage < 0.1,
-        "Drawing test failed with {}% difference",
-        result.pixel_diff_percentage * 100.0
-    );
-}
-
-/// Test edge cases and error handling
-#[test]
-#[cfg(all(feature = "libass-compare", not(feature = "nostd")))]
-fn test_edge_cases_compatibility() {
-    let context = RenderContext::new(TEST_WIDTH, TEST_HEIGHT);
-    let config = TestConfig::default();
-
-    let mut tester = CompatibilityTester::new(context, config).expect("Failed to create tester");
-
-    let script_content = r#"[Script Info]
-Title: Edge Cases Test
-PlayResX: 1920
-PlayResY: 1080
-
-[V4+ Styles]
-Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: Default,Arial,48,&H00FFFFFF,&H000000FF,&H00000000,&H80000000,0,0,0,0,100,100,0,0,1,2,1,2,50,50,50,1
-
-[Events]
-Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,{\fs0}Zero size
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,{\pos(-100,-100)}Off screen
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,{\c&HINVALID&}Invalid color
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,{\unknown}Unknown tag"#;
-
-    let script = Script::parse(script_content).expect("Failed to parse script");
-    let result = tester
-        .test_script_compatibility(&script, "edge_cases")
-        .expect("Test failed");
-
-    // Edge cases should still maintain compatibility
-    assert!(
-        result.pixel_diff_percentage < 0.02,
-        "Edge cases test failed with {}% difference",
-        result.pixel_diff_percentage * 100.0
-    );
-}
-
-/// Run comprehensive test suite
-#[test]
-#[ignore] // Ignored: libass FFI comparison framework is unreliable. Visual regression testing uses mpv reference frames + ass-tool compare instead.
-#[cfg(all(feature = "libass-compare", not(feature = "nostd")))]
-fn test_comprehensive_compatibility_suite() {
-    let context = RenderContext::new(TEST_WIDTH, TEST_HEIGHT);
-    let config = TestConfig {
-        generate_visual_diffs: true,
-        output_dir: "test_output/comprehensive".to_string(),
-        ..Default::default()
-    };
-
-    let mut test_suite =
-        CompatibilityTestSuite::new(context, config).expect("Failed to create test suite");
-
-    // Add various test cases
-    test_suite.add_test_case("basic_dialogue".to_string(), create_basic_dialogue_script());
-    test_suite.add_test_case(
-        "complex_styling".to_string(),
-        create_complex_styling_script(),
-    );
-    test_suite.add_test_case("multi_language".to_string(), create_multi_language_script());
-    test_suite.add_test_case(
-        "performance_stress".to_string(),
-        create_performance_stress_script(),
-    );
-
-    let results = test_suite.run_all_tests().expect("Test suite failed");
-
-    // Check overall compatibility
-    let total_tests = results.len();
-    let passed_tests = results.iter().filter(|r| r.passed).count();
-    let avg_diff =
-        results.iter().map(|r| r.pixel_diff_percentage).sum::<f64>() / total_tests as f64;
-
-    println!("Compatibility Test Results:");
-    println!(
-        "  Passed: {}/{} ({:.1}%)",
-        passed_tests,
-        total_tests,
-        (passed_tests as f64 / total_tests as f64) * 100.0
-    );
-    println!("  Average difference: {:.3}%", avg_diff * 100.0);
-
-    // At least 80% of tests should pass
-    assert!(
-        passed_tests as f64 / total_tests as f64 >= 0.8,
-        "Less than 80% of compatibility tests passed"
-    );
-
-    // Average difference should be less than 2%
-    assert!(
-        avg_diff < 0.02,
-        "Average pixel difference too high: {:.3}%",
-        avg_diff * 100.0
-    );
-}
-
-// Helper functions to create test scripts
-
-#[cfg(all(feature = "libass-compare", not(feature = "nostd")))]
-fn create_basic_dialogue_script() -> String {
-    r#"[Script Info]
-Title: Basic Dialogue
-PlayResX: 1920
-PlayResY: 1080
-
-[V4+ Styles]
-Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: Default,Arial,48,&H00FFFFFF,&H000000FF,&H00000000,&H80000000,0,0,0,0,100,100,0,0,1,2,1,2,50,50,50,1
-
-[Events]
-Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,This is a basic dialogue line.
-Dialogue: 0,0:00:02.00,0:00:06.00,Default,,0,0,0,,This is another line with different timing."#.to_string()
-}
-
-#[cfg(all(feature = "libass-compare", not(feature = "nostd")))]
-fn create_complex_styling_script() -> String {
-    r#"[Script Info]
-Title: Complex Styling
-PlayResX: 1920
-PlayResY: 1080
-
-[V4+ Styles]
-Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: Default,Arial,48,&H00FFFFFF,&H000000FF,&H00000000,&H80000000,0,0,0,0,100,100,0,0,1,2,1,2,50,50,50,1
-Style: Title,Arial,72,&H00FFFF00,&H000000FF,&H00000000,&H80000000,1,0,0,0,120,120,5,0,1,3,2,2,100,100,100,1
-
-[Events]
-Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-Dialogue: 0,0:00:01.00,0:00:05.00,Title,,0,0,0,,{\pos(960,200)}Main Title
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,{\c&H00FF00&\b1}Green bold text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,{\blur2\c&HFF0000&}Blurred red text"#.to_string()
-}
-
-#[cfg(all(feature = "libass-compare", not(feature = "nostd")))]
-fn create_multi_language_script() -> String {
-    r#"[Script Info]
-Title: Multi Language
-PlayResX: 1920
-PlayResY: 1080
-
-[V4+ Styles]
-Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: Default,Arial,48,&H00FFFFFF,&H000000FF,&H00000000,&H80000000,0,0,0,0,100,100,0,0,1,2,1,2,50,50,50,1
-
-[Events]
-Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,English text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,日本語テキスト
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,中文文本
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,العربية النص"#.to_string()
-}
-
-#[cfg(all(feature = "libass-compare", not(feature = "nostd")))]
-fn create_performance_stress_script() -> String {
-    let mut script = r#"[Script Info]
-Title: Performance Stress
-PlayResX: 1920
-PlayResY: 1080
-
-[V4+ Styles]
-Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: Default,Arial,48,&H00FFFFFF,&H000000FF,&H00000000,&H80000000,0,0,0,0,100,100,0,0,1,2,1,2,50,50,50,1
-
-[Events]
-Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text"#.to_string();
-
-    // Add many concurrent dialogue lines
-    for i in 0..20 {
-        script.push_str(&format!(
-            "\nDialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,{{\\pos({},{})}}Line {}",
-            100 + (i % 10) * 180,
-            100 + (i / 10) * 100,
-            i + 1
-        ));
-    }
-
-    script
-}
-
-// Stub tests when libass-compare is not available
-#[cfg(not(feature = "libass-compare"))]
-mod stub_tests {
-    #[test]
-    fn compatibility_tests_require_libass_feature() {
-        println!("Compatibility tests require 'libass-compare' feature to be enabled");
-        println!("Install libass and run with: cargo test --features libass-compare");
-    }
-}
diff --git a/crates/ass-renderer/tests/simple_compatibility_test.rs b/crates/ass-renderer/tests/simple_compatibility_test.rs
deleted file mode 100644
index 0b1ee53..0000000
--- a/crates/ass-renderer/tests/simple_compatibility_test.rs
+++ /dev/null
@@ -1,169 +0,0 @@
-//! Simple compatibility test without complex dependencies
-
-use ass_core::parser::Script;
-
-use ass_renderer::renderer::{RenderContext, Renderer};
-
-#[test]
-fn test_minimal_script_parsing() {
-    // Test basic parsing functionality available in minimal builds
-    let script_content = r#"[Script Info]
-Title: Minimal Test
-PlayResX: 1920
-PlayResY: 1080
-
-[V4+ Styles]
-Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: Default,Arial,48,&H00FFFFFF,&H000000FF,&H00000000,&H80000000,0,0,0,0,100,100,0,0,1,2,1,2,50,50,50,1
-
-[Events]
-Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,Hello World!"#;
-
-    let script = Script::parse(script_content).expect("Failed to parse script");
-
-    // Basic validation - this works without any backends
-    let sections = script.sections();
-    assert!(!sections.is_empty());
-    assert!(sections.len() >= 3); // Should have Script Info, Styles, and Events sections
-
-    println!("✅ Minimal parsing test passed!");
-}
-
-#[test]
-fn test_basic_script_parsing() {
-    // Test that we can parse a basic script
-    let script_content = r#"[Script Info]
-Title: Basic Test
-PlayResX: 1920
-PlayResY: 1080
-
-[V4+ Styles]
-Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: Default,Arial,48,&H00FFFFFF,&H000000FF,&H00000000,&H80000000,0,0,0,0,100,100,0,0,1,2,1,2,50,50,50,1
-
-[Events]
-Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,Hello World!"#;
-
-    let script = Script::parse(script_content).expect("Failed to parse script");
-
-    // Test that we can create a renderer
-    let context = RenderContext::new(1920, 1080);
-    let mut renderer = Renderer::new(context).expect("Failed to create renderer");
-
-    // Test that we can render a frame
-    renderer
-        .load_script(&script)
-        .expect("Failed to load script");
-    let frame = renderer
-        .render_frame(&script, 200)
-        .expect("Failed to render frame"); // 2 seconds
-
-    // Basic validation
-    assert_eq!(frame.width(), 1920);
-    assert_eq!(frame.height(), 1080);
-    assert!(!frame.data().is_empty());
-
-    println!("✅ Basic rendering test passed!");
-    println!("Frame size: {}x{}", frame.width(), frame.height());
-    println!("Data length: {} bytes", frame.data().len());
-}
-
-#[test]
-#[cfg(all(feature = "libass-compare", not(feature = "nostd")))]
-fn test_libass_rendering() {
-    // Test that libass renderer works
-    use ass_renderer::debug::LibassRenderer;
-
-    let script_content = r#"[Script Info]
-Title: Basic Test
-PlayResX: 1920
-PlayResY: 1080
-
-[V4+ Styles]
-Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: Default,Arial,48,&H00FFFFFF,&H000000FF,&H00000000,&H80000000,0,0,0,0,100,100,0,0,1,2,1,2,50,50,50,1
-
-[Events]
-Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,Hello World!"#;
-
-    let script = Script::parse(script_content).expect("Failed to parse script");
-    let mut libass_renderer =
-        LibassRenderer::new(1920, 1080).expect("Failed to create libass renderer");
-
-    let frame = libass_renderer
-        .render_frame(&script, 200)
-        .expect("Failed to render with libass");
-
-    assert_eq!(frame.width(), 1920);
-    assert_eq!(frame.height(), 1080);
-
-    println!("✅ libass rendering test passed!");
-    println!("Frame size: {}x{}", frame.width(), frame.height());
-}
-
-#[test]
-#[cfg(all(feature = "libass-compare", not(feature = "nostd")))]
-fn test_basic_comparison() {
-    // Simple pixel comparison test
-    use ass_renderer::debug::LibassRenderer;
-
-    let script_content = r#"[Script Info]
-Title: Comparison Test
-PlayResX: 1920
-PlayResY: 1080
-
-[V4+ Styles]
-Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: Default,Arial,48,&H00FFFFFF,&H000000FF,&H00000000,&H80000000,0,0,0,0,100,100,0,0,1,2,1,2,50,50,50,1
-
-[Events]
-Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,Test"#;
-
-    let script = Script::parse(script_content).expect("Failed to parse script");
-
-    // Render with our renderer
-    let context = RenderContext::new(1920, 1080);
-    let mut our_renderer = Renderer::new(context).expect("Failed to create our renderer");
-    our_renderer
-        .load_script(&script)
-        .expect("Failed to load script");
-    let our_frame = our_renderer
-        .render_frame(&script, 200)
-        .expect("Failed to render with our renderer");
-
-    // Render with libass
-    let mut libass_renderer =
-        LibassRenderer::new(1920, 1080).expect("Failed to create libass renderer");
-    let libass_frame = libass_renderer
-        .render_frame(&script, 200)
-        .expect("Failed to render with libass");
-
-    // Basic comparison
-    assert_eq!(our_frame.width(), libass_frame.width());
-    assert_eq!(our_frame.height(), libass_frame.height());
-
-    // Count non-transparent pixels in each frame
-    let our_pixels = count_non_transparent_pixels(our_frame.data());
-    let libass_pixels = count_non_transparent_pixels(libass_frame.data());
-
-    println!("✅ Basic comparison test completed!");
-    println!("Our renderer non-transparent pixels: {our_pixels}");
-    println!("libass non-transparent pixels: {libass_pixels}");
-
-    // If both have some pixels, that's a good sign
-    // (We're not expecting pixel-perfect match yet)
-    if our_pixels > 0 || libass_pixels > 0 {
-        println!("✅ At least one renderer produced visible output");
-    }
-}
-
-#[cfg(all(feature = "libass-compare", not(feature = "nostd")))]
-fn count_non_transparent_pixels(data: &[u8]) -> usize {
-    data.chunks(4)
-        .filter(|chunk| chunk.len() == 4 && chunk[3] > 0) // Alpha > 0
-        .count()
-}
diff --git a/crates/ass-renderer/tests/smoke_test.rs b/crates/ass-renderer/tests/smoke_test.rs
new file mode 100644
index 0000000..f780338
--- /dev/null
+++ b/crates/ass-renderer/tests/smoke_test.rs
@@ -0,0 +1,71 @@
+//! Simple compatibility test without complex dependencies
+
+use ass_core::parser::Script;
+
+use ass_renderer::renderer::{RenderContext, Renderer};
+
+#[test]
+fn test_minimal_script_parsing() {
+    // Test basic parsing functionality available in minimal builds
+    let script_content = r#"[Script Info]
+Title: Minimal Test
+PlayResX: 1920
+PlayResY: 1080
+
+[V4+ Styles]
+Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+Style: Default,Arial,48,&H00FFFFFF,&H000000FF,&H00000000,&H80000000,0,0,0,0,100,100,0,0,1,2,1,2,50,50,50,1
+
+[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,Hello World!"#;
+
+    let script = Script::parse(script_content).expect("Failed to parse script");
+
+    // Basic validation - this works without any backends
+    let sections = script.sections();
+    assert!(!sections.is_empty());
+    assert!(sections.len() >= 3); // Should have Script Info, Styles, and Events sections
+
+    println!("✅ Minimal parsing test passed!");
+}
+
+#[test]
+fn test_basic_script_parsing() {
+    // Test that we can parse a basic script
+    let script_content = r#"[Script Info]
+Title: Basic Test
+PlayResX: 1920
+PlayResY: 1080
+
+[V4+ Styles]
+Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+Style: Default,Arial,48,&H00FFFFFF,&H000000FF,&H00000000,&H80000000,0,0,0,0,100,100,0,0,1,2,1,2,50,50,50,1
+
+[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+Dialogue: 0,0:00:01.00,0:00:05.00,Default,,0,0,0,,Hello World!"#;
+
+    let script = Script::parse(script_content).expect("Failed to parse script");
+
+    // Test that we can create a renderer
+    let context = RenderContext::new(1920, 1080);
+    let mut renderer = Renderer::new(context).expect("Failed to create renderer");
+
+    // Test that we can render a frame
+    renderer
+        .load_script(&script)
+        .expect("Failed to load script");
+    let frame = renderer
+        .render_frame(&script, 200)
+        .expect("Failed to render frame"); // 2 seconds
+
+    // Basic validation
+    assert_eq!(frame.width(), 1920);
+    assert_eq!(frame.height(), 1080);
+    assert!(!frame.data().is_empty());
+
+    println!("✅ Basic rendering test passed!");
+    println!("Frame size: {}x{}", frame.width(), frame.height());
+    println!("Data length: {} bytes", frame.data().len());
+}