@devaloop/devalang 0.0.1-beta.2 → 0.1.1

package/rust/core/audio/interpreter/statements/arrow_call/types/pluck.rs

@@ -1,97 +0,0 @@
-use devalang_types::Value;
-use std::collections::HashMap;
-
-pub fn apply_defaults(synth_params: &mut HashMap<String, Value>) {
-    use devalang_types::Value as DV;
-    // pluck: very short attack, short decay, very low sustain, short release
-    synth_params
-        .entry("attack".to_string())
-        .or_insert(DV::Number(2.0));
-    synth_params
-        .entry("decay".to_string())
-        .or_insert(DV::Number(80.0));
-    synth_params
-        .entry("sustain".to_string())
-        .or_insert(DV::Number(0.0));
-    synth_params
-        .entry("release".to_string())
-        .or_insert(DV::Number(120.0));
-    synth_params
-        .entry("glide".to_string())
-        .or_insert(DV::Boolean(false));
-    synth_params
-        .entry("slide".to_string())
-        .or_insert(DV::Boolean(false));
-    // small transient helper for plucks
-    synth_params
-        .entry("pluck_click".to_string())
-        .or_insert(DV::Number(0.08));
-    synth_params
-        .entry("pluck_click_ms".to_string())
-        .or_insert(DV::Number(8.0));
-}
-
-// Prepare per-note modifications for pluck: short attack/release, optional amp curve per-index
-pub fn prepare_note(
-    _note_name: &str,
-    index: usize,
-    _total: usize,
-    _start_time_ms: f32,
-    _duration_ms: f32,
-    amp: f32,
-    _synth_params: &HashMap<String, Value>,
-    note_params: &HashMap<String, Value>,
-    _automation: &Option<HashMap<String, Value>>,
-) -> (f32, f32, f32, HashMap<String, Value>) {
-    // pluck slightly reduces amp for later notes by a tiny fraction
-    let decay = 0.02 * (index as f32);
-    let amp_out = (amp * (1.0 - decay)).max(0.0);
-    let mut params_out = note_params.clone();
-    // ensure short attack & short release to sound plucky
-    params_out
-        .entry("attack".to_string())
-        .or_insert(Value::Number(1.0));
-    params_out
-        .entry("release".to_string())
-        .or_insert(Value::Number(100.0));
-    params_out
-        .entry("sustain".to_string())
-        .or_insert(Value::Number(0.0));
-    // add a small "click" transient and a light resonant filter to emphasize the pluck
-    use devalang_types::Value as DV;
-    let freq = note_to_freq(_note_name);
-    let mut filt: std::collections::HashMap<String, Value> = std::collections::HashMap::new();
-    filt.insert("type".to_string(), Value::String("bandpass".to_string()));
-    // center filter a bit above the note to give a bright pluck transient
-    // use more explicit filter parameter names requested by user
-    filt.insert(
-        "cutoff".to_string(),
-        Value::Number((freq * 2.0).min(10000.0)),
-    );
-    filt.insert("resonance".to_string(), Value::Number(6.0));
-    // only insert filters if not already present
-    if !params_out.contains_key("filters") {
-        params_out.insert("filters".to_string(), DV::Array(vec![DV::Map(filt)]));
-    }
-    // frequency unchanged here; caller computes freq
-    // stronger pitch drop for a plucky character
-    let freq_end = freq * 0.98;
-    (0.0, freq_end, amp_out, params_out)
-}
-
-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/statements/arrow_call/types/sub.rs

@@ -1,100 +0,0 @@
-use devalang_types::Value;
-use std::collections::HashMap;
-
-pub fn apply_defaults(synth_params: &mut HashMap<String, Value>) {
-    use devalang_types::Value as DV;
-    // sub bass: strong sustain, lowpass emphasis
-    synth_params
-        .entry("attack".to_string())
-        .or_insert(DV::Number(10.0));
-    synth_params
-        .entry("decay".to_string())
-        .or_insert(DV::Number(80.0));
-    // sustain stored as 0.0-1.0 for consistency
-    synth_params
-        .entry("sustain".to_string())
-        .or_insert(DV::Number(1.0));
-    synth_params
-        .entry("release".to_string())
-        .or_insert(DV::Number(300.0));
-    synth_params
-        .entry("detune".to_string())
-        .or_insert(DV::Number(0.0));
-    synth_params
-        .entry("lowpass".to_string())
-        .or_insert(DV::Number(150.0));
-    // octave stacking and drive for extra body
-    synth_params
-        .entry("octaves".to_string())
-        .or_insert(DV::Number(1.0));
-    synth_params
-        .entry("drive".to_string())
-        .or_insert(DV::Number(0.0));
-    // encourage a lowpass default if none provided
-    synth_params
-        .entry("lowpass".to_string())
-        .or_insert(DV::Number(120.0));
-}
-
-// prepare_note for sub: shift note one or two octaves down and set stronger amp
-pub fn prepare_note(
-    note_name: &str,
-    _index: usize,
-    _total: usize,
-    _start_time_ms: f32,
-    _duration_ms: f32,
-    amp: f32,
-    _synth_params: &HashMap<String, Value>,
-    note_params: &HashMap<String, Value>,
-    _automation: &Option<HashMap<String, Value>>,
-) -> (f32, f32, f32, HashMap<String, Value>) {
-    let mut params_out = note_params.clone();
-    params_out
-        .entry("attack".to_string())
-        .or_insert(Value::Number(5.0));
-    params_out
-        .entry("release".to_string())
-        .or_insert(Value::Number(200.0));
-    params_out
-        .entry("sustain".to_string())
-        .or_insert(Value::Number(1.0));
-
-    // compute deep-frequency one octave down by default
-    let freq = note_to_freq(note_name) * 0.5;
-    // allow stacking additional octaves for extra body
-    if let Some(Value::Number(o)) = _synth_params.get("octaves") {
-        let oct = (*o as i32).max(1);
-        if oct >= 2 {
-            // add lower harmonic by halving frequency again (engine may layer if octaves param is observed)
-            // we still return the primary frequency but advertise octaves in params
-            params_out.insert("octaves".to_string(), Value::Number(*o));
-        }
-    }
-
-    // boost amplitude a little for sub
-    let amp_out = (amp * 1.5).min(1.0);
-
-    // advertise drive if present so engine/effects can apply soft clipping
-    if let Some(Value::Number(d)) = _synth_params.get("drive") {
-        params_out.insert("drive".to_string(), Value::Number(*d));
-    }
-
-    (0.0, freq, amp_out, params_out)
-}
-
-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/statements/automate.rs

@@ -1,16 +0,0 @@
-use crate::core::parser::statement::{Statement, StatementKind};
-use devalang_types::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/statements/call.rs

@@ -1,295 +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
-
-                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
-}

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
-}