@devaloop/devalang 0.0.1-alpha.16-hotfix.1 → 0.0.1-alpha.17

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

@@ -1,7 +1,8 @@
+use devalang_types::Value;
+
 use crate::core::{
     audio::{engine::AudioEngine, interpreter::driver::execute_audio_block},
     parser::statement::{Statement, StatementKind},
-    shared::value::Value,
     store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
 };
 
@@ -16,71 +17,58 @@ pub fn interprete_spawn_statement(
     max_end_time: f32,
     cursor_time: f32,
 ) -> (f32, f32) {
-    match &stmt.kind {
-        StatementKind::Spawn { name, args } => {
-            let mut local_engine = AudioEngine::new(audio_engine.module_name.clone());
+    if let StatementKind::Spawn { name, args } = &stmt.kind {
+        let mut local_engine = AudioEngine::new(audio_engine.module_name.clone());
 
-            // Function case
-            if let Some(func) = functions.functions.get(name) {
-                if func.parameters.len() != args.len() {
-                    eprintln!(
-                        "❌ Function '{}' expects {} args, got {}",
-                        name,
-                        func.parameters.len(),
-                        args.len()
-                    );
-                    return (max_end_time, cursor_time);
-                }
+        // Function case
+        if let Some(func) = functions.functions.get(name) {
+            if func.parameters.len() != args.len() {
+                return (max_end_time, cursor_time);
+            }
 
-                let mut local_vars = VariableTable::with_parent(variable_table.clone());
-                for (param, arg) in func.parameters.iter().zip(args) {
-                    local_vars.set(param.clone(), arg.clone());
-                }
+            let mut local_vars = VariableTable::with_parent(variable_table.clone());
+            for (param, arg) in func.parameters.iter().zip(args) {
+                local_vars.set(param.clone(), arg.clone());
+            }
 
-                let (spawn_max, _) = execute_audio_block(
-                    &mut local_engine,
-                    global_store,
-                    local_vars,
-                    functions.clone(),
-                    &func.body,
-                    base_bpm,
-                    base_duration,
-                    0.0,
-                    0.0,
-                );
+            let (spawn_max, _) = execute_audio_block(
+                &mut local_engine,
+                global_store,
+                local_vars,
+                functions.clone(),
+                &func.body,
+                base_bpm,
+                base_duration,
+                0.0,
+                0.0,
+            );
 
-                audio_engine.merge_with(local_engine);
-                return (spawn_max.max(max_end_time), cursor_time);
-            }
+            audio_engine.merge_with(local_engine);
+            return (spawn_max.max(max_end_time), cursor_time);
+        }
 
-            // Group case
-            if let Some(group_stmt) = find_group(name, variable_table, global_store) {
-                if let Value::Map(map) = &group_stmt.value {
-                    if let Some(Value::Block(body)) = map.get("body") {
-                        let (spawn_max, _) = execute_audio_block(
-                            &mut local_engine,
-                            global_store,
-                            variable_table.clone(),
-                            functions.clone(),
-                            &body,
-                            base_bpm,
-                            base_duration,
-                            0.0,
-                            0.0,
-                        );
-                        audio_engine.merge_with(local_engine);
-                        return (spawn_max.max(max_end_time), cursor_time);
-                    }
+        // Group case
+        if let Some(group_stmt) = find_group(name, variable_table, global_store) {
+            if let Value::Map(map) = &group_stmt.value {
+                if let Some(Value::Block(body)) = map.get("body") {
+                    let (spawn_max, _) = execute_audio_block(
+                        &mut local_engine,
+                        global_store,
+                        variable_table.clone(),
+                        functions.clone(),
+                        body,
+                        base_bpm,
+                        base_duration,
+                        0.0,
+                        0.0,
+                    );
+                    audio_engine.merge_with(local_engine);
+                    return (spawn_max.max(max_end_time), cursor_time);
                 }
             }
-
-            eprintln!("❌ Function or group '{}' not found", name);
         }
 
-        _ => eprintln!(
-            "❌ interprete_spawn_statement expected Spawn, got {:?}",
-            stmt.kind
-        ),
+        // Function or group not found
     }
 
     (max_end_time, cursor_time)

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

@@ -1,17 +1,38 @@
-use crate::core::{
-    parser::statement::{Statement, StatementKind},
-    shared::value::Value,
-};
+use crate::core::parser::statement::{Statement, StatementKind};
+use devalang_types::Value;
+use devalang_utils::logger::{LogLevel, Logger};
 
 pub fn interprete_tempo_statement(stmt: &Statement) -> Option<(f32, f32)> {
     if let StatementKind::Tempo = &stmt.kind {
-        if let Value::Number(bpm) = &stmt.value {
-            let bpm = *bpm as f32;
-            let duration = 60.0 / bpm;
+        match &stmt.value {
+            Value::Number(bpm) => {
+                let bpm = { *bpm };
+                let duration = 60.0 / bpm;
 
-            return Some((bpm, duration));
-        } else {
-            eprintln!("❌ Invalid tempo value: {:?}", stmt.value);
+                return Some((bpm, duration));
+            }
+
+            Value::String(bpm_str) => {
+                if let Ok(bpm) = bpm_str.parse::<f32>() {
+                    let duration = 60.0 / bpm;
+                    return Some((bpm, duration));
+                }
+            }
+
+            Value::Identifier(bpm_ident) => {
+                if let Ok(bpm) = bpm_ident.parse::<f32>() {
+                    let duration = 60.0 / bpm;
+                    return Some((bpm, duration));
+                }
+            }
+
+            _ => {
+                let logger = Logger::new();
+                logger.log_message(
+                    LogLevel::Warning,
+                    format!("Invalid tempo value: {:?}", stmt.value).as_str(),
+                );
+            }
         }
     }
 

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

@@ -3,10 +3,10 @@ use std::collections::HashMap;
 use crate::core::{
     audio::{engine::AudioEngine, loader::trigger::load_trigger},
     parser::statement::{Statement, StatementKind},
-    shared::{duration::Duration, value::Value},
     store::variable::VariableTable,
 };
-use crate::utils::logger::Logger;
+use devalang_types::{Duration, Value};
+use devalang_utils::logger::Logger;
 
 pub fn interprete_trigger_statement(
     stmt: &Statement,

package/rust/core/audio/loader/trigger.rs

@@ -1,8 +1,5 @@
-use crate::core::{
-    parser::statement::StatementKind,
-    shared::{duration::Duration, value::Value},
-    store::variable::VariableTable,
-};
+use crate::core::{parser::statement::StatementKind, store::variable::VariableTable};
+use devalang_types::{Duration, Value};
 
 pub fn load_trigger(
     trigger: &Value,
@@ -24,9 +21,9 @@ pub fn load_trigger(
 
         Value::Map(map) => {
             if let Some(Value::String(src)) = map.get("entity") {
-                trigger_path = format!("devalang://bank/{}", src.to_string());
+                trigger_path = format!("devalang://bank/{}", src);
             } else if let Some(Value::Identifier(src)) = map.get("entity") {
-                trigger_path = format!("devalang://bank/{}", src.to_string());
+                trigger_path = format!("devalang://bank/{}", src);
             } else {
                 eprintln!(
                     "❌ Trigger map must contain an 'entity' key with a string or identifier value."

package/rust/core/audio/player.rs

@@ -8,6 +8,12 @@ pub struct AudioPlayer {
     last_path: Option<String>,
 }
 
+impl Default for AudioPlayer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl AudioPlayer {
     pub fn new() -> Self {
         let (stream, handle) = OutputStream::try_default().unwrap();

package/rust/core/audio/renderer.rs

@@ -1,11 +1,9 @@
-use crate::{
-    core::{
-        audio::{engine::AudioEngine, interpreter::driver::run_audio_program},
-        parser::statement::Statement,
-        store::global::GlobalStore,
-    },
-    utils::logger::{LogLevel, Logger},
+use crate::core::{
+    audio::{engine::AudioEngine, interpreter::driver::run_audio_program},
+    parser::statement::Statement,
+    store::global::GlobalStore,
 };
+use devalang_utils::logger::{LogLevel, Logger};
 use std::collections::HashMap;
 
 pub fn render_audio_with_modules(

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

@@ -1,3 +1,5 @@
+use devalang_types::Value;
+
 use crate::core::store::variable::VariableTable;
 use std::sync::OnceLock;
 use std::time::{SystemTime, UNIX_EPOCH};
@@ -36,7 +38,7 @@ pub fn resolve_atom_or_var(atom: &str, vars: &VariableTable, bpm: f32, beat: f32
     if let Ok(n) = atom.parse::<f32>() {
         return Some(n);
     }
-    if let Some(crate::core::shared::value::Value::Number(n)) = vars.get(atom) {
+    if let Some(Value::Number(n)) = vars.get(atom) {
         return Some(*n);
     }
     None

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

@@ -25,12 +25,12 @@ fn parse_top_level_args(s: &str) -> Vec<&str> {
 
 fn eval_math_func(func: &str, args: &[f32], fallback_seed: f32) -> Option<f32> {
     match func {
-        "sin" => args.get(0).copied().map(f32::sin),
-        "cos" => args.get(0).copied().map(f32::cos),
+        "sin" => args.first().copied().map(f32::sin),
+        "cos" => args.first().copied().map(f32::cos),
         "random" => {
             // deterministic pseudo-random based on provided seed or a fallback session seed
-            let seed = args.get(0).copied().unwrap_or(fallback_seed);
-            let x = (seed * 12.9898).sin() * 43758.5453;
+            let seed = args.first().copied().unwrap_or(fallback_seed);
+            let x = (seed * 12.9898).sin() * 43_758.547;
             Some((x.fract() * 2.0 - 1.0).clamp(-1.0, 1.0))
         }
         "lerp" => {

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

@@ -44,11 +44,11 @@ fn adsr_envelope_value_t(attack: f32, decay: f32, sustain: f32, release: f32, t:
 fn eval_mod_func(func: &str, args: &[f32], beat: f32) -> Option<f32> {
     match func {
         "lfo.sine" => {
-            let rate = args.get(0).copied().unwrap_or(1.0);
+            let rate = args.first().copied().unwrap_or(1.0);
             Some(lfo_sine(rate, beat))
         }
         "lfo.tri" | "lfo.triangle" => {
-            let rate = args.get(0).copied().unwrap_or(1.0);
+            let rate = args.first().copied().unwrap_or(1.0);
             Some(lfo_triangle(rate, beat))
         }
         // ADSR envelope normalized over t in [0,1]

package/rust/core/builder/mod.rs

@@ -1,12 +1,18 @@
 use crate::core::audio::renderer::render_audio_with_modules;
 use crate::core::parser::statement::Statement;
 use crate::core::store::global::GlobalStore;
-use crate::utils::logger::Logger;
+use devalang_utils::logger::Logger;
 use std::io::Write;
 use std::{collections::HashMap, fs::create_dir_all};
 
 pub struct Builder {}
 
+impl Default for Builder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Builder {
     pub fn new() -> Self {
         Builder {}
@@ -46,7 +52,7 @@ impl Builder {
         let logger = Logger::new();
 
         let audio_engines =
-            render_audio_with_modules(modules.clone(), &normalized_output_dir, global_store);
+            render_audio_with_modules(modules.clone(), normalized_output_dir, global_store);
 
         create_dir_all(format!("{}/audio", normalized_output_dir))
             .expect("Failed to create audio directory");
@@ -54,7 +60,7 @@ impl Builder {
         for (module_name, mut audio_engine) in audio_engines {
             let formatted_module_name = module_name
                 .split('/')
-                .last()
+                .next_back()
                 .unwrap_or(&module_name)
                 .replace(".deva", "");
 

package/rust/core/debugger/lexer.rs

@@ -20,7 +20,7 @@ pub fn write_lexer_log_file(
             content.push_str(&format!("{:?}\n", token));
         }
 
-        content.push_str("\n");
+        content.push('\n');
     }
 
     debugger.write_log_file(&log_directory, file_name, &content);

package/rust/core/debugger/mod.rs

@@ -7,6 +7,12 @@ use std::io::Write;
 
 pub struct Debugger {}
 
+impl Default for Debugger {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Debugger {
     pub fn new() -> Self {
         Debugger {}

package/rust/core/debugger/module.rs

@@ -13,7 +13,7 @@ pub fn write_module_variable_log_file(
     let mut content = String::new();
     let module_name = module_path
         .split('/')
-        .last()
+        .next_back()
         .unwrap_or("index")
         .replace(".deva", "");
 
@@ -24,7 +24,7 @@ pub fn write_module_variable_log_file(
         content.push_str(&format!("{:?} = {:?}\n", var_name, var_data));
     }
 
-    content.push_str("\n");
+    content.push('\n');
 
     debugger.write_log_file(&log_directory, "variables.log", &content);
 }
@@ -38,7 +38,7 @@ pub fn write_module_function_log_file(
     let mut content = String::new();
     let module_name = module_path
         .split('/')
-        .last()
+        .next_back()
         .unwrap_or("index")
         .replace(".deva", "");
 
@@ -49,7 +49,7 @@ pub fn write_module_function_log_file(
         content.push_str(&format!("{:?} = {:?}\n", func_name, func_data));
     }
 
-    content.push_str("\n");
+    content.push('\n');
 
     debugger.write_log_file(&log_directory, "functions.log", &content);
 }

package/rust/core/debugger/preprocessor.rs

@@ -20,7 +20,7 @@ pub fn write_preprocessor_log_file(
             content.push_str(&format!("{:?}\n", stmt));
         }
 
-        content.push_str("\n");
+        content.push('\n');
     }
 
     debugger.write_log_file(&log_directory, file_name, &content);

package/rust/core/debugger/store.rs

@@ -15,7 +15,7 @@ pub fn write_variables_log_file(output_dir: &str, file_name: &str, variables: Va
         content.push_str(&format!("{:?} = {:?}\n", var_name, var_data));
     }
 
-    content.push_str("\n");
+    content.push('\n');
 
     debugger.write_log_file(&log_directory, file_name, &content);
 }
@@ -34,7 +34,7 @@ pub fn write_function_log_file(output_dir: &str, file_name: &str, functions: Fun
         ));
     }
 
-    content.push_str("\n");
+    content.push('\n');
 
     debugger.write_log_file(&log_directory, file_name, &content);
 }

package/rust/core/error/mod.rs

@@ -2,6 +2,7 @@ use crate::core::parser::{
     driver::Parser,
     statement::{Statement, StatementKind},
 };
+use devalang_types::Value;
 use serde::{Deserialize, Serialize};
 
 pub struct ErrorHandler {
@@ -38,6 +39,12 @@ pub struct Error {
     pub column: usize,
 }
 
+impl Default for ErrorHandler {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl ErrorHandler {
     pub fn new() -> Self {
         Self { errors: Vec::new() }
@@ -78,3 +85,185 @@ impl ErrorHandler {
         }
     }
 }
+
+/// Collects errors recursively from statements (mirrors old utils implementation).
+pub fn collect_errors_recursively(statements: &[Statement]) -> Vec<ErrorResult> {
+    let mut errors: Vec<ErrorResult> = Vec::new();
+
+    for stmt in statements {
+        match &stmt.kind {
+            StatementKind::Unknown => {
+                errors.push(ErrorResult {
+                    message: format!("Unknown statement at line {}:{}", stmt.line, stmt.column),
+                    line: stmt.line,
+                    column: stmt.column,
+                    severity: Severity::Warning,
+                    stack: vec![StackFrame {
+                        module: None,
+                        context: Some("Unknown".to_string()),
+                        line: stmt.line,
+                        column: stmt.column,
+                    }],
+                });
+            }
+            StatementKind::Error { message } => {
+                errors.push(ErrorResult {
+                    message: message.clone(),
+                    line: stmt.line,
+                    column: stmt.column,
+                    severity: Severity::Critical,
+                    stack: vec![StackFrame {
+                        module: None,
+                        context: Some("Error".to_string()),
+                        line: stmt.line,
+                        column: stmt.column,
+                    }],
+                });
+            }
+            StatementKind::Loop => {
+                if let Some(body_statements) = extract_loop_body_statements(&stmt.value) {
+                    let nested = collect_errors_recursively(body_statements);
+                    errors.extend(nested.into_iter().map(|mut e| {
+                        e.stack.insert(
+                            0,
+                            StackFrame {
+                                module: None,
+                                context: Some("loop".to_string()),
+                                line: stmt.line,
+                                column: stmt.column,
+                            },
+                        );
+                        e
+                    }));
+                }
+            }
+            _ => {}
+        }
+    }
+
+    errors
+}
+
+fn extract_loop_body_statements(value: &Value) -> Option<&[Statement]> {
+    if let Value::Map(map) = value {
+        if let Some(Value::Block(statements)) = map.get("body") {
+            return Some(statements);
+        }
+    }
+    None
+}
+
+pub fn partition_errors(errors: Vec<ErrorResult>) -> (Vec<ErrorResult>, Vec<ErrorResult>) {
+    let mut warnings = Vec::new();
+    let mut criticals = Vec::new();
+    for e in errors {
+        match e.severity {
+            Severity::Warning => warnings.push(e),
+            Severity::Critical => criticals.push(e),
+        }
+    }
+    (warnings, criticals)
+}
+
+pub fn log_errors_with_stack(prefix: &str, warnings: &[ErrorResult], criticals: &[ErrorResult]) {
+    use devalang_utils::logger::LogLevel;
+    use devalang_utils::logger::Logger;
+
+    let logger = Logger::new();
+    if !warnings.is_empty() {
+        logger.log_message(
+            LogLevel::Warning,
+            &format!("{}: {} warning(s)", prefix, warnings.len()),
+        );
+        for w in warnings {
+            logger.log_message(LogLevel::Warning, &format!("- {}", w.message));
+            if let Some(frame) = w.stack.first() {
+                let module = frame.module.clone().unwrap_or_default();
+                logger.log_message(
+                    LogLevel::Debug,
+                    &format!(
+                        "     ↳ {}:{}:{} {}",
+                        module,
+                        frame.line,
+                        frame.column,
+                        frame.context.clone().unwrap_or_default()
+                    ),
+                );
+            }
+            if w.stack.len() > 1 {
+                for (i, f) in w.stack.iter().enumerate().skip(1) {
+                    let module = f.module.clone().unwrap_or_default();
+                    logger.log_message(
+                        LogLevel::Debug,
+                        &format!(
+                            "       #{} {}:{}:{} {}",
+                            i,
+                            module,
+                            f.line,
+                            f.column,
+                            f.context.clone().unwrap_or_default()
+                        ),
+                    );
+                }
+            }
+        }
+    }
+    if !criticals.is_empty() {
+        logger.log_message(
+            LogLevel::Error,
+            &format!("{}: {} critical error(s)", prefix, criticals.len()),
+        );
+        for c in criticals {
+            logger.log_message(LogLevel::Error, &format!("- {}", c.message));
+            if let Some(frame) = c.stack.first() {
+                let module = frame.module.clone().unwrap_or_default();
+                logger.log_message(
+                    LogLevel::Error,
+                    &format!(
+                        "     ↳ {}:{}:{} {}",
+                        module,
+                        frame.line,
+                        frame.column,
+                        frame.context.clone().unwrap_or_default()
+                    ),
+                );
+            }
+            if c.stack.len() > 1 {
+                for (i, f) in c.stack.iter().enumerate().skip(1) {
+                    let module = f.module.clone().unwrap_or_default();
+                    logger.log_message(
+                        LogLevel::Error,
+                        &format!(
+                            "       #{} {}:{}:{} {}",
+                            i,
+                            module,
+                            f.line,
+                            f.column,
+                            f.context.clone().unwrap_or_default()
+                        ),
+                    );
+                }
+            }
+        }
+    }
+}
+
+/// Collects errors from all modules and annotates stack frames with module names.
+pub fn collect_all_errors_with_modules(
+    statements_by_module: &std::collections::HashMap<String, Vec<Statement>>,
+) -> Vec<ErrorResult> {
+    let mut all: Vec<ErrorResult> = Vec::new();
+    for (module, stmts) in statements_by_module.iter() {
+        let mut errs = collect_errors_recursively(stmts);
+        for e in errs.iter_mut() {
+            // annotate first stack frame module if missing
+            if let Some(first) = e.stack.first_mut() {
+                if first.module.is_none() {
+                    first.module = Some(module.clone());
+                }
+            }
+        }
+        all.extend(errs.into_iter());
+    }
+    all
+}

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

@@ -4,7 +4,7 @@ pub fn handle_arrow_lexer(
     ch: char,
     chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    _indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize,

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

@@ -4,7 +4,7 @@ pub fn handle_at_lexer(
     ch: char,
     _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    _indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize,

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

@@ -4,7 +4,7 @@ pub fn handle_rbrace_lexer(
     ch: char,
     _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    _indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize,
@@ -24,7 +24,7 @@ pub fn handle_lbrace_lexer(
     ch: char,
     _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    _indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut [usize],
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize,