bug fixes & improvements & missing features & font loader

layout-engine/src/chart_layout.rs

@@ -0,0 +1,799 @@
+//! Shared chart layout computation — used by both SVG (chart_render) and PDF (pdf_render).
+//!
+//! This module extracts the **what to draw and where** logic into shared structs.
+//! Each renderer then handles the **how** (actual drawing calls) using these structs.
+
+use dreport_core::models::ChartType;
+
+pub const DEFAULT_COLORS: &[&str] = &[
+    "#4F46E5", "#10B981", "#F59E0B", "#EF4444", "#8B5CF6", "#EC4899", "#06B6D4", "#84CC16",
+];
+
+// ---------------------------------------------------------------------------
+// Shared structs
+// ---------------------------------------------------------------------------
+
+pub struct ChartLayout {
+    /// Absolute plot area origin X (mm). For SVG this equals margin_left;
+    /// for PDF this is base_x_mm + margin_left.
+    pub plot_x: f64,
+    /// Absolute plot area origin Y (mm).
+    pub plot_y: f64,
+    pub plot_w: f64,
+    pub plot_h: f64,
+    pub margin_top: f64,
+    pub margin_bottom: f64,
+    pub margin_left: f64,
+    pub margin_right: f64,
+    pub palette: Vec<String>,
+    pub title: Option<TitleLayout>,
+    pub legend_show: bool,
+    pub legend_pos: String,
+    pub legend_font: f64,
+}
+
+pub struct TitleLayout {
+    pub text: String,
+    pub font_size: f64,
+    pub color: String,
+    /// x position in mm (absolute)
+    pub x: f64,
+    /// y position in mm (absolute)
+    pub y: f64,
+    pub align: String, // "left", "center", "right"
+}
+
+pub struct YAxisLayout {
+    pub ticks: Vec<YTick>,
+    pub show_grid: bool,
+    pub grid_color: String,
+    /// Y axis vertical line positions (mm, absolute)
+    pub axis_x: f64,
+    pub axis_y_start: f64,
+    pub axis_y_end: f64,
+    /// Right edge of the grid lines (axis_x + plot_w)
+    pub grid_end_x: f64,
+}
+
+pub struct YTick {
+    pub value: f64,
+    pub label: String,
+    /// Absolute Y position (mm)
+    pub y: f64,
+}
+
+pub struct XLabelLayout {
+    pub labels: Vec<XLabel>,
+    pub needs_rotate: bool,
+}
+
+pub struct XLabel {
+    pub text: String,
+    /// Absolute X position (mm)
+    pub x: f64,
+    /// Absolute Y position (mm)
+    pub y: f64,
+}
+
+/// Pre-computed bar geometry for a single bar rect
+pub struct BarRect {
+    pub x: f64,
+    pub y: f64,
+    pub w: f64,
+    pub h: f64,
+    pub color_idx: usize,
+    pub value: f64,
+    /// Label position (center x, label y)
+    pub label_x: f64,
+    pub label_y: f64,
+}
+
+pub struct BarChartLayout {
+    pub min_val: f64,
+    pub max_val: f64,
+    pub y_axis: YAxisLayout,
+    pub x_labels: XLabelLayout,
+    pub bars: Vec<BarRect>,
+    pub show_labels: bool,
+    pub label_font: f64,
+    pub label_color: String,
+    pub stacked: bool,
+    /// X axis line endpoints
+    pub x_axis_y: f64,
+    pub x_axis_x1: f64,
+    pub x_axis_x2: f64,
+}
+
+/// Pre-computed point position for line chart
+pub struct LinePoint {
+    pub x: f64,
+    pub y: f64,
+    pub value: f64,
+}
+
+pub struct LineSeriesLayout {
+    pub color_idx: usize,
+    pub points: Vec<LinePoint>,
+}
+
+pub struct LineChartLayout {
+    pub min_val: f64,
+    pub max_val: f64,
+    pub y_axis: YAxisLayout,
+    pub x_labels: XLabelLayout,
+    pub series: Vec<LineSeriesLayout>,
+    pub line_width: f64,
+    pub show_points: bool,
+    pub show_labels: bool,
+    pub label_font: f64,
+    pub label_color: String,
+    /// X axis line endpoints
+    pub x_axis_y: f64,
+    pub x_axis_x1: f64,
+    pub x_axis_x2: f64,
+}
+
+pub struct PieSlice {
+    pub start_angle: f64,
+    pub end_angle: f64,
+    pub sweep: f64,
+    pub color_idx: usize,
+    pub value: f64,
+    pub fraction: f64,
+    /// Label position inside slice
+    pub label_x: f64,
+    pub label_y: f64,
+    pub label_text: String,
+    /// Leader line + category label outside
+    pub leader_start_x: f64,
+    pub leader_start_y: f64,
+    pub leader_end_x: f64,
+    pub leader_end_y: f64,
+    pub cat_label_x: f64,
+    pub cat_label_y: f64,
+    pub cat_label_text: String,
+    pub cat_label_anchor_end: bool, // true = end/right, false = start/left
+}
+
+pub struct PieChartLayout {
+    pub cx: f64,
+    pub cy: f64,
+    pub radius: f64,
+    pub inner_radius: f64,
+    pub slices: Vec<PieSlice>,
+    pub show_labels: bool,
+    pub label_font: f64,
+    pub label_color: String,
+}
+
+/// Legend item with pre-computed position
+pub struct LegendItemLayout {
+    pub name: String,
+    pub color_idx: usize,
+    /// Swatch rect position (mm)
+    pub swatch_x: f64,
+    pub swatch_y: f64,
+    /// Text position (mm)
+    pub text_x: f64,
+    pub text_y: f64,
+}
+
+pub struct LegendLayout {
+    pub items: Vec<LegendItemLayout>,
+    pub font_size: f64,
+    pub position: String,
+    pub swatch_size: f64,
+}
+
+// ---------------------------------------------------------------------------
+// Common input abstraction — both ResolvedChartData and ChartRenderData
+// can provide these values
+// ---------------------------------------------------------------------------
+
+/// Trait that abstracts over the two chart data representations used by
+/// SVG renderer (ResolvedChartData) and PDF renderer (ChartRenderData).
+pub trait ChartDataSource {
+    fn chart_type(&self) -> ChartType;
+    fn categories(&self) -> &[String];
+    fn series_count(&self) -> usize;
+    fn series_name(&self, idx: usize) -> &str;
+    fn series_values(&self, idx: usize) -> &[f64];
+    fn title_text(&self) -> Option<&str>;
+    fn title_font_size(&self) -> Option<f64>;
+    fn title_color(&self) -> Option<&str>;
+    fn title_align(&self) -> Option<&str>;
+    fn legend_show(&self) -> bool;
+    fn legend_position(&self) -> Option<&str>;
+    fn legend_font_size(&self) -> Option<f64>;
+    fn x_label(&self) -> Option<&str>;
+    fn y_label(&self) -> Option<&str>;
+    fn show_grid(&self) -> bool;
+    fn grid_color(&self) -> Option<&str>;
+    fn bar_gap(&self) -> Option<f64>;
+    fn stacked(&self) -> bool;
+    fn colors(&self) -> Option<&[String]>;
+    fn background_color(&self) -> Option<&str>;
+    fn show_labels(&self) -> bool;
+    fn label_font_size(&self) -> Option<f64>;
+    fn label_color(&self) -> Option<&str>;
+    fn inner_radius(&self) -> Option<f64>;
+    fn show_points(&self) -> Option<bool>;
+    fn line_width(&self) -> Option<f64>;
+}
+
+// ---------------------------------------------------------------------------
+// Impl for SVG renderer's ResolvedChartData
+// ---------------------------------------------------------------------------
+
+impl ChartDataSource for crate::data_resolve::ResolvedChartData {
+    fn chart_type(&self) -> ChartType { self.chart_type.clone() }
+    fn categories(&self) -> &[String] { &self.categories }
+    fn series_count(&self) -> usize { self.series.len() }
+    fn series_name(&self, idx: usize) -> &str { &self.series[idx].name }
+    fn series_values(&self, idx: usize) -> &[f64] { &self.series[idx].values }
+    fn title_text(&self) -> Option<&str> {
+        self.title.as_ref().map(|t| t.text.as_str()).filter(|t| !t.is_empty())
+    }
+    fn title_font_size(&self) -> Option<f64> { self.title.as_ref().and_then(|t| t.font_size) }
+    fn title_color(&self) -> Option<&str> { self.title.as_ref().and_then(|t| t.color.as_deref()) }
+    fn title_align(&self) -> Option<&str> { self.title.as_ref().and_then(|t| t.align.as_deref()) }
+    fn legend_show(&self) -> bool { self.legend.as_ref().is_some_and(|l| l.show) }
+    fn legend_position(&self) -> Option<&str> { self.legend.as_ref().and_then(|l| l.position.as_deref()) }
+    fn legend_font_size(&self) -> Option<f64> { self.legend.as_ref().and_then(|l| l.font_size) }
+    fn x_label(&self) -> Option<&str> { self.axis.as_ref().and_then(|a| a.x_label.as_deref()) }
+    fn y_label(&self) -> Option<&str> { self.axis.as_ref().and_then(|a| a.y_label.as_deref()) }
+    fn show_grid(&self) -> bool { self.axis.as_ref().and_then(|a| a.show_grid).unwrap_or(true) }
+    fn grid_color(&self) -> Option<&str> { self.axis.as_ref().and_then(|a| a.grid_color.as_deref()) }
+    fn bar_gap(&self) -> Option<f64> { self.style.bar_gap }
+    fn stacked(&self) -> bool { matches!(self.group_mode, Some(dreport_core::models::GroupMode::Stacked)) }
+    fn colors(&self) -> Option<&[String]> { self.style.colors.as_deref() }
+    fn background_color(&self) -> Option<&str> { self.style.background_color.as_deref() }
+    fn show_labels(&self) -> bool { self.labels.as_ref().is_some_and(|l| l.show) }
+    fn label_font_size(&self) -> Option<f64> { self.labels.as_ref().and_then(|l| l.font_size) }
+    fn label_color(&self) -> Option<&str> { self.labels.as_ref().and_then(|l| l.color.as_deref()) }
+    fn inner_radius(&self) -> Option<f64> { self.style.inner_radius }
+    fn show_points(&self) -> Option<bool> { self.style.show_points }
+    fn line_width(&self) -> Option<f64> { self.style.line_width }
+}
+
+// ---------------------------------------------------------------------------
+// Impl for PDF renderer's ChartRenderData
+// ---------------------------------------------------------------------------
+
+impl ChartDataSource for crate::ChartRenderData {
+    fn chart_type(&self) -> ChartType { self.chart_type.clone() }
+    fn categories(&self) -> &[String] { &self.categories }
+    fn series_count(&self) -> usize { self.series.len() }
+    fn series_name(&self, idx: usize) -> &str { &self.series[idx].name }
+    fn series_values(&self, idx: usize) -> &[f64] { &self.series[idx].values }
+    fn title_text(&self) -> Option<&str> {
+        self.title_text.as_deref().filter(|t| !t.is_empty())
+    }
+    fn title_font_size(&self) -> Option<f64> { self.title_font_size }
+    fn title_color(&self) -> Option<&str> { self.title_color.as_deref() }
+    fn title_align(&self) -> Option<&str> { self.title_align.as_deref() }
+    fn legend_show(&self) -> bool { self.legend_show }
+    fn legend_position(&self) -> Option<&str> { self.legend_position.as_deref() }
+    fn legend_font_size(&self) -> Option<f64> { self.legend_font_size }
+    fn x_label(&self) -> Option<&str> { self.x_label.as_deref() }
+    fn y_label(&self) -> Option<&str> { self.y_label.as_deref() }
+    fn show_grid(&self) -> bool { self.show_grid }
+    fn grid_color(&self) -> Option<&str> { self.grid_color.as_deref() }
+    fn bar_gap(&self) -> Option<f64> { self.bar_gap }
+    fn stacked(&self) -> bool { self.stacked }
+    fn colors(&self) -> Option<&[String]> {
+        if self.colors.is_empty() { None } else { Some(&self.colors) }
+    }
+    fn background_color(&self) -> Option<&str> { self.background_color.as_deref() }
+    fn show_labels(&self) -> bool { self.show_labels }
+    fn label_font_size(&self) -> Option<f64> { self.label_font_size }
+    fn label_color(&self) -> Option<&str> { self.label_color.as_deref() }
+    fn inner_radius(&self) -> Option<f64> { self.inner_radius }
+    fn show_points(&self) -> Option<bool> { self.show_points }
+    fn line_width(&self) -> Option<f64> { self.line_width }
+}
+
+// ---------------------------------------------------------------------------
+// Shared computation functions
+// ---------------------------------------------------------------------------
+
+pub fn color_at(palette: &[String], i: usize) -> &str {
+    &palette[i % palette.len()]
+}
+
+pub fn build_palette(data: &dyn ChartDataSource) -> Vec<String> {
+    let n_colors = data.categories().len().max(data.series_count()).max(1);
+    let user_colors = data.colors();
+    (0..n_colors)
+        .map(|i| {
+            if let Some(uc) = user_colors {
+                if i < uc.len() {
+                    return uc[i].clone();
+                }
+            }
+            DEFAULT_COLORS[i % DEFAULT_COLORS.len()].to_string()
+        })
+        .collect()
+}
+
+pub fn format_value(v: f64) -> String {
+    if v.abs() >= 1_000_000.0 {
+        format!("{:.1}M", v / 1_000_000.0)
+    } else if v.abs() >= 1_000.0 {
+        format!("{:.1}K", v / 1_000.0)
+    } else if v.fract().abs() < 1e-10 {
+        format!("{}", v as i64)
+    } else {
+        format!("{:.1}", v)
+    }
+}
+
+/// Compute the value range (min, max) across all series.
+pub fn compute_value_range(data: &dyn ChartDataSource, stacked: bool) -> (f64, f64) {
+    if data.series_count() == 0 {
+        return (0.0, 1.0);
+    }
+    if stacked {
+        let n = data.categories().len();
+        let mut max_stack = 0.0_f64;
+        for ci in 0..n {
+            let sum: f64 = (0..data.series_count())
+                .map(|si| data.series_values(si).get(ci).copied().unwrap_or(0.0))
+                .sum();
+            max_stack = max_stack.max(sum);
+        }
+        (0.0, max_stack * 1.05)
+    } else {
+        let mut min_v = f64::MAX;
+        let mut max_v = f64::MIN;
+        for si in 0..data.series_count() {
+            for val in data.series_values(si) {
+                min_v = min_v.min(*val);
+                max_v = max_v.max(*val);
+            }
+        }
+        if min_v > 0.0 {
+            min_v = 0.0;
+        }
+        max_v *= 1.05;
+        (min_v, max_v)
+    }
+}
+
+fn safe_range(min_val: f64, max_val: f64) -> f64 {
+    let r = max_val - min_val;
+    if r.abs() < 1e-10 { 1.0 } else { r }
+}
+
+/// Compute margins and plot area. `origin_x/y` is 0 for SVG or base_x_mm/base_y_mm for PDF.
+pub fn compute_chart_layout(
+    data: &dyn ChartDataSource,
+    width_mm: f64,
+    height_mm: f64,
+    origin_x: f64,
+    origin_y: f64,
+) -> ChartLayout {
+    let palette = build_palette(data);
+
+    let mut margin_top = 2.0_f64;
+    let mut margin_bottom = 4.0_f64;
+    let mut margin_left = 8.0_f64;
+    let margin_right = 4.0_f64;
+
+    // Title
+    let title = if let Some(text) = data.title_text() {
+        let fs = data.title_font_size().unwrap_or(4.0);
+        margin_top += fs * 0.4 + 2.0;
+        let color = data.title_color().unwrap_or("#333333").to_string();
+        let align = data.title_align().unwrap_or("center").to_string();
+        let x = match align.as_str() {
+            "left" => origin_x + margin_left,
+            "right" => origin_x + width_mm - margin_right,
+            _ => origin_x + width_mm / 2.0,
+        };
+        let y = origin_y + margin_top - 1.0;
+        Some(TitleLayout { text: text.to_string(), font_size: fs, color, x, y, align })
+    } else {
+        None
+    };
+
+    // Legend space
+    let legend_show = data.legend_show();
+    let legend_pos = data.legend_position().unwrap_or("bottom").to_string();
+    let legend_font = data.legend_font_size().unwrap_or(2.8);
+
+    if legend_show && data.series_count() > 1 {
+        match legend_pos.as_str() {
+            "top" => margin_top += legend_font + 3.0,
+            "bottom" => margin_bottom += legend_font + 3.0,
+            _ => {}
+        }
+    }
+
+    // Axis labels space (bar and line only)
+    let has_axis = !matches!(data.chart_type(), ChartType::Pie);
+    if has_axis {
+        if data.x_label().is_some() {
+            margin_bottom += 4.0;
+        }
+        if data.y_label().is_some() {
+            margin_left += 4.0;
+        }
+        // Category labels bottom space
+        let max_label_len = data.categories().iter().map(|c| c.len()).max().unwrap_or(0);
+        let n_cats = data.categories().len();
+        let available_w = width_mm - margin_left - margin_right;
+        let cat_width = if n_cats > 0 { available_w / n_cats as f64 } else { available_w };
+        let max_chars_fit = (cat_width / 1.25).max(1.0) as usize;
+        let will_rotate = max_label_len > max_chars_fit;
+        if will_rotate {
+            let char_w_mm = 1.1;
+            let max_text_w = max_label_len as f64 * char_w_mm;
+            let label_v = max_text_w * 0.707;
+            margin_bottom += label_v.min(25.0).max(6.0);
+            let label_h = max_text_w * 0.707;
+            let extra_left = (label_h - cat_width / 2.0).max(0.0);
+            margin_left += extra_left.min(10.0);
+        } else {
+            margin_bottom += 4.0;
+        }
+        // Y-axis value labels left space
+        margin_left += 6.0;
+    }
+
+    let plot_x = origin_x + margin_left;
+    let plot_y = origin_y + margin_top;
+    let plot_w = (width_mm - margin_left - margin_right).max(1.0);
+    let plot_h = (height_mm - margin_top - margin_bottom).max(1.0);
+
+    ChartLayout {
+        plot_x, plot_y, plot_w, plot_h,
+        margin_top, margin_bottom, margin_left, margin_right,
+        palette, title, legend_show, legend_pos, legend_font,
+    }
+}
+
+/// Compute Y axis ticks and grid lines.
+pub fn compute_y_axis(
+    min_val: f64, max_val: f64,
+    px: f64, py: f64, pw: f64, ph: f64,
+    show_grid: bool, grid_color: &str,
+) -> YAxisLayout {
+    let range = safe_range(min_val, max_val);
+    let tick_count = 5;
+    let ticks = (0..=tick_count)
+        .map(|i| {
+            let frac = i as f64 / tick_count as f64;
+            let val = min_val + frac * range;
+            let y = py + ph - frac * ph;
+            YTick { value: val, label: format_value(val), y }
+        })
+        .collect();
+
+    YAxisLayout {
+        ticks,
+        show_grid,
+        grid_color: grid_color.to_string(),
+        axis_x: px,
+        axis_y_start: py,
+        axis_y_end: py + ph,
+        grid_end_x: px + pw,
+    }
+}
+
+/// Compute X label positions for bar chart (slot-based spacing).
+pub fn compute_x_labels_bar(categories: &[String], px: f64, baseline_y: f64, pw: f64) -> XLabelLayout {
+    let n_cats = categories.len();
+    if n_cats == 0 {
+        return XLabelLayout { labels: vec![], needs_rotate: false };
+    }
+    let cat_width = pw / n_cats as f64;
+    let max_chars = (cat_width / 1.25).max(1.0) as usize;
+    let needs_rotate = categories.iter().any(|c| c.len() > max_chars);
+    let labels = categories.iter().enumerate().map(|(ci, cat)| {
+        XLabel {
+            text: cat.clone(),
+            x: px + ci as f64 * cat_width + cat_width / 2.0,
+            y: baseline_y + 2.5,
+        }
+    }).collect();
+    XLabelLayout { labels, needs_rotate }
+}
+
+/// Compute X label positions for line chart (point-based spacing).
+pub fn compute_x_labels_line(categories: &[String], px: f64, baseline_y: f64, pw: f64) -> XLabelLayout {
+    let n_cats = categories.len();
+    if n_cats == 0 {
+        return XLabelLayout { labels: vec![], needs_rotate: false };
+    }
+    let spacing = if n_cats == 1 { pw } else { pw / (n_cats - 1) as f64 };
+    let max_chars = (spacing / 1.25).max(1.0) as usize;
+    let needs_rotate = categories.iter().any(|c| c.len() > max_chars);
+    let labels = categories.iter().enumerate().map(|(ci, cat)| {
+        let x = if n_cats == 1 { px + pw / 2.0 } else { px + ci as f64 * pw / (n_cats - 1) as f64 };
+        XLabel { text: cat.clone(), x, y: baseline_y + 2.5 }
+    }).collect();
+    XLabelLayout { labels, needs_rotate }
+}
+
+/// Compute bar chart layout (all bar geometries + axes).
+pub fn compute_bar_layout(data: &dyn ChartDataSource, cl: &ChartLayout) -> BarChartLayout {
+    let px = cl.plot_x;
+    let py = cl.plot_y;
+    let pw = cl.plot_w;
+    let ph = cl.plot_h;
+
+    let stacked = data.stacked();
+    let (min_val, max_val) = compute_value_range(data, stacked);
+    let range = safe_range(min_val, max_val);
+
+    let show_grid = data.show_grid();
+    let grid_color = data.grid_color().unwrap_or("#E5E7EB");
+    let y_axis = compute_y_axis(min_val, max_val, px, py, pw, ph, show_grid, grid_color);
+
+    let n_cats = data.categories().len();
+    let n_series = data.series_count();
+    let cat_width = if n_cats > 0 { pw / n_cats as f64 } else { pw };
+    let bar_gap = data.bar_gap().unwrap_or(0.2).clamp(0.0, 0.8);
+    let group_width = cat_width * (1.0 - bar_gap);
+
+    let show_labels = data.show_labels();
+    let label_font = data.label_font_size().unwrap_or(2.2);
+    let label_color = data.label_color().unwrap_or("#333").to_string();
+
+    let mut bars = Vec::new();
+
+    for ci in 0..n_cats {
+        let cat_x = px + ci as f64 * cat_width;
+        if stacked {
+            let mut y_offset = 0.0_f64;
+            for si in 0..n_series {
+                let val = data.series_values(si).get(ci).copied().unwrap_or(0.0);
+                let bar_h = (val / range) * ph;
+                let bar_y = py + ph - y_offset - bar_h;
+                let bx = cat_x + cat_width * bar_gap / 2.0;
+                bars.push(BarRect {
+                    x: bx,
+                    y: bar_y,
+                    w: group_width,
+                    h: bar_h.max(0.0),
+                    color_idx: si,
+                    value: val,
+                    label_x: cat_x + cat_width / 2.0,
+                    label_y: bar_y + bar_h / 2.0 + label_font * 0.15,
+                });
+                y_offset += bar_h;
+            }
+        } else {
+            let bar_w = if n_series > 0 { group_width / n_series as f64 } else { group_width };
+            for si in 0..n_series {
+                let val = data.series_values(si).get(ci).copied().unwrap_or(0.0);
+                let bar_h = ((val - min_val) / range) * ph;
+                let bx = cat_x + cat_width * bar_gap / 2.0 + si as f64 * bar_w;
+                let by = py + ph - bar_h;
+                bars.push(BarRect {
+                    x: bx,
+                    y: by,
+                    w: bar_w.max(0.1),
+                    h: bar_h.max(0.0),
+                    color_idx: si,
+                    value: val,
+                    label_x: bx + bar_w / 2.0,
+                    label_y: by - 0.8,
+                });
+            }
+        }
+    }
+
+    let x_labels = compute_x_labels_bar(data.categories(), px, py + ph, pw);
+
+    BarChartLayout {
+        min_val, max_val,
+        y_axis, x_labels, bars,
+        show_labels, label_font, label_color, stacked,
+        x_axis_y: py + ph,
+        x_axis_x1: px,
+        x_axis_x2: px + pw,
+    }
+}
+
+/// Compute line chart layout (all point positions + axes).
+pub fn compute_line_layout(data: &dyn ChartDataSource, cl: &ChartLayout) -> LineChartLayout {
+    let px = cl.plot_x;
+    let py = cl.plot_y;
+    let pw = cl.plot_w;
+    let ph = cl.plot_h;
+
+    let (min_val, max_val) = compute_value_range(data, false);
+    let range = safe_range(min_val, max_val);
+    let n_cats = data.categories().len();
+
+    let show_grid = data.show_grid();
+    let grid_color = data.grid_color().unwrap_or("#E5E7EB");
+    let y_axis = compute_y_axis(min_val, max_val, px, py, pw, ph, show_grid, grid_color);
+
+    let line_width = data.line_width().unwrap_or(0.5);
+    let show_points = data.show_points().unwrap_or(true);
+    let show_labels = data.show_labels();
+    let label_font = data.label_font_size().unwrap_or(2.2);
+    let label_color = data.label_color().unwrap_or("#333").to_string();
+
+    let series = (0..data.series_count()).map(|si| {
+        let values = data.series_values(si);
+        let points = values.iter().enumerate().map(|(ci, val)| {
+            let x = if n_cats == 1 { px + pw / 2.0 } else { px + ci as f64 * pw / (n_cats - 1) as f64 };
+            let y = py + ph - ((val - min_val) / range) * ph;
+            LinePoint { x, y, value: *val }
+        }).collect();
+        LineSeriesLayout { color_idx: si, points }
+    }).collect();
+
+    let x_labels = compute_x_labels_line(data.categories(), px, py + ph, pw);
+
+    LineChartLayout {
+        min_val, max_val,
+        y_axis, x_labels, series,
+        line_width: line_width,
+        show_points, show_labels, label_font, label_color,
+        x_axis_y: py + ph,
+        x_axis_x1: px,
+        x_axis_x2: px + pw,
+    }
+}
+
+/// Compute pie chart layout (slice angles and label positions).
+pub fn compute_pie_layout(data: &dyn ChartDataSource, cl: &ChartLayout) -> PieChartLayout {
+    let px = cl.plot_x;
+    let py = cl.plot_y;
+    let pw = cl.plot_w;
+    let ph = cl.plot_h;
+
+    let values: Vec<f64> = if data.series_count() == 1 {
+        data.series_values(0).to_vec()
+    } else {
+        data.categories().iter().enumerate().map(|(ci, _)| {
+            (0..data.series_count())
+                .map(|si| data.series_values(si).get(ci).copied().unwrap_or(0.0))
+                .sum()
+        }).collect()
+    };
+
+    let total: f64 = values.iter().sum();
+    let show_labels = data.show_labels();
+    let label_font = data.label_font_size().unwrap_or(3.0);
+    let label_color = data.label_color().unwrap_or("#333").to_string();
+
+    let cx = px + pw / 2.0;
+    let cy = py + ph / 2.0;
+    let radius = pw.min(ph) / 2.0 * 0.65;
+    let inner_frac = data.inner_radius().unwrap_or(0.0).clamp(0.0, 0.9);
+    let inner_r = radius * inner_frac;
+
+    let mut slices = Vec::new();
+
+    if total > 0.0 {
+        let mut start_angle = -std::f64::consts::FRAC_PI_2;
+        let categories = data.categories();
+
+        for (i, val) in values.iter().enumerate() {
+            if *val <= 0.0 {
+                start_angle += 0.0; // skip
+                continue;
+            }
+            let sweep = (val / total) * std::f64::consts::TAU;
+            let end_angle = start_angle + sweep;
+            let mid_angle = start_angle + sweep / 2.0;
+
+            // Label inside slice
+            let label_r = if inner_r > 0.0 { (radius + inner_r) / 2.0 } else { radius * 0.65 };
+            let lx = cx + label_r * mid_angle.cos();
+            let ly = cy + label_r * mid_angle.sin();
+            let pct = (val / total * 100.0).round();
+
+            // Leader line + category label
+            let line_start_r = radius;
+            let line_end_r = radius + 3.0;
+            let text_r = radius + 4.0;
+
+            let leader_sx = cx + line_start_r * mid_angle.cos();
+            let leader_sy = cy + line_start_r * mid_angle.sin();
+            let leader_ex = cx + line_end_r * mid_angle.cos();
+            let leader_ey = cy + line_end_r * mid_angle.sin();
+            let cat_lx = cx + text_r * mid_angle.cos();
+            let cat_ly = cy + text_r * mid_angle.sin();
+            let cat_text = if i < categories.len() { categories[i].clone() } else { String::new() };
+            let anchor_end = mid_angle.cos() < 0.0;
+
+            slices.push(PieSlice {
+                start_angle, end_angle, sweep,
+                color_idx: i,
+                value: *val,
+                fraction: val / total,
+                label_x: lx, label_y: ly,
+                label_text: format!("{}%", pct),
+                leader_start_x: leader_sx, leader_start_y: leader_sy,
+                leader_end_x: leader_ex, leader_end_y: leader_ey,
+                cat_label_x: cat_lx, cat_label_y: cat_ly,
+                cat_label_text: cat_text,
+                cat_label_anchor_end: anchor_end,
+            });
+
+            start_angle = end_angle;
+        }
+    }
+
+    PieChartLayout {
+        cx, cy, radius, inner_radius: inner_r,
+        slices, show_labels, label_font, label_color,
+    }
+}
+
+/// Compute legend item positions.
+pub fn compute_legend(
+    data: &dyn ChartDataSource,
+    cl: &ChartLayout,
+    origin_x: f64,
+    origin_y: f64,
+    total_w: f64,
+    total_h: f64,
+) -> LegendLayout {
+    let font_size = cl.legend_font;
+    let position = cl.legend_pos.clone();
+    let swatch_size = 2.5;
+    let item_gap = 3.0 + font_size * 0.4;
+    let spacing = 4.0;
+
+    let is_pie = matches!(data.chart_type(), ChartType::Pie);
+    let names: Vec<String> = if is_pie {
+        data.categories().to_vec()
+    } else {
+        (0..data.series_count()).map(|i| data.series_name(i).to_string()).collect()
+    };
+
+    let mut items = Vec::new();
+
+    match position.as_str() {
+        "top" => {
+            let y = origin_y + cl.margin_top - font_size - 1.5;
+            let mut x = origin_x + cl.margin_left;
+            for (i, name) in names.iter().enumerate() {
+                items.push(LegendItemLayout {
+                    name: name.clone(), color_idx: i,
+                    swatch_x: x, swatch_y: y - font_size * 0.3,
+                    text_x: x + item_gap, text_y: y + font_size * 0.3,
+                });
+                x += item_gap + name.len() as f64 * font_size * 0.5 + spacing;
+            }
+        }
+        "right" => {
+            let x = origin_x + cl.margin_left + cl.plot_w + 4.0;
+            let mut y = origin_y + cl.margin_top + 2.0;
+            for (i, name) in names.iter().enumerate() {
+                items.push(LegendItemLayout {
+                    name: name.clone(), color_idx: i,
+                    swatch_x: x, swatch_y: y,
+                    text_x: x + item_gap, text_y: y + font_size * 0.7,
+                });
+                y += font_size + 2.0;
+            }
+        }
+        _ => {
+            // bottom (default)
+            let y = origin_y + total_h - 3.0;
+            let total_legend_w: f64 = names.iter()
+                .map(|n| item_gap + n.len() as f64 * font_size * 0.5 + spacing)
+                .sum::<f64>() - spacing;
+            let mut x = origin_x + (total_w - total_legend_w) / 2.0;
+            for (i, name) in names.iter().enumerate() {
+                items.push(LegendItemLayout {
+                    name: name.clone(), color_idx: i,
+                    swatch_x: x, swatch_y: y - font_size * 0.3,
+                    text_x: x + item_gap, text_y: y + font_size * 0.3,
+                });
+                x += item_gap + name.len() as f64 * font_size * 0.5 + spacing;
+            }
+        }
+    }
+
+    LegendLayout { items, font_size, position, swatch_size }
+}

layout-engine/src/chart_render.rs

@@ -1,15 +1,10 @@
+use crate::chart_layout::{
+    self, color_at, compute_bar_layout, compute_chart_layout, compute_legend,
+    compute_line_layout, compute_pie_layout, format_value, ChartLayout,
+};
 use crate::data_resolve::ResolvedChartData;
-use dreport_core::models::{ChartType, GroupMode};
 use std::fmt::Write;
 
-pub const DEFAULT_COLORS: &[&str] = &[
-    "#4F46E5", "#10B981", "#F59E0B", "#EF4444", "#8B5CF6", "#EC4899", "#06B6D4", "#84CC16",
-];
-
-fn color_at(palette: &[String], i: usize) -> &str {
-    &palette[i % palette.len()]
-}
-
 /// mm cinsinden chart SVG uret
 pub fn render_svg(data: &ResolvedChartData, width_mm: f64, height_mm: f64) -> String {
     let mut svg = String::with_capacity(4096);
@@ -33,134 +28,40 @@ pub fn render_svg(data: &ResolvedChartData, width_mm: f64, height_mm: f64) -> St
     )
     .unwrap();
 
-    // Max sayida renk: kategoriler + seriler
-    let n_colors = data.categories.len().max(data.series.len()).max(1);
-    let palette: Vec<String> = (0..n_colors)
-        .map(|i| {
-            if let Some(ref user_colors) = data.style.colors {
-                if i < user_colors.len() {
-                    return user_colors[i].clone();
-                }
-            }
-            DEFAULT_COLORS[i % DEFAULT_COLORS.len()].to_string()
-        })
-        .collect();
-    // Margin hesaplari
-    let mut margin_top = 2.0_f64;
-    let mut margin_bottom = 4.0_f64;
-    let mut margin_left = 8.0_f64;
-    let margin_right = 4.0_f64;
+    let cl = compute_chart_layout(data, width_mm, height_mm, 0.0, 0.0);
 
     // Title
-    if let Some(ref title) = data.title {
-        if !title.text.is_empty() {
-            let font_size = title.font_size.unwrap_or(4.0);
-            margin_top += font_size * 0.4 + 2.0;
-            let color = title.color.as_deref().unwrap_or("#333333");
-            let align = title.align.as_deref().unwrap_or("center");
-            let x = match align {
-                "left" => margin_left,
-                "right" => width_mm - margin_right,
-                _ => width_mm / 2.0,
-            };
-            let anchor = match align {
-                "left" => "start",
-                "right" => "end",
-                _ => "middle",
-            };
-            write!(
-                svg,
-                r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="{}" text-anchor="{}" font-weight="bold">{}</text>"##,
-                x,
-                margin_top - 1.0,
-                font_size,
-                color,
-                anchor,
-                escape_xml(&title.text)
-            )
-            .unwrap();
-        }
-    }
-
-    // Legend space
-    let legend_show = data.legend.as_ref().is_some_and(|l| l.show);
-    let legend_pos = data
-        .legend
-        .as_ref()
-        .and_then(|l| l.position.as_deref())
-        .unwrap_or("bottom");
-    let legend_font = data
-        .legend
-        .as_ref()
-        .and_then(|l| l.font_size)
-        .unwrap_or(2.8);
-
-    if legend_show && data.series.len() > 1 {
-        match legend_pos {
-            "top" => margin_top += legend_font + 3.0,
-            "bottom" => margin_bottom += legend_font + 3.0,
-            _ => {} // right — icerde handle edilecek
-        }
-    }
-
-    // Axis labels icin yer ac (bar ve line)
-    let has_axis = !matches!(data.chart_type, ChartType::Pie);
-    if has_axis {
-        if data.axis.as_ref().and_then(|a| a.x_label.as_ref()).is_some() {
-            margin_bottom += 4.0;
-        }
-        if data.axis.as_ref().and_then(|a| a.y_label.as_ref()).is_some() {
-            margin_left += 4.0;
-        }
-        // Category labels icin alt bosluk
-        let max_label_len = data.categories.iter().map(|c| c.len()).max().unwrap_or(0);
-        let n_cats = data.categories.len();
-        let available_w = width_mm - margin_left - margin_right;
-        let cat_width = if n_cats > 0 {
-            available_w / n_cats as f64
-        } else {
-            available_w
+    if let Some(ref title) = cl.title {
+        let anchor = match title.align.as_str() {
+            "left" => "start",
+            "right" => "end",
+            _ => "middle",
         };
-        let max_chars_fit = (cat_width / 1.25).max(1.0) as usize;
-        let will_rotate = max_label_len > max_chars_fit;
-        if will_rotate {
-            // Rotated labels (-45°): dikey ≈ text_width * sin(45°), yatay ≈ text_width * cos(45°)
-            let char_w_mm = 1.1;
-            let max_text_w = max_label_len as f64 * char_w_mm;
-            let label_v = max_text_w * 0.707; // sin(45°)
-            margin_bottom += label_v.min(25.0).max(6.0);
-            // Sol taraftaki label yana tasabilir
-            let label_h = max_text_w * 0.707; // cos(45°)
-            let extra_left = (label_h - cat_width / 2.0).max(0.0);
-            margin_left += extra_left.min(10.0);
-        } else {
-            margin_bottom += 4.0;
-        }
-        // Y-axis value labels icin sol bosluk
-        margin_left += 6.0;
+        write!(
+            svg,
+            r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="{}" text-anchor="{}" font-weight="bold">{}</text>"##,
+            title.x, title.y, title.font_size, title.color, anchor, escape_xml(&title.text)
+        )
+        .unwrap();
     }
 
-    let plot_x = margin_left;
-    let plot_y = margin_top;
-    let plot_w = (width_mm - margin_left - margin_right).max(1.0);
-    let plot_h = (height_mm - margin_top - margin_bottom).max(1.0);
-
     match data.chart_type {
-        ChartType::Bar => render_bar(&mut svg, data, &palette, plot_x, plot_y, plot_w, plot_h),
-        ChartType::Line => render_line(&mut svg, data, &palette, plot_x, plot_y, plot_w, plot_h),
-        ChartType::Pie => render_pie(&mut svg, data, &palette, width_mm, height_mm, plot_x, plot_y, plot_w, plot_h),
+        dreport_core::models::ChartType::Bar => render_bar(&mut svg, data, &cl),
+        dreport_core::models::ChartType::Line => render_line(&mut svg, data, &cl),
+        dreport_core::models::ChartType::Pie => render_pie(&mut svg, data, &cl),
     }
 
     // Legend render
-    if legend_show && data.series.len() > 1 {
-        render_legend(&mut svg, data, &palette, legend_pos, legend_font, width_mm, height_mm, margin_left, margin_top, plot_w, plot_h);
+    if cl.legend_show && data.series.len() > 1 {
+        render_legend(&mut svg, data, &cl, width_mm, height_mm);
     }
 
     // Axis labels
+    let has_axis = !matches!(data.chart_type, dreport_core::models::ChartType::Pie);
     if has_axis {
         if let Some(ref axis) = data.axis {
             if let Some(ref x_label) = axis.x_label {
-                let x = plot_x + plot_w / 2.0;
+                let x = cl.plot_x + cl.plot_w / 2.0;
                 let y = height_mm - 2.0;
                 write!(
                     svg,
@@ -171,7 +72,7 @@ pub fn render_svg(data: &ResolvedChartData, width_mm: f64, height_mm: f64) -> St
             }
             if let Some(ref y_label) = axis.y_label {
                 let x = 3.0;
-                let y = plot_y + plot_h / 2.0;
+                let y = cl.plot_y + cl.plot_h / 2.0;
                 write!(
                     svg,
                     r##"<text x="{:.2}" y="{:.2}" font-size="2.8" fill="#666" text-anchor="middle" transform="rotate(-90,{:.2},{:.2})">{}</text>"##,
@@ -186,199 +87,91 @@ pub fn render_svg(data: &ResolvedChartData, width_mm: f64, height_mm: f64) -> St
     svg
 }
 
-fn render_bar(
-    svg: &mut String,
-    data: &ResolvedChartData,
-    palette: &[String],
-    px: f64,
-    py: f64,
-    pw: f64,
-    ph: f64,
-) {
+fn render_bar(svg: &mut String, data: &ResolvedChartData, cl: &ChartLayout) {
     if data.categories.is_empty() || data.series.is_empty() {
         return;
     }
 
-    let stacked = matches!(data.group_mode, Some(GroupMode::Stacked));
-    let (min_val, max_val) = value_range(data, stacked);
+    let bl = compute_bar_layout(data, cl);
 
-    let show_grid = data.axis.as_ref().and_then(|a| a.show_grid).unwrap_or(true);
-    let grid_color = data
-        .axis
-        .as_ref()
-        .and_then(|a| a.grid_color.as_deref())
-        .unwrap_or("#E5E7EB");
+    // Y axis
+    render_y_axis_svg(svg, &bl.y_axis);
 
-    // Grid + Y axis labels
-    render_y_axis(svg, min_val, max_val, px, py, pw, ph, show_grid, grid_color);
+    // Bars
+    for bar in &bl.bars {
+        let color = color_at(&cl.palette, bar.color_idx);
+        write!(
+            svg,
+            r##"<rect x="{:.2}" y="{:.2}" width="{:.2}" height="{:.2}" fill="{}" rx="0.5"/>"##,
+            bar.x, bar.y, bar.w, bar.h, color
+        )
+        .unwrap();
 
-    let n_cats = data.categories.len();
-    let n_series = data.series.len();
-    let cat_width = pw / n_cats as f64;
-    let bar_gap = data.style.bar_gap.unwrap_or(0.2).clamp(0.0, 0.8);
-    let group_width = cat_width * (1.0 - bar_gap);
-
-    let show_labels = data.labels.as_ref().is_some_and(|l| l.show);
-    let label_font = data.labels.as_ref().and_then(|l| l.font_size).unwrap_or(2.2);
-    let label_color = data
-        .labels
-        .as_ref()
-        .and_then(|l| l.color.as_deref())
-        .unwrap_or("#333");
-
-    let range = if (max_val - min_val).abs() < 1e-10 {
-        1.0
-    } else {
-        max_val - min_val
-    };
-
-    for ci in 0..data.categories.len() {
-        let cat_x = px + ci as f64 * cat_width;
-
-        if stacked {
-            let mut y_offset = 0.0_f64;
-            for (si, series) in data.series.iter().enumerate() {
-                let val = series.values.get(ci).copied().unwrap_or(0.0);
-                let bar_h = (val / range) * ph;
-                let bar_y = py + ph - y_offset - bar_h;
-                write!(
-                    svg,
-                    r##"<rect x="{:.2}" y="{:.2}" width="{:.2}" height="{:.2}" fill="{}" rx="0.5"/>"##,
-                    cat_x + cat_width * bar_gap / 2.0,
-                    bar_y,
-                    group_width,
-                    bar_h.max(0.0),
-                    color_at(palette,si)
-                )
-                .unwrap();
-                if show_labels && val > 0.0 {
+        if bl.show_labels {
+            if bl.stacked {
+                if bar.value > 0.0 {
                     write!(
                         svg,
                         r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="{}" text-anchor="middle">{}</text>"##,
-                        cat_x + cat_width / 2.0,
-                        bar_y + bar_h / 2.0 + label_font * 0.15,
-                        label_font,
-                        label_color,
-                        format_value(val)
+                        bar.label_x, bar.label_y, bl.label_font, bl.label_color, format_value(bar.value)
                     )
                     .unwrap();
                 }
-                y_offset += bar_h;
-            }
-        } else {
-            // Grouped
-            let bar_w = group_width / n_series as f64;
-            for (si, series) in data.series.iter().enumerate() {
-                let val = series.values.get(ci).copied().unwrap_or(0.0);
-                let bar_h = ((val - min_val) / range) * ph;
-                let bar_x = cat_x + cat_width * bar_gap / 2.0 + si as f64 * bar_w;
-                let bar_y = py + ph - bar_h;
+            } else {
                 write!(
                     svg,
-                    r##"<rect x="{:.2}" y="{:.2}" width="{:.2}" height="{:.2}" fill="{}" rx="0.5"/>"##,
-                    bar_x,
-                    bar_y,
-                    bar_w.max(0.1),
-                    bar_h.max(0.0),
-                    color_at(palette,si)
+                    r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="{}" text-anchor="middle">{}</text>"##,
+                    bar.label_x, bar.label_y, bl.label_font, bl.label_color, format_value(bar.value)
                 )
                 .unwrap();
-                if show_labels {
-                    write!(
-                        svg,
-                        r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="{}" text-anchor="middle">{}</text>"##,
-                        bar_x + bar_w / 2.0,
-                        bar_y - 0.8,
-                        label_font,
-                        label_color,
-                        format_value(val)
-                    )
-                    .unwrap();
-                }
             }
         }
-
     }
 
-    // X axis labels — rotate if too many categories
-    render_x_labels(svg, &data.categories, px, py + ph, pw, n_cats);
+    // X axis labels
+    render_x_labels_svg(svg, &bl.x_labels);
 
     // X axis line
     write!(
         svg,
         r##"<line x1="{:.2}" y1="{:.2}" x2="{:.2}" y2="{:.2}" stroke="#9CA3AF" stroke-width="0.3"/>"##,
-        px, py + ph, px + pw, py + ph
+        bl.x_axis_x1, bl.x_axis_y, bl.x_axis_x2, bl.x_axis_y
     )
     .unwrap();
 }
 
-fn render_line(
-    svg: &mut String,
-    data: &ResolvedChartData,
-    palette: &[String],
-    px: f64,
-    py: f64,
-    pw: f64,
-    ph: f64,
-) {
+fn render_line(svg: &mut String, data: &ResolvedChartData, cl: &ChartLayout) {
     if data.categories.is_empty() || data.series.is_empty() {
         return;
     }
 
-    let (min_val, max_val) = value_range(data, false);
-    let range = if (max_val - min_val).abs() < 1e-10 {
-        1.0
-    } else {
-        max_val - min_val
-    };
+    let ll = compute_line_layout(data, cl);
 
-    let show_grid = data.axis.as_ref().and_then(|a| a.show_grid).unwrap_or(true);
-    let grid_color = data
-        .axis
-        .as_ref()
-        .and_then(|a| a.grid_color.as_deref())
-        .unwrap_or("#E5E7EB");
-    render_y_axis(svg, min_val, max_val, px, py, pw, ph, show_grid, grid_color);
+    // Y axis
+    render_y_axis_svg(svg, &ll.y_axis);
 
-    let n_cats = data.categories.len();
-    let line_w = data.style.line_width.unwrap_or(0.5);
-    let show_points = data.style.show_points.unwrap_or(true);
-    let show_labels = data.labels.as_ref().is_some_and(|l| l.show);
-    let label_font = data.labels.as_ref().and_then(|l| l.font_size).unwrap_or(2.2);
-    let label_color = data
-        .labels
-        .as_ref()
-        .and_then(|l| l.color.as_deref())
-        .unwrap_or("#333");
-
-    for (si, series) in data.series.iter().enumerate() {
-        let color = color_at(palette,si);
+    for series_layout in &ll.series {
+        let color = color_at(&cl.palette, series_layout.color_idx);
         let mut points = String::new();
         let mut point_circles = String::new();
 
-        for (ci, val) in series.values.iter().enumerate() {
-            let x = if n_cats == 1 {
-                px + pw / 2.0
-            } else {
-                px + ci as f64 * pw / (n_cats - 1) as f64
-            };
-            let y = py + ph - ((val - min_val) / range) * ph;
-            write!(points, "{:.2},{:.2} ", x, y).unwrap();
+        for pt in &series_layout.points {
+            write!(points, "{:.2},{:.2} ", pt.x, pt.y).unwrap();
 
-            if show_points {
+            if ll.show_points {
                 write!(
                     point_circles,
                     r##"<circle cx="{:.2}" cy="{:.2}" r="0.8" fill="{}" stroke="white" stroke-width="0.3"/>"##,
-                    x, y, color
+                    pt.x, pt.y, color
                 )
                 .unwrap();
             }
 
-            if show_labels {
+            if ll.show_labels {
                 write!(
                     svg,
                     r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="{}" text-anchor="middle">{}</text>"##,
-                    x, y - 1.5, label_font, label_color, format_value(*val)
+                    pt.x, pt.y - 1.5, ll.label_font, ll.label_color, format_value(pt.value)
                 )
                 .unwrap();
             }
@@ -387,100 +180,50 @@ fn render_line(
         write!(
             svg,
             r##"<polyline points="{}" fill="none" stroke="{}" stroke-width="{:.2}" stroke-linejoin="round" stroke-linecap="round"/>"##,
-            points.trim(),
-            color,
-            line_w
+            points.trim(), color, ll.line_width
         )
         .unwrap();
         svg.push_str(&point_circles);
     }
 
-    // X axis labels — for line chart, spacing is different
-    render_x_labels_line(svg, &data.categories, px, py + ph, pw, n_cats);
+    // X axis labels
+    render_x_labels_svg(svg, &ll.x_labels);
 
-    // Axis lines
+    // Axis line
     write!(
         svg,
         r##"<line x1="{:.2}" y1="{:.2}" x2="{:.2}" y2="{:.2}" stroke="#9CA3AF" stroke-width="0.3"/>"##,
-        px, py + ph, px + pw, py + ph
+        ll.x_axis_x1, ll.x_axis_y, ll.x_axis_x2, ll.x_axis_y
     )
     .unwrap();
 }
 
-fn render_pie(
-    svg: &mut String,
-    data: &ResolvedChartData,
-    palette: &[String],
-    _total_w: f64,
-    _total_h: f64,
-    px: f64,
-    py: f64,
-    pw: f64,
-    ph: f64,
-) {
-    // Pie icin ilk serinin degerlerini kullan (veya tum serilerin toplamlarini)
-    let values: Vec<f64> = if data.series.len() == 1 {
-        data.series[0].values.clone()
-    } else {
-        // Birden fazla seri varsa, her kategori icin toplam al
-        data.categories
-            .iter()
-            .enumerate()
-            .map(|(ci, _)| {
-                data.series
-                    .iter()
-                    .map(|s| s.values.get(ci).copied().unwrap_or(0.0))
-                    .sum()
-            })
-            .collect()
-    };
+fn render_pie(svg: &mut String, data: &ResolvedChartData, cl: &ChartLayout) {
+    let pl = compute_pie_layout(data, cl);
 
-    let total: f64 = values.iter().sum();
-    if total <= 0.0 || data.categories.is_empty() {
+    if pl.slices.is_empty() {
         return;
     }
 
-    let cx = px + pw / 2.0;
-    let cy = py + ph / 2.0;
-    let radius = pw.min(ph) / 2.0 * 0.65;
-    let inner_frac = data.style.inner_radius.unwrap_or(0.0).clamp(0.0, 0.9);
-    let inner_r = radius * inner_frac;
+    let cx = pl.cx;
+    let cy = pl.cy;
+    let radius = pl.radius;
+    let inner_r = pl.inner_radius;
 
-    let show_labels = data.labels.as_ref().is_some_and(|l| l.show);
-    let label_font = data.labels.as_ref().and_then(|l| l.font_size).unwrap_or(3.0);
-    let label_color = data
-        .labels
-        .as_ref()
-        .and_then(|l| l.color.as_deref())
-        .unwrap_or("#333");
+    for slice in &pl.slices {
+        let color = color_at(&cl.palette, slice.color_idx);
+        let large_arc = if slice.sweep > std::f64::consts::PI { 1 } else { 0 };
 
-    let mut start_angle = -std::f64::consts::FRAC_PI_2; // 12 o'clock
-
-    for (i, val) in values.iter().enumerate() {
-        if *val <= 0.0 {
-            continue;
-        }
-        let sweep = (val / total) * std::f64::consts::TAU;
-        let end_angle = start_angle + sweep;
-        let large_arc = if sweep > std::f64::consts::PI {
-            1
-        } else {
-            0
-        };
-
-        let x1 = cx + radius * start_angle.cos();
-        let y1 = cy + radius * start_angle.sin();
-        let x2 = cx + radius * end_angle.cos();
-        let y2 = cy + radius * end_angle.sin();
-
-        let color = color_at(palette,i);
+        let x1 = cx + radius * slice.start_angle.cos();
+        let y1 = cy + radius * slice.start_angle.sin();
+        let x2 = cx + radius * slice.end_angle.cos();
+        let y2 = cy + radius * slice.end_angle.sin();
 
         if inner_r > 0.0 {
-            // Donut
-            let ix1 = cx + inner_r * start_angle.cos();
-            let iy1 = cy + inner_r * start_angle.sin();
-            let ix2 = cx + inner_r * end_angle.cos();
-            let iy2 = cy + inner_r * end_angle.sin();
+            let ix1 = cx + inner_r * slice.start_angle.cos();
+            let iy1 = cy + inner_r * slice.start_angle.sin();
+            let ix2 = cx + inner_r * slice.end_angle.cos();
+            let iy2 = cy + inner_r * slice.end_angle.sin();
             write!(
                 svg,
                 r##"<path d="M {:.2} {:.2} A {:.2} {:.2} 0 {} 1 {:.2} {:.2} L {:.2} {:.2} A {:.2} {:.2} 0 {} 0 {:.2} {:.2} Z" fill="{}" stroke="white" stroke-width="0.3"/>"##,
@@ -490,7 +233,6 @@ fn render_pie(
             )
             .unwrap();
         } else {
-            // Full pie
             write!(
                 svg,
                 r##"<path d="M {:.2} {:.2} L {:.2} {:.2} A {:.2} {:.2} 0 {} 1 {:.2} {:.2} Z" fill="{}" stroke="white" stroke-width="0.3"/>"##,
@@ -500,258 +242,75 @@ fn render_pie(
         }
 
         // Percentage label inside slice
-        if show_labels {
-            let mid_angle = start_angle + sweep / 2.0;
-            let label_r = if inner_r > 0.0 {
-                (radius + inner_r) / 2.0
-            } else {
-                radius * 0.65
-            };
-            let lx = cx + label_r * mid_angle.cos();
-            let ly = cy + label_r * mid_angle.sin();
-            let pct = (val / total * 100.0).round();
+        if pl.show_labels {
             write!(
                 svg,
                 r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="{}" text-anchor="middle" dominant-baseline="central">{}%</text>"##,
-                lx, ly, label_font, label_color, pct
+                slice.label_x, slice.label_y, pl.label_font, pl.label_color,
+                (slice.fraction * 100.0).round()
             )
             .unwrap();
         }
 
         // Category name label outside slice with leader line
-        if i < data.categories.len() {
-            let mid_angle = start_angle + sweep / 2.0;
-            let line_start_r = radius; // starts at pie edge
-            let line_end_r = radius + 3.0;
-            let text_r = radius + 4.0;
-
-            // Leader line from pie edge to label
-            let lx1 = cx + line_start_r * mid_angle.cos();
-            let ly1 = cy + line_start_r * mid_angle.sin();
-            let lx2 = cx + line_end_r * mid_angle.cos();
-            let ly2 = cy + line_end_r * mid_angle.sin();
+        if !slice.cat_label_text.is_empty() {
             write!(
                 svg,
                 r##"<line x1="{:.2}" y1="{:.2}" x2="{:.2}" y2="{:.2}" stroke="#999" stroke-width="0.2"/>"##,
-                lx1, ly1, lx2, ly2
+                slice.leader_start_x, slice.leader_start_y,
+                slice.leader_end_x, slice.leader_end_y
             )
             .unwrap();
 
-            // Category text
-            let tx = cx + text_r * mid_angle.cos();
-            let ty = cy + text_r * mid_angle.sin();
-            let anchor = if mid_angle.cos() >= 0.0 { "start" } else { "end" };
+            let anchor = if slice.cat_label_anchor_end { "end" } else { "start" };
             write!(
                 svg,
                 r##"<text x="{:.2}" y="{:.2}" font-size="2.5" fill="#555" text-anchor="{}" dominant-baseline="central">{}</text>"##,
-                tx, ty, anchor, escape_xml(&data.categories[i])
+                slice.cat_label_x, slice.cat_label_y, anchor, escape_xml(&slice.cat_label_text)
             )
             .unwrap();
         }
-
-        start_angle = end_angle;
     }
 }
 
-fn render_legend(
-    svg: &mut String,
-    data: &ResolvedChartData,
-    palette: &[String],
-    position: &str,
-    font_size: f64,
-    total_w: f64,
-    total_h: f64,
-    margin_left: f64,
-    margin_top: f64,
-    plot_w: f64,
-    _plot_h: f64,
-) {
-    let names: Vec<&str> = if matches!(data.chart_type, ChartType::Pie) {
-        data.categories.iter().map(|s| s.as_str()).collect()
-    } else {
-        data.series.iter().map(|s| s.name.as_str()).collect()
-    };
+fn render_legend(svg: &mut String, data: &ResolvedChartData, cl: &ChartLayout, total_w: f64, total_h: f64) {
+    let legend = compute_legend(data, cl, 0.0, 0.0, total_w, total_h);
 
-    let item_w = 3.0 + font_size * 0.4; // color rect + gap
-    let spacing = 4.0;
-
-    match position {
-        "top" => {
-            let y = margin_top - font_size - 1.5;
-            let mut x = margin_left;
-            for (i, name) in names.iter().enumerate() {
-                write!(
-                    svg,
-                    r##"<rect x="{:.2}" y="{:.2}" width="2.5" height="2.5" fill="{}" rx="0.3"/>"##,
-                    x, y - font_size * 0.3, color_at(palette,i)
-                )
-                .unwrap();
-                write!(
-                    svg,
-                    r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="#666">{}</text>"##,
-                    x + item_w, y + font_size * 0.3, font_size, escape_xml(name)
-                )
-                .unwrap();
-                x += item_w + name.len() as f64 * font_size * 0.5 + spacing;
-            }
-        }
-        "right" => {
-            let x = margin_left + plot_w + 4.0;
-            let mut y = margin_top + 2.0;
-            for (i, name) in names.iter().enumerate() {
-                write!(
-                    svg,
-                    r##"<rect x="{:.2}" y="{:.2}" width="2.5" height="2.5" fill="{}" rx="0.3"/>"##,
-                    x, y, color_at(palette,i)
-                )
-                .unwrap();
-                write!(
-                    svg,
-                    r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="#666">{}</text>"##,
-                    x + item_w, y + font_size * 0.7, font_size, escape_xml(name)
-                )
-                .unwrap();
-                y += font_size + 2.0;
-            }
-        }
-        _ => {
-            // bottom (default)
-            let y = total_h - 3.0;
-            let total_legend_w: f64 = names
-                .iter()
-                .map(|n| item_w + n.len() as f64 * font_size * 0.5 + spacing)
-                .sum::<f64>()
-                - spacing;
-            let mut x = (total_w - total_legend_w) / 2.0;
-            for (i, name) in names.iter().enumerate() {
-                write!(
-                    svg,
-                    r##"<rect x="{:.2}" y="{:.2}" width="2.5" height="2.5" fill="{}" rx="0.3"/>"##,
-                    x, y - font_size * 0.3, color_at(palette,i)
-                )
-                .unwrap();
-                write!(
-                    svg,
-                    r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="#666">{}</text>"##,
-                    x + item_w, y + font_size * 0.3, font_size, escape_xml(name)
-                )
-                .unwrap();
-                x += item_w + name.len() as f64 * font_size * 0.5 + spacing;
-            }
-        }
-    }
-}
-
-/// X-axis labels ortak render — bar chart icin (slot-based spacing)
-fn render_x_labels(
-    svg: &mut String,
-    categories: &[String],
-    px: f64,
-    baseline_y: f64,
-    pw: f64,
-    n_cats: usize,
-) {
-    if n_cats == 0 {
-        return;
-    }
-    let cat_width = pw / n_cats as f64;
-    let max_chars = (cat_width / 1.25).max(1.0) as usize;
-    let needs_rotate = categories.iter().any(|c| c.len() > max_chars);
-
-    for (ci, cat) in categories.iter().enumerate() {
-        let x = px + ci as f64 * cat_width + cat_width / 2.0;
-        let y = baseline_y + 2.5;
-        render_single_x_label(svg, cat, x, y, needs_rotate);
-    }
-}
-
-/// X-axis labels — line chart icin (point-based spacing)
-fn render_x_labels_line(
-    svg: &mut String,
-    categories: &[String],
-    px: f64,
-    baseline_y: f64,
-    pw: f64,
-    n_cats: usize,
-) {
-    if n_cats == 0 {
-        return;
-    }
-    let spacing = if n_cats == 1 { pw } else { pw / (n_cats - 1) as f64 };
-    let max_chars = (spacing / 1.25).max(1.0) as usize;
-    let needs_rotate = categories.iter().any(|c| c.len() > max_chars);
-
-    for (ci, cat) in categories.iter().enumerate() {
-        let x = if n_cats == 1 {
-            px + pw / 2.0
-        } else {
-            px + ci as f64 * pw / (n_cats - 1) as f64
-        };
-        let y = baseline_y + 2.5;
-        render_single_x_label(svg, cat, x, y, needs_rotate);
-    }
-}
-
-/// Tek bir X-axis label render — rotate gerekiyorsa -45° ile, anchor "end"
-/// Anchor noktasi bar/point'in tam altinda, text sola yukari dogru uzanir
-fn render_single_x_label(svg: &mut String, text: &str, x: f64, y: f64, rotate: bool) {
-    if rotate {
-        // -45° rotate, text-anchor="end": text, anchor noktasindan sola-yukari dogru uzanir
-        // Bu sayede text asagi-sola tasmaz, sadece yukari-sola gider (plot area icinde kalir)
+    for item in &legend.items {
+        let color = color_at(&cl.palette, item.color_idx);
         write!(
             svg,
-            r##"<text x="{:.2}" y="{:.2}" font-size="2.2" fill="#666" text-anchor="end" transform="rotate(-45,{:.2},{:.2})">{}</text>"##,
-            x, y, x, y, escape_xml(text)
+            r##"<rect x="{:.2}" y="{:.2}" width="2.5" height="2.5" fill="{}" rx="0.3"/>"##,
+            item.swatch_x, item.swatch_y, color
         )
         .unwrap();
-    } else {
         write!(
             svg,
-            r##"<text x="{:.2}" y="{:.2}" font-size="2.5" fill="#666" text-anchor="middle">{}</text>"##,
-            x, y, escape_xml(text)
+            r##"<text x="{:.2}" y="{:.2}" font-size="{:.1}" fill="#666">{}</text>"##,
+            item.text_x, item.text_y, legend.font_size, escape_xml(&item.name)
         )
         .unwrap();
     }
 }
 
-fn render_y_axis(
-    svg: &mut String,
-    min_val: f64,
-    max_val: f64,
-    px: f64,
-    py: f64,
-    pw: f64,
-    ph: f64,
-    show_grid: bool,
-    grid_color: &str,
-) {
-    let range = if (max_val - min_val).abs() < 1e-10 {
-        1.0
-    } else {
-        max_val - min_val
-    };
-    let tick_count = 5;
-    for i in 0..=tick_count {
-        let frac = i as f64 / tick_count as f64;
-        let val = min_val + frac * range;
-        let y = py + ph - frac * ph;
+// ---------------------------------------------------------------------------
+// SVG-specific helper renderers that consume shared layout structs
+// ---------------------------------------------------------------------------
 
-        // Label
+fn render_y_axis_svg(svg: &mut String, y_axis: &chart_layout::YAxisLayout) {
+    for tick in &y_axis.ticks {
         write!(
             svg,
             r##"<text x="{:.2}" y="{:.2}" font-size="2.3" fill="#666" text-anchor="end">{}</text>"##,
-            px - 1.5,
-            y + 0.8,
-            format_value(val)
+            y_axis.axis_x - 1.5, tick.y + 0.8, tick.label
         )
         .unwrap();
 
-        // Grid line
-        if show_grid {
+        if y_axis.show_grid {
             write!(
                 svg,
                 r##"<line x1="{:.2}" y1="{:.2}" x2="{:.2}" y2="{:.2}" stroke="{}" stroke-width="0.15"/>"##,
-                px, y, px + pw, y, grid_color
+                y_axis.axis_x, tick.y, y_axis.grid_end_x, tick.y, y_axis.grid_color
             )
             .unwrap();
         }
@@ -761,56 +320,28 @@ fn render_y_axis(
     write!(
         svg,
         r##"<line x1="{:.2}" y1="{:.2}" x2="{:.2}" y2="{:.2}" stroke="#9CA3AF" stroke-width="0.3"/>"##,
-        px, py, px, py + ph
+        y_axis.axis_x, y_axis.axis_y_start, y_axis.axis_x, y_axis.axis_y_end
     )
     .unwrap();
 }
 
-/// Tum serilerdeki min/max deger araligini bul
-fn value_range(data: &ResolvedChartData, stacked: bool) -> (f64, f64) {
-    if data.series.is_empty() {
-        return (0.0, 1.0);
-    }
-
-    if stacked {
-        let n = data.categories.len();
-        let mut max_stack = 0.0_f64;
-        for ci in 0..n {
-            let sum: f64 = data
-                .series
-                .iter()
-                .map(|s| s.values.get(ci).copied().unwrap_or(0.0))
-                .sum();
-            max_stack = max_stack.max(sum);
+fn render_x_labels_svg(svg: &mut String, x_labels: &chart_layout::XLabelLayout) {
+    for label in &x_labels.labels {
+        if x_labels.needs_rotate {
+            write!(
+                svg,
+                r##"<text x="{:.2}" y="{:.2}" font-size="2.2" fill="#666" text-anchor="end" transform="rotate(-45,{:.2},{:.2})">{}</text>"##,
+                label.x, label.y, label.x, label.y, escape_xml(&label.text)
+            )
+            .unwrap();
+        } else {
+            write!(
+                svg,
+                r##"<text x="{:.2}" y="{:.2}" font-size="2.5" fill="#666" text-anchor="middle">{}</text>"##,
+                label.x, label.y, escape_xml(&label.text)
+            )
+            .unwrap();
         }
-        (0.0, max_stack * 1.05)
-    } else {
-        let mut min_v = f64::MAX;
-        let mut max_v = f64::MIN;
-        for series in &data.series {
-            for val in &series.values {
-                min_v = min_v.min(*val);
-                max_v = max_v.max(*val);
-            }
-        }
-        // min sifirdan buyukse sifirdan basla
-        if min_v > 0.0 {
-            min_v = 0.0;
-        }
-        max_v *= 1.05;
-        (min_v, max_v)
-    }
-}
-
-fn format_value(v: f64) -> String {
-    if v.abs() >= 1_000_000.0 {
-        format!("{:.1}M", v / 1_000_000.0)
-    } else if v.abs() >= 1_000.0 {
-        format!("{:.1}K", v / 1_000.0)
-    } else if v.fract().abs() < 1e-10 {
-        format!("{}", v as i64)
-    } else {
-        format!("{:.1}", v)
     }
 }
 

layout-engine/src/data_resolve.rs

@@ -204,7 +204,13 @@ fn resolve_element(el: &TemplateElement, data: &Value, resolved: &mut ResolvedDa
                                 .iter()
                                 .map(|col| {
                                     let v = resolve_path(item, &col.field);
-                                    value_to_string(v)
+                                    let raw = value_to_string(v);
+                                    // Sütun formatı varsa uygula (currency, percentage, number, date)
+                                    if let Some(ref fmt) = col.format {
+                                        crate::expr_eval::apply_format(&raw, Some(fmt.as_str()))
+                                    } else {
+                                        raw
+                                    }
                                 })
                                 .collect()
                         })
@@ -449,6 +455,7 @@ mod tests {
             fonts: vec![],
             header: None,
             footer: None,
+            format_config: None,
             root: ContainerElement {
                 id: "root".to_string(),
                 position: PositionMode::Flow,
@@ -493,6 +500,7 @@ mod tests {
             fonts: vec![],
             header: None,
             footer: None,
+            format_config: None,
             root: ContainerElement {
                 id: "root".to_string(),
                 position: PositionMode::Flow,
@@ -537,6 +545,7 @@ mod tests {
             fonts: vec![],
             header: None,
             footer: None,
+            format_config: None,
             root: ContainerElement {
                 id: "root".to_string(),
                 position: PositionMode::Flow,
@@ -573,6 +582,7 @@ mod tests {
             fonts: vec![],
             header: None,
             footer: None,
+            format_config: None,
             root: ContainerElement {
                 id: "root".to_string(),
                 position: PositionMode::Flow,
@@ -638,6 +648,7 @@ mod tests {
             fonts: vec![],
             header: None,
             footer: None,
+            format_config: None,
             root: ContainerElement {
                 id: "root".to_string(),
                 position: PositionMode::Flow,
@@ -687,6 +698,7 @@ mod tests {
             fonts: vec![],
             header: None,
             footer: None,
+            format_config: None,
             root: ContainerElement {
                 id: "root".to_string(),
                 position: PositionMode::Flow,

layout-engine/src/expr_eval.rs

@@ -65,25 +65,34 @@ fn dexpr_value_to_string(val: &DexprValue) -> String {
     }
 }
 
-/// Format result with given format type
+/// Format result with given format type (varsayılan Türk formatı)
 pub fn apply_format(value: &str, format: Option<&str>) -> String {
+    apply_format_with_config(value, format, &dreport_core::models::FormatConfig::default())
+}
+
+/// Format result with given format type and config
+pub fn apply_format_with_config(value: &str, format: Option<&str>, config: &dreport_core::models::FormatConfig) -> String {
     match format {
-        Some("currency") => format_currency(value),
+        Some("currency") => format_currency(value, config),
         Some("percentage") => format_percentage(value),
-        Some("number") => format_number_str(value),
+        Some("number") => format_number_str(value, config),
         _ => value.to_string(),
     }
 }
 
-fn format_currency(value: &str) -> String {
+fn format_currency(value: &str, config: &dreport_core::models::FormatConfig) -> String {
     if let Ok(n) = value.parse::<f64>() {
         let abs = n.abs();
         let integer = abs.floor() as i64;
         let frac = ((abs - abs.floor()) * 100.0).round() as i64;
 
-        let int_str = format_with_thousands(integer);
+        let int_str = format_with_thousands(integer, &config.thousands_separator);
         let sign = if n < 0.0 { "-" } else { "" };
-        format!("{}{},{:02} ₺", sign, int_str, frac)
+        if config.currency_position == "prefix" {
+            format!("{}{}{}{}{:02}", config.currency_symbol, sign, int_str, config.decimal_separator, frac)
+        } else {
+            format!("{}{}{}{:02} {}", sign, int_str, config.decimal_separator, frac, config.currency_symbol)
+        }
     } else {
         value.to_string()
     }
@@ -97,19 +106,21 @@ fn format_percentage(value: &str) -> String {
     }
 }
 
-fn format_number_str(value: &str) -> String {
+fn format_number_str(value: &str, config: &dreport_core::models::FormatConfig) -> String {
     if let Ok(n) = value.parse::<f64>() {
         if n == n.floor() && n.abs() < 1e15 {
-            format_with_thousands(n.abs() as i64)
+            format_with_thousands(n.abs() as i64, &config.thousands_separator)
         } else {
-            format!("{:.2}", n)
+            // Ondalık ayırıcıyı config'den al
+            let formatted = format!("{:.2}", n);
+            formatted.replace('.', &config.decimal_separator)
         }
     } else {
         value.to_string()
     }
 }
 
-fn format_with_thousands(n: i64) -> String {
+fn format_with_thousands(n: i64, separator: &str) -> String {
     let s = n.to_string();
     let len = s.len();
     if len <= 3 {
@@ -118,7 +129,7 @@ fn format_with_thousands(n: i64) -> String {
     let mut result = String::new();
     for (i, ch) in s.chars().enumerate() {
         if i > 0 && (len - i) % 3 == 0 {
-            result.push('.');
+            result.push_str(separator);
         }
         result.push(ch);
     }

layout-engine/src/font_meta.rs

@@ -0,0 +1,330 @@
+use serde::{Deserialize, Serialize};
+
+/// Parsed metadata from a single font file
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FontMeta {
+    /// Font family name from name table (nameID 16 preferred, fallback nameID 1)
+    pub family: String,
+    /// usWeightClass from OS/2 table (100-900)
+    pub weight: u16,
+    /// fsSelection bit 0 from OS/2 table
+    pub italic: bool,
+    pub units_per_em: u16,
+    /// sTypoAscender from OS/2 table
+    pub ascender: i16,
+    /// sTypoDescender from OS/2 table
+    pub descender: i16,
+}
+
+/// Variant key for looking up a specific font within a family
+#[derive(Debug, Clone, Hash, Eq, PartialEq, Serialize, Deserialize)]
+pub struct FontVariantKey {
+    pub weight: u16,
+    pub italic: bool,
+}
+
+/// Summary of a font family with all its available variants
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FontFamilyInfo {
+    pub family: String,
+    pub variants: Vec<FontVariantKey>,
+}
+
+impl FontMeta {
+    pub fn variant_key(&self) -> FontVariantKey {
+        FontVariantKey {
+            weight: self.weight,
+            italic: self.italic,
+        }
+    }
+
+    pub fn is_bold(&self) -> bool {
+        self.weight >= 700
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+/// Read a big-endian u16 from `data` at `offset`. Returns `None` if out of bounds.
+fn read_u16(data: &[u8], offset: usize) -> Option<u16> {
+    if offset + 2 > data.len() {
+        return None;
+    }
+    Some(u16::from_be_bytes([data[offset], data[offset + 1]]))
+}
+
+/// Read a big-endian i16 from `data` at `offset`. Returns `None` if out of bounds.
+fn read_i16(data: &[u8], offset: usize) -> Option<i16> {
+    if offset + 2 > data.len() {
+        return None;
+    }
+    Some(i16::from_be_bytes([data[offset], data[offset + 1]]))
+}
+
+/// Read a big-endian u32 from `data` at `offset`. Returns `None` if out of bounds.
+fn read_u32(data: &[u8], offset: usize) -> Option<u32> {
+    if offset + 4 > data.len() {
+        return None;
+    }
+    Some(u32::from_be_bytes([
+        data[offset],
+        data[offset + 1],
+        data[offset + 2],
+        data[offset + 3],
+    ]))
+}
+
+/// Find a table in the font's table directory by its 4-byte ASCII tag.
+/// Returns `(offset, length)` into `data`.
+fn find_table(data: &[u8], tag: &[u8; 4]) -> Option<(usize, usize)> {
+    // Offset table (first 12 bytes):
+    //   0: sfVersion (u32) — 0x00010000 for TrueType, 'OTTO' for CFF
+    //   4: numTables (u16)
+    //   6: searchRange (u16)
+    //   8: entrySelector (u16)
+    //  10: rangeShift (u16)
+    let num_tables = read_u16(data, 4)? as usize;
+
+    // Table directory starts at offset 12, each entry is 16 bytes:
+    //   0: tag (4 bytes)
+    //   4: checksum (u32)
+    //   8: offset (u32)
+    //  12: length (u32)
+    for i in 0..num_tables {
+        let entry_offset = 12 + i * 16;
+        if entry_offset + 16 > data.len() {
+            return None;
+        }
+
+        if &data[entry_offset..entry_offset + 4] == tag {
+            let table_offset = read_u32(data, entry_offset + 8)? as usize;
+            let table_length = read_u32(data, entry_offset + 12)? as usize;
+            // Basic sanity check
+            if table_offset.checked_add(table_length)? > data.len() {
+                return None;
+            }
+            return Some((table_offset, table_length));
+        }
+    }
+    None
+}
+
+/// Decode a UTF-16BE byte slice into a `String`.
+fn decode_utf16be(raw: &[u8]) -> Option<String> {
+    if raw.len() % 2 != 0 {
+        return None;
+    }
+    let code_units: Vec<u16> = raw
+        .chunks_exact(2)
+        .map(|c| u16::from_be_bytes([c[0], c[1]]))
+        .collect();
+    String::from_utf16(&code_units).ok()
+}
+
+/// Decode a MacRoman (platform 1, encoding 0) byte slice into a `String`.
+/// MacRoman overlaps with ASCII for 0x00–0x7F; we accept those and replace
+/// high bytes with the Unicode replacement character for simplicity, since
+/// font family names are almost always pure ASCII.
+fn decode_mac_roman(raw: &[u8]) -> String {
+    raw.iter()
+        .map(|&b| {
+            if b < 0x80 {
+                b as char
+            } else {
+                // Simplified: map non-ASCII MacRoman bytes to replacement char.
+                // Full MacRoman table not needed for typical font family names.
+                '\u{FFFD}'
+            }
+        })
+        .collect()
+}
+
+/// Extract the font family name from the `name` table.
+///
+/// Prefers nameID 16 (Typographic Family Name) over nameID 1 (Font Family).
+/// Among platforms, prefers Windows (3) and Unicode (0) for UTF-16BE, falls
+/// back to Macintosh (1) for MacRoman.
+fn read_family_name(data: &[u8], table_offset: usize, table_length: usize) -> Option<String> {
+    let tbl = table_offset;
+    // name table header:
+    //   0: format (u16)
+    //   2: count (u16)
+    //   4: stringOffset (u16) — offset from start of table to string storage
+    let count = read_u16(data, tbl + 2)? as usize;
+    let string_offset = read_u16(data, tbl + 4)? as usize;
+    let storage_base = tbl + string_offset;
+
+    // Each name record (12 bytes, starting at tbl + 6):
+    //   0: platformID (u16)
+    //   2: encodingID (u16)
+    //   4: languageID (u16)
+    //   6: nameID (u16)
+    //   8: length (u16)
+    //  10: offset (u16) — from storage_base
+
+    // We collect candidates, preferring nameID 16 over 1, and Windows/Unicode
+    // over Mac.
+    let mut best: Option<String> = None;
+    let mut best_priority: u8 = 0; // higher = better
+
+    for i in 0..count {
+        let rec = tbl + 6 + i * 12;
+        if rec + 12 > tbl + table_length {
+            break;
+        }
+
+        let platform_id = read_u16(data, rec)?;
+        let encoding_id = read_u16(data, rec + 2)?;
+        let name_id = read_u16(data, rec + 6)?;
+        let str_length = read_u16(data, rec + 8)? as usize;
+        let str_offset = read_u16(data, rec + 10)? as usize;
+
+        // Only interested in nameID 1 (Font Family) or 16 (Typographic Family)
+        if name_id != 1 && name_id != 16 {
+            continue;
+        }
+
+        let name_priority = if name_id == 16 { 4 } else { 0 };
+
+        let abs_start = storage_base + str_offset;
+        let abs_end = abs_start + str_length;
+        if abs_end > data.len() {
+            continue;
+        }
+        let raw = &data[abs_start..abs_end];
+
+        let (decoded, platform_priority) = match platform_id {
+            // Platform 0 — Unicode: UTF-16BE
+            0 => {
+                if let Some(s) = decode_utf16be(raw) {
+                    (s, 2u8)
+                } else {
+                    continue;
+                }
+            }
+            // Platform 1 — Macintosh, encoding 0 = MacRoman
+            1 if encoding_id == 0 => (decode_mac_roman(raw), 1u8),
+            // Platform 3 — Windows, encoding 1 = Unicode BMP (UTF-16BE)
+            3 if encoding_id == 1 => {
+                if let Some(s) = decode_utf16be(raw) {
+                    (s, 3u8)
+                } else {
+                    continue;
+                }
+            }
+            _ => continue,
+        };
+
+        let priority = name_priority + platform_priority;
+        if priority > best_priority {
+            best_priority = priority;
+            best = Some(decoded);
+        }
+    }
+
+    best
+}
+
+/// Parse font metadata from raw TTF/OTF bytes.
+///
+/// Returns `None` if the data is too short, tables are missing, or offsets
+/// point outside the buffer.
+pub fn parse_font_meta(data: &[u8]) -> Option<FontMeta> {
+    // Minimum: 12-byte offset table header
+    if data.len() < 12 {
+        return None;
+    }
+
+    // ---- OS/2 table ----
+    let (os2_off, os2_len) = find_table(data, b"OS/2")?;
+    // Need at least 72 bytes for sTypoDescender (offset 70, 2 bytes)
+    if os2_len < 72 {
+        return None;
+    }
+    let weight = read_u16(data, os2_off + 4)?;
+    let fs_selection = read_u16(data, os2_off + 62)?;
+    let italic = (fs_selection & 1) != 0;
+    let ascender = read_i16(data, os2_off + 68)?;
+    let descender = read_i16(data, os2_off + 70)?;
+
+    // ---- head table ----
+    let (head_off, head_len) = find_table(data, b"head")?;
+    // unitsPerEm is at offset 18 (2 bytes), so need at least 20 bytes
+    if head_len < 20 {
+        return None;
+    }
+    let units_per_em = read_u16(data, head_off + 18)?;
+
+    // ---- name table ----
+    let (name_off, name_len) = find_table(data, b"name")?;
+    let family = read_family_name(data, name_off, name_len)?;
+
+    Some(FontMeta {
+        family,
+        weight,
+        italic,
+        units_per_em,
+        ascender,
+        descender,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn find_table_returns_none_on_empty() {
+        assert!(find_table(&[], b"head").is_none());
+    }
+
+    #[test]
+    fn parse_font_meta_returns_none_on_garbage() {
+        assert!(parse_font_meta(&[0u8; 11]).is_none());
+        assert!(parse_font_meta(&[0u8; 64]).is_none());
+    }
+
+    #[test]
+    fn variant_key_and_is_bold() {
+        let meta = FontMeta {
+            family: "Test".into(),
+            weight: 700,
+            italic: true,
+            units_per_em: 1000,
+            ascender: 800,
+            descender: -200,
+        };
+        assert!(meta.is_bold());
+        assert!(meta.italic);
+        let key = meta.variant_key();
+        assert_eq!(key.weight, 700);
+        assert!(key.italic);
+
+        let regular = FontMeta {
+            weight: 400,
+            italic: false,
+            ..meta.clone()
+        };
+        assert!(!regular.is_bold());
+    }
+
+    #[test]
+    fn decode_utf16be_basic() {
+        // "AB" in UTF-16BE
+        let raw = [0x00, 0x41, 0x00, 0x42];
+        assert_eq!(decode_utf16be(&raw).unwrap(), "AB");
+    }
+
+    #[test]
+    fn decode_utf16be_odd_length_returns_none() {
+        assert!(decode_utf16be(&[0x00, 0x41, 0x00]).is_none());
+    }
+
+    #[test]
+    fn decode_mac_roman_ascii() {
+        let raw = b"Noto Sans";
+        assert_eq!(decode_mac_roman(raw), "Noto Sans");
+    }
+}

layout-engine/src/font_provider.rs

@@ -0,0 +1,51 @@
+use crate::font_meta::FontFamilyInfo;
+use crate::FontData;
+
+/// Font resolution trait — host apps implement this to provide fonts.
+/// Backend implements it with a file-based registry, WASM side with API fetching.
+pub trait FontProvider: Send + Sync {
+    /// List all available font families with their variants.
+    fn list_families(&self) -> Vec<FontFamilyInfo>;
+
+    /// Load a specific font variant. Returns None if not found.
+    fn load_font(&self, family: &str, weight: u16, italic: bool) -> Option<FontData>;
+
+    /// The default/fallback font family name.
+    fn default_family(&self) -> &str {
+        "Noto Sans"
+    }
+
+    /// Load all variants of the given families. Falls back to default family if a family is not found.
+    /// Always includes the default family.
+    fn load_families(&self, families: &[String]) -> Vec<FontData> {
+        let mut result = Vec::new();
+        let mut loaded_families = std::collections::HashSet::new();
+
+        // Always include default family
+        let mut all_families: Vec<String> = vec![self.default_family().to_string()];
+        for f in families {
+            if !all_families.iter().any(|af| af.eq_ignore_ascii_case(f)) {
+                all_families.push(f.clone());
+            }
+        }
+
+        for family in &all_families {
+            let family_lower = family.to_lowercase();
+            if loaded_families.contains(&family_lower) {
+                continue;
+            }
+
+            let infos = self.list_families();
+            if let Some(info) = infos.iter().find(|i| i.family.to_lowercase() == family_lower) {
+                for variant in &info.variants {
+                    if let Some(fd) = self.load_font(&info.family, variant.weight, variant.italic) {
+                        result.push(fd);
+                    }
+                }
+                loaded_families.insert(family_lower);
+            }
+        }
+
+        result
+    }
+}

layout-engine/src/lib.rs

@@ -10,7 +10,10 @@ pub mod expr_eval;
 pub mod wasm_api;
 
 pub mod barcode_gen;
+pub mod chart_layout;
 pub mod chart_render;
+pub mod font_meta;
+pub mod font_provider;
 
 #[cfg(not(target_arch = "wasm32"))]
 pub mod pdf_render;
@@ -18,6 +21,28 @@ pub mod pdf_render;
 use dreport_core::models::{ChartType, Template};
 use serde::{Deserialize, Serialize};
 
+/// Layout hesaplama hata tipi
+#[derive(Debug)]
+pub enum LayoutError {
+    Taffy(taffy::TaffyError),
+}
+
+impl std::fmt::Display for LayoutError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            LayoutError::Taffy(e) => write!(f, "Taffy layout hatası: {:?}", e),
+        }
+    }
+}
+
+impl std::error::Error for LayoutError {}
+
+impl From<taffy::TaffyError> for LayoutError {
+    fn from(e: taffy::TaffyError) -> Self {
+        LayoutError::Taffy(e)
+    }
+}
+
 // --- Layout sonuç tipleri ---
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -172,6 +197,7 @@ pub struct ResolvedStyle {
     // Text
     pub font_size: Option<f64>,
     pub font_weight: Option<String>,
+    pub font_style: Option<String>,
     pub font_family: Option<String>,
     pub color: Option<String>,
     pub text_align: Option<String>,
@@ -203,7 +229,7 @@ pub fn compute_layout(
     template: &Template,
     data: &serde_json::Value,
     font_data: &[FontData],
-) -> LayoutResult {
+) -> Result<LayoutResult, LayoutError> {
     let mut measurer = text_measure::TextMeasurer::new(font_data);
     let resolved = data_resolve::resolve_template(template, data);
     tree::compute(template, &resolved, &mut measurer)
@@ -217,16 +243,41 @@ pub fn compute_layout_cached(
     data: &serde_json::Value,
     font_data: &[FontData],
     text_cache: text_measure::TextMeasureCache,
-) -> (LayoutResult, text_measure::TextMeasureCache) {
+) -> Result<(LayoutResult, text_measure::TextMeasureCache), LayoutError> {
     let mut measurer = text_measure::TextMeasurer::new_with_cache(font_data, text_cache);
     let resolved = data_resolve::resolve_template(template, data);
-    let result = tree::compute(template, &resolved, &mut measurer);
-    (result, measurer.take_cache())
+    let result = tree::compute(template, &resolved, &mut measurer)?;
+    Ok((result, measurer.take_cache()))
 }
 
-/// Font verisi (ham TTF/OTF bytes)
+/// Font verisi (ham TTF/OTF bytes + metadata)
 #[derive(Debug, Clone)]
 pub struct FontData {
     pub family: String,
+    pub weight: u16,
+    pub italic: bool,
     pub data: Vec<u8>,
 }
+
+impl FontData {
+    /// Create FontData from raw bytes, parsing metadata from the font file.
+    /// Returns None if font metadata cannot be parsed.
+    pub fn from_bytes(data: Vec<u8>) -> Option<Self> {
+        let meta = font_meta::parse_font_meta(&data)?;
+        Some(Self {
+            family: meta.family,
+            weight: meta.weight,
+            italic: meta.italic,
+            data,
+        })
+    }
+
+    /// Create FontData with explicit metadata (when metadata is already known).
+    pub fn new(family: String, weight: u16, italic: bool, data: Vec<u8>) -> Self {
+        Self { family, weight, italic, data }
+    }
+
+    pub fn is_bold(&self) -> bool {
+        self.weight >= 700
+    }
+}

layout-engine/src/page_break.rs

@@ -24,6 +24,8 @@ pub struct PageSplitInput {
     pub page_number_formats: HashMap<String, String>,
     /// Root container'ın üst padding'i (mm) — sayfa 2+ için body offset
     pub root_padding_top_mm: f64,
+    /// Header tekrarı kapatılmış tablo ID'leri
+    pub no_repeat_header_tables: HashSet<String>,
 }
 
 /// Body elemanlarını sayfalara böl, header/footer ekle, page number'ları çöz.
@@ -53,7 +55,11 @@ pub fn split_into_pages(input: PageSplitInput) -> Vec<PageLayout> {
     let avoid_groups = build_avoid_groups(&input.body_elements, &input.break_modes, &parent_map);
 
     // Tablo yapısı tespiti: table_id → header element id'leri
-    let table_info = detect_table_structure(&input.body_elements);
+    // repeat_header == false olan tablolar hariç tutulur
+    let mut table_info = detect_table_structure(&input.body_elements);
+    for table_id in &input.no_repeat_header_tables {
+        table_info.remove(table_id);
+    }
 
     // Elemanları sayfalara böl
     let page_slices = split_elements(
@@ -561,6 +567,7 @@ mod tests {
             break_modes: HashMap::new(),
             page_number_formats: HashMap::new(),
             root_padding_top_mm: 0.0,
+            no_repeat_header_tables: HashSet::new(),
         };
 
         let pages = split_into_pages(input);
@@ -584,6 +591,7 @@ mod tests {
             break_modes: HashMap::new(),
             page_number_formats: HashMap::new(),
             root_padding_top_mm: 0.0,
+            no_repeat_header_tables: HashSet::new(),
         };
 
         let pages = split_into_pages(input);
@@ -611,6 +619,7 @@ mod tests {
             break_modes: HashMap::new(),
             page_number_formats: HashMap::new(),
             root_padding_top_mm: 0.0,
+            no_repeat_header_tables: HashSet::new(),
         };
 
         let pages = split_into_pages(input);
@@ -638,6 +647,7 @@ mod tests {
             break_modes: HashMap::new(),
             page_number_formats: HashMap::new(),
             root_padding_top_mm: 0.0,
+            no_repeat_header_tables: HashSet::new(),
         };
 
         let pages = split_into_pages(input);
@@ -678,6 +688,7 @@ mod tests {
             break_modes: HashMap::new(),
             page_number_formats: formats,
             root_padding_top_mm: 0.0,
+            no_repeat_header_tables: HashSet::new(),
         };
 
         let pages = split_into_pages(input);
@@ -768,6 +779,7 @@ mod tests {
             break_modes: HashMap::new(),
             page_number_formats: HashMap::new(),
             root_padding_top_mm: 0.0,
+            no_repeat_header_tables: HashSet::new(),
         };
 
         let pages = split_into_pages(input);
@@ -860,6 +872,7 @@ mod tests {
             break_modes: HashMap::new(),
             page_number_formats: HashMap::new(),
             root_padding_top_mm: 0.0,
+            no_repeat_header_tables: HashSet::new(),
         };
 
         let pages = split_into_pages(input);
@@ -943,6 +956,7 @@ mod tests {
             break_modes: HashMap::new(),
             page_number_formats: HashMap::new(),
             root_padding_top_mm: 5.0,
+            no_repeat_header_tables: HashSet::new(),
         };
 
         let pages = split_into_pages(input);

layout-engine/src/table_layout.rs

@@ -185,6 +185,7 @@ pub fn expand_table(
                 style: TextStyle {
                     font_size: table.style.header_font_size.or(table.style.font_size),
                     font_weight: Some("bold".to_string()),
+                    font_style: None,
                     font_family: None,
                     color: table.style.header_color.clone(),
                     align: Some(col.align.clone()),
@@ -294,6 +295,7 @@ pub fn expand_table(
                     style: TextStyle {
                         font_size: table.style.font_size,
                         font_weight: None,
+                        font_style: None,
                         font_family: None,
                         color: None,
                         align: Some(col.align.clone()),
@@ -446,10 +448,7 @@ mod tests {
             .unwrap()
             .join("backend/fonts/NotoSans-Regular.ttf");
         let font_bytes = std::fs::read(&font_path).expect("Font file not found");
-        let font_data = vec![FontData {
-            family: "Noto Sans".to_string(),
-            data: font_bytes,
-        }];
+        let font_data = vec![FontData::from_bytes(font_bytes).expect("Font parse failed")];
         TextMeasurer::new(&font_data)
     }
 

layout-engine/src/text_measure.rs

@@ -4,6 +4,13 @@ use std::hash::Hash;
 use crate::FontData;
 use cosmic_text::{Attrs, Buffer, Family, FontSystem, Metrics, Shaping, Weight};
 
+/// Tek bir satırın layout bilgisi (PDF render için)
+pub struct TextLine {
+    pub text: String,
+    pub y_offset_pt: f32,
+    pub width_pt: f32,
+}
+
 /// Rich text span — ölçüm için gerekli bilgiler
 #[derive(Clone)]
 pub struct RichSpanMeasure {
@@ -182,6 +189,58 @@ impl TextMeasurer {
         (width_pt, height_pt)
     }
 
+    /// Text'i verilen genişlik kısıtı ile satırlara böl.
+    /// Her satır için text içeriği ve y-offset (pt) döner.
+    /// PDF render sırasında text wrapping için kullanılır.
+    pub fn layout_lines(
+        &mut self,
+        text: &str,
+        font_family: Option<&str>,
+        font_size_pt: f32,
+        font_weight: Option<&str>,
+        available_width_pt: f32,
+    ) -> Vec<TextLine> {
+        if text.is_empty() {
+            return vec![];
+        }
+
+        let font_size_px = font_size_pt * PT_TO_PX;
+        let line_height_px = font_size_px * 1.2;
+        let metrics = Metrics::new(font_size_px, line_height_px);
+
+        let mut buffer = Buffer::new(&mut self.font_system, metrics);
+
+        let width_px = available_width_pt * PT_TO_PX;
+        buffer.set_size(&mut self.font_system, Some(width_px), None);
+
+        let weight = match font_weight {
+            Some("bold") => Weight::BOLD,
+            _ => Weight::NORMAL,
+        };
+
+        let family_name = font_family.unwrap_or("Noto Sans");
+        let attrs = Attrs::new()
+            .family(Family::Name(family_name))
+            .weight(weight);
+
+        buffer.set_text(&mut self.font_system, text, &attrs, Shaping::Advanced, None);
+        buffer.shape_until_scroll(&mut self.font_system, false);
+
+        let mut lines = Vec::new();
+        for run in buffer.layout_runs() {
+            let line_text = run.text.to_string();
+            let line_top_pt = run.line_top / PT_TO_PX;
+            let line_width_pt = run.line_w / PT_TO_PX;
+            lines.push(TextLine {
+                text: line_text,
+                y_offset_pt: line_top_pt,
+                width_pt: line_width_pt,
+            });
+        }
+
+        lines
+    }
+
     /// Rich text ölç — birden fazla span, her biri farklı font/boyut/kalınlık.
     /// cosmic-text set_rich_text() ile attributed text ölçümü yapar.
     pub fn measure_rich_text(
@@ -273,18 +332,9 @@ pub(crate) fn load_test_fonts() -> Vec<crate::FontData> {
         let path = entry.path();
         if path.extension().is_some_and(|e| e == "ttf") {
             let data = std::fs::read(&path).unwrap();
-            let family = if path
-                .file_name()
-                .unwrap()
-                .to_str()
-                .unwrap()
-                .contains("Mono")
-            {
-                "Noto Sans Mono".to_string()
-            } else {
-                "Noto Sans".to_string()
-            };
-            fonts.push(crate::FontData { family, data });
+            if let Some(fd) = crate::FontData::from_bytes(data) {
+                fonts.push(fd);
+            }
         }
     }
     fonts

layout-engine/src/tree.rs

@@ -7,7 +7,7 @@ use crate::data_resolve::ResolvedData;
 use crate::sizing::{self, mm_to_pt, pt_to_mm};
 use crate::table_layout;
 use crate::text_measure::TextMeasurer;
-use crate::{ElementLayout, LayoutResult, ResolvedContent, ResolvedStyle};
+use crate::{ElementLayout, LayoutError, LayoutResult, ResolvedContent, ResolvedStyle};
 
 /// Taffy node ile dreport element arasındaki mapping
 struct NodeInfo {
@@ -33,20 +33,20 @@ pub fn compute(
     template: &Template,
     resolved: &ResolvedData,
     measurer: &mut TextMeasurer,
-) -> LayoutResult {
+) -> Result<LayoutResult, LayoutError> {
     let page_w_pt = mm_to_pt(template.page.width);
     let page_width_mm = template.page.width;
 
     // --- 1. Header layout (varsa) ---
     let (header_elements, header_height_mm) = if let Some(ref header) = template.header {
-        compute_section(header, page_w_pt, page_width_mm, resolved, measurer)
+        compute_section(header, page_w_pt, page_width_mm, resolved, measurer)?
     } else {
         (vec![], 0.0)
     };
 
     // --- 2. Footer layout (varsa) ---
     let (footer_elements, footer_height_mm) = if let Some(ref footer) = template.footer {
-        compute_section(footer, page_w_pt, page_width_mm, resolved, measurer)
+        compute_section(footer, page_w_pt, page_width_mm, resolved, measurer)?
     } else {
         (vec![], 0.0)
     };
@@ -65,7 +65,7 @@ pub fn compute(
         None,
         measurer,
         page_width_mm,
-    );
+    )?;
 
     // Sayfa wrapper: sayfa genişliğinde ama yükseklik sınırsız (auto)
     let page_style = Style {
@@ -77,7 +77,7 @@ pub fn compute(
         },
         ..Default::default()
     };
-    let page_node = taffy.new_with_children(page_style, &[root_node]).unwrap();
+    let page_node = taffy.new_with_children(page_style, &[root_node])?;
 
     taffy
         .compute_layout_with_measure(
@@ -89,14 +89,16 @@ pub fn compute(
             |known_dimensions, available_space, _node_id, context, _style| {
                 measure_leaf(known_dimensions, available_space, context, measurer)
             },
-        )
-        .unwrap();
+        )?;
 
-    let body_elements = collect_layout(&taffy, root_node, &node_map, resolved, 0.0, 0.0);
+    let body_elements = collect_layout(&taffy, root_node, &node_map, resolved, 0.0, 0.0)?;
 
     // --- 4. Container break modlarını topla ---
     let break_modes = collect_break_modes(&template.root);
 
+    // --- 4b. repeat_header == false olan tablo ID'lerini topla ---
+    let no_repeat_header_tables = collect_no_repeat_header_tables(&template.root);
+
     // --- 5. Sayfalara böl ---
     let input = crate::page_break::PageSplitInput {
         body_elements,
@@ -109,11 +111,12 @@ pub fn compute(
         break_modes,
         page_number_formats: resolved.page_number_formats.clone(),
         root_padding_top_mm: template.root.padding.top,
+        no_repeat_header_tables,
     };
 
     let pages = crate::page_break::split_into_pages(input);
 
-    LayoutResult { pages }
+    Ok(LayoutResult { pages })
 }
 
 /// Header veya footer gibi bağımsız bir container section'ı hesapla.
@@ -124,12 +127,12 @@ fn compute_section(
     page_width_mm: f64,
     resolved: &ResolvedData,
     measurer: &mut TextMeasurer,
-) -> (Vec<ElementLayout>, f64) {
+) -> Result<(Vec<ElementLayout>, f64), LayoutError> {
     let mut taffy = TaffyTree::<MeasureContext>::new();
     taffy.disable_rounding();
     let mut node_map: HashMap<NodeId, NodeInfo> = HashMap::new();
 
-    let section_node = build_container(container, &mut taffy, &mut node_map, resolved, None, measurer, page_width_mm);
+    let section_node = build_container(container, &mut taffy, &mut node_map, resolved, None, measurer, page_width_mm)?;
 
     let wrapper_style = Style {
         display: Display::Flex,
@@ -140,7 +143,7 @@ fn compute_section(
         },
         ..Default::default()
     };
-    let wrapper_node = taffy.new_with_children(wrapper_style, &[section_node]).unwrap();
+    let wrapper_node = taffy.new_with_children(wrapper_style, &[section_node])?;
 
     taffy
         .compute_layout_with_measure(
@@ -152,16 +155,15 @@ fn compute_section(
             |known_dimensions, available_space, _node_id, context, _style| {
                 measure_leaf(known_dimensions, available_space, context, measurer)
             },
-        )
-        .unwrap();
+        )?;
 
-    let elements = collect_layout(&taffy, section_node, &node_map, resolved, 0.0, 0.0);
+    let elements = collect_layout(&taffy, section_node, &node_map, resolved, 0.0, 0.0)?;
 
     // Section yüksekliği
-    let section_layout = taffy.layout(section_node).unwrap();
+    let section_layout = taffy.layout(section_node)?;
     let height_mm = pt_to_mm(section_layout.size.height);
 
-    (elements, height_mm)
+    Ok((elements, height_mm))
 }
 
 /// Template ağacındaki tüm container'ların break_inside modlarını topla.
@@ -180,6 +182,29 @@ fn collect_break_modes_recursive(el: &TemplateElement, modes: &mut HashMap<Strin
     }
 }
 
+/// repeat_header == false olan tablo ID'lerini topla.
+fn collect_no_repeat_header_tables(root: &ContainerElement) -> std::collections::HashSet<String> {
+    let mut set = std::collections::HashSet::new();
+    collect_no_repeat_recursive(&TemplateElement::Container(root.clone()), &mut set);
+    set
+}
+
+fn collect_no_repeat_recursive(el: &TemplateElement, set: &mut std::collections::HashSet<String>) {
+    match el {
+        TemplateElement::Container(c) => {
+            for child in &c.children {
+                collect_no_repeat_recursive(child, set);
+            }
+        }
+        TemplateElement::RepeatingTable(t) => {
+            if t.repeat_header == Some(false) {
+                set.insert(t.id.clone());
+            }
+        }
+        _ => {}
+    }
+}
+
 /// Container element'ini taffy node ağacına ekle (recursive)
 fn build_container(
     el: &ContainerElement,
@@ -189,7 +214,7 @@ fn build_container(
     parent_direction: Option<&str>,
     measurer: &mut TextMeasurer,
     page_width_mm: f64,
-) -> NodeId {
+) -> Result<NodeId, LayoutError> {
     let style = sizing::container_to_style(el, parent_direction);
     let direction = el.direction.as_str();
 
@@ -207,12 +232,12 @@ fn build_container(
     let mut children_ids = Vec::new();
 
     for child in &el.children {
-        let child_node = build_element(child, taffy, node_map, resolved, Some(direction), measurer, content_width_mm);
+        let child_node = build_element(child, taffy, node_map, resolved, Some(direction), measurer, content_width_mm)?;
         child_nodes.push(child_node);
         children_ids.push(child.id().to_string());
     }
 
-    let node = taffy.new_with_children(style, &child_nodes).unwrap();
+    let node = taffy.new_with_children(style, &child_nodes)?;
 
     node_map.insert(
         node,
@@ -232,7 +257,7 @@ fn build_container(
         },
     );
 
-    node
+    Ok(node)
 }
 
 /// Herhangi bir element tipini taffy node'a çevir
@@ -244,7 +269,7 @@ fn build_element(
     parent_direction: Option<&str>,
     measurer: &mut TextMeasurer,
     page_width_mm: f64,
-) -> NodeId {
+) -> Result<NodeId, LayoutError> {
     match el {
         TemplateElement::Container(e) => {
             build_container(e, taffy, node_map, resolved, parent_direction, measurer, page_width_mm)
@@ -342,7 +367,7 @@ fn build_element(
                 leaf_style.size.height = Dimension::length(mm_to_pt(stroke_w));
             }
 
-            let node = taffy.new_leaf(leaf_style).unwrap();
+            let node = taffy.new_leaf(leaf_style)?;
             node_map.insert(
                 node,
                 NodeInfo {
@@ -357,13 +382,13 @@ fn build_element(
                     children_ids: vec![],
                 },
             );
-            node
+            Ok(node)
         }
         TemplateElement::Image(e) => {
             let style = sizing::leaf_style(&e.size, &e.position, parent_direction);
             let src = resolved.images.get(&e.id).cloned().unwrap_or_default();
 
-            let node = taffy.new_leaf(style).unwrap();
+            let node = taffy.new_leaf(style)?;
             node_map.insert(
                 node,
                 NodeInfo {
@@ -377,7 +402,7 @@ fn build_element(
                     children_ids: vec![],
                 },
             );
-            node
+            Ok(node)
         }
         TemplateElement::Barcode(e) => {
             let mut style = sizing::leaf_style(&e.size, &e.position, parent_direction);
@@ -394,7 +419,7 @@ fn build_element(
                 style.min_size.width = Dimension::length(mm_to_pt(default_w));
             }
 
-            let node = taffy.new_leaf(style).unwrap();
+            let node = taffy.new_leaf(style)?;
             node_map.insert(
                 node,
                 NodeInfo {
@@ -412,7 +437,7 @@ fn build_element(
                     children_ids: vec![],
                 },
             );
-            node
+            Ok(node)
         }
         TemplateElement::RepeatingTable(e) => {
             // Tabloyu container ağacına expand et (measurer ile auto sütun genişlikleri hesaplanır)
@@ -439,7 +464,7 @@ fn build_element(
         }
         TemplateElement::Shape(e) => {
             let style = sizing::leaf_style(&e.size, &e.position, parent_direction);
-            let node = taffy.new_leaf(style).unwrap();
+            let node = taffy.new_leaf(style)?;
             node_map.insert(
                 node,
                 NodeInfo {
@@ -458,7 +483,7 @@ fn build_element(
                     children_ids: vec![],
                 },
             );
-            node
+            Ok(node)
         }
         TemplateElement::Checkbox(e) => {
             let checked_str = resolved.texts.get(&e.id).map(|s| s.as_str()).unwrap_or("false");
@@ -475,7 +500,7 @@ fn build_element(
                 leaf_style.size.height = Dimension::length(mm_to_pt(box_size_mm));
             }
 
-            let node = taffy.new_leaf(leaf_style).unwrap();
+            let node = taffy.new_leaf(leaf_style)?;
             node_map.insert(
                 node,
                 NodeInfo {
@@ -491,7 +516,7 @@ fn build_element(
                     children_ids: vec![],
                 },
             );
-            node
+            Ok(node)
         }
         TemplateElement::RichText(e) => {
             let spans = resolved.rich_texts.get(&e.id).cloned().unwrap_or_default();
@@ -520,7 +545,7 @@ fn build_element(
                 rich_spans: Some(rich_span_measures),
             };
 
-            let node = taffy.new_leaf_with_context(style, context).unwrap();
+            let node = taffy.new_leaf_with_context(style, context)?;
 
             // ResolvedContent::RichText span'ları oluştur
             let resolved_spans: Vec<crate::ResolvedRichSpan> = spans
@@ -551,7 +576,7 @@ fn build_element(
                     children_ids: vec![],
                 },
             );
-            node
+            Ok(node)
         }
         TemplateElement::Chart(e) => {
             let mut style = sizing::leaf_style(&e.size, &e.position, parent_direction);
@@ -562,7 +587,7 @@ fn build_element(
             if matches!(e.size.height, SizeValue::Auto) {
                 style.min_size.height = Dimension::length(mm_to_pt(60.0));
             }
-            let node = taffy.new_leaf(style).unwrap();
+            let node = taffy.new_leaf(style)?;
             node_map.insert(
                 node,
                 NodeInfo {
@@ -573,7 +598,7 @@ fn build_element(
                     children_ids: vec![],
                 },
             );
-            node
+            Ok(node)
         }
         TemplateElement::PageBreak(e) => {
             // Küçük yükseklik — editörde görünür olması için (0.5mm ≈ 1.4pt)
@@ -584,7 +609,7 @@ fn build_element(
                 },
                 ..Default::default()
             };
-            let node = taffy.new_leaf(style).unwrap();
+            let node = taffy.new_leaf(style)?;
             node_map.insert(
                 node,
                 NodeInfo {
@@ -595,7 +620,7 @@ fn build_element(
                     children_ids: vec![],
                 },
             );
-            node
+            Ok(node)
         }
     }
 }
@@ -626,7 +651,7 @@ fn build_text_leaf(
     size: &SizeConstraint,
     position: &PositionMode,
     parent_direction: Option<&str>,
-) -> NodeId {
+) -> Result<NodeId, LayoutError> {
     let style = sizing::leaf_style(size, position, parent_direction);
     let font_size_pt = text_style.font_size.unwrap_or(11.0) as f32;
 
@@ -638,7 +663,7 @@ fn build_text_leaf(
         rich_spans: None,
     };
 
-    let node = taffy.new_leaf_with_context(style, context).unwrap();
+    let node = taffy.new_leaf_with_context(style, context)?;
 
     node_map.insert(
         node,
@@ -651,6 +676,7 @@ fn build_text_leaf(
             style: ResolvedStyle {
                 font_size: text_style.font_size,
                 font_weight: text_style.font_weight.clone(),
+                font_style: text_style.font_style.clone(),
                 font_family: text_style.font_family.clone(),
                 color: text_style.color.clone(),
                 text_align: text_style.align.clone(),
@@ -660,7 +686,7 @@ fn build_text_leaf(
         },
     );
 
-    node
+    Ok(node)
 }
 
 /// Taffy MeasureFunc: text leaf node'ları ölç
@@ -719,14 +745,14 @@ fn collect_layout(
     resolved: &ResolvedData,
     parent_x_mm: f64,
     parent_y_mm: f64,
-) -> Vec<ElementLayout> {
+) -> Result<Vec<ElementLayout>, LayoutError> {
     let mut elements = Vec::new();
 
     let Some(info) = node_map.get(&node) else {
-        return elements;
+        return Ok(elements);
     };
 
-    let layout = taffy.layout(node).unwrap();
+    let layout = taffy.layout(node)?;
     let x_mm = parent_x_mm + pt_to_mm(layout.location.x);
     let y_mm = parent_y_mm + pt_to_mm(layout.location.y);
     let w_mm = pt_to_mm(layout.size.width);
@@ -736,7 +762,7 @@ fn collect_layout(
     let content = if info.element_type == "chart" {
         resolved.charts.get(&info.element_id).map(|cd| {
             use crate::{ChartRenderData, ChartSeriesData};
-            use crate::chart_render::DEFAULT_COLORS;
+            use crate::chart_layout::DEFAULT_COLORS;
 
             // Renk paleti olustur
             let n_colors = cd.categories.len().max(cd.series.len()).max(1);
@@ -798,13 +824,13 @@ fn collect_layout(
     });
 
     // Child node'ları da topla
-    let children = taffy.children(node).unwrap();
+    let children = taffy.children(node)?;
     for child_node in children {
-        let child_elements = collect_layout(taffy, child_node, node_map, resolved, x_mm, y_mm);
+        let child_elements = collect_layout(taffy, child_node, node_map, resolved, x_mm, y_mm)?;
         elements.extend(child_elements);
     }
 
-    elements
+    Ok(elements)
 }
 
 #[cfg(test)]
@@ -823,6 +849,7 @@ mod tests {
             fonts: vec!["Noto Sans".to_string()],
             header: None,
             footer: None,
+            format_config: None,
             root: ContainerElement {
                 id: "root".to_string(),
                 position: PositionMode::Flow,
@@ -911,7 +938,7 @@ mod tests {
         let fonts = crate::text_measure::load_test_fonts();
         let mut measurer = TextMeasurer::new(&fonts);
 
-        let result = compute(&template, &resolved, &mut measurer);
+        let result = compute(&template, &resolved, &mut measurer).unwrap();
 
         assert_eq!(result.pages.len(), 1);
         let page = &result.pages[0];
@@ -966,6 +993,7 @@ mod tests {
             fonts: vec![],
             header: None,
             footer: None,
+            format_config: None,
             root: ContainerElement {
                 id: "root".to_string(),
                 position: PositionMode::Flow,
@@ -1056,7 +1084,7 @@ mod tests {
         let resolved = crate::data_resolve::resolve_template(&template, &data);
         let fonts = crate::text_measure::load_test_fonts();
         let mut measurer = TextMeasurer::new(&fonts);
-        let result = compute(&template, &resolved, &mut measurer);
+        let result = compute(&template, &resolved, &mut measurer).unwrap();
 
         let page = &result.pages[0];
         let left = page.elements.iter().find(|e| e.id == "left").unwrap();
@@ -1093,6 +1121,7 @@ mod tests {
             fonts: vec![],
             header: None,
             footer: None,
+            format_config: None,
             root: ContainerElement {
                 id: "root".to_string(),
                 position: PositionMode::Flow,
@@ -1140,7 +1169,7 @@ mod tests {
         let resolved = crate::data_resolve::resolve_template(&template, &data);
         let fonts = crate::text_measure::load_test_fonts();
         let mut measurer = TextMeasurer::new(&fonts);
-        let result = compute(&template, &resolved, &mut measurer);
+        let result = compute(&template, &resolved, &mut measurer).unwrap();
 
         let page = &result.pages[0];
         let abs = page.elements.iter().find(|e| e.id == "abs_text").unwrap();
@@ -1181,6 +1210,7 @@ mod tests {
             fonts: vec!["Noto Sans".to_string()],
             header: None,
             footer: None,
+            format_config: None,
             root: ContainerElement {
                 id: "root".to_string(),
                 position: PositionMode::Flow,
@@ -1354,7 +1384,7 @@ mod tests {
         let resolved = crate::data_resolve::resolve_template(&template, &data);
         let fonts = crate::text_measure::load_test_fonts();
         let mut measurer = TextMeasurer::new(&fonts);
-        let result = compute(&template, &resolved, &mut measurer);
+        let result = compute(&template, &resolved, &mut measurer).unwrap();
 
         let page = &result.pages[0];
         println!("\n=== FATURA HEADER LAYOUT ===");

layout-engine/src/wasm_api.rs

@@ -1,4 +1,4 @@
-use std::sync::{Mutex, OnceLock};
+use std::sync::Mutex;
 use std::collections::HashMap;
 
 use wasm_bindgen::prelude::*;
@@ -6,15 +6,14 @@ use wasm_bindgen::prelude::*;
 use crate::FontData;
 use crate::text_measure::TextMeasureCache;
 
-/// Font verileri worker'da cache'lenir.
-static FONTS: OnceLock<Vec<FontData>> = OnceLock::new();
+/// Font verileri — dinamik olarak eklenebilir (Mutex ile).
+static FONTS: Mutex<Vec<FontData>> = Mutex::new(Vec::new());
 
 /// Text ölçüm cache'i — layout call'ları arasında persist eder.
-/// Aynı text + font + size + weight + available_width → aynı sonuç.
-static TEXT_CACHE: OnceLock<Mutex<TextMeasureCache>> = OnceLock::new();
+static TEXT_CACHE: Mutex<Option<TextMeasureCache>> = Mutex::new(None);
 
 /// Barcode pixel cache — (format, value, width, height, include_text) → RGBA bytes (header dahil).
-static BARCODE_CACHE: OnceLock<Mutex<HashMap<BarcodeCacheKey, Vec<u8>>>> = OnceLock::new();
+static BARCODE_CACHE: Mutex<Option<HashMap<BarcodeCacheKey, Vec<u8>>>> = Mutex::new(None);
 
 #[derive(Clone, Eq, PartialEq, Hash)]
 struct BarcodeCacheKey {
@@ -25,41 +24,87 @@ struct BarcodeCacheKey {
     include_text: bool,
 }
 
-/// Font verilerini yükle (worker init sırasında bir kere çağrılır).
-/// `families`: JSON array of font family names — ["Noto Sans", "Noto Sans", ...]
-/// `buffers`: Her font dosyasının raw bytes'ı (sırayla)
+/// Font verilerini yükle (ilk çağrıda mevcut fontları değiştirir).
+/// `buffers`: Her font dosyasının raw bytes'ı
+/// Font metadata (family, weight, italic) otomatik olarak TTF'den parse edilir.
 #[wasm_bindgen(js_name = "loadFonts")]
-pub fn load_fonts(families: &str, buffers: Vec<js_sys::Uint8Array>) -> Result<(), JsValue> {
-    let families: Vec<String> =
-        serde_json::from_str(families).map_err(|e| JsValue::from_str(&e.to_string()))?;
+pub fn load_fonts(buffers: Vec<js_sys::Uint8Array>) -> Result<(), JsValue> {
+    let mut fonts_lock = FONTS.lock().unwrap();
 
-    if families.len() != buffers.len() {
-        return Err(JsValue::from_str("families and buffers length mismatch"));
+    let mut fonts: Vec<FontData> = Vec::with_capacity(buffers.len());
+    for buf in buffers {
+        let data = buf.to_vec();
+        match FontData::from_bytes(data) {
+            Some(fd) => fonts.push(fd),
+            None => {
+                // Skip unparseable fonts silently
+            }
+        }
     }
 
-    let fonts: Vec<FontData> = families
-        .into_iter()
-        .zip(buffers.into_iter())
-        .map(|(family, buf)| FontData {
-            family,
-            data: buf.to_vec(),
-        })
-        .collect();
+    *fonts_lock = fonts;
 
-    FONTS
-        .set(fonts)
-        .map_err(|_| JsValue::from_str("Fonts already loaded"))?;
+    // Text cache'i temizle (yeni fontlarla eski ölçümler geçersiz)
+    *TEXT_CACHE.lock().unwrap() = None;
 
     Ok(())
 }
 
+/// Mevcut font setine yeni fontlar ekle (on-demand loading için).
+/// Mevcut fontları korur, yenileri ekler. Aynı family+weight+italic varsa üzerine yazar.
+#[wasm_bindgen(js_name = "addFonts")]
+pub fn add_fonts(buffers: Vec<js_sys::Uint8Array>) -> Result<(), JsValue> {
+    let mut fonts_lock = FONTS.lock().unwrap();
+
+    for buf in buffers {
+        let data = buf.to_vec();
+        if let Some(fd) = FontData::from_bytes(data) {
+            // Aynı variant varsa kaldır (üzerine yaz)
+            fonts_lock.retain(|existing| {
+                !(existing.family.eq_ignore_ascii_case(&fd.family)
+                    && existing.weight == fd.weight
+                    && existing.italic == fd.italic)
+            });
+            fonts_lock.push(fd);
+        }
+    }
+
+    // Text cache'i temizle
+    *TEXT_CACHE.lock().unwrap() = None;
+
+    Ok(())
+}
+
+/// Yüklü font ailelerini JSON olarak döndür.
+/// Frontend'in hangi fontların yüklü olduğunu bilmesi için.
+#[wasm_bindgen(js_name = "getLoadedFonts")]
+pub fn get_loaded_fonts() -> String {
+    let fonts = FONTS.lock().unwrap();
+    let mut families: HashMap<String, Vec<serde_json::Value>> = HashMap::new();
+
+    for fd in fonts.iter() {
+        let entry = families.entry(fd.family.clone()).or_default();
+        entry.push(serde_json::json!({
+            "weight": fd.weight,
+            "italic": fd.italic,
+        }));
+    }
+
+    let result: Vec<serde_json::Value> = families
+        .into_iter()
+        .map(|(family, variants)| serde_json::json!({
+            "family": family,
+            "variants": variants,
+        }))
+        .collect();
+
+    serde_json::to_string(&result).unwrap_or_else(|_| "[]".to_string())
+}
+
 /// Layout hesapla.
 /// `template_json`: Template JSON string
 /// `data_json`: Data JSON string
 /// Dönen değer: LayoutResult JSON string
-///
-/// Text ölçüm sonuçları cross-call cache'lenir — değişmeyen text elemanları
-/// cosmic-text'e gitmeden cache'ten döner.
 #[wasm_bindgen(js_name = "computeLayout")]
 pub fn compute_layout_wasm(template_json: &str, data_json: &str) -> Result<String, JsValue> {
     let template: dreport_core::models::Template =
@@ -68,18 +113,20 @@ pub fn compute_layout_wasm(template_json: &str, data_json: &str) -> Result<Strin
     let data: serde_json::Value =
         serde_json::from_str(data_json).map_err(|e| JsValue::from_str(&e.to_string()))?;
 
-    let fonts = FONTS
-        .get()
-        .ok_or_else(|| JsValue::from_str("Fonts not loaded. Call loadFonts() first."))?;
+    let fonts = FONTS.lock().unwrap();
+    if fonts.is_empty() {
+        return Err(JsValue::from_str("Fonts not loaded. Call loadFonts() first."));
+    }
 
     // Text cache'i al (veya ilk kullanımda oluştur)
-    let cache_mutex = TEXT_CACHE.get_or_init(|| Mutex::new(TextMeasureCache::default()));
-    let text_cache = cache_mutex.lock().unwrap().take();
+    let mut cache_guard = TEXT_CACHE.lock().unwrap();
+    let text_cache = cache_guard.take().unwrap_or_default();
 
-    let (result, new_cache) = crate::compute_layout_cached(&template, &data, fonts, text_cache);
+    let (result, new_cache) = crate::compute_layout_cached(&template, &data, &fonts, text_cache)
+        .map_err(|e| JsValue::from_str(&e.to_string()))?;
 
     // Güncel cache'i geri koy
-    *cache_mutex.lock().unwrap() = new_cache;
+    *cache_guard = Some(new_cache);
 
     serde_json::to_string(&result).map_err(|e| JsValue::from_str(&e.to_string()))
 }
@@ -96,21 +143,19 @@ pub fn generate_barcode_wasm(format: &str, value: &str, width: u32, height: u32,
         include_text,
     };
 
-    let cache_mutex = BARCODE_CACHE.get_or_init(|| Mutex::new(HashMap::new()));
+    let mut barcode_guard = BARCODE_CACHE.lock().unwrap();
+    let cache = barcode_guard.get_or_insert_with(HashMap::new);
 
     // Cache hit?
-    {
-        let cache = cache_mutex.lock().unwrap();
-        if let Some(cached_data) = cache.get(&cache_key) {
-            let arr = js_sys::Uint8ClampedArray::new_with_length(cached_data.len() as u32);
-            arr.copy_from(cached_data);
-            return Ok(arr);
-        }
+    if let Some(cached_data) = cache.get(&cache_key) {
+        let arr = js_sys::Uint8ClampedArray::new_with_length(cached_data.len() as u32);
+        arr.copy_from(cached_data);
+        return Ok(arr);
     }
 
-    // Cache miss — üret
-    let fonts = FONTS.get().map(|f| f.as_slice());
-    let result = crate::barcode_gen::generate_barcode_pixels(format, value, width, height, include_text, fonts)
+    let fonts = FONTS.lock().unwrap();
+    let fonts_slice: Option<&[FontData]> = if fonts.is_empty() { None } else { Some(&fonts) };
+    let result = crate::barcode_gen::generate_barcode_pixels(format, value, width, height, include_text, fonts_slice)
         .map_err(|e| JsValue::from_str(&e))?;
 
     // Grayscale → RGBA (canvas ImageData formatı)
@@ -132,7 +177,7 @@ pub fn generate_barcode_wasm(format: &str, value: &str, width: u32, height: u32,
     arr.copy_from(&data);
 
     // Cache'e kaydet
-    cache_mutex.lock().unwrap().insert(cache_key, data);
+    cache.insert(cache_key, data);
 
     Ok(arr)
 }