`206b11b`

Expand MathBox input templates and pretty rendering

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 2 months ago

SHA: 206b11b5ef604d9492bb4ea6cca9d4beb010cd0d
Parents: ca03027
Tree: 579012e

6 changed files

Status	File	+	-
M	`garcalc-math/src/convert.rs`	312	100
M	`garcalc-math/src/input.rs`	1194	120
M	`garcalc-math/src/layout.rs`	348	142
M	`garcalc-math/src/lib.rs`	6	6
M	`garcalc-math/src/mathbox.rs`	87	40
M	`garcalc-math/src/render.rs`	717	169

garcalc-math/src/convert.rsmodified

  //! - MathBox -> Expr for evaluation
  //! - Expr -> MathBox for result display
 -use crate::mathbox::{MathBox, Operator, LimitDirection as MathLimitDirection};
 -use garcalc_cas::expr::{Expr, Rational, Symbol, LimitDirection, Sign};
 +use crate::mathbox::{LimitDirection as MathLimitDirection, MathBox, Operator};
 +use garcalc_cas::expr::{Expr, LimitDirection, Rational, Sign, Symbol};
  use thiserror::Error;
  /// Errors that can occur during conversion
          MathBox::Subscript { base, sub } => {
              // Subscripted variables become a combined symbol
 -            if let (MathBox::Symbol(b), MathBox::Number(s) | MathBox::Symbol(s)) = (base.as_ref(), sub.as_ref()) {
 +            if let (MathBox::Symbol(b), MathBox::Number(s) | MathBox::Symbol(s)) =
 +                (base.as_ref(), sub.as_ref())
 +            {
                  Ok(Expr::Symbol(Symbol::new(format!("{}_{}", b, s))))
              } else {
                  let base_expr = to_expr(base)?;
          MathBox::Parens(inner) => to_expr(inner),
 -        MathBox::Integral { lower, upper, body, var } => {
 +        MathBox::Integral {
 +            lower,
 +            upper,
 +            body,
 +            var,
 +        } => {
              let body_expr = to_expr(body)?;
              let var_sym = Symbol::new(extract_symbol_str(var)?);
              })
+         }
 -        MathBox::Limit { var, to, direction, body } => {
 +        MathBox::Limit {
 +            var,
 +            to,
 +            direction,
 +            body,
 +        } => {
              let body_expr = to_expr(body)?;
              let var_sym = Symbol::new(extract_symbol_str(var)?);
              let point_expr = to_expr(to)?;
              })
+         }
 -        MathBox::Sum { var, lower, upper, body } => {
 +        MathBox::Sum {
 +            var,
 +            lower,
 +            upper,
 +            body,
 +        } => {
              let var_sym = Symbol::new(extract_symbol_str(var)?);
              let lower_expr = to_expr(lower)?;
              let upper_expr = to_expr(upper)?;
              })
+         }
 -        MathBox::Product { var, lower, upper, body } => {
 +        MathBox::Product {
 +            var,
 +            lower,
 +            upper,
 +            body,
 +        } => {
              let var_sym = Symbol::new(extract_symbol_str(var)?);
              let lower_expr = to_expr(lower)?;
              let upper_expr = to_expr(upper)?;
          Expr::Mul(factors) => {
              // Check for division pattern (x * y^-1)
 -            let (numerator, denominator): (Vec<_>, Vec<_>) = factors.iter().partition(|f| !is_reciprocal(f));
 +            let (numerator, denominator): (Vec<_>, Vec<_>) =
 +                factors.iter().partition(|f| !is_reciprocal(f));
++
 +            let mut numerator_factors: Vec<Expr> = numerator.into_iter().cloned().collect();
 +            numerator_factors.retain(|f| !is_multiplicative_identity(f));
              if !denominator.is_empty() {
 -                let num_box = if numerator.is_empty() {
 +                let den_factors: Vec<Expr> = denominator
 +                    .iter()
 +                    .map(|f| extract_base_of_reciprocal(f))
 +                    .filter(|f| !is_multiplicative_identity(f))
 +                    .collect();
++
 +                let num_box = if numerator_factors.is_empty() {
                      MathBox::Number("1".to_string())
 -                } else if numerator.len() == 1 {
 -                    from_expr(numerator[0])
 +                } else if numerator_factors.len() == 1 {
 +                    render_mul_factor(&numerator_factors[0])
                  } else {
 -                    from_expr(&Expr::Mul(numerator.into_iter().cloned().collect()))
 +                    from_mul_factors(&numerator_factors)
                  };
 -                let den_factors: Vec<Expr> = denominator.iter().map(|f| extract_base_of_reciprocal(f)).collect();
 +                if den_factors.is_empty() {
 +                    return num_box;
 +                }
++
                  let den_box = if den_factors.len() == 1 {
 -                    from_expr(&den_factors[0])
 +                    render_mul_factor(&den_factors[0])
                  } else {
 -                    from_expr(&Expr::Mul(den_factors))
 +                    from_mul_factors(&den_factors)
                  };
                  return MathBox::Fraction {
+             }
              // Normal multiplication
 -            let mut items = Vec::new();
 -            for (i, factor) in factors.iter().enumerate() {
 -                if i > 0 {
 -                    items.push(MathBox::Operator(Operator::Mul));
 -                }
 -                items.push(from_expr(factor));
 -            }
 -            if items.len() == 1 {
 -                items.pop().unwrap()
 +            if numerator_factors.is_empty() {
 +                MathBox::Number("1".to_string())
 +            } else if numerator_factors.len() == 1 {
 +                render_mul_factor(&numerator_factors[0])
              } else {
 -                MathBox::Row(items)
 +                from_mul_factors(&numerator_factors)
+             }
+         }
+             }
+         }
 -        Expr::Neg(inner) => {
 -            MathBox::Row(vec![
 -                MathBox::Operator(Operator::Sub),
 -                from_expr(inner),
 -            ])
 -        }
 +        Expr::Neg(inner) => MathBox::Row(vec![MathBox::Operator(Operator::Sub), from_expr(inner)]),
          Expr::Func(name, args) => {
 +            if name == "factorial" && args.len() == 1 {
 +                let arg_expr = &args[0];
 +                let arg_box = from_expr(arg_expr);
 +                let formatted_arg = if factorial_arg_needs_parens(arg_expr) {
 +                    MathBox::Parens(Box::new(arg_box))
 +                } else {
 +                    arg_box
 +                };
++
 +                return MathBox::Row(vec![formatted_arg, MathBox::Symbol("!".to_string())]);
 +            }
++
              let arg_boxes: Vec<MathBox> = args.iter().map(from_expr).collect();
              // Special functions get special rendering
+             }
+         }
 -        Expr::Derivative { expr, var, order } => {
 -            MathBox::Derivative {
 -                order: *order,
 -                var: Box::new(MathBox::Symbol(var.0.clone())),
 -                body: Box::new(from_expr(expr)),
 -            }
 -        }
+-
 -        Expr::Integral { expr, var, lower, upper } => {
 -            MathBox::Integral {
 -                lower: lower.as_ref().map(|lo| Box::new(from_expr(lo))),
 -                upper: upper.as_ref().map(|hi| Box::new(from_expr(hi))),
 -                body: Box::new(from_expr(expr)),
 -                var: Box::new(MathBox::Symbol(var.0.clone())),
 -            }
 -        }
+-
 -        Expr::Limit { expr, var, point, direction } => {
 -            MathBox::Limit {
 -                var: Box::new(MathBox::Symbol(var.0.clone())),
 -                to: Box::new(from_expr(point)),
 -                direction: direction.map(|d| match d {
 -                    LimitDirection::Left => MathLimitDirection::FromLeft,
 -                    LimitDirection::Right => MathLimitDirection::FromRight,
 -                }),
 -                body: Box::new(from_expr(expr)),
 -            }
 -        }
+-
 -        Expr::Sum { expr, var, lower, upper } => {
 -            MathBox::Sum {
 -                var: Box::new(MathBox::Symbol(var.0.clone())),
 -                lower: Box::new(from_expr(lower)),
 -                upper: Box::new(from_expr(upper)),
 -                body: Box::new(from_expr(expr)),
 -            }
 -        }
+-
 -        Expr::Product { expr, var, lower, upper } => {
 -            MathBox::Product {
 -                var: Box::new(MathBox::Symbol(var.0.clone())),
 -                lower: Box::new(from_expr(lower)),
 -                upper: Box::new(from_expr(upper)),
 -                body: Box::new(from_expr(expr)),
 -            }
 -        }
 +        Expr::Derivative { expr, var, order } => MathBox::Derivative {
 +            order: *order,
 +            var: Box::new(MathBox::Symbol(var.0.clone())),
 +            body: Box::new(from_expr(expr)),
 +        },
++
 +        Expr::Integral {
 +            expr,
 +            var,
 +            lower,
 +            upper,
 +        } => MathBox::Integral {
 +            lower: lower.as_ref().map(|lo| Box::new(from_expr(lo))),
 +            upper: upper.as_ref().map(|hi| Box::new(from_expr(hi))),
 +            body: Box::new(from_expr(expr)),
 +            var: Box::new(MathBox::Symbol(var.0.clone())),
 +        },
++
 +        Expr::Limit {
 +            expr,
 +            var,
 +            point,
 +            direction,
 +        } => MathBox::Limit {
 +            var: Box::new(MathBox::Symbol(var.0.clone())),
 +            to: Box::new(from_expr(point)),
 +            direction: direction.map(|d| match d {
 +                LimitDirection::Left => MathLimitDirection::FromLeft,
 +                LimitDirection::Right => MathLimitDirection::FromRight,
 +            }),
 +            body: Box::new(from_expr(expr)),
 +        },
++
 +        Expr::Sum {
 +            expr,
 +            var,
 +            lower,
 +            upper,
 +        } => MathBox::Sum {
 +            var: Box::new(MathBox::Symbol(var.0.clone())),
 +            lower: Box::new(from_expr(lower)),
 +            upper: Box::new(from_expr(upper)),
 +            body: Box::new(from_expr(expr)),
 +        },
++
 +        Expr::Product {
 +            expr,
 +            var,
 +            lower,
 +            upper,
 +        } => MathBox::Product {
 +            var: Box::new(MathBox::Symbol(var.0.clone())),
 +            lower: Box::new(from_expr(lower)),
 +            upper: Box::new(from_expr(upper)),
 +            body: Box::new(from_expr(expr)),
 +        },
          Expr::Matrix(rows) => {
              let box_rows: Vec<Vec<MathBox>> = rows
              MathBox::Matrix { rows: box_rows }
+         }
 -        Expr::Equation(lhs, rhs) => {
 -            MathBox::Row(vec![
 -                from_expr(lhs),
 -                MathBox::Operator(Operator::Eq),
 -                from_expr(rhs),
 -            ])
 -        }
 +        Expr::Equation(lhs, rhs) => MathBox::Row(vec![
 +            from_expr(lhs),
 +            MathBox::Operator(Operator::Eq),
 +            from_expr(rhs),
 +        ]),
          Expr::Undefined => MathBox::Symbol("undefined".to_string()),
 -        Expr::Infinity(sign) => {
 -            match sign {
 -                Sign::Positive => MathBox::Symbol("∞".to_string()),
 -                Sign::Negative => MathBox::Row(vec![
 -                    MathBox::Operator(Operator::Sub),
 -                    MathBox::Symbol("∞".to_string()),
 -                ]),
 -            }
 -        }
 +        Expr::Infinity(sign) => match sign {
 +            Sign::Positive => MathBox::Symbol("∞".to_string()),
 +            Sign::Negative => MathBox::Row(vec![
 +                MathBox::Operator(Operator::Sub),
 +                MathBox::Symbol("∞".to_string()),
 +            ]),
 +        },
          Expr::Vector(elems) => {
              // Display vector as a row matrix
              let box_row: Vec<MathBox> = elems.iter().map(from_expr).collect();
 -            MathBox::Matrix { rows: vec![box_row] }
 +            MathBox::Matrix {
 +                rows: vec![box_row],
 +            }
+         }
          Expr::Inequality { lhs, op, rhs } => {
                  InequalityOp::Ge => MathBox::Operator(Operator::Ge),
                  InequalityOp::Ne => MathBox::Operator(Operator::Ne),
              };
 -            MathBox::Row(vec![
 -                from_expr(lhs),
 -                op_box,
 -                from_expr(rhs),
 -            ])
 +            MathBox::Row(vec![from_expr(lhs), op_box, from_expr(rhs)])
+         }
+     }
+ }
              MathBox::Operator(op) => {
                  operators.push(*op);
+             }
 +            MathBox::Symbol(s) if s == "!" => {
 +                let Some(last) = operands.pop() else {
 +                    return Err(ConvertError::MissingField(
 +                        "factorial operand before '!'".to_string(),
 +                    ));
 +                };
 +                operands.push(Expr::Func("factorial".to_string(), vec![last]));
 +            }
              other => {
                  operands.push(to_expr(other)?);
+             }
      if f == f.trunc() && f.abs() < 1e15 {
          format!("{:.0}", f)
      } else {
 -        format!("{:.10}", f).trim_end_matches('0').trim_end_matches('.').to_string()
 +        format!("{:.10}", f)
 +            .trim_end_matches('0')
 +            .trim_end_matches('.')
 +            .to_string()
+     }
+ }
+     }
+ }
 +fn is_multiplicative_identity(expr: &Expr) -> bool {
 +    match expr {
 +        Expr::Integer(1) => true,
 +        Expr::Rational(r) if r.den != 0 && r.num == r.den => true,
 +        Expr::Float(f) if *f == 1.0 => true,
 +        _ => false,
 +    }
 +}
++
 +fn mul_factor_needs_parens(expr: &Expr) -> bool {
 +    matches!(
 +        expr,
 +        Expr::Add(_) | Expr::Equation(_, _) | Expr::Inequality { .. }
 +    )
 +}
++
 +fn render_mul_factor(expr: &Expr) -> MathBox {
 +    let rendered = from_expr(expr);
 +    if mul_factor_needs_parens(expr) {
 +        MathBox::Parens(Box::new(rendered))
 +    } else {
 +        rendered
 +    }
 +}
++
 +fn from_mul_factors(factors: &[Expr]) -> MathBox {
 +    let mut items = Vec::new();
 +    for (i, factor) in factors.iter().enumerate() {
 +        if i > 0 {
 +            items.push(MathBox::Operator(Operator::Mul));
 +        }
 +        items.push(render_mul_factor(factor));
 +    }
 +    if items.len() == 1 {
 +        items.pop().unwrap()
 +    } else {
 +        MathBox::Row(items)
 +    }
 +}
++
 +fn factorial_arg_needs_parens(arg: &Expr) -> bool {
 +    !matches!(
 +        arg,
 +        Expr::Integer(_) | Expr::Rational(_) | Expr::Float(_) | Expr::Symbol(_) | Expr::Func(_, _)
 +    )
 +}
++
  #[cfg(test)]
  mod tests {
      use super::*;
          assert!(matches!(mb, MathBox::Fraction { .. }));
+     }
++
 +    #[test]
 +    fn test_factorial_renders_as_postfix_bang() {
 +        let expr = Expr::Func(
 +            "factorial".to_string(),
 +            vec![Expr::Symbol(Symbol::new("n"))],
 +        );
 +        let mb = from_expr(&expr);
++
 +        if let MathBox::Row(items) = mb {
 +            assert_eq!(items.len(), 2);
 +            assert!(matches!(&items[0], MathBox::Symbol(s) if s == "n"));
 +            assert!(matches!(&items[1], MathBox::Symbol(s) if s == "!"));
 +        } else {
 +            panic!("expected row for factorial rendering");
 +        }
 +    }
++
 +    #[test]
 +    fn test_factorial_wraps_complex_arg_in_parens() {
 +        let expr = Expr::Func(
 +            "factorial".to_string(),
 +            vec![Expr::Add(vec![
 +                Expr::Symbol(Symbol::new("n")),
 +                Expr::Integer(1),
 +            ])],
 +        );
 +        let mb = from_expr(&expr);
++
 +        if let MathBox::Row(items) = mb {
 +            assert!(matches!(&items[0], MathBox::Parens(_)));
 +            assert!(matches!(&items[1], MathBox::Symbol(s) if s == "!"));
 +        } else {
 +            panic!("expected row for factorial rendering");
 +        }
 +    }
++
 +    #[test]
 +    fn test_row_postfix_factorial_converts_to_expr() {
 +        let mb = MathBox::Row(vec![
 +            MathBox::Symbol("n".to_string()),
 +            MathBox::Symbol("!".to_string()),
 +        ]);
++
 +        let expr = to_expr(&mb).unwrap();
 +        assert_eq!(
 +            expr,
 +            Expr::Func(
 +                "factorial".to_string(),
 +                vec![Expr::Symbol(Symbol::new("n"))]
 +            )
 +        );
 +    }
++
 +    #[test]
 +    fn test_from_expr_fraction_drops_unity_factor_in_numerator() {
 +        let expr = Expr::Mul(vec![
 +            Expr::Integer(1),
 +            Expr::Symbol(Symbol::new("n")),
 +            Expr::Pow(Box::new(Expr::Integer(2)), Box::new(Expr::Integer(-1))),
 +        ]);
++
 +        let mb = from_expr(&expr);
 +        if let MathBox::Fraction { num, den } = mb {
 +            assert!(!matches!(num.as_ref(), MathBox::Number(s) if s == "1"));
 +            assert!(matches!(den.as_ref(), MathBox::Number(s) if s == "2"));
 +        } else {
 +            panic!("expected fraction");
 +        }
 +    }
++
 +    #[test]
 +    fn test_from_expr_mul_wraps_additive_factor_with_parens() {
 +        let expr = Expr::Mul(vec![
 +            Expr::Symbol(Symbol::new("n")),
 +            Expr::Add(vec![Expr::Integer(1), Expr::Symbol(Symbol::new("n"))]),
 +        ]);
++
 +        let mb = from_expr(&expr);
 +        if let MathBox::Row(items) = mb {
 +            assert_eq!(items.len(), 3);
 +            assert!(matches!(&items[0], MathBox::Symbol(s) if s == "n"));
 +            assert!(matches!(&items[1], MathBox::Operator(Operator::Mul)));
 +            assert!(matches!(&items[2], MathBox::Parens(_)));
 +        } else {
 +            panic!("expected multiplication row");
 +        }
 +    }
++
 +    #[test]
 +    fn test_from_expr_fraction_numerator_hides_one_and_wraps_additive_factor() {
 +        let expr = Expr::Mul(vec![
 +            Expr::Integer(1),
 +            Expr::Symbol(Symbol::new("n")),
 +            Expr::Add(vec![Expr::Integer(1), Expr::Symbol(Symbol::new("n"))]),
 +            Expr::Pow(Box::new(Expr::Integer(2)), Box::new(Expr::Integer(-1))),
 +        ]);
++
 +        let mb = from_expr(&expr);
 +        if let MathBox::Fraction { num, den } = mb {
 +            assert!(matches!(den.as_ref(), MathBox::Number(s) if s == "2"));
 +            if let MathBox::Row(items) = num.as_ref() {
 +                assert_eq!(items.len(), 3);
 +                assert!(matches!(&items[0], MathBox::Symbol(s) if s == "n"));
 +                assert!(matches!(&items[1], MathBox::Operator(Operator::Mul)));
 +                assert!(matches!(&items[2], MathBox::Parens(_)));
 +            } else {
 +                panic!("expected row in fraction numerator");
 +            }
 +        } else {
 +            panic!("expected fraction");
 +        }
 +    }
+ }

garcalc-math/src/input.rsmodified

1494 lines changed — click to load

  //! Provides structured keyboard navigation through a MathBox tree
  //! with support for template insertion via commands.
 -use crate::mathbox::{MathBox, Cursor, Operator};
 +use crate::mathbox::{Cursor, MathBox, Operator};
  /// Result of processing a key event
  #[derive(Debug, Clone, PartialEq)]
+ }
  impl MathInput {
 +    fn char_count(s: &str) -> usize {
 +        s.chars().count()
 +    }
++
 +    fn byte_index_at_char(s: &str, char_idx: usize) -> usize {
 +        let target = char_idx.min(Self::char_count(s));
 +        if target == 0 {
 +            return 0;
 +        }
 +        s.char_indices()
 +            .nth(target)
 +            .map(|(idx, _)| idx)
 +            .unwrap_or_else(|| s.len())
 +    }
++
 +    fn remove_char_at(s: &mut String, char_idx: usize) -> bool {
 +        let len = Self::char_count(s);
 +        if char_idx >= len {
 +            return false;
 +        }
 +        let start = Self::byte_index_at_char(s, char_idx);
 +        let end = Self::byte_index_at_char(s, char_idx + 1);
 +        s.drain(start..end);
 +        true
 +    }
++
      /// Create a new empty input
      pub fn new() -> Self {
          let mut cursor = Cursor::new();
          // Normal input
          match ch {
 -            '\\' => {
 +            '\\' | ':' => {
                  // Enter command mode
                  self.command_buffer = Some(String::new());
                  InputResult::Consumed
                  self.wrap_in_power();
                  InputResult::Consumed
+             }
 +            '!' => {
 +                // Apply factorial to current element
 +                self.wrap_in_factorial();
 +                InputResult::Consumed
 +            }
              '_' => {
                  // Convert current element to subscript base
                  self.wrap_in_subscript();
      /// Handle a special key
      pub fn handle_key(&mut self, key: SpecialKey) -> InputResult {
 -        // Cancel command mode on special keys
 -        if self.command_buffer.is_some() && !matches!(key, SpecialKey::Backspace) {
 -            self.command_buffer = None;
 +        if self.command_buffer.is_some() {
 +            match key {
 +                SpecialKey::Enter => {
 +                    if let Some(cmd) = self.command_buffer.take() {
 +                        if cmd.is_empty() {
 +                            return InputResult::Consumed;
 +                        }
 +                        return self.execute_command(&cmd);
 +                    }
 +                    return InputResult::Ignored;
 +                }
 +                SpecialKey::Escape => {
 +                    self.command_buffer = None;
 +                    return InputResult::Consumed;
 +                }
 +                SpecialKey::Backspace => {
 +                    if let Some(ref mut buf) = self.command_buffer {
 +                        buf.pop();
 +                        if buf.is_empty() {
 +                            self.command_buffer = None;
 +                        }
 +                    }
 +                    return InputResult::Consumed;
 +                }
 +                _ => {
 +                    // For navigation/editing keys, leave command mode and continue handling the key.
 +                    self.command_buffer = None;
 +                }
 +            }
+         }
          match key {
                  InputResult::Consumed
+             }
              SpecialKey::Enter => InputResult::Evaluate,
 -            SpecialKey::Escape => {
 -                if self.command_buffer.is_some() {
 -                    self.command_buffer = None;
 -                    InputResult::Consumed
 -                } else {
 -                    InputResult::Cancel
 -                }
 -            }
 +            SpecialKey::Escape => InputResult::Cancel,
              SpecialKey::Backspace => {
 -                if let Some(ref mut buf) = self.command_buffer {
 -                    buf.pop();
 -                    if buf.is_empty() {
 -                        self.command_buffer = None;
 -                    }
 -                    InputResult::Consumed
 -                } else {
 -                    self.delete_at_cursor();
 -                    InputResult::Consumed
 -                }
 +                self.delete_at_cursor();
 +                InputResult::Consumed
+             }
              SpecialKey::Delete => {
                  self.delete_forward();
              "lim" | "limit" => Some(MathBox::limit_template()),
              "sum" => Some(MathBox::sum_template()),
              "prod" | "product" => Some(MathBox::product_template()),
 +            "solve" => Some(MathBox::Func {
 +                name: "solve".to_string(),
 +                args: vec![MathBox::Slot, MathBox::Symbol("x".to_string())],
 +            }),
              "abs" => Some(MathBox::Abs(Box::new(MathBox::Slot))),
              "pi" => Some(MathBox::Symbol("π".to_string())),
              "theta" => Some(MathBox::Symbol("θ".to_string())),
              "sigma" => Some(MathBox::Symbol("σ".to_string())),
              "omega" => Some(MathBox::Symbol("ω".to_string())),
              "inf" | "infinity" => Some(MathBox::Symbol("∞".to_string())),
 -            "sin" | "cos" | "tan" | "ln" | "log" | "exp" => {
 -                Some(MathBox::Func {
 -                    name: cmd.to_lowercase(),
 -                    args: vec![MathBox::Slot],
 -                })
 -            }
 +            "sin" | "cos" | "tan" | "ln" | "log" | "exp" => Some(MathBox::Func {
 +                name: cmd.to_lowercase(),
 +                args: vec![MathBox::Slot],
 +            }),
              "matrix" => Some(MathBox::matrix_template(2, 2)),
              _ => None,
          };
              if current.is_slot() {
                  *current = template;
                  // Move cursor into first child if it's a container
 -                if self.get_current().map(|c| c.child_count() > 0).unwrap_or(false) {
 -                    self.cursor.enter(0);
 +                if self
 +                    .get_current()
 +                    .map(|c| c.child_count() > 0)
 +                    .unwrap_or(false)
 +                {
 +                    self.focus_first_slot_in_current_subtree();
+                 }
              } else {
                  // Insert after current
 -                self.insert_after_current(template);
 +                if self.insert_after_current(template)
 +                    && self
 +                        .get_current()
 +                        .map(|c| c.child_count() > 0)
 +                        .unwrap_or(false)
 +                {
 +                    self.focus_first_slot_in_current_subtree();
 +                }
+             }
+         }
+     }
+         }
+     }
 +    /// Wrap the current element in factorial
 +    fn wrap_in_factorial(&mut self) {
 +        if let Some(current) = self.get_current_mut() {
 +            if !current.is_slot() {
 +                let arg = std::mem::replace(current, MathBox::Slot);
 +                *current = MathBox::Func {
 +                    name: "factorial".to_string(),
 +                    args: vec![arg],
 +                };
 +                self.cursor.offset = 0;
 +            } else {
 +                *current = MathBox::Func {
 +                    name: "factorial".to_string(),
 +                    args: vec![MathBox::Slot],
 +                };
 +                self.cursor.enter(0);
 +            }
 +        }
 +    }
++
      /// Append a digit to the current number
      fn append_to_number(&mut self, ch: char) {
 +        let offset = self.cursor.offset;
 +        let mut new_offset = None;
          if let Some(current) = self.get_current_mut() {
              match current {
                  MathBox::Number(s) => {
 -                    s.push(ch);
 +                    let insert_at = Self::byte_index_at_char(s, offset);
 +                    s.insert(insert_at, ch);
 +                    new_offset = Some(offset + 1);
+                 }
                  MathBox::Slot => {
                      *current = MathBox::Number(ch.to_string());
 +                    new_offset = Some(1);
+                 }
                  _ => {
 -                    // Insert after current
 -                    self.insert_after_current(MathBox::Number(ch.to_string()));
 +                    if self.insert_after_current(MathBox::Number(ch.to_string())) {
 +                        new_offset = Some(1);
 +                    }
+                 }
+             }
+         }
 +        if let Some(new_offset) = new_offset {
 +            self.cursor.offset = new_offset;
 +        }
+     }
      /// Append a character to the current symbol
      fn append_to_symbol(&mut self, ch: char) {
 +        let offset = self.cursor.offset;
 +        let mut new_offset = None;
          if let Some(current) = self.get_current_mut() {
              match current {
                  MathBox::Symbol(s) => {
 -                    s.push(ch);
 +                    let insert_at = Self::byte_index_at_char(s, offset);
 +                    s.insert(insert_at, ch);
 +                    new_offset = Some(offset + 1);
+                 }
                  MathBox::Slot => {
                      *current = MathBox::Symbol(ch.to_string());
 +                    new_offset = Some(1);
+                 }
                  _ => {
 -                    self.insert_after_current(MathBox::Symbol(ch.to_string()));
 +                    if self.insert_after_current(MathBox::Symbol(ch.to_string())) {
 +                        new_offset = Some(1);
 +                    }
+                 }
+             }
+         }
 +        if let Some(new_offset) = new_offset {
 +            self.cursor.offset = new_offset;
 +        }
+     }
      /// Insert an element at the cursor position
+     }
      /// Insert an element after the current one (in a Row)
 -    fn insert_after_current(&mut self, element: MathBox) {
 -        // This is complex - need to handle row insertion
 -        // For now, simplified implementation
 -        if let Some(current) = self.get_current_mut() {
 -            if matches!(current, MathBox::Row(_)) {
 -                if let MathBox::Row(items) = current {
 -                    items.push(element);
 -                }
 +    fn insert_after_current(&mut self, element: MathBox) -> bool {
 +        let current_path = self.cursor.path.clone();
++
 +        // Case 1: cursor is on a Row node; insert at the row offset.
 +        if let Some(MathBox::Row(items)) = Self::get_node_mut_at_path(&mut self.root, &current_path)
 +        {
 +            let insert_idx = self.cursor.offset.min(items.len());
 +            items.insert(insert_idx, element);
 +            self.cursor.path = current_path;
 +            self.cursor.enter(insert_idx);
 +            return true;
 +        }
++
 +        // Case 2: parent is a Row; insert as next sibling.
 +        if let Some((&idx, parent_path)) = current_path.split_last() {
 +            if let Some(MathBox::Row(items)) =
 +                Self::get_node_mut_at_path(&mut self.root, parent_path)
 +            {
 +                let insert_idx = (idx + 1).min(items.len());
 +                items.insert(insert_idx, element);
 +                self.cursor.path = parent_path.to_vec();
 +                self.cursor.enter(insert_idx);
 +                return true;
+             }
+         }
++
 +        // Case 3: no row context; wrap current node into a Row and append.
 +        if let Some(current) = Self::get_node_mut_at_path(&mut self.root, &current_path) {
 +            let old = std::mem::replace(current, MathBox::Slot);
 +            *current = MathBox::Row(vec![old, element]);
 +            self.cursor.path = current_path;
 +            self.cursor.enter(1);
 +            return true;
 +        }
++
 +        false
+     }
      /// Try to exit current container (parens, etc.)
      /// Delete at cursor
      fn delete_at_cursor(&mut self) {
 -        if let Some(current) = self.get_current_mut() {
 -            match current {
 -                MathBox::Number(s) if !s.is_empty() => {
 -                    s.pop();
 -                    if s.is_empty() {
 -                        *current = MathBox::Slot;
 +        let path = self.cursor.path.clone();
 +        let offset = self.cursor.offset;
++
 +        match self.get_current() {
 +            Some(MathBox::Number(_)) => {
 +                if offset > 0 {
 +                    let mut became_slot = false;
 +                    let mut removed = false;
 +                    if let Some(MathBox::Number(s)) =
 +                        Self::get_node_mut_at_path(&mut self.root, &path)
 +                    {
 +                        removed = Self::remove_char_at(s, offset - 1);
 +                        if s.is_empty() {
 +                            became_slot = true;
 +                        }
+                     }
 -                }
 -                MathBox::Symbol(s) if !s.is_empty() => {
 -                    s.pop();
 -                    if s.is_empty() {
 -                        *current = MathBox::Slot;
 +                    if became_slot {
 +                        if let Some(current) = Self::get_node_mut_at_path(&mut self.root, &path) {
 +                            *current = MathBox::Slot;
 +                        }
 +                        self.cursor.offset = 0;
 +                    } else if removed {
 +                        self.cursor.offset = offset - 1;
+                     }
 +                } else {
 +                    self.delete_previous_from_path(&path);
+                 }
 -                _ => {
 -                    // Replace with slot or exit
 -                    if !self.cursor.is_at_root() {
 -                        self.cursor.exit();
 +            }
 +            Some(MathBox::Symbol(_)) => {
 +                if offset > 0 {
 +                    let mut became_slot = false;
 +                    let mut removed = false;
 +                    if let Some(MathBox::Symbol(s)) =
 +                        Self::get_node_mut_at_path(&mut self.root, &path)
 +                    {
 +                        removed = Self::remove_char_at(s, offset - 1);
 +                        if s.is_empty() {
 +                            became_slot = true;
 +                        }
 +                    }
 +                    if became_slot {
 +                        if let Some(current) = Self::get_node_mut_at_path(&mut self.root, &path) {
 +                            *current = MathBox::Slot;
 +                        }
 +                        self.cursor.offset = 0;
 +                    } else if removed {
 +                        self.cursor.offset = offset - 1;
+                     }
 +                } else {
 +                    self.delete_previous_from_path(&path);
+                 }
+             }
 +            Some(MathBox::Slot) => {
 +                if !self.delete_current_slot_in_row(&path) {
 +                    self.delete_previous_from_path(&path);
 +                }
 +            }
 +            Some(_) => {
 +                if !path.is_empty() {
 +                    self.replace_current_with_slot(&path);
 +                }
 +            }
 +            None => {}
+         }
+     }
      /// Delete forward
      fn delete_forward(&mut self) {
 -        // For now, same as backspace
 -        self.delete_at_cursor();
 +        let path = self.cursor.path.clone();
 +        let offset = self.cursor.offset;
++
 +        match self.get_current() {
 +            Some(MathBox::Number(s)) => {
 +                let len = Self::char_count(s);
 +                if offset < len {
 +                    let mut became_slot = false;
 +                    if let Some(MathBox::Number(cur)) =
 +                        Self::get_node_mut_at_path(&mut self.root, &path)
 +                    {
 +                        Self::remove_char_at(cur, offset);
 +                        if cur.is_empty() {
 +                            became_slot = true;
 +                        }
 +                    }
 +                    if became_slot {
 +                        if let Some(current) = Self::get_node_mut_at_path(&mut self.root, &path) {
 +                            *current = MathBox::Slot;
 +                        }
 +                        self.cursor.offset = 0;
 +                    }
 +                } else {
 +                    self.delete_next_from_path(&path);
 +                }
 +            }
 +            Some(MathBox::Symbol(s)) => {
 +                let len = Self::char_count(s);
 +                if offset < len {
 +                    let mut became_slot = false;
 +                    if let Some(MathBox::Symbol(cur)) =
 +                        Self::get_node_mut_at_path(&mut self.root, &path)
 +                    {
 +                        Self::remove_char_at(cur, offset);
 +                        if cur.is_empty() {
 +                            became_slot = true;
 +                        }
 +                    }
 +                    if became_slot {
 +                        if let Some(current) = Self::get_node_mut_at_path(&mut self.root, &path) {
 +                            *current = MathBox::Slot;
 +                        }
 +                        self.cursor.offset = 0;
 +                    }
 +                } else {
 +                    self.delete_next_from_path(&path);
 +                }
 +            }
 +            Some(MathBox::Slot) => {
 +                self.delete_next_from_path(&path);
 +            }
 +            Some(_) => {
 +                if !path.is_empty() {
 +                    self.replace_current_with_slot(&path);
 +                }
 +            }
 +            None => {}
 +        }
+     }
      /// Move cursor left
      fn move_left(&mut self) {
 -        if self.cursor.offset > 0 {
 -            self.cursor.offset -= 1;
 -        } else if !self.cursor.is_at_root() {
 -            // Exit current and try to move to previous sibling
 -            if let Some(idx) = self.cursor.exit() {
 -                if idx > 0 {
 -                    self.cursor.enter(idx - 1);
 -                    // Move to end of new element
 -                    self.move_to_end_of_current();
 -                }
 +        if let Some(current) = self.get_current() {
 +            if matches!(current, MathBox::Number(_) | MathBox::Symbol(_)) && self.cursor.offset > 0
 +            {
 +                self.cursor.offset -= 1;
 +                return;
 +            }
 +        }
++
 +        let mut path = self.cursor.path.clone();
 +        while let Some(idx) = path.pop() {
 +            if idx > 0 {
 +                path.push(idx - 1);
 +                self.cursor.path = path;
 +                self.cursor.offset = 0;
 +                self.move_to_end_of_current();
 +                return;
+             }
+         }
+     }
      fn move_right(&mut self) {
          if let Some(current) = self.get_current() {
              match current {
 -                MathBox::Number(s) | MathBox::Symbol(s) if self.cursor.offset < s.len() => {
 +                MathBox::Number(s) | MathBox::Symbol(s)
 +                    if self.cursor.offset < Self::char_count(s) =>
 +                {
                      self.cursor.offset += 1;
 +                    return;
+                 }
 -                _ => {
 -                    // Try to enter first child or move to next sibling
 -                    if current.child_count() > 0 && self.cursor.offset == 0 {
 -                        self.cursor.enter(0);
 -                    } else if !self.cursor.is_at_root() {
 -                        if let Some(idx) = self.cursor.exit() {
 -                            let parent = self.get_current();
 -                            if let Some(p) = parent {
 -                                if idx + 1 < p.child_count() {
 -                                    self.cursor.enter(idx + 1);
 -                                }
 -                            }
 -                        }
 -                    }
 +                _ if current.child_count() > 0 => {
 +                    self.cursor.enter(0);
 +                    return;
 +                }
 +                _ => {}
 +            }
 +        }
++
 +        let mut path = self.cursor.path.clone();
 +        while let Some(idx) = path.pop() {
 +            if let Some(parent) = Self::get_node_at_path(&self.root, &path) {
 +                if idx + 1 < parent.child_count() {
 +                    path.push(idx + 1);
 +                    self.cursor.path = path;
 +                    self.cursor.offset = 0;
 +                    return;
+                 }
+             }
+         }
      /// Move to next slot (Tab)
      fn move_to_next_slot(&mut self) {
 -        // Simple: try next sibling, or exit and try next
 -        if let Some(current) = self.get_current() {
 -            if current.child_count() > 0 {
 -                self.cursor.enter(0);
 -                return;
 -            }
 +        let slots = self.collect_slot_paths();
 +        if slots.is_empty() {
 +            return;
+         }
 -        if !self.cursor.is_at_root() {
 -            if let Some(idx) = self.cursor.exit() {
 -                if let Some(parent) = self.get_current() {
 -                    if idx + 1 < parent.child_count() {
 -                        self.cursor.enter(idx + 1);
 -                    }
 -                }
 -            }
 -        }
 +        let current_path = self.cursor.path.clone();
 +        let next_idx = if let Some(idx) = slots.iter().position(|p| p == &current_path) {
 +            (idx + 1) % slots.len()
 +        } else {
 +            slots.iter().position(|p| p > &current_path).unwrap_or(0)
 +        };
++
 +        self.cursor.path = slots[next_idx].clone();
 +        self.cursor.offset = 0;
+     }
      /// Move to previous slot (Shift+Tab)
      fn move_to_prev_slot(&mut self) {
 -        if !self.cursor.is_at_root() {
 -            if let Some(idx) = self.cursor.exit() {
 -                if idx > 0 {
 -                    self.cursor.enter(idx - 1);
 -                    self.move_to_end_of_current();
 -                }
 -            }
 +        let slots = self.collect_slot_paths();
 +        if slots.is_empty() {
 +            return;
+         }
++
 +        let current_path = self.cursor.path.clone();
 +        let prev_idx = if let Some(idx) = slots.iter().position(|p| p == &current_path) {
 +            if idx == 0 { slots.len() - 1 } else { idx - 1 }
 +        } else {
 +            match slots.iter().rposition(|p| p < &current_path) {
 +                Some(idx) => idx,
 +                None => slots.len() - 1,
 +            }
 +        };
++
 +        self.cursor.path = slots[prev_idx].clone();
 +        self.cursor.offset = 0;
+     }
      /// Move cursor to start
          if let Some(current) = self.get_current() {
              match current {
                  MathBox::Number(s) | MathBox::Symbol(s) => {
 -                    self.cursor.offset = s.len();
 +                    self.cursor.offset = Self::char_count(s);
+                 }
                  _ if current.child_count() > 0 => {
                      self.cursor.enter(current.child_count() - 1);
      /// Get the current element at cursor
      fn get_current(&self) -> Option<&MathBox> {
 -        let mut current = &self.root;
 -        for &idx in &self.cursor.path {
 -            current = current.child(idx)?;
 -        }
 -        Some(current)
 +        Self::get_node_at_path(&self.root, &self.cursor.path)
+     }
      /// Get mutable reference to current element
      fn get_current_mut(&mut self) -> Option<&mut MathBox> {
 -        let mut current = &mut self.root;
 -        for &idx in &self.cursor.path {
 -            current = current.child_mut(idx)?;
 -        }
 -        Some(current)
 +        Self::get_node_mut_at_path(&mut self.root, &self.cursor.path)
+     }
      /// Get the root MathBox
      pub fn cursor_path(&self) -> &[usize] {
          &self.cursor.path
+     }
++
 +    /// Get character offset within the currently focused token
 +    pub fn cursor_offset(&self) -> usize {
 +        self.cursor.offset
 +    }
++
 +    fn get_node_at_path<'a>(root: &'a MathBox, path: &[usize]) -> Option<&'a MathBox> {
 +        let mut current = root;
 +        for &idx in path {
 +            current = current.child(idx)?;
 +        }
 +        Some(current)
 +    }
++
 +    fn get_node_mut_at_path<'a>(root: &'a mut MathBox, path: &[usize]) -> Option<&'a mut MathBox> {
 +        let mut current = root;
 +        for &idx in path {
 +            current = current.child_mut(idx)?;
 +        }
 +        Some(current)
 +    }
++
 +    fn collect_slot_paths(&self) -> Vec<Vec<usize>> {
 +        fn walk(node: &MathBox, path: &mut Vec<usize>, out: &mut Vec<Vec<usize>>) {
 +            if matches!(node, MathBox::Slot) {
 +                out.push(path.clone());
 +                return;
 +            }
 +            for i in MathInput::ordered_child_indices(node) {
 +                if let Some(child) = node.child(i) {
 +                    path.push(i);
 +                    walk(child, path, out);
 +                    path.pop();
 +                }
 +            }
 +        }
++
 +        let mut out = Vec::new();
 +        let mut path = Vec::new();
 +        walk(&self.root, &mut path, &mut out);
 +        out
 +    }
++
 +    fn ordered_child_indices(node: &MathBox) -> Vec<usize> {
 +        match node {
 +            MathBox::Power { .. } => vec![0, 1],
 +            MathBox::Derivative { .. } => vec![0, 1],
 +            MathBox::Sum { .. } | MathBox::Product { .. } => vec![1, 2, 3, 0],
 +            MathBox::Integral { lower, upper, .. } => {
 +                let has_lower = lower.is_some();
 +                let has_upper = upper.is_some();
 +                let mut indices = Vec::new();
 +                if has_upper {
 +                    indices.push(if has_lower { 1 } else { 0 });
 +                }
 +                if has_lower {
 +                    indices.push(0);
 +                }
 +                let body_idx = usize::from(has_lower) + usize::from(has_upper);
 +                indices.push(body_idx);
 +                indices.push(body_idx + 1); // variable slot/symbol
 +                indices
 +            }
 +            _ => (0..node.child_count()).collect(),
 +        }
 +    }
++
 +    fn focus_first_slot_in_current_subtree(&mut self) {
 +        let base = self.cursor.path.clone();
 +        let slots = self.collect_slot_paths();
 +        if let Some(path) = slots
 +            .into_iter()
 +            .find(|p| p.len() > base.len() && p.starts_with(&base))
 +        {
 +            self.cursor.path = path;
 +            self.cursor.offset = 0;
 +        }
 +    }
++
 +    fn previous_sibling_path(&self, path: &[usize]) -> Option<Vec<usize>> {
 +        let mut cursor = path.to_vec();
 +        while let Some(idx) = cursor.pop() {
 +            if idx > 0 {
 +                cursor.push(idx - 1);
 +                return Some(cursor);
 +            }
 +        }
 +        None
 +    }
++
 +    fn next_sibling_path(&self, path: &[usize]) -> Option<Vec<usize>> {
 +        let mut cursor = path.to_vec();
 +        while let Some(idx) = cursor.pop() {
 +            if let Some(parent) = Self::get_node_at_path(&self.root, &cursor) {
 +                if idx + 1 < parent.child_count() {
 +                    cursor.push(idx + 1);
 +                    return Some(cursor);
 +                }
 +            }
 +        }
 +        None
 +    }
++
 +    fn replace_current_with_slot(&mut self, path: &[usize]) {
 +        if let Some(current) = Self::get_node_mut_at_path(&mut self.root, path) {
 +            *current = MathBox::Slot;
 +            self.cursor.path = path.to_vec();
 +            self.cursor.offset = 0;
 +        }
 +    }
++
 +    fn is_effectively_empty(node: &MathBox) -> bool {
 +        match node {
 +            MathBox::Slot => true,
 +            MathBox::Number(s) | MathBox::Symbol(s) => s.is_empty(),
 +            MathBox::Operator(_) => false,
 +            MathBox::Fraction { num, den } => {
 +                Self::is_effectively_empty(num) && Self::is_effectively_empty(den)
 +            }
 +            MathBox::Power { base, exp } => {
 +                Self::is_effectively_empty(base) && Self::is_effectively_empty(exp)
 +            }
 +            MathBox::Subscript { base, sub } => {
 +                Self::is_effectively_empty(base) && Self::is_effectively_empty(sub)
 +            }
 +            MathBox::Root { index, radicand } => {
 +                let index_empty = index
 +                    .as_deref()
 +                    .map(Self::is_effectively_empty)
 +                    .unwrap_or(true);
 +                index_empty && Self::is_effectively_empty(radicand)
 +            }
 +            MathBox::Func { args, .. } => args.iter().all(Self::is_effectively_empty),
 +            MathBox::Abs(inner) | MathBox::Parens(inner) => Self::is_effectively_empty(inner),
 +            MathBox::Integral {
 +                lower,
 +                upper,
 +                body,
 +                var,
 +            } => {
 +                let lower_empty = lower
 +                    .as_deref()
 +                    .map(Self::is_effectively_empty)
 +                    .unwrap_or(true);
 +                let upper_empty = upper
 +                    .as_deref()
 +                    .map(Self::is_effectively_empty)
 +                    .unwrap_or(true);
 +                lower_empty
 +                    && upper_empty
 +                    && Self::is_effectively_empty(body)
 +                    && Self::is_effectively_empty(var)
 +            }
 +            MathBox::Derivative { var, body, .. } => {
 +                Self::is_effectively_empty(var) && Self::is_effectively_empty(body)
 +            }
 +            MathBox::Limit { var, to, body, .. } => {
 +                Self::is_effectively_empty(var)
 +                    && Self::is_effectively_empty(to)
 +                    && Self::is_effectively_empty(body)
 +            }
 +            MathBox::Sum {
 +                var,
 +                lower,
 +                upper,
 +                body,
 +            }
 +            | MathBox::Product {
 +                var,
 +                lower,
 +                upper,
 +                body,
 +            } => {
 +                Self::is_effectively_empty(var)
 +                    && Self::is_effectively_empty(lower)
 +                    && Self::is_effectively_empty(upper)
 +                    && Self::is_effectively_empty(body)
 +            }
 +            MathBox::Matrix { rows } => rows.iter().flatten().all(Self::is_effectively_empty),
 +            MathBox::Row(items) => items.iter().all(Self::is_effectively_empty),
 +        }
 +    }
++
 +    fn collapse_parent_if_empty(&mut self, current_path: &[usize]) -> bool {
 +        let Some((_, parent_path)) = current_path.split_last() else {
 +            return false;
 +        };
 +        if parent_path.is_empty() {
 +            return false;
 +        }
++
 +        let should_collapse = Self::get_node_at_path(&self.root, parent_path)
 +            .map(Self::is_effectively_empty)
 +            .unwrap_or(false);
 +        if should_collapse {
 +            self.replace_current_with_slot(parent_path);
 +            return true;
 +        }
 +        false
 +    }
++
 +    fn remove_sibling_from_parent_row(
 +        &mut self,
 +        parent_path: &[usize],
 +        remove_idx: usize,
 +        cursor_idx: usize,
 +    ) -> bool {
 +        if let Some(MathBox::Row(items)) = Self::get_node_mut_at_path(&mut self.root, parent_path) {
 +            if remove_idx >= items.len() {
 +                return false;
 +            }
++
 +            items.remove(remove_idx);
 +            if items.is_empty() {
 +                items.push(MathBox::Slot);
 +            }
++
 +            let new_idx = cursor_idx.min(items.len().saturating_sub(1));
 +            self.cursor.path = parent_path.to_vec();
 +            self.cursor.enter(new_idx);
 +            self.cursor.offset = 0;
 +            return true;
 +        }
 +        false
 +    }
++
 +    fn delete_current_slot_in_row(&mut self, path: &[usize]) -> bool {
 +        let Some((&idx, parent_path)) = path.split_last() else {
 +            return false;
 +        };
 +        self.remove_sibling_from_parent_row(parent_path, idx, idx.saturating_sub(1))
 +    }
++
 +    fn delete_previous_from_path(&mut self, current_path: &[usize]) {
 +        if let Some(prev_path) = self.previous_sibling_path(current_path) {
 +            if let (Some((&cur_idx, cur_parent)), Some((&prev_idx, prev_parent))) =
 +                (current_path.split_last(), prev_path.split_last())
 +            {
 +                if cur_parent == prev_parent
 +                    && prev_idx + 1 == cur_idx
 +                    && self.remove_sibling_from_parent_row(
 +                        cur_parent,
 +                        prev_idx,
 +                        cur_idx.saturating_sub(1),
 +                    )
 +                {
 +                    return;
 +                }
 +            }
++
 +            if let Some(node) = Self::get_node_mut_at_path(&mut self.root, &prev_path) {
 +                match node {
 +                    MathBox::Number(s) if !s.is_empty() => {
 +                        let last = Self::char_count(s).saturating_sub(1);
 +                        Self::remove_char_at(s, last);
 +                        if s.is_empty() {
 +                            *node = MathBox::Slot;
 +                            self.cursor.offset = 0;
 +                        } else {
 +                            self.cursor.offset = Self::char_count(s);
 +                        }
 +                        self.cursor.path = prev_path;
 +                    }
 +                    MathBox::Symbol(s) if !s.is_empty() => {
 +                        let last = Self::char_count(s).saturating_sub(1);
 +                        Self::remove_char_at(s, last);
 +                        if s.is_empty() {
 +                            *node = MathBox::Slot;
 +                            self.cursor.offset = 0;
 +                        } else {
 +                            self.cursor.offset = Self::char_count(s);
 +                        }
 +                        self.cursor.path = prev_path;
 +                    }
 +                    _ => {
 +                        *node = MathBox::Slot;
 +                        self.cursor.path = prev_path;
 +                        self.cursor.offset = 0;
 +                    }
 +                }
 +            }
 +            return;
 +        }
++
 +        let _ = self.collapse_parent_if_empty(current_path);
 +    }
++
 +    fn delete_next_from_path(&mut self, current_path: &[usize]) {
 +        if let Some(next_path) = self.next_sibling_path(current_path) {
 +            if let (Some((&cur_idx, cur_parent)), Some((&next_idx, next_parent))) =
 +                (current_path.split_last(), next_path.split_last())
 +            {
 +                if cur_parent == next_parent
 +                    && cur_idx + 1 == next_idx
 +                    && self.remove_sibling_from_parent_row(cur_parent, next_idx, cur_idx)
 +                {
 +                    return;
 +                }
 +            }
++
 +            if let Some(node) = Self::get_node_mut_at_path(&mut self.root, &next_path) {
 +                match node {
 +                    MathBox::Number(s) if !s.is_empty() => {
 +                        Self::remove_char_at(s, 0);
 +                        if s.is_empty() {
 +                            *node = MathBox::Slot;
 +                        }
 +                    }
 +                    MathBox::Symbol(s) if !s.is_empty() => {
 +                        Self::remove_char_at(s, 0);
 +                        if s.is_empty() {
 +                            *node = MathBox::Slot;
 +                        }
 +                    }
 +                    _ => {
 +                        *node = MathBox::Slot;
 +                    }
 +                }
 +            }
 +            return;
 +        }
++
 +        let _ = self.collapse_parent_if_empty(current_path);
 +    }
+ }
  /// Special keys that can be handled
  mod tests {
      use super::*;
 +    fn run_command(input: &mut MathInput, cmd: &str) {
 +        input.handle_char('\\');
 +        for ch in cmd.chars() {
 +            input.handle_char(ch);
 +        }
 +        input.handle_char(' ');
 +    }
++
      #[test]
      fn test_new_input() {
          let input = MathInput::new();
+         }
+     }
 +    #[test]
 +    fn test_power_input() {
 +        let mut input = MathInput::new();
 +        input.handle_char('2');
 +        input.handle_char('^');
 +        input.handle_char('2');
++
 +        if let MathBox::Row(items) = &input.root {
 +            if let MathBox::Power { base, exp } = &items[0] {
 +                assert!(matches!(base.as_ref(), MathBox::Number(s) if s == "2"));
 +                assert!(matches!(exp.as_ref(), MathBox::Number(s) if s == "2"));
 +            } else {
 +                panic!("Expected Power");
 +            }
 +        }
 +    }
++
 +    #[test]
 +    fn test_factorial_input_wraps_current() {
 +        let mut input = MathInput::new();
 +        input.handle_char('5');
 +        input.handle_char('!');
++
 +        if let MathBox::Row(items) = &input.root {
 +            if let MathBox::Func { name, args } = &items[0] {
 +                assert_eq!(name, "factorial");
 +                assert_eq!(args.len(), 1);
 +                assert!(matches!(&args[0], MathBox::Number(s) if s == "5"));
 +            } else {
 +                panic!("Expected factorial function");
 +            }
 +        } else {
 +            panic!("Expected Row");
 +        }
 +    }
++
 +    #[test]
 +    fn test_factorial_input_on_empty_slot_inserts_template() {
 +        let mut input = MathInput::new();
 +        input.handle_char('!');
++
 +        if let MathBox::Row(items) = &input.root {
 +            if let MathBox::Func { name, args } = &items[0] {
 +                assert_eq!(name, "factorial");
 +                assert_eq!(args.len(), 1);
 +                assert!(matches!(&args[0], MathBox::Slot));
 +            } else {
 +                panic!("Expected factorial function");
 +            }
 +        } else {
 +            panic!("Expected Row");
 +        }
 +        assert_eq!(input.cursor_path(), &[0, 0]);
 +    }
++
 +    #[test]
 +    fn test_insert_in_middle_of_number() {
 +        let mut input = MathInput::new();
 +        input.handle_char('1');
 +        input.handle_char('2');
 +        input.handle_char('3');
++
 +        input.handle_key(SpecialKey::Left);
 +        input.handle_key(SpecialKey::Left);
 +        input.handle_char('4');
++
 +        if let MathBox::Row(items) = &input.root {
 +            assert!(matches!(&items[0], MathBox::Number(s) if s == "1423"));
 +        }
 +        assert_eq!(input.cursor_offset(), 2);
 +    }
++
 +    #[test]
 +    fn test_backspace_uses_cursor_offset() {
 +        let mut input = MathInput::new();
 +        input.handle_char('1');
 +        input.handle_char('2');
 +        input.handle_char('3');
++
 +        input.handle_key(SpecialKey::Left);
 +        input.handle_key(SpecialKey::Left);
 +        input.handle_key(SpecialKey::Backspace);
++
 +        if let MathBox::Row(items) = &input.root {
 +            assert!(matches!(&items[0], MathBox::Number(s) if s == "23"));
 +        }
 +        assert_eq!(input.cursor_offset(), 0);
 +    }
++
 +    #[test]
 +    fn test_delete_uses_cursor_offset() {
 +        let mut input = MathInput::new();
 +        input.handle_char('1');
 +        input.handle_char('2');
 +        input.handle_char('3');
++
 +        input.handle_key(SpecialKey::Left);
 +        input.handle_key(SpecialKey::Left);
 +        input.handle_key(SpecialKey::Delete);
++
 +        if let MathBox::Row(items) = &input.root {
 +            assert!(matches!(&items[0], MathBox::Number(s) if s == "13"));
 +        }
 +        assert_eq!(input.cursor_offset(), 1);
 +    }
++
 +    #[test]
 +    fn test_row_insertion_after_number() {
 +        let mut input = MathInput::new();
 +        input.handle_char('2');
 +        input.handle_char('+');
 +        input.handle_char('3');
++
 +        if let MathBox::Row(items) = &input.root {
 +            assert_eq!(items.len(), 3);
 +            assert!(matches!(&items[0], MathBox::Number(s) if s == "2"));
 +            assert!(matches!(&items[1], MathBox::Operator(Operator::Add)));
 +            assert!(matches!(&items[2], MathBox::Number(s) if s == "3"));
 +        } else {
 +            panic!("Expected Row");
 +        }
 +    }
++
      #[test]
      fn test_command_mode() {
          let mut input = MathInput::new();
              assert!(matches!(items[0], MathBox::Root { index: None, .. }));
+         }
+     }
++
 +    #[test]
 +    fn test_command_mode_colon_alias() {
 +        let mut input = MathInput::new();
 +        input.handle_char(':');
 +        assert!(input.command_buffer.is_some());
++
 +        input.handle_char('s');
 +        input.handle_char('u');
 +        input.handle_char('m');
 +        input.handle_char(' ');
++
 +        if let MathBox::Row(items) = &input.root {
 +            assert!(matches!(items[0], MathBox::Sum { .. }));
 +        }
 +    }
++
 +    #[test]
 +    fn test_command_mode_executes_on_enter() {
 +        let mut input = MathInput::new();
 +        input.handle_char(':');
 +        input.handle_char('f');
 +        input.handle_char('r');
 +        input.handle_char('a');
 +        input.handle_char('c');
++
 +        let result = input.handle_key(SpecialKey::Enter);
 +        assert!(matches!(result, InputResult::Consumed));
 +        assert!(input.command_buffer.is_none());
++
 +        if let MathBox::Row(items) = &input.root {
 +            assert!(matches!(items[0], MathBox::Fraction { .. }));
 +        } else {
 +            panic!("Expected Row");
 +        }
 +    }
++
 +    #[test]
 +    fn test_sum_command_template() {
 +        let mut input = MathInput::new();
 +        run_command(&mut input, "sum");
++
 +        if let MathBox::Row(items) = &input.root {
 +            if let MathBox::Sum {
 +                var,
 +                lower,
 +                upper,
 +                body,
 +            } = &items[0]
 +            {
 +                assert!(matches!(var.as_ref(), MathBox::Symbol(s) if s == "i"));
 +                assert!(matches!(lower.as_ref(), MathBox::Slot));
 +                assert!(matches!(upper.as_ref(), MathBox::Slot));
 +                assert!(matches!(body.as_ref(), MathBox::Slot));
 +            } else {
 +                panic!("Expected Sum template");
 +            }
 +        }
 +    }
++
 +    #[test]
 +    fn test_diff_command_template() {
 +        let mut input = MathInput::new();
 +        run_command(&mut input, "diff");
++
 +        if let MathBox::Row(items) = &input.root {
 +            if let MathBox::Derivative { order, var, body } = &items[0] {
 +                assert_eq!(*order, 1);
 +                assert!(matches!(var.as_ref(), MathBox::Slot));
 +                assert!(matches!(body.as_ref(), MathBox::Slot));
 +            } else {
 +                panic!("Expected Derivative template");
 +            }
 +        }
 +    }
++
 +    #[test]
 +    fn test_lim_command_template() {
 +        let mut input = MathInput::new();
 +        run_command(&mut input, "lim");
++
 +        if let MathBox::Row(items) = &input.root {
 +            if let MathBox::Limit {
 +                var,
 +                to,
 +                direction,
 +                body,
 +            } = &items[0]
 +            {
 +                assert!(matches!(var.as_ref(), MathBox::Symbol(s) if s == "x"));
 +                assert!(matches!(to.as_ref(), MathBox::Slot));
 +                assert!(direction.is_none());
 +                assert!(matches!(body.as_ref(), MathBox::Slot));
 +            } else {
 +                panic!("Expected Limit template");
 +            }
 +        }
 +    }
++
 +    #[test]
 +    fn test_dint_command_template() {
 +        let mut input = MathInput::new();
 +        run_command(&mut input, "dint");
++
 +        if let MathBox::Row(items) = &input.root {
 +            if let MathBox::Integral {
 +                lower,
 +                upper,
 +                body,
 +                var,
 +            } = &items[0]
 +            {
 +                assert!(matches!(lower.as_deref(), Some(MathBox::Slot)));
 +                assert!(matches!(upper.as_deref(), Some(MathBox::Slot)));
 +                assert!(matches!(body.as_ref(), MathBox::Slot));
 +                assert!(matches!(var.as_ref(), MathBox::Symbol(s) if s == "x"));
 +            } else {
 +                panic!("Expected definite Integral template");
 +            }
 +        }
 +    }
++
 +    #[test]
 +    fn test_solve_command_template() {
 +        let mut input = MathInput::new();
 +        run_command(&mut input, "solve");
++
 +        assert_eq!(input.cursor_path(), &[0, 0]);
 +        if let MathBox::Row(items) = &input.root {
 +            if let MathBox::Func { name, args } = &items[0] {
 +                assert_eq!(name, "solve");
 +                assert_eq!(args.len(), 2);
 +                assert!(matches!(&args[0], MathBox::Slot));
 +                assert!(matches!(&args[1], MathBox::Symbol(s) if s == "x"));
 +            } else {
 +                panic!("Expected solve function template");
 +            }
 +        } else {
 +            panic!("Expected Row");
 +        }
 +    }
++
 +    #[test]
 +    fn test_tab_cycles_fraction_slots() {
 +        let mut input = MathInput::new();
 +        run_command(&mut input, "frac");
++
 +        assert_eq!(input.cursor_path(), &[0, 0]);
++
 +        input.handle_key(SpecialKey::Tab);
 +        assert_eq!(input.cursor_path(), &[0, 1]);
++
 +        input.handle_key(SpecialKey::Tab);
 +        assert_eq!(input.cursor_path(), &[0, 0]);
++
 +        input.handle_key(SpecialKey::ShiftTab);
 +        assert_eq!(input.cursor_path(), &[0, 1]);
 +    }
++
 +    #[test]
 +    fn test_tab_skips_non_slot_children_in_sum() {
 +        let mut input = MathInput::new();
 +        run_command(&mut input, "sum");
++
 +        // Starts at lower bound slot by policy (non-slot var is skipped).
 +        assert_eq!(input.cursor_path(), &[0, 1]);
++
 +        input.handle_key(SpecialKey::Tab);
 +        assert_eq!(input.cursor_path(), &[0, 2]);
++
 +        input.handle_key(SpecialKey::Tab);
 +        assert_eq!(input.cursor_path(), &[0, 3]);
++
 +        input.handle_key(SpecialKey::Tab);
 +        assert_eq!(input.cursor_path(), &[0, 1]);
 +    }
++
 +    #[test]
 +    fn test_nested_tab_order_with_power_in_sum_body() {
 +        let mut input = MathInput::new();
 +        run_command(&mut input, "sum");
++
 +        input.handle_key(SpecialKey::Tab);
 +        input.handle_key(SpecialKey::Tab);
 +        assert_eq!(input.cursor_path(), &[0, 3]);
++
 +        input.handle_char('x');
 +        input.handle_char('^');
 +        assert_eq!(input.cursor_path(), &[0, 3, 1]);
++
 +        // From nested exponent slot, Tab should cycle to first slot in the expression.
 +        input.handle_key(SpecialKey::Tab);
 +        assert_eq!(input.cursor_path(), &[0, 1]);
++
 +        // Shift+Tab should return to the nested exponent slot.
 +        input.handle_key(SpecialKey::ShiftTab);
 +        assert_eq!(input.cursor_path(), &[0, 3, 1]);
 +    }
++
 +    #[test]
 +    fn test_dint_focus_and_tab_order_upper_lower_body() {
 +        let mut input = MathInput::new();
 +        run_command(&mut input, "dint");
++
 +        // Policy: upper -> lower -> body -> var (var may be non-slot default).
 +        assert_eq!(input.cursor_path(), &[0, 1]);
++
 +        input.handle_key(SpecialKey::Tab);
 +        assert_eq!(input.cursor_path(), &[0, 0]);
++
 +        input.handle_key(SpecialKey::Tab);
 +        assert_eq!(input.cursor_path(), &[0, 2]);
++
 +        input.handle_key(SpecialKey::Tab);
 +        assert_eq!(input.cursor_path(), &[0, 1]);
 +    }
++
 +    #[test]
 +    fn test_diff_focus_and_tab_order_var_body() {
 +        let mut input = MathInput::new();
 +        run_command(&mut input, "diff");
++
 +        assert_eq!(input.cursor_path(), &[0, 0]);
 +        input.handle_key(SpecialKey::Tab);
 +        assert_eq!(input.cursor_path(), &[0, 1]);
 +        input.handle_key(SpecialKey::Tab);
 +        assert_eq!(input.cursor_path(), &[0, 0]);
 +    }
++
 +    #[test]
 +    fn test_close_paren_exits_container() {
 +        let mut input = MathInput::new();
 +        input.handle_char('(');
 +        assert_eq!(input.cursor_path(), &[0, 0]);
++
 +        input.handle_char(')');
 +        assert_eq!(input.cursor_path(), &[0]);
 +    }
++
 +    #[test]
 +    fn test_backspace_at_exponent_start_deletes_base() {
 +        let mut input = MathInput::new();
 +        input.handle_char('2');
 +        input.handle_char('^');
 +        input.handle_char('3');
++
 +        input.handle_key(SpecialKey::Left);
 +        assert_eq!(input.cursor_path(), &[0, 1]);
 +        assert_eq!(input.cursor_offset(), 0);
++
 +        input.handle_key(SpecialKey::Backspace);
 +        assert_eq!(input.cursor_path(), &[0, 0]);
 +        assert_eq!(input.cursor_offset(), 0);
++
 +        if let MathBox::Row(items) = &input.root {
 +            if let MathBox::Power { base, exp } = &items[0] {
 +                assert!(matches!(base.as_ref(), MathBox::Slot));
 +                assert!(matches!(exp.as_ref(), MathBox::Number(s) if s == "3"));
 +            } else {
 +                panic!("Expected Power");
 +            }
 +        }
 +    }
++
 +    #[test]
 +    fn test_delete_at_base_end_deletes_exponent_prefix() {
 +        let mut input = MathInput::new();
 +        input.handle_char('2');
 +        input.handle_char('^');
 +        input.handle_char('3');
 +        input.handle_char('4');
++
 +        input.handle_key(SpecialKey::Down);
 +        assert_eq!(input.cursor_path(), &[0, 0]);
 +        input.handle_key(SpecialKey::Right);
 +        assert_eq!(input.cursor_offset(), 1);
++
 +        input.handle_key(SpecialKey::Delete);
 +        assert_eq!(input.cursor_path(), &[0, 0]);
 +        assert_eq!(input.cursor_offset(), 1);
++
 +        if let MathBox::Row(items) = &input.root {
 +            if let MathBox::Power { exp, .. } = &items[0] {
 +                assert!(matches!(exp.as_ref(), MathBox::Number(s) if s == "4"));
 +            } else {
 +                panic!("Expected Power");
 +            }
 +        }
 +    }
++
 +    #[test]
 +    fn test_backspace_from_denominator_slot_targets_numerator() {
 +        let mut input = MathInput::new();
 +        run_command(&mut input, "frac");
 +        input.handle_char('1');
++
 +        input.handle_key(SpecialKey::Tab);
 +        assert_eq!(input.cursor_path(), &[0, 1]);
 +        assert!(matches!(input.get_current(), Some(MathBox::Slot)));
++
 +        input.handle_key(SpecialKey::Backspace);
 +        assert_eq!(input.cursor_path(), &[0, 0]);
++
 +        if let MathBox::Row(items) = &input.root {
 +            if let MathBox::Fraction { num, den } = &items[0] {
 +                assert!(matches!(num.as_ref(), MathBox::Slot));
 +                assert!(matches!(den.as_ref(), MathBox::Slot));
 +            } else {
 +                panic!("Expected Fraction");
 +            }
 +        }
 +    }
++
 +    #[test]
 +    fn test_delete_from_numerator_slot_targets_denominator() {
 +        let mut input = MathInput::new();
 +        run_command(&mut input, "frac");
++
 +        input.handle_key(SpecialKey::Tab);
 +        input.handle_char('5');
 +        input.handle_key(SpecialKey::ShiftTab);
 +        assert_eq!(input.cursor_path(), &[0, 0]);
++
 +        input.handle_key(SpecialKey::Delete);
 +        assert_eq!(input.cursor_path(), &[0, 0]);
++
 +        if let MathBox::Row(items) = &input.root {
 +            if let MathBox::Fraction { num, den } = &items[0] {
 +                assert!(matches!(num.as_ref(), MathBox::Slot));
 +                assert!(matches!(den.as_ref(), MathBox::Slot));
 +            } else {
 +                panic!("Expected Fraction");
 +            }
 +        }
 +    }
++
 +    #[test]
 +    fn test_backspace_on_container_replaces_with_slot() {
 +        let mut input = MathInput::new();
 +        input.handle_char('(');
 +        input.handle_char('x');
 +        input.handle_char(')');
 +        assert_eq!(input.cursor_path(), &[0]);
++
 +        input.handle_key(SpecialKey::Backspace);
 +        assert_eq!(input.cursor_path(), &[0]);
++
 +        if let MathBox::Row(items) = &input.root {
 +            assert!(matches!(&items[0], MathBox::Slot));
 +        } else {
 +            panic!("Expected Row");
 +        }
 +    }
++
 +    #[test]
 +    fn test_backspace_clears_empty_sum_template() {
 +        let mut input = MathInput::new();
 +        run_command(&mut input, "sum");
++
 +        assert_eq!(input.cursor_path(), &[0, 1]);
 +        input.handle_key(SpecialKey::Backspace);
 +        assert_eq!(input.cursor_path(), &[0, 0]);
++
 +        input.handle_key(SpecialKey::Backspace);
 +        assert_eq!(input.cursor_path(), &[0]);
++
 +        if let MathBox::Row(items) = &input.root {
 +            assert!(matches!(&items[0], MathBox::Slot));
 +        } else {
 +            panic!("Expected Row");
 +        }
 +    }
++
 +    #[test]
 +    fn test_backspace_on_row_slot_removes_current_slot() {
 +        let mut input = MathInput::new();
 +        input.handle_char('2');
 +        input.handle_char('+');
 +        input.handle_char('3');
++
 +        input.handle_key(SpecialKey::Backspace);
 +        input.handle_key(SpecialKey::Backspace);
++
 +        assert_eq!(input.cursor_path(), &[1]);
 +        if let MathBox::Row(items) = &input.root {
 +            assert_eq!(items.len(), 2);
 +            assert!(matches!(&items[0], MathBox::Number(s) if s == "2"));
 +            assert!(matches!(&items[1], MathBox::Operator(Operator::Add)));
 +        } else {
 +            panic!("Expected Row");
 +        }
 +    }
+ }

garcalc-math/src/layout.rsmodified

  //! Computes bounding boxes and positions for mathematical typesetting.
  //! Uses baseline-aligned layout with proper ascent/descent metrics.
 -use crate::mathbox::{MathBox, Operator, LimitDirection};
 +use crate::mathbox::{LimitDirection, MathBox, Operator};
  use cairo::Context;
  /// Layout metrics for a rendered element
          self.layout_at_depth(mathbox, ctx, 0)
+     }
 +    /// Compute layout from an explicit starting depth
 +    pub fn layout_with_depth(&self, mathbox: &MathBox, ctx: &Context, depth: u32) -> LayoutBox {
 +        self.layout_at_depth(mathbox, ctx, depth)
 +    }
++
      /// Compute layout at a specific nesting depth
      fn layout_at_depth(&self, mathbox: &MathBox, ctx: &Context, depth: u32) -> LayoutBox {
          let scale = self.scale_for_depth(depth);
              MathBox::Symbol(s) => self.layout_symbol(s, ctx, font_size),
              MathBox::Operator(op) => self.layout_operator(*op, ctx, font_size),
              MathBox::Slot => self.layout_slot(ctx, font_size),
 -            MathBox::Fraction { num, den } => {
 -                self.layout_fraction(num, den, ctx, depth)
 -            }
 -            MathBox::Power { base, exp } => {
 -                self.layout_power(base, exp, ctx, depth)
 -            }
 -            MathBox::Subscript { base, sub } => {
 -                self.layout_subscript(base, sub, ctx, depth)
 -            }
 +            MathBox::Fraction { num, den } => self.layout_fraction(num, den, ctx, depth),
 +            MathBox::Power { base, exp } => self.layout_power(base, exp, ctx, depth),
 +            MathBox::Subscript { base, sub } => self.layout_subscript(base, sub, ctx, depth),
              MathBox::Root { index, radicand } => {
                  self.layout_root(index.as_deref(), radicand, ctx, depth)
+             }
 -            MathBox::Func { name, args } => {
 -                self.layout_func(name, args, ctx, depth)
 -            }
 +            MathBox::Func { name, args } => self.layout_func(name, args, ctx, depth),
              MathBox::Abs(inner) => self.layout_abs(inner, ctx, depth),
              MathBox::Parens(inner) => self.layout_parens(inner, ctx, depth),
 -            MathBox::Integral { lower, upper, body, var } => {
 -                self.layout_integral(
 -                    lower.as_deref(),
 -                    upper.as_deref(),
 -                    body,
 -                    var,
 -                    ctx,
 -                    depth,
 -                )
 -            }
 +            MathBox::Integral {
 +                lower,
 +                upper,
 +                body,
 +                var,
 +            } => self.layout_integral(lower.as_deref(), upper.as_deref(), body, var, ctx, depth),
              MathBox::Derivative { order, var, body } => {
                  self.layout_derivative(*order, var, body, ctx, depth)
+             }
 -            MathBox::Limit { var, to, direction, body } => {
 -                self.layout_limit(var, to, *direction, body, ctx, depth)
 -            }
 -            MathBox::Sum { var, lower, upper, body } => {
 -                self.layout_bigop("∑", var, lower, upper, body, ctx, depth)
 -            }
 -            MathBox::Product { var, lower, upper, body } => {
 -                self.layout_bigop("∏", var, lower, upper, body, ctx, depth)
 -            }
 +            MathBox::Limit {
 +                var,
 +                to,
 +                direction,
 +                body,
 +            } => self.layout_limit(var, to, *direction, body, ctx, depth),
 +            MathBox::Sum {
 +                var,
 +                lower,
 +                upper,
 +                body,
 +            } => self.layout_bigop("∑", var, lower, upper, body, ctx, depth),
 +            MathBox::Product {
 +                var,
 +                lower,
 +                upper,
 +                body,
 +            } => self.layout_bigop("∏", var, lower, upper, body, ctx, depth),
              MathBox::Matrix { rows } => self.layout_matrix(rows, ctx, depth),
              MathBox::Row(items) => self.layout_row(items, ctx, depth),
+         }
      /// Layout a symbol (may use italic)
      fn layout_symbol(&self, symbol: &str, ctx: &Context, font_size: f64) -> LayoutBox {
 -        ctx.select_font_face(&self.font_family, cairo::FontSlant::Italic, cairo::FontWeight::Normal);
 +        ctx.select_font_face(
 +            &self.font_family,
 +            cairo::FontSlant::Italic,
 +            cairo::FontWeight::Normal,
 +        );
          let layout = self.layout_text(symbol, ctx, font_size);
 -        ctx.select_font_face(&self.font_family, cairo::FontSlant::Normal, cairo::FontWeight::Normal);
 +        ctx.select_font_face(
 +            &self.font_family,
 +            cairo::FontSlant::Normal,
 +            cairo::FontWeight::Normal,
 +        );
          layout
+     }
      /// Layout an empty slot (placeholder box)
      fn layout_slot(&self, _ctx: &Context, font_size: f64) -> LayoutBox {
 -        let slot_width = font_size * 0.8;
 -        let slot_height = font_size * 0.8;
 +        // Keep slots readable at nested depths by enforcing a minimum visual size.
 +        let slot_width = (font_size * 0.86).max(10.0);
 +        let slot_height = (font_size * 0.9).max(11.0);
          LayoutBox {
              width: slot_width,
 -            ascent: slot_height * 0.6,
 -            descent: slot_height * 0.4,
 +            ascent: slot_height * 0.62,
 +            descent: slot_height * 0.38,
              children: vec![],
+         }
+     }
              width,
              ascent: gap + bar_thickness / 2.0 + num_layout.height(),
              descent: gap + bar_thickness / 2.0 + den_layout.height(),
 -            children: vec![
 -                (num_x, num_y, num_layout),
 -                (den_x, den_y, den_layout),
 -            ],
 +            children: vec![(num_x, num_y, num_layout), (den_x, den_y, den_layout)],
+         }
+     }
      /// Layout a power (superscript)
 -    fn layout_power(
 -        &self,
 -        base: &MathBox,
 -        exp: &MathBox,
 -        ctx: &Context,
 -        depth: u32,
 -    ) -> LayoutBox {
 +    fn layout_power(&self, base: &MathBox, exp: &MathBox, ctx: &Context, depth: u32) -> LayoutBox {
          let base_layout = self.layout_at_depth(base, ctx, depth);
          let exp_layout = self.layout_at_depth(exp, ctx, depth + 1);
 +        let scale = self.scale_for_depth(depth);
 +        let font_size = self.base_font_size * scale;
 -        // Exponent is raised above the baseline
 -        let exp_raise = base_layout.ascent * 0.5;
 +        // Exponent is raised above the baseline and slightly kerned to the right.
 +        let exp_raise = base_layout.ascent * 0.58 + exp_layout.descent * 0.1;
 +        let exp_kern = (font_size * 0.06).max(0.8);
          LayoutBox {
 -            width: base_layout.width + exp_layout.width,
 -            ascent: (base_layout.ascent).max(exp_raise + exp_layout.height()),
 +            width: base_layout.width + exp_kern + exp_layout.width,
 +            ascent: base_layout.ascent.max(exp_raise + exp_layout.ascent),
              descent: base_layout.descent,
              children: vec![
                  (0.0, 0.0, base_layout.clone()),
 -                (base_layout.width, -exp_raise, exp_layout),
 +                (base_layout.width + exp_kern, -exp_raise, exp_layout),
              ],
+         }
+     }
      ) -> LayoutBox {
          let base_layout = self.layout_at_depth(base, ctx, depth);
          let sub_layout = self.layout_at_depth(sub, ctx, depth + 1);
 +        let scale = self.scale_for_depth(depth);
 +        let font_size = self.base_font_size * scale;
 -        // Subscript is lowered below the baseline
 -        let sub_lower = base_layout.descent + sub_layout.ascent * 0.3;
 +        // Subscript is lowered with a small right kern to avoid touching the base.
 +        let sub_lower =
 +            (base_layout.descent * 0.6 + sub_layout.ascent * 0.9).max(sub_layout.ascent * 0.75);
 +        let sub_kern = (font_size * 0.05).max(0.6);
          LayoutBox {
 -            width: base_layout.width + sub_layout.width,
 -            ascent: base_layout.ascent,
 -            descent: (base_layout.descent).max(sub_lower + sub_layout.height()),
 +            width: base_layout.width + sub_kern + sub_layout.width,
 +            ascent: base_layout
 +                .ascent
 +                .max((sub_layout.ascent - sub_lower).max(0.0)),
 +            descent: base_layout.descent.max(sub_lower + sub_layout.descent),
              children: vec![
                  (0.0, 0.0, base_layout.clone()),
 -                (base_layout.width, sub_lower, sub_layout),
 +                (base_layout.width + sub_kern, sub_lower, sub_layout),
              ],
+         }
+     }
+     }
      /// Layout a function call
 -    fn layout_func(
 -        &self,
 -        name: &str,
 -        args: &[MathBox],
 -        ctx: &Context,
 -        depth: u32,
 -    ) -> LayoutBox {
 +    fn layout_func(&self, name: &str, args: &[MathBox], ctx: &Context, depth: u32) -> LayoutBox {
 +        if name == "factorial" && args.len() == 1 {
 +            return self.layout_factorial(&args[0], ctx, depth);
 +        }
++
          let scale = self.scale_for_depth(depth);
          let font_size = self.base_font_size * scale;
+         }
+     }
 +    fn layout_factorial(&self, arg: &MathBox, ctx: &Context, depth: u32) -> LayoutBox {
 +        let scale = self.scale_for_depth(depth);
 +        let font_size = self.base_font_size * scale;
 +        let gap = (font_size * 0.06).max(0.6);
++
 +        let arg_layout = self.layout_at_depth(arg, ctx, depth);
 +        let arg_width = arg_layout.width;
 +        let bang_layout = self.layout_text("!", ctx, font_size);
++
 +        LayoutBox {
 +            width: arg_width + gap + bang_layout.width,
 +            ascent: arg_layout.ascent.max(bang_layout.ascent),
 +            descent: arg_layout.descent.max(bang_layout.descent),
 +            children: vec![(0.0, 0.0, arg_layout), (arg_width + gap, 0.0, bang_layout)],
 +        }
 +    }
++
      /// Layout absolute value
      fn layout_abs(&self, inner: &MathBox, ctx: &Context, depth: u32) -> LayoutBox {
          let inner_layout = self.layout_at_depth(inner, ctx, depth);
          let body_layout = self.layout_at_depth(body, ctx, depth);
          let var_layout = self.layout_at_depth(var, ctx, depth);
 +        let d_layout = self.layout_text("d", ctx, font_size);
 -        // Integral symbol sizing
 -        let int_height = (body_layout.height()).max(font_size * 1.5);
 -        let int_width = font_size * 0.5;
 +        // Integral symbol sizing and metrics
 +        let symbol_size = body_layout.height().max(font_size * 1.8);
 +        ctx.set_font_size(symbol_size);
 +        let int_extents = ctx.text_extents("∫").unwrap();
 +        let int_font_extents = ctx.font_extents().unwrap();
 +        let symbol_width = int_extents.x_advance();
 +        let symbol_ascent = int_font_extents.ascent();
 +        let symbol_descent = int_font_extents.descent();
++
 +        let lo_layout = lower.map(|lo| self.layout_at_depth(lo, ctx, depth + 1));
 +        let hi_layout = upper.map(|hi| self.layout_at_depth(hi, ctx, depth + 1));
++
 +        let bound_gap = font_size * 0.14;
 +        let bounds_width = symbol_width
 +            .max(lo_layout.as_ref().map(|l| l.width).unwrap_or(0.0))
 +            .max(hi_layout.as_ref().map(|l| l.width).unwrap_or(0.0));
 +        let body_gap = font_size * 0.22;
 +        let dx_gap = font_size * 0.14;
 -        let mut width = int_width;
 -        let mut ascent = int_height / 2.0;
 -        let mut descent = int_height / 2.0;
          let mut children = vec![];
+-
 -        // Lower bound
 -        if let Some(lo) = lower {
 -            let lo_layout = self.layout_at_depth(lo, ctx, depth + 1);
 -            children.push((0.0, int_height / 2.0 + lo_layout.ascent, lo_layout.clone()));
 -            descent = descent.max(int_height / 2.0 + lo_layout.height());
 -            width = width.max(lo_layout.width);
 -        }
+-
 -        // Upper bound
 -        if let Some(hi) = upper {
 -            let hi_layout = self.layout_at_depth(hi, ctx, depth + 1);
 -            children.push((0.0, -(int_height / 2.0 + hi_layout.descent), hi_layout.clone()));
 -            ascent = ascent.max(int_height / 2.0 + hi_layout.height());
 -            width = width.max(hi_layout.width);
 -        }
+-
 -        // Body
 -        let body_x = width + font_size * 0.2;
 +        let body_x = bounds_width + body_gap;
          children.push((body_x, 0.0, body_layout.clone()));
 -        width = body_x + body_layout.width;
 -        // "dx" part
 -        let d_layout = self.layout_text("d", ctx, font_size);
 -        children.push((width + font_size * 0.1, 0.0, d_layout.clone()));
 -        width += font_size * 0.1 + d_layout.width;
 -        children.push((width, 0.0, var_layout.clone()));
 -        width += var_layout.width;
 +        let d_x = body_x + body_layout.width + dx_gap;
 +        children.push((d_x, 0.0, d_layout.clone()));
 +        let var_x = d_x + d_layout.width;
 +        children.push((var_x, 0.0, var_layout.clone()));
++
 +        let ascent =
 +            symbol_ascent + bound_gap + hi_layout.as_ref().map(|l| l.height()).unwrap_or(0.0);
 +        let descent =
 +            symbol_descent + bound_gap + lo_layout.as_ref().map(|l| l.height()).unwrap_or(0.0);
          LayoutBox {
 -            width,
 -            ascent,
 -            descent,
 +            width: var_x + var_layout.width,
 +            ascent: ascent.max(body_layout.ascent),
 +            descent: descent.max(body_layout.descent),
              children,
+         }
+     }
      ) -> LayoutBox {
          let scale = self.scale_for_depth(depth);
          let font_size = self.base_font_size * scale;
 +        let frac_font_size = font_size * 0.8;
          let var_layout = self.layout_at_depth(var, ctx, depth + 1);
          let body_layout = self.layout_at_depth(body, ctx, depth);
              "d".to_string()
          };
 -        let d_layout = self.layout_text(&d_str, ctx, font_size);
 -        let dx_layout = self.layout_text(&dx_str, ctx, font_size);
+-
 -        let frac_width = d_layout.width.max(dx_layout.width + var_layout.width) + font_size * 0.2;
 -        let bar_gap = font_size * 0.1;
+-
 -        let width = frac_width + font_size * 0.2 + body_layout.width;
 -        let frac_height = d_layout.height() + dx_layout.height() + var_layout.height() + bar_gap * 2.0;
 +        let d_layout = self.layout_text(&d_str, ctx, frac_font_size);
 +        let dx_layout = self.layout_text(&dx_str, ctx, frac_font_size);
 +        let den_sep = (frac_font_size * 0.08).max(0.6);
 +        let denom_width = dx_layout.width + den_sep + var_layout.width;
 +        let denom_height = dx_layout.height().max(var_layout.height());
 +        let frac_width = d_layout.width.max(denom_width) + font_size * 0.18;
 +        let bar_gap = font_size * 0.14;
 +        let body_gap = font_size * 0.3;
          LayoutBox {
 -            width,
 -            ascent: frac_height / 2.0 + bar_gap,
 -            descent: frac_height / 2.0 + bar_gap,
 -            children: vec![
 -                (frac_width + font_size * 0.2, 0.0, body_layout),
 -            ],
 +            width: frac_width + body_gap + body_layout.width,
 +            ascent: (bar_gap + d_layout.height()).max(body_layout.ascent),
 +            descent: (bar_gap + denom_height).max(body_layout.descent),
 +            children: vec![(frac_width + body_gap, 0.0, body_layout)],
+         }
+     }
          // "lim" text
          let lim_layout = self.layout_text("lim", ctx, font_size);
 +        let lim_width = lim_layout.width;
          // Build subscript: "x→a" or "x→a⁺" or "x→a⁻"
 -        let arrow_layout = self.layout_text("→", ctx, font_size * 0.7);
 +        let sub_font_size = font_size * 0.7;
 +        let arrow_layout = self.layout_text("→", ctx, sub_font_size);
          let dir_str = match direction {
              Some(LimitDirection::FromRight) => "⁺",
              Some(LimitDirection::FromLeft) => "⁻",
              None => "",
          };
          let dir_layout = if !dir_str.is_empty() {
 -            Some(self.layout_text(dir_str, ctx, font_size * 0.5))
 +            Some(self.layout_text(dir_str, ctx, sub_font_size * 0.6))
          } else {
              None
          };
 -        let subscript_width = var_layout.width + arrow_layout.width + to_layout.width
 +        let sub_sep = (sub_font_size * 0.08).max(0.5);
 +        let subscript_width = var_layout.width
 +            + sub_sep
 +            + arrow_layout.width
 +            + sub_sep
 +            + to_layout.width
              + dir_layout.as_ref().map(|l| l.width).unwrap_or(0.0);
 -        let subscript_height = var_layout.height().max(arrow_layout.height()).max(to_layout.height());
 +        let subscript_height = var_layout
 +            .height()
 +            .max(arrow_layout.height())
 +            .max(to_layout.height());
 -        let lim_width = lim_layout.width.max(subscript_width);
 +        let lim_col_width = lim_width.max(subscript_width);
 +        let body_gap = font_size * 0.3;
 +        let subscript_drop = font_size * 0.2 + subscript_height;
          LayoutBox {
 -            width: lim_width + font_size * 0.3 + body_layout.width,
 +            width: lim_col_width + body_gap + body_layout.width,
              ascent: lim_layout.ascent.max(body_layout.ascent),
 -            descent: (lim_layout.descent + subscript_height + font_size * 0.1).max(body_layout.descent),
 -            children: vec![
 -                (lim_width + font_size * 0.3, 0.0, body_layout),
 -            ],
 +            descent: subscript_drop.max(body_layout.descent),
 +            children: vec![(lim_col_width + body_gap, 0.0, body_layout)],
+         }
+     }
      fn layout_bigop(
          &self,
          symbol: &str,
 -        _var: &MathBox,
 +        var: &MathBox,
          lower: &MathBox,
          upper: &MathBox,
          body: &MathBox,
          let font_size = self.base_font_size * scale;
          let body_layout = self.layout_at_depth(body, ctx, depth);
 +        let var_layout = self.layout_at_depth(var, ctx, depth + 1);
          let lower_layout = self.layout_at_depth(lower, ctx, depth + 1);
          let upper_layout = self.layout_at_depth(upper, ctx, depth + 1);
          ctx.set_font_size(symbol_size);
          let symbol_extents = ctx.text_extents(symbol).unwrap();
          let symbol_width = symbol_extents.x_advance();
 -        let symbol_height = symbol_size;
+-
 -        let op_width = symbol_width.max(lower_layout.width).max(upper_layout.width);
 -        let gap = font_size * 0.1;
+-
 -        let ascent = symbol_height / 2.0 + gap + upper_layout.height();
 -        let descent = symbol_height / 2.0 + gap + lower_layout.height();
 +        let symbol_font_extents = ctx.font_extents().unwrap();
 +        let symbol_ascent = symbol_font_extents.ascent();
 +        let symbol_descent = symbol_font_extents.descent();
++
 +        let bound_font_size = self.base_font_size * self.scale_for_depth(depth + 1);
 +        let eq_layout = self.layout_text("=", ctx, bound_font_size);
 +        let lower_sep = (bound_font_size * 0.08).max(0.6);
 +        let lower_block_width =
 +            var_layout.width + lower_sep + eq_layout.width + lower_sep + lower_layout.width;
++
 +        let op_width = symbol_width.max(lower_block_width).max(upper_layout.width);
 +        let bounds_gap = font_size * 0.16;
 +        let body_gap = font_size * 0.32;
 +        // Rendering centers big-op symbols around the expression baseline.
 +        // Reserve half of total glyph height above and below for consistent placement.
 +        let symbol_half_height = (symbol_ascent + symbol_descent) * 0.5;
++
 +        let ascent =
 +            (symbol_half_height + bounds_gap + upper_layout.height()).max(body_layout.ascent);
 +        let descent =
 +            (symbol_half_height + bounds_gap + lower_layout.height().max(var_layout.height()))
 +                .max(body_layout.descent);
          LayoutBox {
 -            width: op_width + font_size * 0.3 + body_layout.width,
 -            ascent: ascent.max(body_layout.ascent),
 -            descent: descent.max(body_layout.descent),
 -            children: vec![
 -                (op_width + font_size * 0.3, 0.0, body_layout),
 -            ],
 +            width: op_width + body_gap + body_layout.width,
 +            ascent,
 +            descent,
 +            children: vec![(op_width + body_gap, 0.0, body_layout)],
+         }
+     }
          let total_width: f64 = col_widths.iter().sum::<f64>()
              + cell_padding * (num_cols as f64 - 1.0)
              + 2.0 * bracket_width;
 -        let total_height: f64 = row_heights.iter().sum::<f64>()
 -            + cell_padding * (rows.len() as f64 - 1.0);
 +        let total_height: f64 =
 +            row_heights.iter().sum::<f64>() + cell_padding * (rows.len() as f64 - 1.0);
          // Position cells
          let mut children = vec![];
  #[cfg(test)]
  mod tests {
      use super::*;
 +    use cairo::{Context, Format, ImageSurface};
++
 +    fn test_context() -> Context {
 +        let surface = ImageSurface::create(Format::ARgb32, 256, 256).unwrap();
 +        Context::new(&surface).unwrap()
 +    }
      #[test]
      fn test_scale_for_depth() {
          assert_eq!(superscript_digits(2), "²");
          assert_eq!(superscript_digits(123), "¹²³");
+     }
++
 +    #[test]
 +    fn test_slot_min_size_at_nested_depth() {
 +        let engine = MathLayoutEngine::default();
 +        let ctx = test_context();
 +        let slot = engine.layout_with_depth(&MathBox::Slot, &ctx, 2);
 +        assert!(slot.width >= 10.0);
 +        assert!(slot.height() >= 11.0);
 +    }
++
 +    #[test]
 +    fn test_power_layout_raises_exponent() {
 +        let engine = MathLayoutEngine::default();
 +        let ctx = test_context();
 +        let power = MathBox::Power {
 +            base: Box::new(MathBox::Number("2".to_string())),
 +            exp: Box::new(MathBox::Slot),
 +        };
 +        let layout = engine.layout(&power, &ctx);
 +        let base_layout = engine.layout(&MathBox::Number("2".to_string()), &ctx);
++
 +        assert!(layout.width > base_layout.width);
 +        assert!(layout.ascent > base_layout.ascent);
 +        assert_eq!(layout.children.len(), 2);
 +        assert!(layout.children[1].1 < 0.0);
 +    }
++
 +    #[test]
 +    fn test_subscript_layout_lowers_and_extends_descent() {
 +        let engine = MathLayoutEngine::default();
 +        let ctx = test_context();
 +        let sub = MathBox::Subscript {
 +            base: Box::new(MathBox::Number("x".to_string())),
 +            sub: Box::new(MathBox::Slot),
 +        };
 +        let layout = engine.layout(&sub, &ctx);
 +        let base_layout = engine.layout(&MathBox::Number("x".to_string()), &ctx);
++
 +        assert!(layout.descent > base_layout.descent);
 +        assert_eq!(layout.children.len(), 2);
 +        assert!(layout.children[1].1 > 0.0);
 +    }
++
 +    #[test]
 +    fn test_bigop_layout_reserves_space_for_var_equals_lower() {
 +        let engine = MathLayoutEngine::default();
 +        let ctx = test_context();
++
 +        let short = MathBox::Sum {
 +            var: Box::new(MathBox::Symbol("i".to_string())),
 +            lower: Box::new(MathBox::Number("1".to_string())),
 +            upper: Box::new(MathBox::Number("5".to_string())),
 +            body: Box::new(MathBox::Slot),
 +        };
 +        let wide = MathBox::Sum {
 +            var: Box::new(MathBox::Symbol("index".to_string())),
 +            lower: Box::new(MathBox::Number("123456".to_string())),
 +            upper: Box::new(MathBox::Number("5".to_string())),
 +            body: Box::new(MathBox::Slot),
 +        };
++
 +        let short_layout = engine.layout(&short, &ctx);
 +        let wide_layout = engine.layout(&wide, &ctx);
 +        assert!(wide_layout.width > short_layout.width);
 +    }
++
 +    #[test]
 +    fn test_bigop_layout_expands_ascent_descent_for_bounds() {
 +        let engine = MathLayoutEngine::default();
 +        let ctx = test_context();
++
 +        let sum = MathBox::Sum {
 +            var: Box::new(MathBox::Symbol("i".to_string())),
 +            lower: Box::new(MathBox::Slot),
 +            upper: Box::new(MathBox::Slot),
 +            body: Box::new(MathBox::Number("x".to_string())),
 +        };
 +        let body_layout = engine.layout(&MathBox::Number("x".to_string()), &ctx);
 +        let sum_layout = engine.layout(&sum, &ctx);
++
 +        assert!(sum_layout.ascent > body_layout.ascent);
 +        assert!(sum_layout.descent > body_layout.descent);
 +    }
++
 +    #[test]
 +    fn test_derivative_layout_widens_for_long_variable() {
 +        let engine = MathLayoutEngine::default();
 +        let ctx = test_context();
++
 +        let short = MathBox::Derivative {
 +            order: 1,
 +            var: Box::new(MathBox::Symbol("x".to_string())),
 +            body: Box::new(MathBox::Slot),
 +        };
 +        let long = MathBox::Derivative {
 +            order: 1,
 +            var: Box::new(MathBox::Symbol("variable".to_string())),
 +            body: Box::new(MathBox::Slot),
 +        };
++
 +        let short_layout = engine.layout(&short, &ctx);
 +        let long_layout = engine.layout(&long, &ctx);
 +        assert!(long_layout.width > short_layout.width);
 +    }
++
 +    #[test]
 +    fn test_integral_layout_bounds_expand_vertical_space() {
 +        let engine = MathLayoutEngine::default();
 +        let ctx = test_context();
++
 +        let plain = MathBox::Integral {
 +            lower: None,
 +            upper: None,
 +            body: Box::new(MathBox::Slot),
 +            var: Box::new(MathBox::Symbol("x".to_string())),
 +        };
 +        let bounded = MathBox::Integral {
 +            lower: Some(Box::new(MathBox::Slot)),
 +            upper: Some(Box::new(MathBox::Slot)),
 +            body: Box::new(MathBox::Slot),
 +            var: Box::new(MathBox::Symbol("x".to_string())),
 +        };
++
 +        let plain_layout = engine.layout(&plain, &ctx);
 +        let bounded_layout = engine.layout(&bounded, &ctx);
 +        assert!(bounded_layout.ascent > plain_layout.ascent);
 +        assert!(bounded_layout.descent > plain_layout.descent);
 +    }
++
 +    #[test]
 +    fn test_limit_layout_widens_for_wide_subscript_and_extends_descent() {
 +        let engine = MathLayoutEngine::default();
 +        let ctx = test_context();
++
 +        let narrow = MathBox::Limit {
 +            var: Box::new(MathBox::Symbol("x".to_string())),
 +            to: Box::new(MathBox::Number("1".to_string())),
 +            direction: None,
 +            body: Box::new(MathBox::Slot),
 +        };
 +        let wide = MathBox::Limit {
 +            var: Box::new(MathBox::Symbol("veryLongVariable".to_string())),
 +            to: Box::new(MathBox::Number("123456".to_string())),
 +            direction: Some(LimitDirection::FromRight),
 +            body: Box::new(MathBox::Slot),
 +        };
++
 +        let narrow_layout = engine.layout(&narrow, &ctx);
 +        let wide_layout = engine.layout(&wide, &ctx);
 +        let body_layout = engine.layout(&MathBox::Slot, &ctx);
++
 +        assert!(wide_layout.width > narrow_layout.width);
 +        assert!(wide_layout.descent > body_layout.descent);
 +    }
+ }

garcalc-math/src/lib.rsmodified

  //! - Keyboard navigation through expression tree
  //! - Bidirectional conversion with CAS Expr type
 -pub mod mathbox;
 +pub mod convert;
 +pub mod input;
  pub mod layout;
 +pub mod mathbox;
  pub mod render;
 -pub mod input;
 -pub mod convert;
 -pub use mathbox::{MathBox, Cursor};
 +pub use convert::{ConvertError, from_expr, to_expr};
 +pub use input::{InputResult, MathInput};
  pub use layout::{LayoutBox, MathLayoutEngine};
 +pub use mathbox::{Cursor, MathBox};
  pub use render::MathRenderer;
 -pub use input::{MathInput, InputResult};
 -pub use convert::{to_expr, from_expr, ConvertError};

garcalc-math/src/mathbox.rsmodified

      },
      /// Function call with arguments
 -    Func {
 -        name: String,
 -        args: Vec<MathBox>,
 -    },
 +    Func { name: String, args: Vec<MathBox> },
      /// Absolute value
      Abs(Box<MathBox>),
      },
      /// Matrix with rows of cells
 -    Matrix {
 -        rows: Vec<Vec<MathBox>>,
 -    },
 +    Matrix { rows: Vec<Vec<MathBox>> },
      /// Horizontal sequence of elements (e.g., 2 + 3 × x)
      Row(Vec<MathBox>),
  /// Mathematical operators
  #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
  pub enum Operator {
 -    Add,      // +
 -    Sub,      // -
 -    Mul,      // × or *
 -    Div,      // ÷ (for inline division, not fraction)
 -    Eq,       // =
 -    Lt,       // <
 -    Gt,       // >
 -    Le,       // ≤
 -    Ge,       // ≥
 -    Ne,       // ≠
 -    Comma,    // ,
 +    Add,   // +
 +    Sub,   // -
 +    Mul,   // × or *
 +    Div,   // ÷ (for inline division, not fraction)
 +    Eq,    // =
 +    Lt,    // <
 +    Gt,    // >
 +    Le,    // ≤
 +    Ge,    // ≥
 +    Ne,    // ≠
 +    Comma, // ,
+ }
  impl Operator {
 => Some(sub),
                  _ => None,
              },
 -            MathBox::Root { index: idx, radicand } => {
 +            MathBox::Root {
 +                index: idx,
 +                radicand,
 +            } => {
                  if let Some(i) = idx {
                      match index {
 => Some(i),
                          _ => None,
+                     }
+                 }
 -            },
 +            }
              MathBox::Func { args, .. } => args.get_mut(index),
              MathBox::Abs(inner) | MathBox::Parens(inner) => match index {
 => Some(inner),
                  _ => None,
              },
 -            MathBox::Integral { lower, upper, body, var } => {
 +            MathBox::Integral {
 +                lower,
 +                upper,
 +                body,
 +                var,
 +            } => {
                  let mut i = 0;
                  if let Some(l) = lower {
 -                    if index == i { return Some(l); }
 +                    if index == i {
 +                        return Some(l);
 +                    }
                      i += 1;
+                 }
                  if let Some(u) = upper {
 -                    if index == i { return Some(u); }
 +                    if index == i {
 +                        return Some(u);
 +                    }
                      i += 1;
+                 }
 -                if index == i { return Some(body); }
 -                if index == i + 1 { return Some(var); }
 +                if index == i {
 +                    return Some(body);
 +                }
 +                if index == i + 1 {
 +                    return Some(var);
 +                }
                  None
 -            },
 +            }
              MathBox::Derivative { var, body, .. } => match index {
 => Some(var),
 => Some(body),
 => Some(body),
                  _ => None,
              },
 -            MathBox::Sum { var, lower, upper, body }
 -            | MathBox::Product { var, lower, upper, body } => match index {
 +            MathBox::Sum {
 +                var,
 +                lower,
 +                upper,
 +                body,
 +            }
 +            | MathBox::Product {
 +                var,
 +                lower,
 +                upper,
 +                body,
 +            } => match index {
 => Some(var),
 => Some(lower),
 => Some(upper),
+                     }
+                 }
                  None
 -            },
 +            }
              MathBox::Row(items) => items.get_mut(index),
              _ => None,
+         }
 => Some(sub),
                  _ => None,
              },
 -            MathBox::Root { index: idx, radicand } => {
 +            MathBox::Root {
 +                index: idx,
 +                radicand,
 +            } => {
                  if let Some(i) = idx {
                      match index {
 => Some(i),
                          _ => None,
+                     }
+                 }
 -            },
 +            }
              MathBox::Func { args, .. } => args.get(index),
              MathBox::Abs(inner) | MathBox::Parens(inner) => match index {
 => Some(inner),
                  _ => None,
              },
 -            MathBox::Integral { lower, upper, body, var } => {
 +            MathBox::Integral {
 +                lower,
 +                upper,
 +                body,
 +                var,
 +            } => {
                  let mut i = 0;
                  if let Some(l) = lower {
 -                    if index == i { return Some(l); }
 +                    if index == i {
 +                        return Some(l);
 +                    }
                      i += 1;
+                 }
                  if let Some(u) = upper {
 -                    if index == i { return Some(u); }
 +                    if index == i {
 +                        return Some(u);
 +                    }
                      i += 1;
+                 }
 -                if index == i { return Some(body); }
 -                if index == i + 1 { return Some(var); }
 +                if index == i {
 +                    return Some(body);
 +                }
 +                if index == i + 1 {
 +                    return Some(var);
 +                }
                  None
 -            },
 +            }
              MathBox::Derivative { var, body, .. } => match index {
 => Some(var),
 => Some(body),
 => Some(body),
                  _ => None,
              },
 -            MathBox::Sum { var, lower, upper, body }
 -            | MathBox::Product { var, lower, upper, body } => match index {
 +            MathBox::Sum {
 +                var,
 +                lower,
 +                upper,
 +                body,
 +            }
 +            | MathBox::Product {
 +                var,
 +                lower,
 +                upper,
 +                body,
 +            } => match index {
 => Some(var),
 => Some(lower),
 => Some(upper),
+                     }
+                 }
                  None
 -            },
 +            }
              MathBox::Row(items) => items.get(index),
              _ => None,
+         }

garcalc-math/src/render.rsmodified

1305 lines changed — click to load

  //! fraction bars, radical signs, integral symbols, etc.
  use crate::layout::{LayoutBox, MathLayoutEngine};
 -use crate::mathbox::{MathBox, Operator, LimitDirection};
 +use crate::mathbox::{LimitDirection, MathBox, Operator};
  use cairo::Context;
  use gartk_core::Color;
 +use std::cell::Cell;
  /// Renderer for mathematical notation
  pub struct MathRenderer<'a> {
      pub slot_bg_color: Color,
      /// Slot border color when focused
      pub slot_focus_color: Color,
 +    /// Whether the insertion cursor should be drawn
 +    cursor_visible: Cell<bool>,
+ }
  impl<'a> MathRenderer<'a> {
              fg_color: Color::new(0.0, 0.0, 0.0, 1.0),
              slot_bg_color: Color::new(0.9, 0.9, 0.95, 1.0),
              slot_focus_color: Color::new(0.3, 0.5, 0.9, 1.0),
 +            cursor_visible: Cell::new(true),
+         }
+     }
      /// Render a MathBox tree at the given position
      /// (x, y) is the baseline position
      pub fn render(&self, mathbox: &MathBox, x: f64, y: f64) {
 -        self.render_at_depth(mathbox, x, y, 0, None);
 +        self.render_at_depth(mathbox, x, y, 0, None, 0);
+     }
      /// Render with cursor highlighting
 -    pub fn render_with_cursor(&self, mathbox: &MathBox, x: f64, y: f64, cursor_path: &[usize]) {
 -        self.render_at_depth(mathbox, x, y, 0, Some(cursor_path));
 +    pub fn render_with_cursor(
 +        &self,
 +        mathbox: &MathBox,
 +        x: f64,
 +        y: f64,
 +        cursor_path: &[usize],
 +        cursor_offset: usize,
 +        cursor_visible: bool,
 +    ) {
 +        self.cursor_visible.set(cursor_visible);
 +        self.render_at_depth(mathbox, x, y, 0, Some(cursor_path), cursor_offset);
 +        self.cursor_visible.set(true);
+     }
      /// Internal render with depth tracking
          y: f64,
          depth: u32,
          cursor_path: Option<&[usize]>,
 +        cursor_offset: usize,
      ) {
          let scale = self.scale_for_depth(depth);
          let font_size = self.layout_engine.base_font_size * scale;
          // Check if cursor is at this node
          let is_cursor_here = cursor_path.map(|p| p.is_empty()).unwrap_or(false);
 +        let is_active_container = cursor_path.map(|p| p.len() == 1).unwrap_or(false)
 +            && Self::is_focusable_container(mathbox);
          match mathbox {
              MathBox::Number(s) => {
                  self.draw_text(s, x, y, font_size, false);
                  if is_cursor_here {
 -                    self.draw_cursor(x, y, font_size);
 +                    let width = self.text_advance(s, font_size, false);
 +                    self.draw_focus_frame(x, y, width, font_size, 1.4, 0.35);
 +                }
 +                if is_cursor_here && self.cursor_visible.get() {
 +                    let cursor_x =
 +                        x + self.text_advance_for_offset(s, font_size, false, cursor_offset);
 +                    self.draw_cursor(cursor_x, y, font_size);
+                 }
+             }
              MathBox::Symbol(s) => {
                  self.draw_text(s, x, y, font_size, true);
                  if is_cursor_here {
 -                    self.draw_cursor(x, y, font_size);
 +                    let width = self.text_advance(s, font_size, true);
 +                    self.draw_focus_frame(x, y, width, font_size, 1.4, 0.35);
 +                }
 +                if is_cursor_here && self.cursor_visible.get() {
 +                    let cursor_x =
 +                        x + self.text_advance_for_offset(s, font_size, true, cursor_offset);
 +                    self.draw_cursor(cursor_x, y, font_size);
+                 }
+             }
              MathBox::Operator(op) => {
                  self.draw_slot(x, y, font_size, is_cursor_here);
+             }
              MathBox::Fraction { num, den } => {
 -                self.render_fraction(num, den, x, y, depth, cursor_path);
 +                self.render_fraction(num, den, x, y, depth, cursor_path, cursor_offset);
+             }
              MathBox::Power { base, exp } => {
 -                self.render_power(base, exp, x, y, depth, cursor_path);
 +                self.render_power(base, exp, x, y, depth, cursor_path, cursor_offset);
+             }
              MathBox::Subscript { base, sub } => {
 -                self.render_subscript(base, sub, x, y, depth, cursor_path);
 +                self.render_subscript(base, sub, x, y, depth, cursor_path, cursor_offset);
+             }
              MathBox::Root { index, radicand } => {
 -                self.render_root(index.as_deref(), radicand, x, y, depth, cursor_path);
 +                self.render_root(
 +                    index.as_deref(),
 +                    radicand,
 +                    x,
 +                    y,
 +                    depth,
 +                    cursor_path,
 +                    cursor_offset,
 +                );
+             }
              MathBox::Func { name, args } => {
 -                self.render_func(name, args, x, y, depth, cursor_path);
 +                self.render_func(name, args, x, y, depth, cursor_path, cursor_offset);
+             }
              MathBox::Abs(inner) => {
 -                self.render_abs(inner, x, y, depth, cursor_path);
 +                self.render_abs(inner, x, y, depth, cursor_path, cursor_offset);
+             }
              MathBox::Parens(inner) => {
 -                self.render_parens(inner, x, y, depth, cursor_path);
 +                self.render_parens(inner, x, y, depth, cursor_path, cursor_offset);
+             }
 -            MathBox::Integral { lower, upper, body, var } => {
 +            MathBox::Integral {
 +                lower,
 +                upper,
 +                body,
 +                var,
 +            } => {
                  self.render_integral(
                      lower.as_deref(),
                      upper.as_deref(),
                      y,
                      depth,
                      cursor_path,
 +                    cursor_offset,
                  );
+             }
              MathBox::Derivative { order, var, body } => {
 -                self.render_derivative(*order, var, body, x, y, depth, cursor_path);
 +                self.render_derivative(*order, var, body, x, y, depth, cursor_path, cursor_offset);
+             }
 -            MathBox::Limit { var, to, direction, body } => {
 -                self.render_limit(var, to, *direction, body, x, y, depth, cursor_path);
 +            MathBox::Limit {
 +                var,
 +                to,
 +                direction,
 +                body,
 +            } => {
 +                self.render_limit(
 +                    var,
 +                    to,
 +                    *direction,
 +                    body,
 +                    x,
 +                    y,
 +                    depth,
 +                    cursor_path,
 +                    cursor_offset,
 +                );
+             }
 -            MathBox::Sum { var, lower, upper, body } => {
 -                self.render_bigop("∑", var, lower, upper, body, x, y, depth, cursor_path);
 +            MathBox::Sum {
 +                var,
 +                lower,
 +                upper,
 +                body,
 +            } => {
 +                self.render_bigop(
 +                    "∑",
 +                    var,
 +                    lower,
 +                    upper,
 +                    body,
 +                    x,
 +                    y,
 +                    depth,
 +                    cursor_path,
 +                    cursor_offset,
 +                );
+             }
 -            MathBox::Product { var, lower, upper, body } => {
 -                self.render_bigop("∏", var, lower, upper, body, x, y, depth, cursor_path);
 +            MathBox::Product {
 +                var,
 +                lower,
 +                upper,
 +                body,
 +            } => {
 +                self.render_bigop(
 +                    "∏",
 +                    var,
 +                    lower,
 +                    upper,
 +                    body,
 +                    x,
 +                    y,
 +                    depth,
 +                    cursor_path,
 +                    cursor_offset,
 +                );
+             }
              MathBox::Matrix { rows } => {
 -                self.render_matrix(rows, x, y, depth, cursor_path);
 +                self.render_matrix(rows, x, y, depth, cursor_path, cursor_offset);
+             }
              MathBox::Row(items) => {
 -                self.render_row(items, x, y, depth, cursor_path);
 +                self.render_row(items, x, y, depth, cursor_path, cursor_offset);
+             }
+         }
++
 +        if is_active_container {
 +            self.draw_container_focus_frame(mathbox, x, y, depth);
 +        }
+     }
      fn scale_for_depth(&self, depth: u32) -> f64 {
          self.ctx.restore().unwrap();
+     }
 +    /// Measure text advance using the same style as `draw_text`
 +    fn text_advance(&self, text: &str, font_size: f64, italic: bool) -> f64 {
 +        self.ctx.save().unwrap();
 +        let slant = if italic {
 +            cairo::FontSlant::Italic
 +        } else {
 +            cairo::FontSlant::Normal
 +        };
 +        self.ctx.select_font_face(
 +            &self.layout_engine.font_family,
 +            slant,
 +            cairo::FontWeight::Normal,
 +        );
 +        self.ctx.set_font_size(font_size);
 +        let advance = self
 +            .ctx
 +            .text_extents(text)
 +            .map(|e| e.x_advance())
 +            .unwrap_or(0.0);
 +        self.ctx.restore().unwrap();
 +        advance
 +    }
++
 +    fn text_advance_for_offset(
 +        &self,
 +        text: &str,
 +        font_size: f64,
 +        italic: bool,
 +        char_offset: usize,
 +    ) -> f64 {
 +        let prefix: String = text
 +            .chars()
 +            .take(char_offset.min(text.chars().count()))
 +            .collect();
 +        self.text_advance(&prefix, font_size, italic)
 +    }
++
      /// Draw an operator
      fn draw_operator(&self, op: Operator, x: f64, y: f64, font_size: f64) {
          let padding = font_size * 0.15;
      /// Draw an empty slot
      fn draw_slot(&self, x: f64, y: f64, font_size: f64, focused: bool) {
 -        let width = font_size * 0.8;
 -        let height = font_size * 0.8;
 -        let ascent = height * 0.6;
 +        let (width, height, ascent) = Self::slot_geometry(font_size);
          self.ctx.save().unwrap();
          self.set_color(&self.slot_focus_color);
          self.ctx.set_line_width(2.0);
 -        let height = font_size * 0.8;
 +        let (_, height, _) = Self::slot_geometry(font_size);
          self.ctx.move_to(x, y - height * 0.6);
          self.ctx.line_to(x, y + height * 0.4);
          self.ctx.stroke().unwrap();
          self.ctx.restore().unwrap();
+     }
 +    /// Draw a focus frame around the active token
 +    fn draw_focus_frame(
 +        &self,
 +        x: f64,
 +        y: f64,
 +        width: f64,
 +        font_size: f64,
 +        line_width: f64,
 +        alpha: f64,
 +    ) {
 +        let ascent = font_size * 0.72;
 +        let descent = font_size * 0.28;
 +        let padding = (font_size * 0.12).max(1.2);
 +        self.draw_focus_bounds(x, y, width, ascent, descent, padding, line_width, alpha);
 +    }
++
 +    /// Draw a focus frame around the active container (e.g. power/fraction)
 +    fn draw_container_focus_frame(&self, mathbox: &MathBox, x: f64, y: f64, depth: u32) {
 +        let layout = self
 +            .layout_engine
 +            .layout_with_depth(mathbox, self.ctx, depth);
 +        let scale = self.scale_for_depth(depth);
 +        let padding = (self.layout_engine.base_font_size * scale * 0.12).max(1.4);
 +        self.draw_focus_bounds(
 +            x,
 +            y,
 +            layout.width,
 +            layout.ascent,
 +            layout.descent,
 +            padding,
 +            1.5,
 +            0.28,
 +        );
 +    }
++
 +    fn draw_focus_bounds(
 +        &self,
 +        x: f64,
 +        y: f64,
 +        width: f64,
 +        ascent: f64,
 +        descent: f64,
 +        padding: f64,
 +        line_width: f64,
 +        alpha: f64,
 +    ) {
 +        self.ctx.save().unwrap();
 +        self.set_color(&Color::new(
 +            self.slot_focus_color.r,
 +            self.slot_focus_color.g,
 +            self.slot_focus_color.b,
 +            alpha,
 +        ));
 +        self.ctx.set_line_width(line_width);
 +        self.ctx.rectangle(
 +            x - padding,
 +            y - ascent - padding,
 +            width + padding * 2.0,
 +            ascent + descent + padding * 2.0,
 +        );
 +        self.ctx.stroke().unwrap();
 +        self.ctx.restore().unwrap();
 +    }
++
 +    fn is_focusable_container(mathbox: &MathBox) -> bool {
 +        matches!(
 +            mathbox,
 +            MathBox::Fraction { .. }
 +                | MathBox::Power { .. }
 +                | MathBox::Subscript { .. }
 +                | MathBox::Root { .. }
 +                | MathBox::Func { .. }
 +                | MathBox::Abs(_)
 +                | MathBox::Parens(_)
 +                | MathBox::Integral { .. }
 +                | MathBox::Derivative { .. }
 +                | MathBox::Limit { .. }
 +                | MathBox::Sum { .. }
 +                | MathBox::Product { .. }
 +                | MathBox::Matrix { .. }
 +        )
 +    }
++
      /// Render a fraction
      fn render_fraction(
          &self,
          y: f64,
          depth: u32,
          cursor_path: Option<&[usize]>,
 +        cursor_offset: usize,
      ) {
 -        let layout = self.layout_engine.layout(&MathBox::Fraction {
 -            num: Box::new(num.clone()),
 -            den: Box::new(den.clone()),
 -        }, self.ctx);
 +        let layout = self.layout_engine.layout(
 +            &MathBox::Fraction {
 +                num: Box::new(num.clone()),
 +                den: Box::new(den.clone()),
 +            },
 +            self.ctx,
 +        );
          let scale = self.scale_for_depth(depth);
          let bar_thickness = 1.0 * scale;
          // Draw numerator and denominator
          let num_cursor = cursor_path.and_then(|p| {
 -            if !p.is_empty() && p[0] == 0 { Some(&p[1..]) } else { None }
 +            if !p.is_empty() && p[0] == 0 {
 +                Some(&p[1..])
 +            } else {
 +                None
 +            }
          });
          let den_cursor = cursor_path.and_then(|p| {
 -            if !p.is_empty() && p[0] == 1 { Some(&p[1..]) } else { None }
 +            if !p.is_empty() && p[0] == 1 {
 +                Some(&p[1..])
 +            } else {
 +                None
 +            }
          });
 -        self.render_at_depth(num, num_x, num_y, depth + 1, num_cursor);
 -        self.render_at_depth(den, den_x, den_y, depth + 1, den_cursor);
 +        self.render_at_depth(num, num_x, num_y, depth + 1, num_cursor, cursor_offset);
 +        self.render_at_depth(den, den_x, den_y, depth + 1, den_cursor, cursor_offset);
+     }
      /// Render a power (superscript)
          y: f64,
          depth: u32,
          cursor_path: Option<&[usize]>,
 +        cursor_offset: usize,
      ) {
 -        let base_layout = self.layout_engine.layout(base, self.ctx);
 +        let base_layout = self.layout_engine.layout_with_depth(base, self.ctx, depth);
 +        let exp_layout = self
 +            .layout_engine
 +            .layout_with_depth(exp, self.ctx, depth + 1);
 +        let scale = self.scale_for_depth(depth);
 +        let font_size = self.layout_engine.base_font_size * scale;
          let base_cursor = cursor_path.and_then(|p| {
 -            if !p.is_empty() && p[0] == 0 { Some(&p[1..]) } else { None }
 +            if !p.is_empty() && p[0] == 0 {
 +                Some(&p[1..])
 +            } else {
 +                None
 +            }
          });
          let exp_cursor = cursor_path.and_then(|p| {
 -            if !p.is_empty() && p[0] == 1 { Some(&p[1..]) } else { None }
 +            if !p.is_empty() && p[0] == 1 {
 +                Some(&p[1..])
 +            } else {
 +                None
 +            }
          });
 -        self.render_at_depth(base, x, y, depth, base_cursor);
+-
 -        let exp_raise = base_layout.ascent * 0.5;
 -        self.render_at_depth(exp, x + base_layout.width, y - exp_raise, depth + 1, exp_cursor);
 +        self.render_at_depth(base, x, y, depth, base_cursor, cursor_offset);
++
 +        let exp_raise = base_layout.ascent * 0.58 + exp_layout.descent * 0.1;
 +        let exp_kern = (font_size * 0.06).max(0.8);
 +        self.render_at_depth(
 +            exp,
 +            x + base_layout.width + exp_kern,
 +            y - exp_raise,
 +            depth + 1,
 +            exp_cursor,
 +            cursor_offset,
 +        );
+     }
      /// Render a subscript
          y: f64,
          depth: u32,
          cursor_path: Option<&[usize]>,
 +        cursor_offset: usize,
      ) {
 -        let base_layout = self.layout_engine.layout(base, self.ctx);
 -        let sub_layout = self.layout_engine.layout(sub, self.ctx);
 +        let base_layout = self.layout_engine.layout_with_depth(base, self.ctx, depth);
 +        let sub_layout = self
 +            .layout_engine
 +            .layout_with_depth(sub, self.ctx, depth + 1);
 +        let scale = self.scale_for_depth(depth);
 +        let font_size = self.layout_engine.base_font_size * scale;
          let base_cursor = cursor_path.and_then(|p| {
 -            if !p.is_empty() && p[0] == 0 { Some(&p[1..]) } else { None }
 +            if !p.is_empty() && p[0] == 0 {
 +                Some(&p[1..])
 +            } else {
 +                None
 +            }
          });
          let sub_cursor = cursor_path.and_then(|p| {
 -            if !p.is_empty() && p[0] == 1 { Some(&p[1..]) } else { None }
 +            if !p.is_empty() && p[0] == 1 {
 +                Some(&p[1..])
 +            } else {
 +                None
 +            }
          });
 -        self.render_at_depth(base, x, y, depth, base_cursor);
+-
 -        let sub_lower = base_layout.descent + sub_layout.ascent * 0.3;
 -        self.render_at_depth(sub, x + base_layout.width, y + sub_lower, depth + 1, sub_cursor);
 +        self.render_at_depth(base, x, y, depth, base_cursor, cursor_offset);
++
 +        let sub_lower =
 +            (base_layout.descent * 0.6 + sub_layout.ascent * 0.9).max(sub_layout.ascent * 0.75);
 +        let sub_kern = (font_size * 0.05).max(0.6);
 +        self.render_at_depth(
 +            sub,
 +            x + base_layout.width + sub_kern,
 +            y + sub_lower,
 +            depth + 1,
 +            sub_cursor,
 +            cursor_offset,
 +        );
+     }
      /// Render a root (square or nth)
          y: f64,
          depth: u32,
          cursor_path: Option<&[usize]>,
 +        cursor_offset: usize,
      ) {
          let radicand_layout = self.layout_engine.layout(radicand, self.ctx);
          let scale = self.scale_for_depth(depth);
          if let Some(idx) = index {
              let idx_layout = self.layout_engine.layout(idx, self.ctx);
              let idx_cursor = cursor_path.and_then(|p| {
 -                if !p.is_empty() && p[0] == 0 { Some(&p[1..]) } else { None }
 +                if !p.is_empty() && p[0] == 0 {
 +                    Some(&p[1..])
 +                } else {
 +                    None
 +                }
              });
              self.render_at_depth(
                  idx,
                  y - radicand_layout.ascent * 0.5 - idx_layout.descent,
                  depth + 2,
                  idx_cursor,
 +                cursor_offset,
              );
              radicand_x += idx_layout.width;
+         }
          // Radical checkmark
          let check_width = radical_width * 0.4;
          self.ctx.move_to(radicand_x - radical_width, y);
 -        self.ctx.line_to(radicand_x - radical_width + check_width * 0.3, y + radicand_layout.descent * 0.3);
 -        self.ctx.line_to(radicand_x - radical_width + check_width, y + radicand_layout.descent);
 -        self.ctx.line_to(radicand_x, y - radicand_layout.ascent - gap);
 +        self.ctx.line_to(
 +            radicand_x - radical_width + check_width * 0.3,
 +            y + radicand_layout.descent * 0.3,
 +        );
 +        self.ctx.line_to(
 +            radicand_x - radical_width + check_width,
 +            y + radicand_layout.descent,
 +        );
 +        self.ctx
 +            .line_to(radicand_x, y - radicand_layout.ascent - gap);
          // Overbar
 -        self.ctx.line_to(radicand_x + radicand_layout.width + bar_overhang, y - radicand_layout.ascent - gap);
 +        self.ctx.line_to(
 +            radicand_x + radicand_layout.width + bar_overhang,
 +            y - radicand_layout.ascent - gap,
 +        );
          self.ctx.stroke().unwrap();
          self.ctx.restore().unwrap();
          // Draw radicand
          let rad_cursor = cursor_path.and_then(|p| {
              let idx = if index.is_some() { 1 } else { 0 };
 -            if !p.is_empty() && p[0] == idx { Some(&p[1..]) } else { None }
 +            if !p.is_empty() && p[0] == idx {
 +                Some(&p[1..])
 +            } else {
 +                None
 +            }
          });
 -        self.render_at_depth(radicand, radicand_x, y, depth, rad_cursor);
 +        self.render_at_depth(radicand, radicand_x, y, depth, rad_cursor, cursor_offset);
+     }
      /// Render a function call
          y: f64,
          depth: u32,
          cursor_path: Option<&[usize]>,
 +        cursor_offset: usize,
      ) {
 +        if name == "factorial" && args.len() == 1 {
 +            self.render_factorial(&args[0], x, y, depth, cursor_path, cursor_offset);
 +            return;
 +        }
++
          let scale = self.scale_for_depth(depth);
          let font_size = self.layout_engine.base_font_size * scale;
          let paren_width = font_size * 0.3;
+             }
              let arg_cursor = cursor_path.and_then(|p| {
 -                if !p.is_empty() && p[0] == i { Some(&p[1..]) } else { None }
 +                if !p.is_empty() && p[0] == i {
 +                    Some(&p[1..])
 +                } else {
 +                    None
 +                }
              });
 -            self.render_at_depth(arg, current_x, y, depth, arg_cursor);
 +            self.render_at_depth(arg, current_x, y, depth, arg_cursor, cursor_offset);
              let arg_layout = self.layout_engine.layout(arg, self.ctx);
              current_x += arg_layout.width;
          self.draw_text(")", current_x, y, font_size, false);
+     }
 +    fn render_factorial(
 +        &self,
 +        arg: &MathBox,
 +        x: f64,
 +        y: f64,
 +        depth: u32,
 +        cursor_path: Option<&[usize]>,
 +        cursor_offset: usize,
 +    ) {
 +        let scale = self.scale_for_depth(depth);
 +        let font_size = self.layout_engine.base_font_size * scale;
 +        let gap = (font_size * 0.06).max(0.6);
++
 +        let arg_cursor = cursor_path.and_then(|p| {
 +            if !p.is_empty() && p[0] == 0 {
 +                Some(&p[1..])
 +            } else {
 +                None
 +            }
 +        });
 +        self.render_at_depth(arg, x, y, depth, arg_cursor, cursor_offset);
++
 +        let arg_layout = self.layout_engine.layout_with_depth(arg, self.ctx, depth);
 +        self.draw_text("!", x + arg_layout.width + gap, y, font_size, false);
 +    }
++
      /// Render absolute value
      fn render_abs(
          &self,
          y: f64,
          depth: u32,
          cursor_path: Option<&[usize]>,
 +        cursor_offset: usize,
      ) {
          let inner_layout = self.layout_engine.layout(inner, self.ctx);
          let scale = self.scale_for_depth(depth);
          self.ctx.set_line_width(1.5 * scale);
          // Left bar
 -        self.ctx.move_to(x + bar_width / 2.0, y - inner_layout.ascent);
 -        self.ctx.line_to(x + bar_width / 2.0, y + inner_layout.descent);
 +        self.ctx
 +            .move_to(x + bar_width / 2.0, y - inner_layout.ascent);
 +        self.ctx
 +            .line_to(x + bar_width / 2.0, y + inner_layout.descent);
          self.ctx.stroke().unwrap();
          // Right bar
          // Draw inner expression
          let inner_cursor = cursor_path.and_then(|p| {
 -            if !p.is_empty() && p[0] == 0 { Some(&p[1..]) } else { None }
 +            if !p.is_empty() && p[0] == 0 {
 +                Some(&p[1..])
 +            } else {
 +                None
 +            }
          });
 -        self.render_at_depth(inner, x + bar_width, y, depth, inner_cursor);
 +        self.render_at_depth(inner, x + bar_width, y, depth, inner_cursor, cursor_offset);
+     }
      /// Render parenthesized expression
          y: f64,
          depth: u32,
          cursor_path: Option<&[usize]>,
 +        cursor_offset: usize,
      ) {
          let inner_layout = self.layout_engine.layout(inner, self.ctx);
          let scale = self.scale_for_depth(depth);
          // For now, draw text parentheses (could be replaced with curved paths)
          self.draw_text("(", x, y, font_size * 1.2, false);
 -        self.draw_text(")", x + paren_width + inner_layout.width, y, font_size * 1.2, false);
 +        self.draw_text(
 +            ")",
 +            x + paren_width + inner_layout.width,
 +            y,
 +            font_size * 1.2,
 +            false,
 +        );
          let inner_cursor = cursor_path.and_then(|p| {
 -            if !p.is_empty() && p[0] == 0 { Some(&p[1..]) } else { None }
 +            if !p.is_empty() && p[0] == 0 {
 +                Some(&p[1..])
 +            } else {
 +                None
 +            }
          });
 -        self.render_at_depth(inner, x + paren_width, y, depth, inner_cursor);
 +        self.render_at_depth(
 +            inner,
 +            x + paren_width,
 +            y,
 +            depth,
 +            inner_cursor,
 +            cursor_offset,
 +        );
+     }
      /// Render an integral
          y: f64,
          depth: u32,
          cursor_path: Option<&[usize]>,
 +        cursor_offset: usize,
      ) {
 -        let body_layout = self.layout_engine.layout(body, self.ctx);
          let scale = self.scale_for_depth(depth);
          let font_size = self.layout_engine.base_font_size * scale;
 +        let body_layout = self.layout_engine.layout_with_depth(body, self.ctx, depth);
++
 +        let symbol_size = body_layout.height().max(font_size * 1.8);
 +        self.ctx.set_font_size(symbol_size);
 +        let int_extents = self.ctx.text_extents("∫").unwrap();
 +        let int_font_extents = self.ctx.font_extents().unwrap();
 +        let symbol_width = int_extents.x_advance();
 +        let symbol_ascent = int_font_extents.ascent();
 +        let symbol_descent = int_font_extents.descent();
++
 +        let lo_layout = lower.map(|lo| {
 +            self.layout_engine
 +                .layout_with_depth(lo, self.ctx, depth + 1)
 +        });
 +        let hi_layout = upper.map(|hi| {
 +            self.layout_engine
 +                .layout_with_depth(hi, self.ctx, depth + 1)
 +        });
 -        let int_height = body_layout.height().max(font_size * 1.5);
 -        let int_width = font_size * 0.5;
 +        let bound_gap = font_size * 0.14;
 +        let bounds_width = symbol_width
 +            .max(lo_layout.as_ref().map(|l| l.width).unwrap_or(0.0))
 +            .max(hi_layout.as_ref().map(|l| l.width).unwrap_or(0.0));
 +        let body_gap = font_size * 0.22;
 +        let dx_gap = font_size * 0.14;
 -        // Draw integral symbol using a large font size
 +        // Draw integral symbol centered in bounds column
          self.ctx.save().unwrap();
          self.set_color(&self.fg_color);
 -        self.ctx.set_font_size(int_height);
 -        self.ctx.move_to(x, y + int_height * 0.3);
 +        self.ctx.set_font_size(symbol_size);
 +        let symbol_x = x + (bounds_width - symbol_width) / 2.0;
 +        let symbol_baseline = y + (symbol_ascent - symbol_descent) * 0.5;
 +        self.ctx.move_to(symbol_x, symbol_baseline);
          self.ctx.show_text("∫").unwrap();
          self.ctx.restore().unwrap();
 -        let mut bounds_width = int_width;
          let mut child_idx = 0;
          // Draw lower bound
 -        if let Some(lo) = lower {
 -            let lo_layout = self.layout_engine.layout(lo, self.ctx);
 +        if let (Some(lo), Some(lo_layout)) = (lower, lo_layout.as_ref()) {
              let lo_cursor = cursor_path.and_then(|p| {
 -                if !p.is_empty() && p[0] == child_idx { Some(&p[1..]) } else { None }
 +                if !p.is_empty() && p[0] == child_idx {
 +                    Some(&p[1..])
 +                } else {
 +                    None
 +                }
              });
 -            self.render_at_depth(
 -                lo,
 -                x,
 -                y + int_height / 2.0 + lo_layout.ascent,
 -                depth + 1,
 -                lo_cursor,
 -            );
 -            bounds_width = bounds_width.max(lo_layout.width);
 +            let lo_x = x + (bounds_width - lo_layout.width) / 2.0;
 +            let lo_baseline = y + symbol_descent + bound_gap + lo_layout.ascent;
 +            self.render_at_depth(lo, lo_x, lo_baseline, depth + 1, lo_cursor, cursor_offset);
              child_idx += 1;
+         }
          // Draw upper bound
 -        if let Some(hi) = upper {
 -            let hi_layout = self.layout_engine.layout(hi, self.ctx);
 +        if let (Some(hi), Some(hi_layout)) = (upper, hi_layout.as_ref()) {
              let hi_cursor = cursor_path.and_then(|p| {
 -                if !p.is_empty() && p[0] == child_idx { Some(&p[1..]) } else { None }
 +                if !p.is_empty() && p[0] == child_idx {
 +                    Some(&p[1..])
 +                } else {
 +                    None
 +                }
              });
 -            self.render_at_depth(
 -                hi,
 -                x,
 -                y - int_height / 2.0 - hi_layout.descent,
 -                depth + 1,
 -                hi_cursor,
 -            );
 -            bounds_width = bounds_width.max(hi_layout.width);
 +            let hi_x = x + (bounds_width - hi_layout.width) / 2.0;
 +            let hi_baseline = y - symbol_ascent - bound_gap - hi_layout.descent;
 +            self.render_at_depth(hi, hi_x, hi_baseline, depth + 1, hi_cursor, cursor_offset);
              child_idx += 1;
+         }
          // Draw body
 -        let body_x = x + bounds_width + font_size * 0.2;
 +        let body_x = x + bounds_width + body_gap;
          let body_cursor = cursor_path.and_then(|p| {
 -            if !p.is_empty() && p[0] == child_idx { Some(&p[1..]) } else { None }
 +            if !p.is_empty() && p[0] == child_idx {
 +                Some(&p[1..])
 +            } else {
 +                None
 +            }
          });
 -        self.render_at_depth(body, body_x, y, depth, body_cursor);
 +        self.render_at_depth(body, body_x, y, depth, body_cursor, cursor_offset);
          child_idx += 1;
          // Draw "dx"
 -        let var_x = body_x + body_layout.width + font_size * 0.1;
 -        self.draw_text("d", var_x, y, font_size, false);
 +        let d_width = self.text_advance("d", font_size, false);
 +        let d_x = body_x + body_layout.width + dx_gap;
 +        self.draw_text("d", d_x, y, font_size, false);
 -        let d_extents = self.ctx.text_extents("d").unwrap();
          let var_cursor = cursor_path.and_then(|p| {
 -            if !p.is_empty() && p[0] == child_idx { Some(&p[1..]) } else { None }
 +            if !p.is_empty() && p[0] == child_idx {
 +                Some(&p[1..])
 +            } else {
 +                None
 +            }
          });
 -        self.render_at_depth(var, var_x + d_extents.x_advance(), y, depth, var_cursor);
 +        self.render_at_depth(var, d_x + d_width, y, depth, var_cursor, cursor_offset);
+     }
      /// Render a derivative
          y: f64,
          depth: u32,
          cursor_path: Option<&[usize]>,
 +        cursor_offset: usize,
      ) {
          let scale = self.scale_for_depth(depth);
          let font_size = self.layout_engine.base_font_size * scale;
 +        let frac_font_size = font_size * 0.8;
          // Build strings for numerator and denominator
          let num_str = if order > 1 {
              "d".to_string()
          };
 -        // Measure text
 -        self.ctx.set_font_size(font_size * 0.8);
 -        let num_extents = self.ctx.text_extents(&num_str).unwrap();
 -        let den_prefix_extents = self.ctx.text_extents(&den_prefix).unwrap();
+-
 -        let var_layout = self.layout_engine.layout(var, self.ctx);
 -        let _body_layout = self.layout_engine.layout(body, self.ctx);
+-
 -        let frac_width = num_extents.x_advance().max(den_prefix_extents.x_advance() + var_layout.width);
 -        let bar_gap = font_size * 0.15;
 +        // Measure text and guard spacing
 +        let num_width = self.text_advance(&num_str, frac_font_size, false);
 +        let den_prefix_width = self.text_advance(&den_prefix, frac_font_size, false);
 +        self.ctx.set_font_size(frac_font_size);
 +        let frac_font_extents = self.ctx.font_extents().unwrap();
 +        let frac_ascent = frac_font_extents.ascent();
 +        let frac_descent = frac_font_extents.descent();
++
 +        let var_layout = self
 +            .layout_engine
 +            .layout_with_depth(var, self.ctx, depth + 1);
 +        let den_sep = (frac_font_size * 0.08).max(0.6);
 +        let denom_width = den_prefix_width + den_sep + var_layout.width;
 +        let frac_width = num_width.max(denom_width) + font_size * 0.18;
 +        let bar_gap = font_size * 0.14;
 +        let body_gap = font_size * 0.3;
          // Draw numerator
 -        self.draw_text(&num_str, x + (frac_width - num_extents.x_advance()) / 2.0, y - bar_gap - font_size * 0.3, font_size * 0.8, false);
 +        self.draw_text(
 +            &num_str,
 +            x + (frac_width - num_width) / 2.0,
 +            y - bar_gap - frac_descent,
 +            frac_font_size,
 +            false,
 +        );
          // Draw fraction bar
          self.ctx.save().unwrap();
          self.ctx.restore().unwrap();
          // Draw denominator
 -        let den_x = x + (frac_width - den_prefix_extents.x_advance() - var_layout.width) / 2.0;
 -        self.draw_text(&den_prefix, den_x, y + bar_gap + font_size * 0.6, font_size * 0.8, false);
 +        let den_x = x + (frac_width - denom_width) / 2.0;
 +        let den_baseline = y + bar_gap + frac_ascent.max(var_layout.ascent);
 +        self.draw_text(&den_prefix, den_x, den_baseline, frac_font_size, false);
          let var_cursor = cursor_path.and_then(|p| {
 -            if !p.is_empty() && p[0] == 0 { Some(&p[1..]) } else { None }
 +            if !p.is_empty() && p[0] == 0 {
 +                Some(&p[1..])
 +            } else {
 +                None
 +            }
          });
 -        self.render_at_depth(var, den_x + den_prefix_extents.x_advance(), y + bar_gap + font_size * 0.6, depth + 1, var_cursor);
 +        self.render_at_depth(
 +            var,
 +            den_x + den_prefix_width + den_sep,
 +            den_baseline,
 +            depth + 1,
 +            var_cursor,
 +            cursor_offset,
 +        );
          // Draw body
          let body_cursor = cursor_path.and_then(|p| {
 -            if !p.is_empty() && p[0] == 1 { Some(&p[1..]) } else { None }
 +            if !p.is_empty() && p[0] == 1 {
 +                Some(&p[1..])
 +            } else {
 +                None
 +            }
          });
 -        self.render_at_depth(body, x + frac_width + font_size * 0.3, y, depth, body_cursor);
 +        self.render_at_depth(
 +            body,
 +            x + frac_width + body_gap,
 +            y,
 +            depth,
 +            body_cursor,
 +            cursor_offset,
 +        );
+     }
      /// Render a limit
          y: f64,
          depth: u32,
          cursor_path: Option<&[usize]>,
 +        cursor_offset: usize,
      ) {
          let scale = self.scale_for_depth(depth);
          let font_size = self.layout_engine.base_font_size * scale;
 +        let sub_font_size = font_size * 0.7;
 +        let body_gap = font_size * 0.3;
++
 +        let lim_width = self.text_advance("lim", font_size, false);
 +        let var_layout = self
 +            .layout_engine
 +            .layout_with_depth(var, self.ctx, depth + 1);
 +        let to_layout = self
 +            .layout_engine
 +            .layout_with_depth(to, self.ctx, depth + 1);
 +        let arrow_width = self.text_advance("→", sub_font_size, false);
 +        let dir_width = if direction.is_some() {
 +            self.text_advance("⁺", sub_font_size * 0.6, false)
 +        } else {
 +            0.0
 +        };
 +        let sub_sep = (sub_font_size * 0.08).max(0.5);
 +        let subscript_width =
 +            var_layout.width + sub_sep + arrow_width + sub_sep + to_layout.width + dir_width;
 +        let lim_col_width = lim_width.max(subscript_width);
 +        let lim_x = x + (lim_col_width - lim_width) / 2.0;
 +        let sub_start_x = x + (lim_col_width - subscript_width) / 2.0;
 +        let subscript_y = y + font_size * 0.2 + var_layout.ascent.max(to_layout.ascent);
          // Draw "lim"
 -        self.draw_text("lim", x, y, font_size, false);
 -        self.ctx.set_font_size(font_size);
 -        let lim_extents = self.ctx.text_extents("lim").unwrap();
+-
 -        // Draw subscript: var → to
 -        let subscript_y = y + font_size * 0.5;
 -        let sub_font_size = font_size * 0.7;
 +        self.draw_text("lim", lim_x, y, font_size, false);
          let var_cursor = cursor_path.and_then(|p| {
 -            if !p.is_empty() && p[0] == 0 { Some(&p[1..]) } else { None }
 +            if !p.is_empty() && p[0] == 0 {
 +                Some(&p[1..])
 +            } else {
 +                None
 +            }
          });
 -        self.render_at_depth(var, x, subscript_y, depth + 1, var_cursor);
 +        self.render_at_depth(
 +            var,
 +            sub_start_x,
 +            subscript_y,
 +            depth + 1,
 +            var_cursor,
 +            cursor_offset,
 +        );
 -        let var_layout = self.layout_engine.layout(var, self.ctx);
 -        let arrow_x = x + var_layout.width;
 +        let arrow_x = sub_start_x + var_layout.width + sub_sep;
          self.draw_text("→", arrow_x, subscript_y, sub_font_size, false);
 -        self.ctx.set_font_size(sub_font_size);
 -        let arrow_extents = self.ctx.text_extents("→").unwrap();
+-
          let to_cursor = cursor_path.and_then(|p| {
 -            if !p.is_empty() && p[0] == 1 { Some(&p[1..]) } else { None }
 +            if !p.is_empty() && p[0] == 1 {
 +                Some(&p[1..])
 +            } else {
 +                None
 +            }
          });
 -        self.render_at_depth(to, arrow_x + arrow_extents.x_advance(), subscript_y, depth + 1, to_cursor);
+-
 -        let to_layout = self.layout_engine.layout(to, self.ctx);
 +        self.render_at_depth(
 +            to,
 +            arrow_x + arrow_width + sub_sep,
 +            subscript_y,
 +            depth + 1,
 +            to_cursor,
 +            cursor_offset,
 +        );
          // Draw direction indicator if present
          if let Some(dir) = direction {
                  LimitDirection::FromRight => "⁺",
                  LimitDirection::FromLeft => "⁻",
              };
 -            self.draw_text(dir_str, arrow_x + arrow_extents.x_advance() + to_layout.width, subscript_y - sub_font_size * 0.3, sub_font_size * 0.6, false);
 +            self.draw_text(
 +                dir_str,
 +                arrow_x + arrow_width + sub_sep + to_layout.width,
 +                subscript_y - sub_font_size * 0.3,
 +                sub_font_size * 0.6,
 +                false,
 +            );
+         }
          // Draw body
 -        let body_x = x + lim_extents.x_advance() + font_size * 0.3;
 +        let body_x = x + lim_col_width + body_gap;
          let body_cursor = cursor_path.and_then(|p| {
 -            if !p.is_empty() && p[0] == 2 { Some(&p[1..]) } else { None }
 +            if !p.is_empty() && p[0] == 2 {
 +                Some(&p[1..])
 +            } else {
 +                None
 +            }
          });
 -        self.render_at_depth(body, body_x, y, depth, body_cursor);
 +        self.render_at_depth(body, body_x, y, depth, body_cursor, cursor_offset);
+     }
      /// Render a big operator (sum, product)
      fn render_bigop(
          &self,
          symbol: &str,
 -        _var: &MathBox,
 +        var: &MathBox,
          lower: &MathBox,
          upper: &MathBox,
          body: &MathBox,
          y: f64,
          depth: u32,
          cursor_path: Option<&[usize]>,
 +        cursor_offset: usize,
      ) {
          let scale = self.scale_for_depth(depth);
          let font_size = self.layout_engine.base_font_size * scale;
          let symbol_size = font_size * 1.5;
+-
 -        // Draw the big symbol
 +        let bound_scale = self.scale_for_depth(depth + 1);
 +        let bound_font_size = self.layout_engine.base_font_size * bound_scale;
++
 +        let var_layout = self
 +            .layout_engine
 +            .layout_with_depth(var, self.ctx, depth + 1);
 +        let lower_layout = self
 +            .layout_engine
 +            .layout_with_depth(lower, self.ctx, depth + 1);
 +        let upper_layout = self
 +            .layout_engine
 +            .layout_with_depth(upper, self.ctx, depth + 1);
 +        let eq_width = self.text_advance("=", bound_font_size, false);
 +        let lower_sep = (bound_font_size * 0.08).max(0.6);
 +        let lower_block_width =
 +            var_layout.width + lower_sep + eq_width + lower_sep + lower_layout.width;
++
 +        // Draw the big symbol centered in the operator column.
          self.ctx.save().unwrap();
          self.set_color(&self.fg_color);
          self.ctx.set_font_size(symbol_size);
 -        self.ctx.move_to(x, y + symbol_size * 0.3);
 -        self.ctx.show_text(symbol).unwrap();
          let symbol_extents = self.ctx.text_extents(symbol).unwrap();
 +        let symbol_width = symbol_extents.x_advance();
 +        let symbol_font_extents = self.ctx.font_extents().unwrap();
 +        let symbol_ascent = symbol_font_extents.ascent();
 +        let symbol_descent = symbol_font_extents.descent();
 +        let op_width = symbol_width.max(lower_block_width).max(upper_layout.width);
 +        let symbol_x = x + (op_width - symbol_width) / 2.0;
 +        let symbol_baseline = y + (symbol_ascent - symbol_descent) * 0.5;
 +        self.ctx.move_to(symbol_x, symbol_baseline);
 +        self.ctx.show_text(symbol).unwrap();
          self.ctx.restore().unwrap();
 -        let op_width = symbol_extents.x_advance();
 -        let gap = font_size * 0.15;
 +        let bounds_gap = font_size * 0.16;
 +        let body_gap = font_size * 0.32;
 +        let symbol_top = symbol_baseline - symbol_ascent;
 +        let symbol_bottom = symbol_baseline + symbol_descent;
 +        let upper_baseline = symbol_top - bounds_gap - upper_layout.descent;
 +        let lower_baseline =
 +            symbol_bottom + bounds_gap + lower_layout.ascent.max(var_layout.ascent);
 +        let upper_x = x + (op_width - upper_layout.width) / 2.0;
 +        let lower_start_x = x + (op_width - lower_block_width) / 2.0;
          // Draw upper bound
 -        let upper_layout = self.layout_engine.layout(upper, self.ctx);
 -        let upper_x = x + (op_width - upper_layout.width) / 2.0;
          let upper_cursor = cursor_path.and_then(|p| {
 -            if !p.is_empty() && p[0] == 2 { Some(&p[1..]) } else { None }
 +            if !p.is_empty() && p[0] == 2 {
 +                Some(&p[1..])
 +            } else {
 +                None
 +            }
          });
 -        self.render_at_depth(upper, upper_x, y - symbol_size / 2.0 - gap - upper_layout.descent, depth + 1, upper_cursor);
 +        self.render_at_depth(
 +            upper,
 +            upper_x,
 +            upper_baseline,
 +            depth + 1,
 +            upper_cursor,
 +            cursor_offset,
 +        );
++
 +        // Draw lower bound as "var = lower"
 +        let var_cursor = cursor_path.and_then(|p| {
 +            if !p.is_empty() && p[0] == 0 {
 +                Some(&p[1..])
 +            } else {
 +                None
 +            }
 +        });
 +        self.render_at_depth(
 +            var,
 +            lower_start_x,
 +            lower_baseline,
 +            depth + 1,
 +            var_cursor,
 +            cursor_offset,
 +        );
++
 +        let eq_x = lower_start_x + var_layout.width + lower_sep;
 +        self.draw_text("=", eq_x, lower_baseline, bound_font_size, false);
 -        // Draw lower bound (includes "var=")
 -        let lower_layout = self.layout_engine.layout(lower, self.ctx);
 -        let lower_x = x + (op_width - lower_layout.width) / 2.0;
          let lower_cursor = cursor_path.and_then(|p| {
 -            if !p.is_empty() && p[0] == 1 { Some(&p[1..]) } else { None }
 +            if !p.is_empty() && p[0] == 1 {
 +                Some(&p[1..])
 +            } else {
 +                None
 +            }
          });
 -        self.render_at_depth(lower, lower_x, y + symbol_size / 2.0 + gap + lower_layout.ascent, depth + 1, lower_cursor);
 +        self.render_at_depth(
 +            lower,
 +            eq_x + eq_width + lower_sep,
 +            lower_baseline,
 +            depth + 1,
 +            lower_cursor,
 +            cursor_offset,
 +        );
          // Draw body
 -        let body_x = x + op_width + font_size * 0.3;
 +        let body_x = x + op_width + body_gap;
          let body_cursor = cursor_path.and_then(|p| {
 -            if !p.is_empty() && p[0] == 3 { Some(&p[1..]) } else { None }
 +            if !p.is_empty() && p[0] == 3 {
 +                Some(&p[1..])
 +            } else {
 +                None
 +            }
          });
 -        self.render_at_depth(body, body_x, y, depth, body_cursor);
 +        self.render_at_depth(body, body_x, y, depth, body_cursor, cursor_offset);
+     }
      /// Render a matrix
          y: f64,
          depth: u32,
          cursor_path: Option<&[usize]>,
 +        cursor_offset: usize,
      ) {
          if rows.is_empty() {
              return;
          let total_width: f64 = col_widths.iter().sum::<f64>()
              + cell_padding * (num_cols as f64 - 1.0)
              + 2.0 * bracket_width;
 -        let total_height: f64 = row_heights.iter().sum::<f64>()
 -            + cell_padding * (rows.len() as f64 - 1.0);
 +        let total_height: f64 =
 +            row_heights.iter().sum::<f64>() + cell_padding * (rows.len() as f64 - 1.0);
          // Draw brackets
          self.ctx.save().unwrap();
          // Right bracket
          let right_x = x + total_width - bracket_width;
 -        self.ctx.move_to(right_x - bracket_gap, y - total_height / 2.0);
 +        self.ctx
 +            .move_to(right_x - bracket_gap, y - total_height / 2.0);
          self.ctx.line_to(right_x, y - total_height / 2.0);
          self.ctx.line_to(right_x, y + total_height / 2.0);
 -        self.ctx.line_to(right_x - bracket_gap, y + total_height / 2.0);
 +        self.ctx
 +            .line_to(right_x - bracket_gap, y + total_height / 2.0);
          self.ctx.stroke().unwrap();
          self.ctx.restore().unwrap();
                  let cy = cell_y + row_h / 2.0;
                  let cell_cursor = cursor_path.and_then(|p| {
 -                    if !p.is_empty() && p[0] == cell_idx { Some(&p[1..]) } else { None }
 +                    if !p.is_empty() && p[0] == cell_idx {
 +                        Some(&p[1..])
 +                    } else {
 +                        None
 +                    }
                  });
 -                self.render_at_depth(cell, cx, cy, depth, cell_cursor);
 +                self.render_at_depth(cell, cx, cy, depth, cell_cursor, cursor_offset);
                  cell_x += col_w + cell_padding;
                  cell_idx += 1;
          y: f64,
          depth: u32,
          cursor_path: Option<&[usize]>,
 +        cursor_offset: usize,
      ) {
          let mut current_x = x;
          for (i, item) in items.iter().enumerate() {
              let item_cursor = cursor_path.and_then(|p| {
 -                if !p.is_empty() && p[0] == i { Some(&p[1..]) } else { None }
 +                if !p.is_empty() && p[0] == i {
 +                    Some(&p[1..])
 +                } else {
 +                    None
 +                }
              });
 -            self.render_at_depth(item, current_x, y, depth, item_cursor);
 +            self.render_at_depth(item, current_x, y, depth, item_cursor, cursor_offset);
              let layout = self.layout_engine.layout(item, self.ctx);
              current_x += layout.width;
      fn set_color(&self, color: &Color) {
          self.ctx.set_source_rgba(color.r, color.g, color.b, color.a);
+     }
++
 +    fn slot_geometry(font_size: f64) -> (f64, f64, f64) {
 +        let width = (font_size * 0.86).max(10.0);
 +        let height = (font_size * 0.9).max(11.0);
 +        let ascent = height * 0.62;
 +        (width, height, ascent)
 +    }
+ }
  /// Convert a number to superscript Unicode digits