@devaloop/devalang 0.0.1-beta.3 → 0.1.1

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

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