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

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

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

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

@@ -0,0 +1,192 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +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)
+}

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

@@ -0,0 +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)
+}

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

@@ -0,0 +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)
+}

package/rust/core/audio/interpreter/{automate.rs → statements/automate.rs}

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

package/rust/core/audio/interpreter/{call.rs → statements/call.rs}

@@ -3,8 +3,9 @@ use devalang_types::{Duration, Value};
 use crate::core::{
     audio::{engine::AudioEngine, interpreter::driver::execute_audio_block},
     parser::statement::{Statement, StatementKind},
-    store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
+    store::global::GlobalStore,
 };
+use devalang_types::store::{FunctionTable, VariableTable};
 
 pub fn interprete_call_statement(
     stmt: &Statement,
@@ -84,9 +85,9 @@ pub fn interprete_call_statement(
                 // Build a variable table snapshot for resolution like triggers do
                 // Preserve the full parent chain so lookups behave the same as runtime
                 fn clone_with_parents(
-                    orig: &crate::core::store::variable::VariableTable,
-                ) -> crate::core::store::variable::VariableTable {
-                    crate::core::store::variable::VariableTable {
+                    orig: &devalang_types::VariableTable,
+                ) -> devalang_types::VariableTable {
+                    devalang_types::VariableTable {
                         variables: orig.variables.clone(),
                         parent: orig
                             .parent

package/rust/core/audio/interpreter/{condition.rs → statements/condition.rs}

@@ -6,8 +6,9 @@ use crate::core::{
         interpreter::driver::execute_audio_block,
     },
     parser::statement::Statement,
-    store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
+    store::global::GlobalStore,
 };
+use devalang_types::store::{FunctionTable, VariableTable};
 
 pub fn interprete_condition_statement(
     stmt: &Statement,

package/rust/core/audio/interpreter/{function.rs → statements/function.rs}

@@ -1,7 +1,5 @@
-use crate::core::{
-    parser::statement::{Statement, StatementKind},
-    store::function::{FunctionDef, FunctionTable},
-};
+use crate::core::parser::statement::{Statement, StatementKind};
+use devalang_types::store::{FunctionDef, FunctionTable};
 
 pub fn interprete_function_statement(
     stmt: &Statement,

package/rust/core/audio/interpreter/{let_.rs → statements/let_.rs}

@@ -1,8 +1,6 @@
-use crate::core::{
-    parser::statement::{Statement, StatementKind},
-    store::variable::VariableTable,
-};
+use crate::core::parser::statement::{Statement, StatementKind};
 use devalang_types::Value;
+use devalang_types::store::VariableTable;
 
 pub fn interprete_let_statement(
     stmt: &Statement,

package/rust/core/audio/interpreter/{load.rs → statements/load.rs}

@@ -1,9 +1,7 @@
 use devalang_types::Value;
 
-use crate::core::{
-    parser::statement::{Statement, StatementKind},
-    store::variable::VariableTable,
-};
+use crate::core::parser::statement::{Statement, StatementKind};
+use devalang_types::store::VariableTable;
 
 pub fn interprete_load_statement(
     stmt: &Statement,

package/rust/core/audio/interpreter/{loop_.rs → statements/loop_.rs}

@@ -3,8 +3,9 @@ use devalang_types::Value;
 use crate::core::{
     audio::{engine::AudioEngine, interpreter::driver::execute_audio_block},
     parser::statement::Statement,
-    store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
+    store::global::GlobalStore,
 };
+use devalang_types::store::{FunctionTable, VariableTable};
 
 pub fn interprete_loop_statement(
     stmt: &Statement,

package/rust/core/audio/interpreter/statements/mod.rs

@@ -0,0 +1,12 @@
+pub mod arrow_call;
+pub mod automate;
+pub mod call;
+pub mod condition;
+pub mod function;
+pub mod let_;
+pub mod load;
+pub mod loop_;
+pub mod sleep;
+pub mod spawn;
+pub mod tempo;
+pub mod trigger;