@devaloop/devalang 0.0.1-beta.1 → 0.0.1-beta.2

package/rust/core/audio/evaluator/condition.rs

@@ -0,0 +1,61 @@
+use crate::core::audio::special::resolve_env_atom;
+use devalang_types::Value;
+use devalang_types::VariableTable;
+
+pub fn evaluate_condition_string(expr: &str, vars: &VariableTable) -> bool {
+    let tokens: Vec<&str> = expr.split_whitespace().collect();
+    if tokens.len() != 3 {
+        return false;
+    }
+
+    let left = tokens[0];
+    let op = tokens[1];
+    let right = tokens[2];
+
+    // 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 = 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,
+        "==" => {
+            // 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,
+    }
+}

package/rust/core/audio/evaluator/mod.rs

@@ -0,0 +1,9 @@
+pub mod condition;
+pub mod numeric;
+pub mod rhs;
+pub mod string_expr;
+
+pub use condition::evaluate_condition_string;
+pub use numeric::evaluate_numeric_expression;
+pub use rhs::evaluate_rhs_into_value;
+pub use string_expr::evaluate_string_expression;

package/rust/core/audio/{evaluator.rs → evaluator/numeric.rs}

@@ -2,62 +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::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();
-    if tokens.len() != 3 {
-        return false;
-    }
-
-    let left = tokens[0];
-    let op = tokens[1];
-    let right = tokens[2];
-
-    // 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 = 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,
-        "==" => {
-            // 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,
-    }
-}
+use devalang_types::VariableTable;
 
 // Very small expression evaluator for `$env.*`, `$math.*` and variables.
 // Supports: +, -, *, / and simple parentheses, left-to-right (no precedence), and $math.(sin|cos)(expr)
@@ -204,107 +150,3 @@ pub fn evaluate_numeric_expression(
 
     eval(&expr, vars, env_bpm, env_beat)
 }
-
-pub fn evaluate_rhs_into_value(
-    raw: &str,
-    vars: &VariableTable,
-    env_bpm: f32,
-    env_beat: f32,
-) -> Value {
-    if let Some(num) = evaluate_numeric_expression(raw, vars, env_bpm, env_beat) {
-        Value::Number(num)
-    } else {
-        Value::String(raw.to_string())
-    }
-}
-
-// Evaluate a simple string concatenation expression like: "hello " + name + "!" + $env.beat
-// - Splits on + outside quotes
-// - Terms can be string literals (double quotes), variables (Number/String/Boolean), or numeric env/math expressions
-// Returns None if parsing fails (fallback to raw print)
-pub fn evaluate_string_expression(
-    expr: &str,
-    vars: &VariableTable,
-    env_bpm: f32,
-    env_beat: f32,
-) -> Option<String> {
-    // Quick reject if no '+' present
-    if !expr.contains('+') {
-        return None;
-    }
-
-    // Split by '+' outside of quotes
-    let mut parts: Vec<String> = Vec::new();
-    let mut cur = String::new();
-    let mut in_quotes = false;
-    let mut escape = false;
-    for ch in expr.chars() {
-        if escape {
-            cur.push(ch);
-            escape = false;
-            continue;
-        }
-        if ch == '\\' {
-            // escape next char
-            escape = true;
-            continue;
-        }
-        if ch == '"' {
-            in_quotes = !in_quotes;
-            cur.push(ch);
-            continue;
-        }
-        if ch == '+' && !in_quotes {
-            parts.push(cur.to_string());
-            cur.clear();
-            continue;
-        }
-        cur.push(ch);
-    }
-    if !cur.is_empty() {
-        parts.push(cur.to_string());
-    }
-    if parts.is_empty() {
-        return None;
-    }
-
-    // Resolve each part into a string
-    fn strip_quotes(s: &str) -> Option<String> {
-        let st = s.trim();
-        if st.len() >= 2 && st.starts_with('"') && st.ends_with('"') {
-            Some(st[1..st.len() - 1].to_string())
-        } else {
-            None
-        }
-    }
-
-    let mut out = String::new();
-    for p in parts {
-        if p.is_empty() {
-            continue;
-        }
-        if let Some(lit) = strip_quotes(&p) {
-            out.push_str(&lit);
-            continue;
-        }
-        // Try variables first
-        if let Some(val) = vars.get(&p) {
-            match val {
-                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;
-        }
-        // Try env/math/numeric expression for this term
-        if let Some(n) = evaluate_numeric_expression(&p, vars, env_bpm, env_beat) {
-            out.push_str(&format!("{}", n));
-            continue;
-        }
-        // Bareword not resolved: include as-is (safe fallback)
-        out.push_str(&p);
-    }
-
-    Some(out)
-}

package/rust/core/audio/evaluator/rhs.rs

@@ -0,0 +1,16 @@
+use crate::core::audio::evaluator::numeric::evaluate_numeric_expression;
+use devalang_types::Value;
+use devalang_types::VariableTable;
+
+pub fn evaluate_rhs_into_value(
+    raw: &str,
+    vars: &VariableTable,
+    env_bpm: f32,
+    env_beat: f32,
+) -> Value {
+    if let Some(num) = evaluate_numeric_expression(raw, vars, env_bpm, env_beat) {
+        Value::Number(num)
+    } else {
+        Value::String(raw.to_string())
+    }
+}

package/rust/core/audio/evaluator/string_expr.rs

@@ -0,0 +1,94 @@
+use crate::core::audio::evaluator::numeric::evaluate_numeric_expression;
+use devalang_types::Value;
+use devalang_types::VariableTable;
+
+// Evaluate a simple string concatenation expression like: "hello " + name + "!" + $env.beat
+// - Splits on + outside quotes
+// - Terms can be string literals (double quotes), variables (Number/String/Boolean), or numeric env/math expressions
+// Returns None if parsing fails (fallback to raw print)
+pub fn evaluate_string_expression(
+    expr: &str,
+    vars: &VariableTable,
+    env_bpm: f32,
+    env_beat: f32,
+) -> Option<String> {
+    // Quick reject if no '+' present
+    if !expr.contains('+') {
+        return None;
+    }
+
+    // Split by '+' outside of quotes
+    let mut parts: Vec<String> = Vec::new();
+    let mut cur = String::new();
+    let mut in_quotes = false;
+    let mut escape = false;
+    for ch in expr.chars() {
+        if escape {
+            cur.push(ch);
+            escape = false;
+            continue;
+        }
+        if ch == '\\' {
+            // escape next char
+            escape = true;
+            continue;
+        }
+        if ch == '"' {
+            in_quotes = !in_quotes;
+            cur.push(ch);
+            continue;
+        }
+        if ch == '+' && !in_quotes {
+            parts.push(cur.to_string());
+            cur.clear();
+            continue;
+        }
+        cur.push(ch);
+    }
+    if !cur.is_empty() {
+        parts.push(cur.to_string());
+    }
+    if parts.is_empty() {
+        return None;
+    }
+
+    // Resolve each part into a string
+    fn strip_quotes(s: &str) -> Option<String> {
+        let st = s.trim();
+        if st.len() >= 2 && st.starts_with('"') && st.ends_with('"') {
+            Some(st[1..st.len() - 1].to_string())
+        } else {
+            None
+        }
+    }
+
+    let mut out = String::new();
+    for p in parts {
+        if p.is_empty() {
+            continue;
+        }
+        if let Some(lit) = strip_quotes(&p) {
+            out.push_str(&lit);
+            continue;
+        }
+        // Try variables first
+        if let Some(val) = vars.get(&p) {
+            match val {
+                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;
+        }
+        // Try env/math/numeric expression for this term
+        if let Some(n) = evaluate_numeric_expression(&p, vars, env_bpm, env_beat) {
+            out.push_str(&format!("{}", n));
+            continue;
+        }
+        // Bareword not resolved: include as-is (safe fallback)
+        out.push_str(&p);
+    }
+
+    Some(out)
+}

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

@@ -5,22 +5,32 @@ use rayon::prelude::*;
 use crate::core::{
     audio::{
         engine::AudioEngine,
-        interpreter::{
-            arrow_call::interprete_call_arrow_statement, call::interprete_call_statement,
-            function::interprete_function_statement, let_::interprete_let_statement,
-            load::interprete_load_statement, loop_::interprete_loop_statement,
-            sleep::interprete_sleep_statement, spawn::interprete_spawn_statement,
-            tempo::interprete_tempo_statement, trigger::interprete_trigger_statement,
+        interpreter::statements::{
+            arrow_call::interprete::interprete_arrow_call_statement,
+            call::interprete_call_statement, function::interprete_function_statement,
+            let_::interprete_let_statement, load::interprete_load_statement,
+            loop_::interprete_loop_statement, sleep::interprete_sleep_statement,
+            spawn::interprete_spawn_statement, tempo::interprete_tempo_statement,
+            trigger::interprete_trigger_statement,
         },
     },
     parser::statement::{Statement, StatementKind},
-    store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
+    store::global::GlobalStore,
 };
+use devalang_types::{FunctionTable, VariableTable};
 
 // WASM playhead callback support (only compiled for wasm32 target)
 #[cfg(target_arch = "wasm32")]
 use serde::Serialize;
 
+#[cfg(target_arch = "wasm32")]
+#[derive(Serialize, Clone)]
+pub struct PlayheadEvent {
+    time: f32,
+    line: usize,
+    column: usize,
+}
+
 #[cfg(target_arch = "wasm32")]
 use wasm_bindgen::prelude::JsValue;
 
@@ -30,28 +40,33 @@ use std::cell::RefCell;
 #[cfg(target_arch = "wasm32")]
 thread_local! {
     static PLAYHEAD_CB: RefCell<Option<js_sys::Function>> = RefCell::new(None);
+    static PLAYHEAD_EVENTS: RefCell<Vec<PlayheadEvent>> = RefCell::new(Vec::new());
 }
 
 #[cfg(target_arch = "wasm32")]
 pub fn register_playhead_callback(cb: js_sys::Function) {
-    PLAYHEAD_CB.with(|c| *c.borrow_mut() = Some(cb));
+    PLAYHEAD_CB.with(|c| {
+        *c.borrow_mut() = Some(cb);
+    });
 }
 
 #[cfg(target_arch = "wasm32")]
 pub fn unregister_playhead_callback() {
-    PLAYHEAD_CB.with(|c| *c.borrow_mut() = None);
+    PLAYHEAD_CB.with(|c| {
+        *c.borrow_mut() = None;
+    });
 }
 
 #[cfg(target_arch = "wasm32")]
-fn emit_playhead(time: f32, line: usize, column: usize) {
-    #[derive(Serialize)]
-    struct PlayheadEvent {
-        time: f32,
-        line: usize,
-        column: usize,
-    }
+pub fn collect_playhead_events() -> Vec<PlayheadEvent> {
+    PLAYHEAD_EVENTS.with(|c| c.borrow().clone())
+}
 
+#[cfg(target_arch = "wasm32")]
+fn emit_playhead(time: f32, line: usize, column: usize) {
     let ev = PlayheadEvent { time, line, column };
+    PLAYHEAD_EVENTS.with(|c| c.borrow_mut().push(ev.clone()));
+
     if let Ok(v) = serde_wasm_bindgen::to_value(&ev) {
         PLAYHEAD_CB.with(|c| {
             if let Some(f) = c.borrow().as_ref() {
@@ -70,6 +85,13 @@ pub fn run_audio_program(
     _module_functions: FunctionTable,
     global_store: &mut GlobalStore,
 ) -> (f32, f32) {
+    // Clear any previously collected playhead events for wasm target so each
+    // run starts with an empty events buffer.
+    #[cfg(target_arch = "wasm32")]
+    {
+        PLAYHEAD_EVENTS.with(|c| c.borrow_mut().clear());
+    }
+
     let base_bpm = 120.0;
     let base_duration = 60.0 / base_bpm;
 
@@ -232,7 +254,7 @@ pub fn execute_audio_block(
                 max_end_time = new_max;
             }
             StatementKind::ArrowCall { .. } => {
-                let (new_max, new_cursor) = interprete_call_arrow_statement(
+                let (new_max, new_cursor) = interprete_arrow_call_statement(
                     stmt,
                     audio_engine,
                     &variable_table,
@@ -250,11 +272,12 @@ pub fn execute_audio_block(
                 }
             }
             StatementKind::Automate { .. } => {
-                if let Some(new_table) =
-                    crate::core::audio::interpreter::automate::interprete_automate_statement(
-                        stmt,
-                        &mut variable_table,
-                    )
+                if
+                    let Some(new_table) =
+                        crate::core::audio::interpreter::statements::automate::interprete_automate_statement(
+                            stmt,
+                            &mut variable_table
+                        )
                 {
                     variable_table = new_table;
                 }
@@ -338,9 +361,18 @@ pub fn execute_audio_block(
         }
 
         // Emit playhead event for UI bindings when building real-time playback
+        // Only emit for statements that are "playable" (i.e., schedule audio)
         #[cfg(target_arch = "wasm32")]
         {
-            emit_playhead(cursor_time, stmt.line, stmt.column);
+            if matches!(
+                stmt.kind,
+                StatementKind::Trigger { .. }
+                    | StatementKind::Call { .. }
+                    | StatementKind::Spawn { .. }
+                    | StatementKind::Loop
+            ) {
+                emit_playhead(cursor_time, stmt.line, stmt.column);
+            }
         }
     }
 

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

@@ -1,14 +1,2 @@
 pub mod driver;
-
-pub mod arrow_call;
-pub mod automate;
-pub mod call;
-pub mod condition;
-pub mod function;
-pub mod let_;
-pub mod load;
-pub mod loop_;
-pub mod sleep;
-pub mod spawn;
-pub mod tempo;
-pub mod trigger;
+pub mod statements;

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

@@ -0,0 +1,175 @@
+use crate::core::{
+    audio::{
+        engine::AudioEngine,
+        interpreter::statements::arrow_call::methods::{
+            chord::interprete_chord_method, note::interprete_note_method,
+        },
+    },
+    parser::statement::{Statement, StatementKind},
+    store::global::GlobalStore,
+};
+use devalang_types::{Value, VariableTable};
+use devalang_utils::logger::{LogLevel, Logger};
+
+use std::collections::HashMap;
+
+pub fn interprete_arrow_call_statement(
+    stmt: &Statement,
+    audio_engine: &mut AudioEngine,
+    variable_table: &VariableTable,
+    global_store: &GlobalStore,
+    base_bpm: f32,
+    base_duration: f32,
+    max_end_time: &mut f32,
+    cursor_time: Option<&mut f32>,
+    update_cursor: bool,
+) -> (f32, f32) {
+    let cursor_copy = cursor_time.as_ref().map(|c| **c).unwrap_or(0.0);
+
+    if let StatementKind::ArrowCall {
+        target,
+        method,
+        args,
+    } = &stmt.kind
+    {
+        let Some(Value::Statement(synth_stmt)) = variable_table.get(target) else {
+            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 {
+            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 {
+            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" {
+            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 {
+            let logger = Logger::new();
+            logger.log_message(
+                LogLevel::Error,
+                &format!("Missing 'value' map 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);
+        };
+
+        // Synth parameters (mutable so we can apply type presets)
+        let mut synth_params = params.clone();
+
+        // Apply type defaults using the modular types module
+        crate::core::audio::interpreter::statements::arrow_call::types::apply_type(
+            &mut synth_params,
+        );
+
+        let amp = extract_f32(&synth_params, "amp", base_bpm).unwrap_or(1.0);
+
+        match method.as_str() {
+            "note" => {
+                return interprete_note_method(
+                    args,
+                    target,
+                    audio_engine,
+                    variable_table,
+                    global_store,
+                    &waveform_str,
+                    &synth_params,
+                    amp,
+                    base_bpm,
+                    base_duration,
+                    max_end_time,
+                    cursor_time,
+                    cursor_copy,
+                    update_cursor,
+                );
+            }
+
+            "chord" => {
+                return interprete_chord_method(
+                    args,
+                    target,
+                    audio_engine,
+                    variable_table,
+                    global_store,
+                    &waveform_str,
+                    &synth_params,
+                    amp,
+                    base_bpm,
+                    base_duration,
+                    max_end_time,
+                    cursor_time,
+                    cursor_copy,
+                    update_cursor,
+                );
+            }
+
+            _ => {
+                let logger = Logger::new();
+                logger.log_message(
+                    LogLevel::Error,
+                    &format!("Unknown method '{}' on synth '{}'.", method, target),
+                );
+            }
+        }
+    }
+
+    (*max_end_time, cursor_copy)
+}
+
+fn extract_f32(map: &HashMap<String, Value>, key: &str, base_bpm: f32) -> Option<f32> {
+    map.get(key).and_then(|v| match v {
+        Value::Number(n) => Some(*n),
+        Value::Beat(beat_str) => {
+            let parts: Vec<&str> = beat_str.split('/').collect();
+            if parts.len() == 2 {
+                let numerator = parts[0].parse::<f32>().ok()?;
+                let denominator = parts[1].parse::<f32>().ok()?;
+
+                Some((numerator / denominator) * ((60.0 / base_bpm) * 1000.0))
+            } else {
+                None
+            }
+        }
+        _ => None,
+    })
+}