@devaloop/devalang 0.0.1-alpha.8 → 0.0.1-beta.1

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

@@ -0,0 +1,311 @@
+use crate::core::{
+    audio::engine::AudioEngine,
+    parser::statement::{Statement, StatementKind},
+    plugin::runner::WasmPluginRunner,
+    store::{global::GlobalStore, variable::VariableTable},
+};
+use devalang_types::Value;
+use devalang_utils::logger::{LogLevel, Logger};
+
+use std::collections::HashMap;
+
+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,
+    mut 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
+        let synth_params = params.clone();
+        let amp = extract_f32(&synth_params, "amp", base_bpm).unwrap_or(1.0);
+
+        if method == "note" {
+            let filtered_args: Vec<_> = args
+                .iter()
+                .filter(|arg| !matches!(arg, Value::Unknown))
+                .collect();
+
+            let Some(Value::Identifier(note_name)) = filtered_args.first().map(|v| (*v).clone())
+            else {
+                println!(
+                    "❌ Invalid or missing argument for 'note' method on '{}'.",
+                    target
+                );
+                return (*max_end_time, cursor_copy);
+            };
+
+            let mut note_params = HashMap::new();
+            if let Some(arg1) = filtered_args.get(1) {
+                if let Value::Map(map) = (*arg1).clone() {
+                    for (key, value) in map {
+                        note_params.insert(key, value);
+                    }
+                }
+            }
+
+            // Note parameters and calculations
+            let amp_note = extract_f32(&note_params, "amp", base_bpm).unwrap_or(amp);
+            let duration_ms =
+                extract_f32(&note_params, "duration", base_bpm).unwrap_or(base_duration * 1000.0);
+
+            let duration_secs = duration_ms / 1000.0;
+            let final_freq = note_to_freq(&note_name);
+            let start_time = cursor_copy;
+            let end_time = start_time + duration_secs;
+
+            // Fetch automation map if present:
+            // - Global (per-synth): key "<target>__automation" => map with key "params"
+            // - Per-note: note parameter "automate" => map
+            let auto_key = format!("{}__automation", target);
+            let synth_automation = match variable_table.get(&auto_key) {
+                Some(Value::Map(map)) => match map.get("params") {
+                    Some(Value::Map(p)) => Some(p.clone()),
+                    _ => None,
+                },
+                _ => None,
+            };
+
+            let note_automation = match note_params.get("automate") {
+                Some(Value::Map(m)) => Some(m.clone()),
+                _ => None,
+            };
+
+            // Merge: per-note overrides synth automation per key (volume/pan/pitch)
+            let automation = match (synth_automation, note_automation) {
+                (Some(mut a), Some(n)) => {
+                    for (k, v) in n {
+                        a.insert(k, v);
+                    }
+                    Some(a)
+                }
+                (None, Some(n)) => Some(n),
+                (Some(a), None) => Some(a),
+                _ => None,
+            };
+
+            // 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);
+
+            if update_cursor {
+                if let Some(c) = cursor_time.as_mut() {
+                    **c = end_time;
+                }
+            }
+
+            return (*max_end_time, end_time);
+        } else {
+            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,
+    })
+}
+
+fn note_to_freq(note: &str) -> f32 {
+    let notes = [
+        "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B",
+    ];
+
+    if note.len() < 2 || note.len() > 3 {
+        return 440.0;
+    }
+
+    let (name, octave_str) = note.split_at(note.len() - 1);
+    let semitone = notes.iter().position(|&n| n == name).unwrap_or(9) as i32;
+    let octave = octave_str.parse::<i32>().unwrap_or(4);
+    let midi_note = (octave + 1) * 12 + semitone;
+
+    440.0 * (2.0_f32).powf(((midi_note as f32) - 69.0) / 12.0)
+}

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

@@ -0,0 +1,18 @@
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    store::variable::VariableTable,
+};
+
+// Store automation configuration into the variable table under a namespaced key
+// Key: "<target>__automation" => Value::Map({ target, params })
+pub fn interprete_automate_statement(
+    stmt: &Statement,
+    variable_table: &mut VariableTable,
+) -> Option<VariableTable> {
+    if let StatementKind::Automate { target } = &stmt.kind {
+        let key = format!("{}__automation", target);
+        variable_table.set(key, stmt.value.clone());
+        return Some(variable_table.clone());
+    }
+    None
+}

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

@@ -1,42 +1,294 @@
-use crate::core::{
-    audio::{ engine::AudioEngine, interpreter::{ driver::execute_audio_block } },
-    parser::statement::{ Statement, StatementKind },
-    shared::{ duration::Duration, value::Value },
-    store::variable::VariableTable,
-};
-
-pub fn interprete_call_statement(
-    stmt: &Statement,
-    audio_engine: AudioEngine,
-    variable_table: VariableTable,
-    base_bpm: f32,
-    base_duration: f32,
-    max_end_time: f32,
-    cursor_time: f32
-) -> (AudioEngine, f32, f32) {
-    if let Value::String(identifier) = &stmt.value {
-        if let Some(Value::Map(map)) = variable_table.clone().get(identifier) {
-            if let Some(Value::Block(block)) = map.get("body") {
-                let (eng, _, end_time) = execute_audio_block(
-                    audio_engine,
-                    variable_table,
-                    block.clone(),
-                    base_bpm,
-                    base_duration,
-                    max_end_time,
-                    cursor_time
-                );
-
-                return (eng, max_end_time.max(end_time), end_time);
-            } else {
-                eprintln!("❌ 'body' must be a block");
-            }
-        } else {
-            eprintln!("❌ Call target '{}' not found or invalid", identifier);
-        }
-    } else {
-        eprintln!("❌ Invalid call statement: expected string identifier");
-    }
-
-    (audio_engine, max_end_time, cursor_time)
-}
+use devalang_types::{Duration, Value};
+
+use crate::core::{
+    audio::{engine::AudioEngine, interpreter::driver::execute_audio_block},
+    parser::statement::{Statement, StatementKind},
+    store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
+};
+
+pub fn interprete_call_statement(
+    stmt: &Statement,
+    audio_engine: &mut AudioEngine,
+    variable_table: &VariableTable,
+    functions: &FunctionTable,
+    global_store: &GlobalStore,
+    base_bpm: f32,
+    base_duration: f32,
+    max_end_time: f32,
+    cursor_time: f32,
+) -> (f32, f32) {
+    if let StatementKind::Call { name, args } = &stmt.kind {
+        // Classic function call case
+        if let Some(func) = functions.functions.get(name) {
+            // function found
+            if func.parameters.len() != args.len() {
+                eprintln!(
+                    "❌ Function '{}' expects {} args, got {}",
+                    name,
+                    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());
+            }
+
+            return execute_audio_block(
+                audio_engine,
+                global_store,
+                local_vars,
+                functions.clone(),
+                &func.body,
+                base_bpm,
+                base_duration,
+                max_end_time,
+                cursor_time,
+            );
+        }
+
+        // Group case
+        if let Some(group_stmt) = find_group(name, variable_table, global_store) {
+            // group found
+            if let Value::Map(map) = &group_stmt.value {
+                if let Some(Value::Block(body)) = map.get("body") {
+                    return execute_audio_block(
+                        audio_engine,
+                        global_store,
+                        variable_table.clone(),
+                        functions.clone(),
+                        body,
+                        base_bpm,
+                        base_duration,
+                        max_end_time,
+                        cursor_time,
+                    );
+                }
+            }
+        }
+
+        // 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
+    }
+
+    (max_end_time, cursor_time)
+}
+
+fn find_group(
+    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::Group = 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::Group = stmt_box.kind {
+                    return Some(*stmt_box.clone());
+                }
+            }
+            Value::Map(map) => {
+                // Try to rebuild a Group statement from the stored map
+                if let (Some(Value::String(_id)), Some(Value::Block(_body))) =
+                    (map.get("identifier"), map.get("body"))
+                {
+                    let stmt = Statement {
+                        kind: StatementKind::Group,
+                        value: Value::Map(map.clone()),
+                        indent: 0,
+                        line: 0,
+                        column: 0,
+                    };
+                    return Some(stmt);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    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
+}