@devaloop/devalang 0.0.1-beta.2 → 0.0.1-beta.3

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

@@ -1,116 +1,116 @@
-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)
-}
+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 +1,97 @@
-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)
-}
+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 +1,100 @@
-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)
-}
+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 +1,16 @@
-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
-}
+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
+}