@devaloop/devalang 0.0.1-alpha.13 → 0.0.1-alpha.15

package/rust/core/audio/engine.rs

@@ -100,30 +100,137 @@ impl AudioEngine {
         freq: f32,
         amp: f32,
         start_time_ms: f32,
-        duration_ms: f32
+        duration_ms: f32,
+        synth_params: HashMap<String, Value>,
+        note_params: HashMap<String, Value>,
+        automation: Option<HashMap<String, Value>>
     ) {
+        let valid_synth_params = vec!["attack", "decay", "sustain", "release"];
+        let valid_note_params = vec![
+            "duration",
+            "velocity",
+            "glide",
+            "slide",
+            "amp",
+            "target_freq",
+            "target_amp",
+            "modulation",
+            "expression",
+            // allow per-note automation map
+            "automate"
+        ];
+
+        // Synth params validation
+        for key in synth_params.keys() {
+            if !valid_synth_params.contains(&key.as_str()) {
+                eprintln!("⚠️ Unknown synth parameter: '{}'", key);
+            }
+        }
+
+        // Note params validation
+        for key in note_params.keys() {
+            if !valid_note_params.contains(&key.as_str()) {
+                eprintln!("⚠️ Unknown note parameter: '{}'", key);
+            }
+        }
+
+        // Synth parameters
+        let attack = self.extract_f32(&synth_params, "attack").unwrap_or(0.0);
+        let decay = self.extract_f32(&synth_params, "decay").unwrap_or(0.0);
+        let sustain = self.extract_f32(&synth_params, "sustain").unwrap_or(1.0);
+        let release = self.extract_f32(&synth_params, "release").unwrap_or(0.0);
+        let attack_s = if attack > 10.0 { attack / 1000.0 } else { attack };
+        let decay_s = if decay > 10.0 { decay / 1000.0 } else { decay };
+        let release_s = if release > 10.0 { release / 1000.0 } else { release };
+        let sustain_level = if sustain > 1.0 {
+            (sustain / 100.0).clamp(0.0, 1.0)
+        } else {
+            sustain.clamp(0.0, 1.0)
+        };
+
+        // Note parameters
+        let duration_ms = self.extract_f32(&note_params, "duration").unwrap_or(duration_ms);
+        let velocity = self.extract_f32(&note_params, "velocity").unwrap_or(1.0);
+        let glide = self.extract_boolean(&note_params, "glide").unwrap_or(false);
+        let slide = self.extract_boolean(&note_params, "slide").unwrap_or(false);
+
+    let _amplitude = (i16::MAX as f32) * amp.clamp(0.0, 1.0) * velocity.clamp(0.0, 1.0);
+
+        // Logic for glide and slide
+        let freq_start = freq;
+        let mut freq_end = freq;
+        let amp_start = amp * velocity.clamp(0.0, 1.0);
+        let mut amp_end = amp_start;
+
+        if glide {
+            if let Some(Value::Number(target_freq)) = note_params.get("target_freq") {
+                freq_end = *target_freq;
+            } else {
+                freq_end = freq * 1.5; // By default, glide to a perfect fifth
+            }
+        }
+
+        if slide {
+            if let Some(Value::Number(target_amp)) = note_params.get("target_amp") {
+                amp_end = *target_amp * velocity.clamp(0.0, 1.0);
+            } else {
+                amp_end = amp_start * 0.5; // By default, slide to half the amplitude
+            }
+        }
         let sample_rate = SAMPLE_RATE as f32;
         let channels = CHANNELS as usize;
 
         let total_samples = ((duration_ms / 1000.0) * sample_rate) as usize;
         let start_sample = ((start_time_ms / 1000.0) * sample_rate) as usize;
-        let amplitude = (i16::MAX as f32) * amp.clamp(0.0, 1.0);
 
-        let mut samples = Vec::with_capacity(total_samples);
+        // Precompute automation envelopes
+        let (volume_env, pan_env, pitch_env) = Self::env_maps_from_automation(&automation);
+
+        let mut stereo_samples: Vec<i16> = Vec::with_capacity(total_samples * 2);
         let fade_len = (sample_rate * 0.01) as usize; // 10 ms fade
 
+        let attack_samples = (attack_s * sample_rate) as usize;
+        let decay_samples = (decay_s * sample_rate) as usize;
+        let release_samples = (release_s * sample_rate) as usize;
+        let sustain_samples = if total_samples > attack_samples + decay_samples + release_samples {
+            total_samples - attack_samples - decay_samples - release_samples
+        } else {
+            0
+        };
+
         for i in 0..total_samples {
             let t = ((start_sample + i) as f32) / sample_rate;
-            let phase = 2.0 * std::f32::consts::PI * freq * t;
-
-            let mut value = match waveform.as_str() {
-                "sine" => phase.sin(),
-                "square" => if phase.sin() >= 0.0 { 1.0 } else { -1.0 }
-                "saw" => 2.0 * (freq * t - (freq * t + 0.5).floor()),
-                "triangle" => (2.0 * (2.0 * (freq * t).fract() - 1.0)).abs() * 2.0 - 1.0,
-                _ => 0.0,
+
+            // Glide
+            let current_freq = if glide {
+                freq_start + ((freq_end - freq_start) * (i as f32)) / (total_samples as f32)
+            } else {
+                freq
             };
 
+            // Pitch automation (in semitones), applied as frequency multiplier
+            let pitch_semi = Self::eval_env_map(&pitch_env, (i as f32) / (total_samples as f32), 0.0);
+            let current_freq = current_freq * (2.0_f32).powf(pitch_semi / 12.0);
+
+            // Slide
+            let current_amp = if slide {
+                amp_start + ((amp_end - amp_start) * (i as f32)) / (total_samples as f32)
+            } else {
+                amp_start
+            };
+
+            let mut value = Self::oscillator_sample(&waveform, current_freq, t);
+
+            // ADSR envelope
+            let envelope = Self::adsr_envelope_value(
+                i,
+                attack_samples,
+                decay_samples,
+                sustain_samples,
+                release_samples,
+                sustain_level,
+            );
+
             // Fade in/out
             if i < fade_len {
                 value *= (i as f32) / (fade_len as f32);
@@ -131,27 +238,32 @@ impl AudioEngine {
                 value *= ((total_samples - i) as f32) / (fade_len as f32);
             }
 
-            samples.push((value * amplitude) as i16);
+            value *= envelope;
+            // Apply dynamic amplitude (slide + velocity)
+            let mut sample_val = value * (i16::MAX as f32) * current_amp;
+
+            // Volume automation multiplier
+            let vol_mul = Self::eval_env_map(&volume_env, (i as f32) / (total_samples as f32), 1.0)
+                .clamp(0.0, 10.0);
+            sample_val *= vol_mul;
+
+            // Pan automation [-1..1]; consistency with pad_samples method
+            let pan_val = Self::eval_env_map(&pan_env, (i as f32) / (total_samples as f32), 0.0)
+                .clamp(-1.0, 1.0);
+            let (left_gain, right_gain) = Self::pan_gains(pan_val);
+
+            let left = (sample_val * left_gain)
+                .round()
+                .clamp(i16::MIN as f32, i16::MAX as f32) as i16;
+            let right = (sample_val * right_gain)
+                .round()
+                .clamp(i16::MIN as f32, i16::MAX as f32) as i16;
+
+            stereo_samples.push(left);
+            stereo_samples.push(right);
         }
 
-        // Convert to stereo
-        let stereo_samples: Vec<i16> = samples
-            .iter()
-            .flat_map(|s| vec![*s, *s])
-            .collect();
-
-        let offset = start_sample * channels;
-        let required_len = offset + stereo_samples.len();
-
-        if self.buffer.len() < required_len {
-            self.buffer.resize(required_len, 0);
-        }
-
-        for (i, sample) in stereo_samples.iter().enumerate() {
-            if *sample != 0 {
-            }
-            self.buffer[offset + i] = self.buffer[offset + i].saturating_add(*sample);
-        }
+        self.mix_stereo_samples_into_buffer(start_sample, channels, &stereo_samples);
     }
 
     pub fn insert_sample(
@@ -169,7 +281,7 @@ impl AudioEngine {
 
         let root = Path::new(env!("CARGO_MANIFEST_DIR"));
         let module_root = Path::new(&self.module_name);
-        let mut resolved_path = String::new();
+        let resolved_path: String;
 
         // Get the variable path from the variable table
         let mut var_path = filepath.to_string();
@@ -179,41 +291,14 @@ impl AudioEngine {
             var_path = sample_path.clone();
         }
 
-        // If it's a namespace
-        if var_path.contains(".") {
-            let parts: Vec<&str> = var_path.trim_start_matches('.').split('.').collect();
-            if parts.len() == 2 {
-                let bank_name = parts[0];
-                let entity_name = parts[1];
-
-                // Verifies if the bank is declared
-                if !variable_table.variables.contains_key(bank_name) {
-                    eprintln!(
-                        "❌ Bank '{}' not declared. Please declare it first using : 'bank {}'",
-                        bank_name,
-                        bank_name
-                    );
-                    return;
-                }
-
-                resolved_path = root
-                    .join(".deva")
-                    .join("bank")
-                    .join(bank_name)
-                    .join(format!("{}.wav", entity_name))
-                    .to_string_lossy()
-                    .to_string();
-            } else {
-                eprintln!("❌ Invalid namespace format: {}", var_path);
-                return;
-            }
-        } else if var_path.starts_with("devalang://") {
+        // Handle devalang:// protocol
+        if var_path.starts_with("devalang://") {
             let path_after_protocol = var_path.replace("devalang://", "");
             let parts: Vec<&str> = path_after_protocol.split('/').collect();
 
             if parts.len() < 3 {
                 eprintln!(
-                    "❌ Invalid devalang:// path format. Expected devalang://<type>/<bank>/<entity>"
+                    "❌ Invalid devalang:// path format. Expected devalang://<type>/<author>.<bank>/<entity>"
                 );
                 return;
             }
@@ -390,8 +475,7 @@ impl AudioEngine {
             let adjusted_sample = adjusted.round().clamp(i16::MIN as f32, i16::MAX as f32) as i16;
 
             // PAN
-            let left_gain = 1.0 - pan.max(0.0); // Pan > 0 => reduce left
-            let right_gain = 1.0 + pan.min(0.0); // Pan < 0 => reduce right
+            let (left_gain, right_gain) = Self::pan_gains(pan);
 
             let left = ((adjusted_sample as f32) * left_gain) as i16;
             let right = ((adjusted_sample as f32) * right_gain) as i16;
@@ -405,4 +489,171 @@ impl AudioEngine {
             }
         }
     }
+
+    // ===== Helper methods to keep long functions modular and readable =====
+
+    fn env_maps_from_automation(
+        automation: &Option<HashMap<String, Value>>
+    ) -> (
+        Option<HashMap<String, Value>>,
+        Option<HashMap<String, Value>>,
+        Option<HashMap<String, Value>>,
+    ) {
+        if let Some(auto) = automation {
+            let vol = match auto.get("volume") {
+                Some(Value::Map(m)) => Some(m.clone()),
+                _ => None,
+            };
+            let pan = match auto.get("pan") {
+                Some(Value::Map(m)) => Some(m.clone()),
+                _ => None,
+            };
+            let pit = match auto.get("pitch") {
+                Some(Value::Map(m)) => Some(m.clone()),
+                _ => None,
+            };
+            (vol, pan, pit)
+        } else {
+            (None, None, None)
+        }
+    }
+
+    // Evaluate envelope map at progress [0,1]
+    fn eval_env_map(
+        env_opt: &Option<HashMap<String, Value>>,
+        progress: f32,
+        default_val: f32,
+    ) -> f32 {
+        let env = match env_opt {
+            Some(m) => m,
+            None => {
+                return default_val;
+            }
+        };
+        let mut points: Vec<(f32, f32)> = Vec::with_capacity(env.len());
+        for (k, v) in env.iter() {
+            // accept keys like "0" or "0%"
+            let key = if k.ends_with('%') { &k[..k.len() - 1] } else { &k[..] };
+            if let Ok(mut p) = key.parse::<f32>() {
+                p = (p / 100.0).clamp(0.0, 1.0);
+                let val = match v {
+                    Value::Number(n) => *n,
+                    Value::String(s) => s.parse::<f32>().unwrap_or(default_val),
+                    Value::Identifier(s) => s.parse::<f32>().unwrap_or(default_val),
+                    _ => default_val,
+                };
+                points.push((p, val));
+            }
+        }
+        if points.is_empty() {
+            return default_val;
+        }
+        points.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
+        let t = progress.clamp(0.0, 1.0);
+        if t <= points[0].0 {
+            return points[0].1;
+        }
+        if t >= points[points.len() - 1].0 {
+            return points[points.len() - 1].1;
+        }
+        for w in points.windows(2) {
+            let (p0, v0) = w[0];
+            let (p1, v1) = w[1];
+            if t >= p0 && t <= p1 {
+                let ratio = if (p1 - p0).abs() < std::f32::EPSILON {
+                    0.0
+                } else {
+                    (t - p0) / (p1 - p0)
+                };
+                return v0 + (v1 - v0) * ratio;
+            }
+        }
+        default_val
+    }
+
+    fn oscillator_sample(waveform: &str, current_freq: f32, t: f32) -> f32 {
+        let phase = 2.0 * std::f32::consts::PI * current_freq * t;
+        match waveform {
+            "sine" => phase.sin(),
+            "square" => {
+                if phase.sin() >= 0.0 { 1.0 } else { -1.0 }
+            }
+            "saw" => 2.0 * (current_freq * t - (current_freq * t + 0.5).floor()),
+            "triangle" => (2.0 * (2.0 * (current_freq * t).fract() - 1.0)).abs() * 2.0 - 1.0,
+            _ => 0.0,
+        }
+    }
+
+    fn adsr_envelope_value(
+        i: usize,
+        attack_samples: usize,
+        decay_samples: usize,
+        sustain_samples: usize,
+        release_samples: usize,
+        sustain_level: f32,
+    ) -> f32 {
+        if i < attack_samples {
+            (i as f32) / (attack_samples as f32)
+        } else if i < attack_samples + decay_samples {
+            1.0 - (1.0 - sustain_level) * (((i - attack_samples) as f32) / (decay_samples as f32))
+        } else if i < attack_samples + decay_samples + sustain_samples {
+            sustain_level
+        } else if release_samples > 0 {
+            sustain_level
+                * (1.0
+                    - ((i - attack_samples - decay_samples - sustain_samples) as f32)
+                        / (release_samples as f32))
+        } else {
+            0.0
+        }
+    }
+
+    fn pan_gains(pan_val: f32) -> (f32, f32) {
+        let left_gain = 1.0 - pan_val.max(0.0);
+        let right_gain = 1.0 + pan_val.min(0.0);
+        (left_gain, right_gain)
+    }
+
+    fn mix_stereo_samples_into_buffer(
+        &mut self,
+        start_sample: usize,
+        channels: usize,
+        stereo_samples: &[i16],
+    ) {
+        let offset = start_sample * channels;
+        let required_len = offset + stereo_samples.len();
+
+        if self.buffer.len() < required_len {
+            self.buffer.resize(required_len, 0);
+        }
+
+        for (i, sample) in stereo_samples.iter().enumerate() {
+            // Debug: track if we hit non-zero samples (to trace silent buffers)
+            // if i == 0 { eprintln!("[debug] first stereo sample: {}", sample); }
+            self.buffer[offset + i] = self.buffer[offset + i].saturating_add(*sample);
+        }
+    }
+
+    fn extract_f32(&self, map: &HashMap<String, Value>, key: &str) -> Option<f32> {
+        match map.get(key) {
+            Some(Value::Number(n)) => Some(*n),
+            Some(Value::String(s)) => s.parse::<f32>().ok(),
+            Some(Value::Boolean(b)) => Some(if *b { 1.0 } else { 0.0 }),
+            _ => None,
+        }
+    }
+
+    fn extract_boolean(&self, map: &HashMap<String, Value>, key: &str) -> Option<bool> {
+        match map.get(key) {
+            Some(Value::Boolean(b)) => Some(*b),
+            Some(Value::Number(n)) => Some(*n != 0.0),
+            Some(Value::Identifier(s)) => {
+                if s == "true" { Some(true) } else if s == "false" { Some(false) } else { None }
+            }
+            Some(Value::String(s)) => {
+                if s == "true" { Some(true) } else if s == "false" { Some(false) } else { None }
+            }
+            _ => None,
+        }
+    }
 }

package/rust/core/audio/evaluator.rs

@@ -1,4 +1,10 @@
 use crate::core::{ shared::value::Value, store::variable::VariableTable };
+use crate::core::audio::special::{
+    resolve_env_atom,
+    find_and_eval_first_math_call,
+    find_and_eval_first_easing_call,
+    find_and_eval_first_mod_call,
+};
 
 pub fn evaluate_condition_string(expr: &str, vars: &VariableTable) -> bool {
     let tokens: Vec<&str> = expr.split_whitespace().collect();
@@ -29,3 +35,98 @@ pub fn evaluate_condition_string(expr: &str, vars: &VariableTable) -> bool {
         _ => false,
     }
 }
+
+// Very small expression evaluator for `$env.*`, `$math.*` and variables.
+// Supports: +, -, *, / and simple parentheses, left-to-right (no precedence), and $math.(sin|cos)(expr)
+pub fn evaluate_numeric_expression(expr: &str, vars: &VariableTable, env_bpm: f32, env_beat: f32) -> Option<f32> {
+    let expr = expr.replace(" ", "");
+
+    // Helper to resolve an atom to a number
+    fn resolve_atom(atom: &str, vars: &VariableTable, bpm: f32, beat: f32) -> Option<f32> {
+        if let Some(v) = resolve_env_atom(atom, bpm, beat) { return Some(v); }
+        if let Ok(n) = atom.parse::<f32>() { return Some(n); }
+        if let Some(Value::Number(n)) = vars.get(atom) { return Some(*n); }
+        None
+    }
+
+    // Shunting-like, simplified: first evaluate any $math.func(...) calls anywhere in the expression,
+    // then fold remaining parentheses and evaluate left-to-right.
+    fn eval(expr: &str, vars: &VariableTable, bpm: f32, beat: f32) -> Option<f32> {
+        // 1) Replace $math.* calls progressively
+        let mut s = expr.to_string();
+        // Evaluate modulators first (they may feed easing/math)
+        while let Some(next) = find_and_eval_first_mod_call(&s, evaluate_numeric_expression, vars, bpm, beat) { s = next; }
+        // Then easing functions
+        while let Some(next) = find_and_eval_first_easing_call(&s, evaluate_numeric_expression, vars, bpm, beat) { s = next; }
+        // Finally math transforms
+        while let Some(next) = find_and_eval_first_math_call(&s, evaluate_numeric_expression, vars, bpm, beat) { s = next; }
+
+    // 2) Evaluate remaining (pure) parentheses starting from innermost
+        if let Some(open) = s.rfind('(') {
+            if let Some(close_rel) = s[open..].find(')') { // index relatif
+                let close = open + close_rel;
+                let inner = &s[open + 1..close];
+                let val = eval(inner, vars, bpm, beat)?;
+                let mut replaced = String::new();
+                replaced.push_str(&s[..open]);
+                replaced.push_str(&val.to_string());
+                replaced.push_str(&s[close + 1..]);
+                return eval(&replaced, vars, bpm, beat);
+            }
+        }
+
+        // Tokenize by operators left-to-right
+        let mut parts: Vec<String> = Vec::new();
+        let mut cur = String::new();
+        for ch in s.chars() {
+            if "+-*/".contains(ch) {
+                if !cur.is_empty() { parts.push(cur.clone()); cur.clear(); }
+                parts.push(ch.to_string());
+            } else {
+                cur.push(ch);
+            }
+        }
+        if !cur.is_empty() { parts.push(cur); }
+        if parts.is_empty() { return None; }
+
+        // Resolve atoms and compute
+        let mut acc: Option<f32> = None;
+        let mut op: Option<char> = None;
+        for part in parts {
+            if part.len() == 1 && "+-*/".contains(part.chars().next().unwrap()) {
+                op = part.chars().next();
+                continue;
+            }
+            let val = if let Some(v) = resolve_atom(&part, vars, bpm, beat) {
+                v
+            } else if part.starts_with("$env.") {
+                // $env atom not handled by resolve_atom (when composed), try recursive eval
+                eval(&part, vars, bpm, beat)?
+            } else {
+                return None;
+            };
+
+            acc = Some(match (acc, op) {
+                (None, _) => val,
+                (Some(a), Some('+')) => a + val,
+                (Some(a), Some('-')) => a - val,
+                (Some(a), Some('*')) => a * val,
+                (Some(a), Some('/')) => if val != 0.0 { a / val } else { return Some(f32::INFINITY); },
+                (Some(_), None) => val,
+                _ => return None,
+            });
+        }
+
+        acc
+    }
+
+    eval(&expr, vars, env_bpm, env_beat)
+}
+
+pub fn evaluate_rhs_into_value(raw: &str, vars: &VariableTable, env_bpm: f32, env_beat: f32) -> Value {
+    if let Some(num) = evaluate_numeric_expression(raw, vars, env_bpm, env_beat) {
+        Value::Number(num)
+    } else {
+        Value::String(raw.to_string())
+    }
+}

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

@@ -23,11 +23,16 @@ pub fn interprete_call_arrow_statement(
         .unwrap_or(0.0);
 
     if let StatementKind::ArrowCall { target, method, args } = &stmt.kind {
-        let Some(Value::Map(synth_map)) = variable_table.get(target) else {
+        let Some(Value::Statement(synth_stmt)) = variable_table.get(target) else {
             println!("❌ Synth '{}' not found in variable table", target);
             return (*max_end_time, cursor_copy);
         };
 
+        let Value::Map(synth_map) = &synth_stmt.value else {
+            println!("❌ Invalid synth statement for '{}', expected a map.", target);
+            return (*max_end_time, cursor_copy);
+        };
+
         let Some(Value::String(entity)) = synth_map.get("entity") else {
             println!("❌ Missing 'entity' key in synth '{}'.", target);
             return (*max_end_time, cursor_copy);
@@ -53,37 +58,77 @@ pub fn interprete_call_arrow_statement(
             return (*max_end_time, cursor_copy);
         };
 
-        let freq = extract_f32(params, "freq", base_bpm).unwrap_or(440.0);
-        let amp = extract_f32(params, "amp", base_bpm).unwrap_or(1.0);
+        // Synth parameters
+    let synth_params = params.clone();
+    let amp = extract_f32(&synth_params, "amp", base_bpm).unwrap_or(1.0);
 
         if method == "note" {
-            let Some(Value::Identifier(note_name)) = args.get(0) else {
+            let filtered_args: Vec<_> = args
+                .iter()
+                .filter(|arg| !matches!(arg, Value::Unknown))
+                .collect();
+
+            let Some(Value::Identifier(note_name)) = filtered_args.get(0).map(|v| (*v).clone()) else {
                 println!("❌ Invalid or missing argument for 'note' method on '{}'.", target);
                 return (*max_end_time, cursor_copy);
             };
 
-            let mut final_note_params = HashMap::new();
-            if let Some(Value::Map(note_params)) = args.get(1) {
-                for (key, value) in note_params {
-                    final_note_params.insert(key.clone(), value.clone());
+            let mut note_params = HashMap::new();
+            if let Some(arg1) = filtered_args.get(1) {
+                match (*arg1).clone() {
+                    Value::Map(map) => {
+                        for (key, value) in map {
+                            note_params.insert(key, value);
+                        }
+                    }
+                    _ => {}
                 }
             }
 
-            let duration_ms = extract_f32(&final_note_params, "duration", base_bpm).unwrap_or(
-                base_duration
-            );
+            // 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 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,
+            };
+
             audio_engine.insert_note(
                 waveform.clone(),
                 final_freq,
-                amp,
+                amp_note,
                 start_time * 1000.0,
-                duration_ms
+                duration_ms,
+                synth_params,
+                note_params,
+                automation
             );
 
             *max_end_time = (*max_end_time).max(end_time);

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

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