@devaloop/devalang 0.0.1-beta.2 → 0.1.1

package/rust/core/audio/interpreter/statements/arrow_call/methods/note.rs

@@ -1,316 +0,0 @@
-use crate::core::{audio::engine::AudioEngine, plugin::runner::WasmPluginRunner};
-use devalang_types::Value;
-use devalang_utils::logger::{LogLevel, Logger};
-use std::collections::HashMap;
-
-pub fn interprete_note_method(
-    args: &Vec<devalang_types::Value>,
-    target: &str,
-    audio_engine: &mut AudioEngine,
-    variable_table: &devalang_types::VariableTable,
-    global_store: &crate::core::store::global::GlobalStore,
-    waveform_str: &str,
-    synth_params: &HashMap<String, devalang_types::Value>,
-    amp: f32,
-    base_bpm: f32,
-    base_duration: f32,
-    max_end_time: &mut f32,
-    mut cursor_time: Option<&mut f32>,
-    cursor_copy: f32,
-    update_cursor: bool,
-) -> (f32, f32) {
-    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 {
-        // Allow types to adjust per-note scheduling/params
-        let start_ms = start_time * 1000.0;
-        let mut final_amp = amp_note;
-        let mut final_note_params = note_params.clone();
-
-        let mut handled = false;
-        if let Some(tval) = synth_params.get("type") {
-            let tname = match tval {
-                Value::String(s) => s.as_str(),
-                Value::Identifier(s) => s.as_str(),
-                _ => "",
-            };
-            match tname {
-                "arp" => {
-                    // compute a step (ms) from synth params (rate/step). compute_arp_step
-                    // will interpret `rate` as number of notes across the provided duration
-                    let step_ms = crate::core::audio::interpreter::statements::arrow_call::types::arp::
-                        compute_arp_step(duration_ms, 1, &synth_params);
-                    let steps = if step_ms > 0.0 {
-                        ((duration_ms / step_ms).ceil() as usize).max(1)
-                    } else {
-                        1usize
-                    };
-
-                    // For each arp step, call prepare_note to get per-step params and schedule it
-                    for idx in 0..steps {
-                        let (start_abs_ms, freq_step, amp_out, params_out) =
-                            crate::core::audio::interpreter::statements::arrow_call::types::arp::prepare_note(
-                                &note_name,
-                                idx,
-                                steps,
-                                start_ms,
-                                duration_ms,
-                                amp_note,
-                                &synth_params,
-                                &final_note_params,
-                                &automation,
-                            );
-
-                        // sub-note duration: default to step_ms so arp steps are audible and sequenced
-                        let sub_duration_ms = if step_ms > 0.0 { step_ms } else { duration_ms };
-
-                        audio_engine.insert_note(
-                            waveform_str.to_string(),
-                            freq_step,
-                            amp_out,
-                            start_abs_ms,
-                            sub_duration_ms,
-                            synth_params.clone(),
-                            params_out.clone(),
-                            automation.clone(),
-                        );
-                    }
-
-                    // mark handled to avoid the unconditional insert below
-                    handled = true;
-                }
-                "pluck" => {
-                    let (_s, _f, amp_out, params_out) =
-                        crate::core::audio::interpreter::statements::arrow_call::types::pluck::prepare_note(
-                            &note_name,
-                            0,
-                            1,
-                            start_ms,
-                            duration_ms,
-                            amp_note,
-                            &synth_params,
-                            &final_note_params,
-                            &automation,
-                        );
-                    final_amp = amp_out;
-                    final_note_params = params_out;
-                }
-                "pad" => {
-                    let (_s, _f, amp_out, params_out) =
-                        crate::core::audio::interpreter::statements::arrow_call::types::pad::prepare_note(
-                            &note_name,
-                            0,
-                            1,
-                            start_ms,
-                            duration_ms,
-                            amp_note,
-                            &synth_params,
-                            &final_note_params,
-                            &automation,
-                        );
-                    final_amp = amp_out;
-                    final_note_params = params_out;
-                }
-                _ => {}
-            }
-        }
-
-        if !handled {
-            audio_engine.insert_note(
-                waveform_str.to_string(),
-                final_freq,
-                final_amp,
-                start_ms,
-                duration_ms,
-                synth_params.clone(),
-                final_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);
-}
-
-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/statements/arrow_call/mod.rs

@@ -1,3 +0,0 @@
-pub mod interprete;
-pub mod methods;
-pub mod types;

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

@@ -1,192 +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;
-    synth_params
-        .entry("attack".to_string())
-        .or_insert(DV::Number(1.0));
-    synth_params
-        .entry("decay".to_string())
-        .or_insert(DV::Number(50.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));
-    // arp defaults
-    synth_params
-        .entry("gate".to_string())
-        .or_insert(DV::Number(80.0));
-    synth_params
-        .entry("pattern".to_string())
-        .or_insert(DV::String("up".to_string()));
-    // per-step velocity shaping
-    synth_params
-        .entry("velocity_scale".to_string())
-        .or_insert(DV::Number(0.25));
-}
-
-// Helper to compute an arp step and schedule notes; this is small and returns the computed step
-pub fn compute_arp_step(
-    duration_ms: f32,
-    note_count: usize,
-    synth_params: &HashMap<String, Value>,
-) -> f32 {
-    // New API: synth_params may contain "rate" (beats/duration string or number),
-    // "pattern" (up, down, updown), and "step" (ms or number)
-    use devalang_types::Duration as D;
-
-    // If rate is provided as number (notes across duration), use it
-    if let Some(Value::Number(rate)) = synth_params.get("rate") {
-        if *rate > 0.0 {
-            return duration_ms / *rate;
-        }
-    }
-
-    // If rate provided as Duration/Beat/String parse as musical fraction -> seconds
-    if let Some(v) = synth_params.get("rate") {
-        match v {
-            Value::Duration(d) => match d {
-                D::Number(sec) => {
-                    if *sec > 0.0 {
-                        return sec * 1000.0;
-                    }
-                }
-                D::Beat(_) | D::Identifier(_) => {
-                    // need bpm; fallback 120
-                    let bpm = synth_params
-                        .get("bpm")
-                        .and_then(|bv| {
-                            if let Value::Number(n) = bv {
-                                Some(*n)
-                            } else {
-                                None
-                            }
-                        })
-                        .unwrap_or(120.0);
-                    if let Some(sec) =
-                        crate::core::audio::engine::driver::duration_to_seconds(d, bpm)
-                    {
-                        if sec > 0.0 {
-                            return sec * 1000.0;
-                        }
-                    }
-                }
-                _ => {}
-            },
-            Value::String(s) | Value::Identifier(s) => {
-                let bpm = synth_params
-                    .get("bpm")
-                    .and_then(|bv| {
-                        if let Value::Number(n) = bv {
-                            Some(*n)
-                        } else {
-                            None
-                        }
-                    })
-                    .unwrap_or(120.0);
-                if let Some(sec) =
-                    crate::core::audio::engine::driver::parse_fraction_to_seconds(s, bpm)
-                {
-                    if sec > 0.0 {
-                        return sec * 1000.0;
-                    }
-                }
-                if let Ok(n) = s.parse::<f32>() {
-                    if n > 0.0 {
-                        return duration_ms / n;
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-
-    // fallback to explicit step param
-    let default_step = (duration_ms / (note_count as f32)) * 0.5;
-    match synth_params.get("step") {
-        Some(Value::Number(n)) => *n,
-        Some(Value::String(s)) => s.parse::<f32>().unwrap_or(default_step),
-        Some(Value::Identifier(s)) => s.parse::<f32>().unwrap_or(default_step),
-        _ => default_step,
-    }
-}
-
-// Ensure arp defaults include an arp_step if provided as beats / number string
-pub fn ensure_arp_step(synth_params: &mut HashMap<String, Value>, default_step: f32) {
-    use devalang_types::Value as DV;
-    if !synth_params.contains_key("arp_step") {
-        synth_params.insert("arp_step".to_string(), DV::Number(default_step));
-    }
-}
-
-// Prepare per-note scheduling & params for arp
-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>) {
-    // compute a slightly syncopated step: half-step + small swing
-    let mut step = compute_arp_step(duration_ms, total, synth_params);
-    // introduce simple swing based on index
-    let swing = match synth_params.get("swing") {
-        Some(Value::Number(n)) => *n,
-        _ => 0.05,
-    };
-    if index % 2 == 1 {
-        step *= 1.0 + swing;
-    }
-    let start = start_time_ms + (index as f32) * step;
-    // For now, arp doesn't alter amp or params beyond start offset
-    let amp_out = amp;
-    let mut params_out = note_params.clone();
-    // optionally expose arp-specific params into note params
-    if let Some(Value::Number(n)) = synth_params.get("gate") {
-        // normalize gate to 0.0-1.0 if >1 (percent)
-        let gate_val = if *n > 1.0 { (*n) / 100.0 } else { *n };
-        params_out
-            .entry("gate".to_string())
-            .or_insert(Value::Number(gate_val));
-    }
-    // simple velocity curve across arp steps (so later steps can be quieter/louder)
-    if let Some(Value::Number(vscale)) = synth_params.get("velocity_scale") {
-        let mult = 1.0 - ((index as f32) / (total as f32)) * (*vscale);
-        params_out.insert("velocity".to_string(), Value::Number(mult.max(0.0)));
-    }
-    // propagate pattern if present (engine or higher layer may use it)
-    if let Some(Value::String(p)) = synth_params.get("pattern") {
-        params_out.insert("pattern".to_string(), Value::String(p.clone()));
-    }
-    (start, note_to_freq(note_name), 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/mod.rs

@@ -1,24 +0,0 @@
-pub mod arp;
-pub mod pad;
-pub mod pluck;
-pub mod sub;
-
-use devalang_types::Value;
-use std::collections::HashMap;
-
-pub fn apply_type(synth_params: &mut HashMap<String, Value>) {
-    if let Some(tval) = synth_params.get("type") {
-        let tname = match tval {
-            Value::String(s) => s.as_str(),
-            Value::Identifier(s) => s.as_str(),
-            _ => "",
-        };
-        match tname {
-            "pad" => pad::apply_defaults(synth_params),
-            "pluck" => pluck::apply_defaults(synth_params),
-            "arp" => arp::apply_defaults(synth_params),
-            "sub" => sub::apply_defaults(synth_params),
-            _ => {}
-        }
-    }
-}

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

@@ -1,116 +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;
-    // pad: long attack/release, high sustain (0.0-1.0)
-    synth_params
-        .entry("attack".to_string())
-        .or_insert(DV::Number(600.0));
-    synth_params
-        .entry("decay".to_string())
-        .or_insert(DV::Number(300.0));
-    synth_params
-        .entry("sustain".to_string())
-        .or_insert(DV::Number(0.8));
-    synth_params
-        .entry("release".to_string())
-        .or_insert(DV::Number(900.0));
-    // optional unison/voices parameters
-    synth_params
-        .entry("voices".to_string())
-        .or_insert(DV::Number(3.0));
-    synth_params
-        .entry("unison_detune".to_string())
-        .or_insert(DV::Number(15.0));
-    // slightly wider default chorus/depth for pads
-    if !synth_params.contains_key("effects") {
-        let mut ch: std::collections::HashMap<String, Value> = std::collections::HashMap::new();
-        ch.insert("type".to_string(), Value::String("chorus".to_string()));
-        ch.insert("depth".to_string(), Value::Number(0.12));
-        ch.insert("rate".to_string(), Value::Number(0.25));
-        synth_params.insert("effects".to_string(), DV::Array(vec![DV::Map(ch)]));
-    }
-}
-
-// Prepare per-note modifications for pad: longer release/attack, gentle detune per-voice
-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();
-    // inject pad envelope defaults if missing
-    params_out
-        .entry("attack".to_string())
-        .or_insert(Value::Number(600.0));
-    params_out
-        .entry("release".to_string())
-        .or_insert(Value::Number(900.0));
-    params_out
-        .entry("sustain".to_string())
-        .or_insert(Value::Number(0.8));
-
-    // propagate unison/voices into per-note params if synth provided
-    if let Some(Value::Number(v)) = synth_params.get("voices") {
-        params_out.insert("voices".to_string(), Value::Number(*v));
-    }
-    if let Some(Value::Number(d)) = synth_params.get("unison_detune") {
-        params_out.insert("unison_detune".to_string(), Value::Number(*d));
-    }
-
-    // gentle detune based on index and synth param "detune" if present
-    // gentle detune based on synth detune or unison settings
-    let detune_base = match synth_params.get("detune") {
-        Some(Value::Number(n)) => *n,
-        _ => 0.0,
-    };
-    let mut detune = detune_base * ((index as f32) / (total as f32));
-    // if unison used, spread voices around center
-    if let Some(Value::Number(_voices)) = synth_params.get("voices") {
-        if let Some(Value::Number(ud)) = synth_params.get("unison_detune") {
-            // spread by a fraction based on voice index
-            detune += (*ud) * (((index as f32) - (total as f32 - 1.0) / 2.0) / (total as f32));
-        }
-    }
-
-    params_out.insert("detune".to_string(), Value::Number(detune));
-
-    // compute frequency with detune in cents
-    let freq = note_to_freq(_note_name) * (2.0_f32).powf(detune / 1200.0);
-
-    // add a subtle chorus placeholder effect if none present (engine may ignore unknown effects)
-    use devalang_types::Value as DV;
-    if !params_out.contains_key("effects") {
-        let mut ch: std::collections::HashMap<String, Value> = std::collections::HashMap::new();
-        ch.insert("type".to_string(), Value::String("chorus".to_string()));
-        ch.insert("depth".to_string(), Value::Number(0.15));
-        ch.insert("rate".to_string(), Value::Number(0.25));
-        params_out.insert("effects".to_string(), DV::Array(vec![DV::Map(ch)]));
-    }
-
-    (0.0, freq, amp, 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)
-}