@devaloop/devalang 0.0.1-beta.3 → 0.1.1

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

@@ -1,325 +0,0 @@
-use devalang_types::{Duration, Value};
-
-use crate::core::{
-    audio::{engine::AudioEngine, interpreter::driver::execute_audio_block},
-    parser::statement::{Statement, StatementKind},
-    store::global::GlobalStore,
-};
-use devalang_types::store::{FunctionTable, 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: &devalang_types::VariableTable,
-                ) -> devalang_types::VariableTable {
-                    devalang_types::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
-
-                // extract optional swing/humanize from pattern_stmt.value
-                let mut swing: f32 = 0.0;
-                let mut humanize: f32 = 0.0;
-                if let Value::Map(m) = &pattern_stmt.value {
-                    if let Some(Value::Number(s)) = m.get("swing") {
-                        swing = *s;
-                    }
-                    if let Some(Value::Number(h)) = m.get("humanize") {
-                        humanize = *h;
-                    }
-                }
-
-                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 mut event_time = cursor_time + (i as f32) * step_duration;
-                    if swing.abs() > 0.0001 {
-                        if i % 2 == 1 {
-                            event_time += swing * step_duration;
-                        } else {
-                            event_time -= swing * step_duration;
-                        }
-                    }
-
-                    if humanize.abs() > 0.0001 {
-                        let jitter_range = humanize * step_duration;
-                        let seed = (audio_engine.module_name.len() + i) as u64
-                            + (event_time.to_bits() as u64);
-                        let mut x = seed.wrapping_mul(0x9E3779B97F4A7C15).rotate_left(13);
-                        x ^= x >> 7;
-                        let r = (x as i64 % 1000) as f32 / 1000.0;
-                        let jitter = (r * 2.0 - 1.0) * jitter_range / 2.0;
-                        event_time += jitter;
-                    }
-
-                    // 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
-}

package/rust/core/audio/interpreter/statements/condition.rs

@@ -1,72 +0,0 @@
-use devalang_types::Value;
-
-use crate::core::{
-    audio::{
-        engine::AudioEngine, evaluator::evaluate_condition_string,
-        interpreter::driver::execute_audio_block,
-    },
-    parser::statement::Statement,
-    store::global::GlobalStore,
-};
-use devalang_types::store::{FunctionTable, VariableTable};
-
-pub fn interprete_condition_statement(
-    stmt: &Statement,
-    audio_engine: &mut AudioEngine,
-    global_store: &GlobalStore,
-    variable_table: &VariableTable,
-    functions_table: &FunctionTable,
-    base_bpm: f32,
-    base_duration: f32,
-    max_end_time: f32,
-    cursor_time: f32,
-) -> (f32, f32) {
-    let cur_time = cursor_time;
-    let max_time = max_end_time;
-
-    let mut current = stmt.value.clone();
-
-    loop {
-        let Value::Map(map) = current else {
-            break;
-        };
-
-        let should_execute = match map.get("condition") {
-            Some(Value::Boolean(b)) => *b,
-            Some(Value::String(expr)) => evaluate_condition_string(expr, &variable_table.clone()),
-            Some(_) => false,
-            None => true,
-        };
-
-        if should_execute {
-            if let Some(Value::Block(block)) = map.get("body") {
-                let (new_max, cursor_time) = execute_audio_block(
-                    audio_engine,
-                    global_store,
-                    variable_table.clone(),
-                    functions_table.clone(),
-                    block,
-                    base_bpm,
-                    base_duration,
-                    max_time,
-                    cur_time,
-                );
-                return (new_max, cursor_time);
-            } else {
-                break;
-            }
-        }
-
-        // Advance to the next condition
-        match map.get("next") {
-            Some(Value::Map(next_map)) => {
-                current = Value::Map(next_map.clone());
-            }
-            _ => {
-                break;
-            }
-        }
-    }
-
-    (max_end_time, cursor_time)
-}

package/rust/core/audio/interpreter/statements/function.rs

@@ -1,24 +0,0 @@
-use crate::core::parser::statement::{Statement, StatementKind};
-use devalang_types::store::{FunctionDef, FunctionTable};
-
-pub fn interprete_function_statement(
-    stmt: &Statement,
-    functions_table: &mut FunctionTable,
-) -> Option<FunctionTable> {
-    if let StatementKind::Function {
-        name,
-        parameters,
-        body,
-    } = &stmt.kind
-    {
-        functions_table.add_function(FunctionDef {
-            name: name.clone(),
-            parameters: parameters.clone(),
-            body: body.clone(),
-        });
-
-        return Some(functions_table.clone());
-    }
-
-    None
-}

package/rust/core/audio/interpreter/statements/let_.rs

@@ -1,36 +0,0 @@
-use crate::core::parser::statement::{Statement, StatementKind};
-use devalang_types::Value;
-use devalang_types::store::VariableTable;
-
-pub fn interprete_let_statement(
-    stmt: &Statement,
-    variable_table: &mut VariableTable,
-) -> Option<VariableTable> {
-    if let StatementKind::Let { name } = &stmt.kind {
-        // If RHS is a string and looks like an expression, evaluate it
-        let evaluated = match &stmt.value {
-            Value::String(s) if s.contains("$env") || s.contains("$math") => {
-                // We don't have direct env here; use defaults or infer from table
-                let bpm = if let Some(Value::Number(n)) = variable_table.get("bpm") {
-                    *n
-                } else {
-                    120.0
-                };
-                // Try to infer beat from time-based variables if any, else 0.0
-                let beat = if let Some(Value::Number(n)) = variable_table.get("beat") {
-                    *n
-                } else {
-                    0.0
-                };
-                crate::core::audio::evaluator::evaluate_rhs_into_value(s, variable_table, bpm, beat)
-            }
-            other => other.clone(),
-        };
-
-        variable_table.set(name.to_string(), evaluated);
-
-        return Some(variable_table.clone());
-    }
-
-    None
-}

package/rust/core/audio/interpreter/statements/load.rs

@@ -1,17 +0,0 @@
-use devalang_types::Value;
-
-use crate::core::parser::statement::{Statement, StatementKind};
-use devalang_types::store::VariableTable;
-
-pub fn interprete_load_statement(
-    stmt: &Statement,
-    variable_table: &mut VariableTable,
-) -> Option<VariableTable> {
-    if let StatementKind::Load { source, alias } = &stmt.kind {
-        variable_table.set(alias.to_string(), Value::Sample(source.clone()));
-
-        return Some(variable_table.clone());
-    }
-
-    None
-}

package/rust/core/audio/interpreter/statements/loop_.rs

@@ -1,115 +0,0 @@
-use devalang_types::Value;
-
-use crate::core::{
-    audio::{engine::AudioEngine, interpreter::driver::execute_audio_block},
-    parser::statement::Statement,
-    store::global::GlobalStore,
-};
-use devalang_types::store::{FunctionTable, VariableTable};
-
-pub fn interprete_loop_statement(
-    stmt: &Statement,
-    audio_engine: &mut AudioEngine,
-    global_store: &GlobalStore,
-    variable_table: &VariableTable,
-    functions_table: &FunctionTable,
-    base_bpm: f32,
-    base_duration: f32,
-    max_end_time: f32,
-    cursor_time: f32,
-) -> (f32, f32) {
-    if let Value::Map(loop_value) = &stmt.value {
-        // Foreach form: { foreach: Identifier(name), array: Array([...]), body: Block }
-        if let (
-            Some(Value::Identifier(var_name)),
-            Some(Value::Array(items)),
-            Some(Value::Block(loop_body)),
-        ) = (
-            loop_value.get("foreach"),
-            loop_value.get("array"),
-            loop_value.get("body"),
-        ) {
-            let engine = audio_engine;
-            let mut cur_time = cursor_time;
-            let mut max_time = max_end_time;
-
-            for item in items {
-                let mut scoped_vars = variable_table.clone();
-                scoped_vars.set(var_name.clone(), item.clone());
-
-                let (block_end_time, new_cursor) = execute_audio_block(
-                    engine,
-                    global_store,
-                    scoped_vars,
-                    functions_table.clone(),
-                    loop_body,
-                    base_bpm,
-                    base_duration,
-                    max_time,
-                    cur_time,
-                );
-
-                cur_time = new_cursor.max(block_end_time);
-                max_time = max_time.max(cur_time);
-            }
-
-            return (max_time, cur_time);
-        }
-
-        let loop_count = match loop_value.get("iterator") {
-            Some(Value::Number(n)) => *n as usize,
-            Some(Value::Identifier(ident)) => {
-                if let Some(Value::Number(n)) = variable_table.get(ident) {
-                    *n as usize
-                } else {
-                    eprintln!("❌ Loop iterator must be a number, found: {:?}", ident);
-                    return (max_end_time, cursor_time);
-                }
-            }
-            _ => {
-                eprintln!(
-                    "❌ Loop iterator must be a number, found: {:?}",
-                    loop_value.get("iterator")
-                );
-                return (max_end_time, cursor_time);
-            }
-        };
-
-        let loop_body = match loop_value.get("body") {
-            Some(Value::Block(body)) => body.clone(),
-            _ => {
-                eprintln!(
-                    "❌ Loop body must be a block, found: {:?}",
-                    loop_value.get("body")
-                );
-                return (max_end_time, cursor_time);
-            }
-        };
-
-        let engine = audio_engine;
-        let mut cur_time = cursor_time;
-        let mut max_time = max_end_time;
-
-        for _ in 0..loop_count {
-            let (block_end_time, new_cursor) = execute_audio_block(
-                engine,
-                global_store,
-                variable_table.clone(),
-                functions_table.clone(),
-                &loop_body,
-                base_bpm,
-                base_duration,
-                max_time,
-                cur_time,
-            );
-
-            cur_time = new_cursor.max(block_end_time);
-            max_time = max_time.max(cur_time);
-        }
-
-        return (max_time, cur_time);
-    }
-
-    eprintln!("❌ Loop statement value is not a map");
-    (max_end_time, cursor_time)
-}

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

@@ -1,12 +0,0 @@
-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;

package/rust/core/audio/interpreter/statements/sleep.rs

@@ -1,28 +0,0 @@
-use crate::core::parser::statement::Statement;
-use devalang_types::Value;
-
-pub fn interprete_sleep_statement(
-    stmt: &Statement,
-    cursor_time: f32,
-    max_end_time: f32,
-) -> (f32, f32) {
-    let duration_secs = match &stmt.value {
-        Value::Number(ms) => *ms / 1000.0,
-        Value::String(s) if s.ends_with("ms") => s
-            .trim_end_matches("ms")
-            .parse::<f32>()
-            .map(|ms| ms / 1000.0)
-            .unwrap_or_else(|_| {
-                eprintln!("❌ Invalid sleep value (ms): {}", s);
-                0.0
-            }),
-        other => {
-            eprintln!("❌ Invalid sleep value: {:?}", other);
-            0.0
-        }
-    };
-
-    let new_cursor = cursor_time + duration_secs;
-    let new_max = max_end_time.max(new_cursor);
-    (new_cursor, new_max)
-}