@devaloop/devalang 0.0.1-alpha.16-hotfix.3 → 0.0.1-alpha.18

package/rust/core/audio/evaluator.rs

@@ -2,7 +2,8 @@ use crate::core::audio::special::{
     find_and_eval_first_easing_call, find_and_eval_first_math_call, find_and_eval_first_mod_call,
     resolve_env_atom,
 };
-use crate::core::{shared::value::Value, store::variable::VariableTable};
+use crate::core::store::variable::VariableTable;
+use devalang_types::Value;
 
 pub fn evaluate_condition_string(expr: &str, vars: &VariableTable) -> bool {
     let tokens: Vec<&str> = expr.split_whitespace().collect();
@@ -14,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,
+        "==" => {
+            // 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,
     }
 }
@@ -61,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
@@ -148,7 +187,9 @@ pub fn evaluate_numeric_expression(
                     }
                 }
                 (Some(_), None) => val,
-                _ => return None,
+                _ => {
+                    return None;
+                }
             });
         }
 
@@ -243,9 +284,9 @@ pub fn evaluate_string_expression(
         // Try variables first
         if let Some(val) = vars.get(&p) {
             match val {
-                crate::core::shared::value::Value::String(s) => out.push_str(s),
-                crate::core::shared::value::Value::Number(n) => out.push_str(&format!("{}", n)),
-                crate::core::shared::value::Value::Boolean(b) => out.push_str(&format!("{}", b)),
+                Value::String(s) => out.push_str(s),
+                Value::Number(n) => out.push_str(&format!("{}", n)),
+                Value::Boolean(b) => out.push_str(&format!("{}", b)),
                 other => out.push_str(&format!("{:?}", other)),
             }
             continue;

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

@@ -1,9 +1,11 @@
 use crate::core::{
     audio::engine::AudioEngine,
     parser::statement::{Statement, StatementKind},
-    shared::value::Value,
-    store::variable::VariableTable,
+    plugin::runner::WasmPluginRunner,
+    store::{global::GlobalStore, variable::VariableTable},
 };
+use devalang_types::Value;
+use devalang_utils::logger::{Logger, LogLevel};
 
 use std::collections::HashMap;
 
@@ -11,6 +13,7 @@ pub fn interprete_call_arrow_statement(
     stmt: &Statement,
     audio_engine: &mut AudioEngine,
     variable_table: &VariableTable,
+    global_store: &GlobalStore,
     base_bpm: f32,
     base_duration: f32,
     max_end_time: &mut f32,
@@ -26,38 +29,44 @@ 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);
         };
 
-        let Some(Value::String(waveform)) = value_map.get("waveform") else {
-            println!("❌ Missing or invalid 'waveform' in synth '{}'.", target);
-            return (*max_end_time, cursor_copy);
+        let waveform_str = match value_map.get("waveform") {
+            Some(Value::String(s)) => s.clone(),
+            Some(Value::Identifier(s)) => s.clone(),
+            _ => {
+                let logger = Logger::new();
+                logger.log_message(LogLevel::Error, &format!("Missing or invalid 'waveform' in synth '{}'.", target));
+                return (*max_end_time, cursor_copy);
+            }
         };
-
         let Some(Value::Map(params)) = value_map.get("parameters") else {
             println!("❌ Missing or invalid 'parameters' in synth '{}'.", target);
             return (*max_end_time, cursor_copy);
@@ -73,7 +82,7 @@ pub fn interprete_call_arrow_statement(
                 .filter(|arg| !matches!(arg, Value::Unknown))
                 .collect();
 
-            let Some(Value::Identifier(note_name)) = filtered_args.get(0).map(|v| (*v).clone())
+            let Some(Value::Identifier(note_name)) = filtered_args.first().map(|v| (*v).clone())
             else {
                 println!(
                     "❌ Invalid or missing argument for 'note' method on '{}'.",
@@ -84,13 +93,10 @@ pub fn interprete_call_arrow_statement(
 
             let mut note_params = HashMap::new();
             if let Some(arg1) = filtered_args.get(1) {
-                match (*arg1).clone() {
-                    Value::Map(map) => {
-                        for (key, value) in map {
-                            note_params.insert(key, value);
-                        }
+                if let Value::Map(map) = (*arg1).clone() {
+                    for (key, value) in map {
+                        note_params.insert(key, value);
                     }
-                    _ => {}
                 }
             }
 
@@ -134,16 +140,89 @@ pub fn interprete_call_arrow_statement(
                 _ => None,
             };
 
-            audio_engine.insert_note(
-                waveform.clone(),
-                final_freq,
-                amp_note,
-                start_time * 1000.0,
-                duration_ms,
-                synth_params,
-                note_params,
-                automation,
-            );
+            // If waveform references a plugin alias (e.g., alias.synth), use the WASM plugin runner
+            if waveform_str.contains('.') && waveform_str.ends_with(".synth") {
+                let alias = waveform_str.split('.').next().unwrap_or("");
+                if let Some(Value::String(uri)) = variable_table.get(alias) {
+                    if let Some(id) = uri.strip_prefix("devalang://plugin/") {
+                        let mut parts = id.split('.');
+                        let author = parts.next().unwrap_or("");
+                        let name = parts.next().unwrap_or("");
+                        let key = format!("{}:{}", author, name);
+                        if let Some((_info, wasm_bytes)) = global_store.plugins.get(&key) {
+                            // Prepare buffer (stereo f32)
+                            let sample_rate = 44100.0_f32;
+                            let total_samples = ((duration_ms / 1000.0) * sample_rate) as usize;
+                            let channels = 2usize;
+                            let start_index = ((start_time * sample_rate) as usize) * channels;
+                            let required_len = start_index + total_samples * channels;
+                            if audio_engine.buffer.len() < required_len {
+                                audio_engine.buffer.resize(required_len, 0);
+                            }
+                            let mut fbuf = vec![0.0f32; total_samples * channels];
+                            let runner = WasmPluginRunner::new();
+                            let mut params_num: std::collections::HashMap<String, f32> =
+                                std::collections::HashMap::new();
+                            let mut params_str: std::collections::HashMap<String, String> =
+                                std::collections::HashMap::new();
+                            for (k, v) in synth_params.iter() {
+                                match v {
+                                    Value::Number(n) => {
+                                        params_num.insert(k.clone(), *n);
+                                    }
+                                    Value::String(s) => {
+                                        params_str.insert(k.clone(), s.clone());
+                                    }
+                                    Value::Identifier(s) => {
+                                        params_str.insert(k.clone(), s.clone());
+                                    }
+                                    _ => {}
+                                }
+                            }
+                            let _ = runner.render_note_with_params_in_place(
+                                wasm_bytes,
+                                &mut fbuf,
+                                None,
+                                final_freq,
+                                amp_note,
+                                duration_ms as i32,
+                                44100,
+                                2,
+                                &params_num,
+                                Some(&params_str),
+                            );
+                            for (i, sample) in
+                                fbuf.iter().enumerate().take(total_samples * channels)
+                            {
+                                let s = (sample.clamp(-1.0, 1.0) * (i16::MAX as f32)) as i16;
+                                let idx = start_index + i;
+                                audio_engine.buffer[idx] =
+                                    audio_engine.buffer[idx].saturating_add(s);
+                            }
+                        } else {
+                            let logger = Logger::new();
+                            logger.log_message(LogLevel::Warning, &format!("Plugin bytes not found for key '{}' (alias '{}').", key, alias));
+                        }
+                    } else {
+                        let logger = Logger::new();
+                        logger.log_message(LogLevel::Warning, &format!("Invalid plugin URI in alias '{}': {}", alias, uri));
+                    }
+                } else {
+                    let logger = Logger::new();
+                    logger.log_message(LogLevel::Warning, &format!("Plugin alias '{}' not found in variable table.", alias));
+                }
+            } else {
+                audio_engine.insert_note(
+                    waveform_str.clone(),
+                    final_freq,
+                    amp_note,
+                    start_time * 1000.0,
+                    duration_ms,
+                    synth_params,
+                    note_params,
+                    automation,
+                );
+            }
 
             *max_end_time = (*max_end_time).max(end_time);
 
@@ -155,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));
         }
     }
 
@@ -181,7 +261,7 @@ fn extract_f32(map: &HashMap<String, Value>, key: &str, base_bpm: f32) -> Option
 }
 
 fn note_to_freq(note: &str) -> f32 {
-    let notes = vec![
+    let notes = [
         "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B",
     ];