@devaloop/devalang 0.0.1-alpha.17 → 0.0.1-alpha.18

package/rust/core/audio/evaluator.rs

@@ -15,22 +15,46 @@ pub fn evaluate_condition_string(expr: &str, vars: &VariableTable) -> bool {
     let op = tokens[1];
     let right = tokens[2];
 
-    let left_val = match vars.get(left) {
-        Some(Value::Number(n)) => n,
-        _ => {
-            return false;
+    // Resolve left and right to numeric values where possible. Accept numbers, variables or env atoms.
+    fn resolve_for_cond(s: &str, vars: &VariableTable) -> Option<f32> {
+        if let Ok(n) = s.parse::<f32>() {
+            return Some(n);
+        }
+        if let Some(Value::Number(n)) = vars.get(s) {
+            return Some(*n);
+        }
+        if let Some(v) = resolve_env_atom(s, 120.0, 1.0) {
+            return Some(v);
         }
+        None
+    }
+
+    let left_val = match resolve_for_cond(left, vars) {
+        Some(v) => v,
+        None => return false,
     };
 
-    let right_val: f32 = right.parse().unwrap_or(0.0);
+    let right_val = match resolve_for_cond(right, vars) {
+        Some(v) => v,
+        None => return false,
+    };
 
     match op {
-        ">" => *left_val > right_val,
-        "<" => *left_val < right_val,
-        ">=" => *left_val >= right_val,
-        "<=" => *left_val <= right_val,
-        "==" => (*left_val - right_val).abs() < f32::EPSILON,
-        "!=" => (*left_val - right_val).abs() > f32::EPSILON,
+        ">" => left_val > right_val,
+        "<" => left_val < right_val,
+        ">=" => left_val >= right_val,
+        "<=" => left_val <= right_val,
+        "==" => {
+            // relative epsilon for floating comparisons
+            let diff = (left_val - right_val).abs();
+            let largest = left_val.abs().max(right_val.abs()).max(1.0);
+            diff <= (f32::EPSILON * largest)
+        }
+        "!=" => {
+            let diff = (left_val - right_val).abs();
+            let largest = left_val.abs().max(right_val.abs()).max(1.0);
+            diff > (f32::EPSILON * largest)
+        }
         _ => false,
     }
 }
@@ -62,25 +86,39 @@ pub fn evaluate_numeric_expression(
     // Shunting-like, simplified: first evaluate any $math.func(...) calls anywhere in the expression,
     // then fold remaining parentheses and evaluate left-to-right.
     fn eval(expr: &str, vars: &VariableTable, bpm: f32, beat: f32) -> Option<f32> {
-        // 1) Replace $math.* calls progressively
+        // 1) Replace $math/$easing/$mod calls progressively with a max iteration guard
         let mut s = expr.to_string();
+        let mut iterations = 0u32;
+        const MAX_ITER: u32 = 64;
+
         // Evaluate modulators first (they may feed easing/math)
-        while let Some(next) =
-            find_and_eval_first_mod_call(&s, evaluate_numeric_expression, vars, bpm, beat)
-        {
-            s = next;
+        while iterations < MAX_ITER {
+            if let Some(next) = find_and_eval_first_mod_call(&s, evaluate_numeric_expression, vars, bpm, beat) {
+                s = next;
+                iterations += 1;
+                continue;
+            }
+            break;
         }
-        // Then easing functions
-        while let Some(next) =
-            find_and_eval_first_easing_call(&s, evaluate_numeric_expression, vars, bpm, beat)
-        {
-            s = next;
+
+        iterations = 0;
+        while iterations < MAX_ITER {
+            if let Some(next) = find_and_eval_first_easing_call(&s, evaluate_numeric_expression, vars, bpm, beat) {
+                s = next;
+                iterations += 1;
+                continue;
+            }
+            break;
         }
-        // Finally math transforms
-        while let Some(next) =
-            find_and_eval_first_math_call(&s, evaluate_numeric_expression, vars, bpm, beat)
-        {
-            s = next;
+
+        iterations = 0;
+        while iterations < MAX_ITER {
+            if let Some(next) = find_and_eval_first_math_call(&s, evaluate_numeric_expression, vars, bpm, beat) {
+                s = next;
+                iterations += 1;
+                continue;
+            }
+            break;
         }
 
         // 2) Evaluate remaining (pure) parentheses starting from innermost

package/rust/core/audio/interpreter/arrow_call.rs

@@ -5,6 +5,7 @@ use crate::core::{
     store::{global::GlobalStore, variable::VariableTable},
 };
 use devalang_types::Value;
+use devalang_utils::logger::{Logger, LogLevel};
 
 use std::collections::HashMap;
 
@@ -28,30 +29,32 @@ pub fn interprete_call_arrow_statement(
     } = &stmt.kind
     {
         let Some(Value::Statement(synth_stmt)) = variable_table.get(target) else {
-            println!("❌ Synth '{}' not found in variable table", target);
+            let logger = Logger::new();
+            logger.log_message(LogLevel::Error, &format!("Synth '{}' not found in variable table", target));
             return (*max_end_time, cursor_copy);
         };
 
         let Value::Map(synth_map) = &synth_stmt.value else {
-            println!(
-                "❌ Invalid synth statement for '{}', expected a map.",
-                target
-            );
+            let logger = Logger::new();
+            logger.log_message(LogLevel::Error, &format!("Invalid synth statement for '{}', expected a map.", target));
             return (*max_end_time, cursor_copy);
         };
 
         let Some(Value::String(entity)) = synth_map.get("entity") else {
-            println!("❌ Missing 'entity' key in synth '{}'.", target);
+            let logger = Logger::new();
+            logger.log_message(LogLevel::Error, &format!("Missing 'entity' key in synth '{}'.", target));
             return (*max_end_time, cursor_copy);
         };
 
         if entity != "synth" {
-            println!("❌ '{}' is not a synth, entity is '{}'.", target, entity);
+            let logger = Logger::new();
+            logger.log_message(LogLevel::Error, &format!("'{}' is not a synth, entity is '{}'.", target, entity));
             return (*max_end_time, cursor_copy);
         }
 
         let Some(Value::Map(value_map)) = synth_map.get("value") else {
-            println!("❌ Missing 'value' map in synth '{}'.", target);
+            let logger = Logger::new();
+            logger.log_message(LogLevel::Error, &format!("Missing 'value' map in synth '{}'.", target));
             return (*max_end_time, cursor_copy);
         };
 
@@ -59,7 +62,8 @@ pub fn interprete_call_arrow_statement(
             Some(Value::String(s)) => s.clone(),
             Some(Value::Identifier(s)) => s.clone(),
             _ => {
-                println!("? Missing or invalid 'waveform' in synth '{}'.", target);
+                let logger = Logger::new();
+                logger.log_message(LogLevel::Error, &format!("Missing or invalid 'waveform' in synth '{}'.", target));
                 return (*max_end_time, cursor_copy);
             }
         };
@@ -196,16 +200,16 @@ pub fn interprete_call_arrow_statement(
                                     audio_engine.buffer[idx].saturating_add(s);
                             }
                         } else {
-                            println!(
-                                "? Plugin bytes not found for key '{}' (alias '{}').",
-                                key, alias
-                            );
+                            let logger = Logger::new();
+                            logger.log_message(LogLevel::Warning, &format!("Plugin bytes not found for key '{}' (alias '{}').", key, alias));
                         }
                     } else {
-                        println!("? Invalid plugin URI in alias '{}': {}", alias, uri);
+                        let logger = Logger::new();
+                        logger.log_message(LogLevel::Warning, &format!("Invalid plugin URI in alias '{}': {}", alias, uri));
                     }
                 } else {
-                    println!("? Plugin alias '{}' not found in variable table.", alias);
+                    let logger = Logger::new();
+                    logger.log_message(LogLevel::Warning, &format!("Plugin alias '{}' not found in variable table.", alias));
                 }
             } else {
                 audio_engine.insert_note(
@@ -230,7 +234,8 @@ pub fn interprete_call_arrow_statement(
 
             return (*max_end_time, end_time);
         } else {
-            println!("❌ Unknown method '{}' on synth '{}'.", method, target);
+            let logger = Logger::new();
+            logger.log_message(LogLevel::Error, &format!("Unknown method '{}' on synth '{}'.", method, target));
         }
     }
 

package/rust/core/audio/interpreter/call.rs

@@ -1,4 +1,4 @@
-use devalang_types::Value;
+use devalang_types::{Duration, Value};
 
 use crate::core::{
     audio::{engine::AudioEngine, interpreter::driver::execute_audio_block},
@@ -69,6 +69,111 @@ pub fn interprete_call_statement(
             }
         }
 
+        // Pattern case
+        if let Some(pattern_stmt) = find_pattern(name, variable_table, global_store) {
+            // Extract pattern string from statement value
+            if let Value::String(pat) = &pattern_stmt.value {
+                // Determine target entity (explicit or inferred)
+                let mut target_entity = name.clone();
+                if let StatementKind::Pattern { name: _n, target } = &pattern_stmt.kind {
+                    if let Some(t) = target {
+                        target_entity = t.clone();
+                    }
+                }
+
+                // Build a variable table snapshot for resolution like triggers do
+                // Preserve the full parent chain so lookups behave the same as runtime
+                fn clone_with_parents(orig: &crate::core::store::variable::VariableTable) -> crate::core::store::variable::VariableTable {
+                    crate::core::store::variable::VariableTable {
+                        variables: orig.variables.clone(),
+                        parent: orig.parent.as_ref().map(|p| Box::new(clone_with_parents(p))),
+                    }
+                }
+
+                let final_variable_table = clone_with_parents(variable_table);
+
+                // Normalize pattern: remove spaces and line breaks
+                let pattern_str: String = pat.chars().filter(|c| !c.is_whitespace()).collect();
+                if pattern_str.is_empty() {
+                    return (max_end_time, cursor_time);
+                }
+
+                let step_count = pattern_str.len() as f32;
+                // Assume pattern spans one bar (4 beats)
+                let total_bar = 4.0 * base_duration;
+                let step_duration = total_bar / step_count; // seconds per step
+
+                let mut updated_max = max_end_time;
+
+                for (i, ch) in pattern_str.chars().enumerate() {
+                    if ch == '-' {
+                        continue; // rest
+                    }
+
+                    // Schedule a trigger at cursor_time + offset
+                    let event_time = cursor_time + (i as f32) * step_duration;
+
+                    // Resolve trigger value similarly to interprete_trigger_statement
+                    let mut trigger_val = Value::String(target_entity.clone());
+                    if let Some(val) = variable_table.variables.get(&target_entity) {
+                        match val {
+                            Value::Identifier(id) => {
+                                // resolve from parent if available
+                                if let Some(parent) = &variable_table.parent {
+                                    if let Some(v) = parent.get(id) {
+                                        trigger_val = v.clone();
+                                    }
+                                } else if let Some(v) = variable_table.get(id) {
+                                    trigger_val = v.clone();
+                                }
+                            }
+                            Value::Map(map) => {
+                                if let Some(Value::String(src)) = map.get("entity") {
+                                    trigger_val = Value::String(src.clone());
+                                } else if let Some(Value::Identifier(src)) = map.get("entity") {
+                                    trigger_val = Value::Identifier(src.clone());
+                                }
+                            }
+                            Value::Sample(sample_src) => {
+                                trigger_val = Value::Sample(sample_src.clone());
+                            }
+                            _ => {
+                                // leave as string
+                            }
+                        }
+                    }
+
+                    // Use loader to get sample path and sample length
+                    let (src, sample_length) =
+                        crate::core::audio::loader::trigger::load_trigger(&trigger_val, &Duration::Number(step_duration), &None, base_duration, final_variable_table.clone());
+
+                    let play_length = step_duration.min(sample_length);
+
+                    let trigger_src = match trigger_val.get("entity") {
+                        Some(Value::String(s)) => s.clone(),
+                        Some(Value::Identifier(id)) => id.clone(),
+                        Some(Value::Statement(stmt)) => {
+                            if let StatementKind::Trigger { entity, .. } = &stmt.kind {
+                                entity.clone()
+                            } else {
+                                src.clone()
+                            }
+                        }
+                        _ => src.clone(),
+                    };
+
+                    audio_engine.insert_sample(&trigger_src, event_time, play_length, None, &final_variable_table);
+
+                    let end_time = event_time + play_length;
+                    if end_time > updated_max {
+                        updated_max = end_time;
+                    }
+                }
+
+                return (updated_max, cursor_time);
+            }
+        }
+
         // Function or group not found; keep as debug-free fail path
     }
 
@@ -117,3 +222,53 @@ fn find_group(
 
     None
 }
+
+fn find_pattern(
+    name: &str,
+    variable_table: &VariableTable,
+    global_store: &GlobalStore,
+) -> Option<Statement> {
+    use crate::core::parser::statement::Statement;
+    use crate::core::parser::statement::StatementKind;
+
+    if let Some(Value::Statement(stmt_box)) = variable_table.get(name) {
+        if let StatementKind::Pattern { .. } = stmt_box.kind {
+            return Some(*stmt_box.clone());
+        }
+    }
+
+    if let Some(val) = global_store.variables.variables.get(name) {
+        match val {
+            Value::Statement(stmt_box) => {
+                if let StatementKind::Pattern { .. } = stmt_box.kind {
+                    return Some(*stmt_box.clone());
+                }
+            }
+            Value::Map(map) => {
+                if let Some(Value::String(_pat)) = map.get("pattern") {
+                    // Rebuild a Pattern statement from stored map if possible
+                    let stmt = Statement {
+                        kind: StatementKind::Pattern {
+                            name: name.to_string(),
+                            target: map.get("target").and_then(|v| match v {
+                                Value::String(s) => Some(s.clone()),
+                                _ => None,
+                            }),
+                        },
+                        value: Value::String(map.get("pattern").and_then(|v| match v {
+                            Value::String(s) => Some(s.clone()),
+                            _ => None,
+                        }).unwrap_or_default()),
+                        indent: 0,
+                        line: 0,
+                        column: 0,
+                    };
+                    return Some(stmt);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    None
+}

package/rust/core/audio/interpreter/spawn.rs

@@ -1,4 +1,4 @@
-use devalang_types::Value;
+use devalang_types::{Duration, Value};
 
 use crate::core::{
     audio::{engine::AudioEngine, interpreter::driver::execute_audio_block},
@@ -68,6 +68,100 @@ pub fn interprete_spawn_statement(
             }
         }
 
+        // Pattern case: allow spawning a pattern similar to call
+        if let Some(pattern_stmt) = find_pattern(name, variable_table, global_store) {
+            if let Value::String(pat) = &pattern_stmt.value {
+                let mut target_entity = name.clone();
+                if let StatementKind::Pattern { name: _n, target } = &pattern_stmt.kind {
+                    if let Some(t) = target {
+                        target_entity = t.clone();
+                    }
+                }
+
+                let final_variable_table = if let Some(parent) = &variable_table.parent {
+                    crate::core::store::variable::VariableTable {
+                        variables: parent.variables.clone(),
+                        parent: None,
+                    }
+                } else {
+                    variable_table.clone()
+                };
+
+                let pattern_str: String = pat.chars().filter(|c| !c.is_whitespace()).collect();
+                if pattern_str.is_empty() {
+                    return (max_end_time, cursor_time);
+                }
+
+                let step_count = pattern_str.len() as f32;
+                let total_bar = 4.0 * base_duration;
+                let step_duration = total_bar / step_count;
+
+                let mut updated_max = max_end_time;
+
+                for (i, ch) in pattern_str.chars().enumerate() {
+                    if ch == '-' {
+                        continue;
+                    }
+
+                    let event_time = cursor_time + (i as f32) * step_duration;
+
+                    let mut trigger_val = Value::String(target_entity.clone());
+                    if let Some(val) = variable_table.variables.get(&target_entity) {
+                        match val {
+                            Value::Identifier(id) => {
+                                if let Some(parent) = &variable_table.parent {
+                                    if let Some(v) = parent.get(id) {
+                                        trigger_val = v.clone();
+                                    }
+                                } else if let Some(v) = variable_table.get(id) {
+                                    trigger_val = v.clone();
+                                }
+                            }
+                            Value::Map(map) => {
+                                if let Some(Value::String(src)) = map.get("entity") {
+                                    trigger_val = Value::String(src.clone());
+                                } else if let Some(Value::Identifier(src)) = map.get("entity") {
+                                    trigger_val = Value::Identifier(src.clone());
+                                }
+                            }
+                            Value::Sample(sample_src) => {
+                                trigger_val = Value::Sample(sample_src.clone());
+                            }
+                            _ => {}
+                        }
+                    }
+
+                    let (src, sample_length) =
+                        crate::core::audio::loader::trigger::load_trigger(&trigger_val, &Duration::Number(step_duration), &None, base_duration, final_variable_table.clone());
+
+                    let play_length = step_duration.min(sample_length);
+
+                    let trigger_src = match trigger_val.get("entity") {
+                        Some(Value::String(s)) => s.clone(),
+                        Some(Value::Identifier(id)) => id.clone(),
+                        Some(Value::Statement(stmt)) => {
+                            if let StatementKind::Trigger { entity, .. } = &stmt.kind {
+                                entity.clone()
+                            } else {
+                                src.clone()
+                            }
+                        }
+                        _ => src.clone(),
+                    };
+
+                    audio_engine.insert_sample(&trigger_src, event_time, play_length, None, &final_variable_table);
+
+                    let end_time = event_time + play_length;
+                    if end_time > updated_max {
+                        updated_max = end_time;
+                    }
+                }
+
+                audio_engine.merge_with(local_engine);
+                return (updated_max.max(max_end_time), cursor_time);
+            }
+        }
+
         // Function or group not found
     }
 
@@ -91,3 +185,53 @@ fn find_group<'a>(
     }
     None
 }
+
+fn find_pattern(
+    name: &str,
+    variable_table: &VariableTable,
+    global_store: &GlobalStore,
+) -> Option<Statement> {
+    use crate::core::parser::statement::Statement;
+    use crate::core::parser::statement::StatementKind;
+
+    if let Some(Value::Statement(stmt_box)) = variable_table.get(name) {
+        if let StatementKind::Pattern { .. } = stmt_box.kind {
+            return Some(*stmt_box.clone());
+        }
+    }
+
+    if let Some(val) = global_store.variables.variables.get(name) {
+        match val {
+            Value::Statement(stmt_box) => {
+                if let StatementKind::Pattern { .. } = stmt_box.kind {
+                    return Some(*stmt_box.clone());
+                }
+            }
+            Value::Map(map) => {
+                if let Some(Value::String(_pat)) = map.get("pattern") {
+                    // Rebuild a Pattern statement from stored map if possible
+                    let stmt = Statement {
+                        kind: StatementKind::Pattern {
+                            name: name.to_string(),
+                            target: map.get("target").and_then(|v| match v {
+                                Value::String(s) => Some(s.clone()),
+                                _ => None,
+                            }),
+                        },
+                        value: Value::String(map.get("pattern").and_then(|v| match v {
+                            Value::String(s) => Some(s.clone()),
+                            _ => None,
+                        }).unwrap_or_default()),
+                        indent: 0,
+                        line: 0,
+                        column: 0,
+                    };
+                    return Some(stmt);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    None
+}

package/rust/core/audio/special/math.rs

@@ -1,4 +1,5 @@
 use crate::core::store::variable::VariableTable;
+use devalang_utils::logger::{Logger, LogLevel};
 
 // Parse comma-separated arguments at top level (no nested parentheses split)
 fn parse_top_level_args(s: &str) -> Vec<&str> {
@@ -56,9 +57,21 @@ pub fn find_and_eval_first_math_call<EvalFn>(
 where
     EvalFn: Fn(&str, &VariableTable, f32, f32) -> Option<f32>,
 {
+    let logger = Logger::new();
+
     let start = s.find("$math.")?;
-    let open_rel = s[start..].find('(')?;
+    let open_rel = match s[start..].find('(') {
+        Some(i) => i,
+        None => {
+            logger.log_message(LogLevel::Error, &format!("Malformed $math call: missing '(' in '{}'", s));
+            return None;
+        }
+    };
     let open = start + open_rel;
+    if open <= start + 6 {
+        logger.log_message(LogLevel::Error, &format!("Malformed $math call: missing function name in '{}'", s));
+        return None;
+    }
     let func = &s[start + 6..open];
 
     // Find matching close parenthesis, handling nesting
@@ -77,7 +90,13 @@ where
             _ => {}
         }
     }
-    let close = close_abs?;
+    let close = match close_abs {
+        Some(c) => c,
+        None => {
+            logger.log_message(LogLevel::Error, &format!("Malformed $math call: missing closing ')' in '{}'", s));
+            return None;
+        }
+    };
 
     let inner = &s[open + 1..close];
     let raw_args = parse_top_level_args(inner);
@@ -86,6 +105,7 @@ where
         if let Some(v) = eval(a, vars, bpm, beat) {
             args.push(v);
         } else {
+            logger.log_message(LogLevel::Error, &format!("Failed to evaluate argument '{}' for $math.{}", a, func));
             return None;
         }
     }

package/rust/core/lexer/driver.rs

@@ -0,0 +1,61 @@
+use crate::core::{
+    lexer::{handler::driver::handle_content_lexing, token::Token},
+    utils::path::normalize_path,
+};
+use std::fs;
+use std::path::Path;
+
+pub struct Lexer {}
+
+impl Default for Lexer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Lexer {
+    pub fn new() -> Self {
+        Lexer {}
+    }
+
+    pub fn lex_from_source(&self, source: &str) -> Result<Vec<Token>, String> {
+        handle_content_lexing(source.to_string())
+    }
+
+    pub fn lex_tokens(&self, entrypoint: &str) -> Result<Vec<Token>, String> {
+        let path = normalize_path(entrypoint);
+        let resolved_path = Self::resolve_entry_path(&path)?;
+
+        let file_content = fs::read_to_string(&resolved_path).map_err(|e| {
+            format!(
+                "Failed to read the entrypoint file '{}': {}",
+                resolved_path, e
+            )
+        })?;
+
+        handle_content_lexing(file_content).map_err(|e| format!("Failed to lex the content: {}", e))
+    }
+
+    fn resolve_entry_path(path: &str) -> Result<String, String> {
+        let candidate = Path::new(path);
+
+        if candidate.is_dir() {
+            let index_path = candidate.join("index.deva");
+            if index_path.exists() {
+                Ok(index_path.to_string_lossy().replace("\\", "/"))
+            } else {
+                Err(format!(
+                    "Expected 'index.deva' in directory '{}', but it was not found",
+                    path
+                ))
+            }
+        } else if candidate.is_file() {
+            return Ok(path.to_string());
+        } else {
+            return Err(format!(
+                "Provided entrypoint '{}' is not a valid file or directory",
+                path
+            ));
+        }
+    }
+}

package/rust/core/lexer/handler/identifier.rs

@@ -1,4 +1,4 @@
-use crate::core::lexer::token::{Token, TokenKind};
+use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_identifier_lexer(
     ch: char,
@@ -7,7 +7,7 @@ pub fn handle_identifier_lexer(
     _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
-    column: &mut usize,
+    column: &mut usize
 ) {
     let mut ident = ch.to_string();
 
@@ -25,6 +25,7 @@ pub fn handle_identifier_lexer(
         "if" => TokenKind::If,
         "else" => TokenKind::Else,
         "bank" => TokenKind::Bank,
+        "pattern" => TokenKind::Pattern,
         "bpm" => TokenKind::Tempo,
         "loop" => TokenKind::Loop,
         "for" => TokenKind::Loop,