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

package/rust/core/audio/special/math.rs

@@ -1,134 +1,134 @@
-use crate::core::store::variable::VariableTable;
-use devalang_utils::logger::{LogLevel, Logger};
-
-// Parse comma-separated arguments at top level (no nested parentheses split)
-fn parse_top_level_args(s: &str) -> Vec<&str> {
-    let mut args = Vec::new();
-    let mut depth = 0i32;
-    let mut start = 0usize;
-    for (i, ch) in s.char_indices() {
-        match ch {
-            '(' => depth += 1,
-            ')' => depth -= 1,
-            ',' if depth == 0 => {
-                args.push(s[start..i].trim());
-                start = i + 1;
-            }
-            _ => {}
-        }
-    }
-    let last = s[start..].trim();
-    if !last.is_empty() {
-        args.push(last);
-    }
-    args
-}
-
-fn eval_math_func(func: &str, args: &[f32], fallback_seed: f32) -> Option<f32> {
-    match func {
-        "sin" => args.first().copied().map(f32::sin),
-        "cos" => args.first().copied().map(f32::cos),
-        "random" => {
-            // deterministic pseudo-random based on provided seed or a fallback session seed
-            let seed = args.first().copied().unwrap_or(fallback_seed);
-            let x = (seed * 12.9898).sin() * 43_758.547;
-            Some((x.fract() * 2.0 - 1.0).clamp(-1.0, 1.0))
-        }
-        "lerp" => {
-            if args.len() >= 3 {
-                Some(args[0] + (args[1] - args[0]) * args[2])
-            } else {
-                None
-            }
-        }
-        _ => None,
-    }
-}
-
-// Find and evaluate the first $math.<fn>(...) occurrence in the string, replacing it with a number.
-// Supports multi-argument functions by splitting on top-level commas.
-pub fn find_and_eval_first_math_call<EvalFn>(
-    s: &str,
-    eval: EvalFn,
-    vars: &VariableTable,
-    bpm: f32,
-    beat: f32,
-) -> Option<String>
-where
-    EvalFn: Fn(&str, &VariableTable, f32, f32) -> Option<f32>,
-{
-    let logger = Logger::new();
-
-    let start = s.find("$math.")?;
-    let open_rel = match s[start..].find('(') {
-        Some(i) => i,
-        None => {
-            logger.log_message(
-                LogLevel::Error,
-                &format!("Malformed $math call: missing '(' in '{}'", s),
-            );
-            return None;
-        }
-    };
-    let open = start + open_rel;
-    if open <= start + 6 {
-        logger.log_message(
-            LogLevel::Error,
-            &format!("Malformed $math call: missing function name in '{}'", s),
-        );
-        return None;
-    }
-    let func = &s[start + 6..open];
-
-    // Find matching close parenthesis, handling nesting
-    let mut depth: i32 = 0;
-    let mut close_abs: Option<usize> = None;
-    for (i, ch) in s[open..].char_indices() {
-        match ch {
-            '(' => depth += 1,
-            ')' => {
-                depth -= 1;
-                if depth == 0 {
-                    close_abs = Some(open + i);
-                    break;
-                }
-            }
-            _ => {}
-        }
-    }
-    let close = match close_abs {
-        Some(c) => c,
-        None => {
-            logger.log_message(
-                LogLevel::Error,
-                &format!("Malformed $math call: missing closing ')' in '{}'", s),
-            );
-            return None;
-        }
-    };
-
-    let inner = &s[open + 1..close];
-    let raw_args = parse_top_level_args(inner);
-    let mut args: Vec<f32> = Vec::with_capacity(raw_args.len());
-    for a in raw_args {
-        if let Some(v) = eval(a, vars, bpm, beat) {
-            args.push(v);
-        } else {
-            logger.log_message(
-                LogLevel::Error,
-                &format!("Failed to evaluate argument '{}' for $math.{}", a, func),
-            );
-            return None;
-        }
-    }
-
-    // If no explicit seed is provided, use $env.seed via fallback
-    let fallback_seed = eval("$env.seed", vars, bpm, beat).unwrap_or(0.0);
-    let result = eval_math_func(func, &args, fallback_seed)?;
-
-    let mut replaced = String::new();
-    replaced.push_str(&s[..start]);
-    replaced.push_str(&result.to_string());
-    replaced.push_str(&s[close + 1..]);
-    Some(replaced)
-}
+use devalang_types::VariableTable;
+use devalang_utils::logger::{LogLevel, Logger};
+
+// Parse comma-separated arguments at top level (no nested parentheses split)
+fn parse_top_level_args(s: &str) -> Vec<&str> {
+    let mut args = Vec::new();
+    let mut depth = 0i32;
+    let mut start = 0usize;
+    for (i, ch) in s.char_indices() {
+        match ch {
+            '(' => depth += 1,
+            ')' => depth -= 1,
+            ',' if depth == 0 => {
+                args.push(s[start..i].trim());
+                start = i + 1;
+            }
+            _ => {}
+        }
+    }
+    let last = s[start..].trim();
+    if !last.is_empty() {
+        args.push(last);
+    }
+    args
+}
+
+fn eval_math_func(func: &str, args: &[f32], fallback_seed: f32) -> Option<f32> {
+    match func {
+        "sin" => args.first().copied().map(f32::sin),
+        "cos" => args.first().copied().map(f32::cos),
+        "random" => {
+            // deterministic pseudo-random based on provided seed or a fallback session seed
+            let seed = args.first().copied().unwrap_or(fallback_seed);
+            let x = (seed * 12.9898).sin() * 43_758.547;
+            Some((x.fract() * 2.0 - 1.0).clamp(-1.0, 1.0))
+        }
+        "lerp" => {
+            if args.len() >= 3 {
+                Some(args[0] + (args[1] - args[0]) * args[2])
+            } else {
+                None
+            }
+        }
+        _ => None,
+    }
+}
+
+// Find and evaluate the first $math.<fn>(...) occurrence in the string, replacing it with a number.
+// Supports multi-argument functions by splitting on top-level commas.
+pub fn find_and_eval_first_math_call<EvalFn>(
+    s: &str,
+    eval: EvalFn,
+    vars: &VariableTable,
+    bpm: f32,
+    beat: f32,
+) -> Option<String>
+where
+    EvalFn: Fn(&str, &VariableTable, f32, f32) -> Option<f32>,
+{
+    let logger = Logger::new();
+
+    let start = s.find("$math.")?;
+    let open_rel = match s[start..].find('(') {
+        Some(i) => i,
+        None => {
+            logger.log_message(
+                LogLevel::Error,
+                &format!("Malformed $math call: missing '(' in '{}'", s),
+            );
+            return None;
+        }
+    };
+    let open = start + open_rel;
+    if open <= start + 6 {
+        logger.log_message(
+            LogLevel::Error,
+            &format!("Malformed $math call: missing function name in '{}'", s),
+        );
+        return None;
+    }
+    let func = &s[start + 6..open];
+
+    // Find matching close parenthesis, handling nesting
+    let mut depth: i32 = 0;
+    let mut close_abs: Option<usize> = None;
+    for (i, ch) in s[open..].char_indices() {
+        match ch {
+            '(' => depth += 1,
+            ')' => {
+                depth -= 1;
+                if depth == 0 {
+                    close_abs = Some(open + i);
+                    break;
+                }
+            }
+            _ => {}
+        }
+    }
+    let close = match close_abs {
+        Some(c) => c,
+        None => {
+            logger.log_message(
+                LogLevel::Error,
+                &format!("Malformed $math call: missing closing ')' in '{}'", s),
+            );
+            return None;
+        }
+    };
+
+    let inner = &s[open + 1..close];
+    let raw_args = parse_top_level_args(inner);
+    let mut args: Vec<f32> = Vec::with_capacity(raw_args.len());
+    for a in raw_args {
+        if let Some(v) = eval(a, vars, bpm, beat) {
+            args.push(v);
+        } else {
+            logger.log_message(
+                LogLevel::Error,
+                &format!("Failed to evaluate argument '{}' for $math.{}", a, func),
+            );
+            return None;
+        }
+    }
+
+    // If no explicit seed is provided, use $env.seed via fallback
+    let fallback_seed = eval("$env.seed", vars, bpm, beat).unwrap_or(0.0);
+    let result = eval_math_func(func, &args, fallback_seed)?;
+
+    let mut replaced = String::new();
+    replaced.push_str(&s[..start]);
+    replaced.push_str(&result.to_string());
+    replaced.push_str(&s[close + 1..]);
+    Some(replaced)
+}

package/rust/core/audio/special/mod.rs

@@ -1,9 +1,9 @@
-pub mod easing;
-pub mod env;
-pub mod math;
-pub mod modulator;
-
-pub use easing::find_and_eval_first_easing_call;
-pub use env::resolve_env_atom;
-pub use math::find_and_eval_first_math_call;
-pub use modulator::find_and_eval_first_mod_call;
+pub mod easing;
+pub mod env;
+pub mod math;
+pub mod modulator;
+
+pub use easing::find_and_eval_first_easing_call;
+pub use env::resolve_env_atom;
+pub use math::find_and_eval_first_math_call;
+pub use modulator::find_and_eval_first_mod_call;

package/rust/core/audio/special/modulator.rs

@@ -1,143 +1,143 @@
-use crate::core::store::variable::VariableTable;
-
-fn lfo_sine(rate_per_beat: f32, beat: f32) -> f32 {
-    // Output in [-1,1]
-    (2.0 * std::f32::consts::PI * rate_per_beat * beat).sin()
-}
-
-fn lfo_triangle(rate_per_beat: f32, beat: f32) -> f32 {
-    // Triangle in [-1,1]
-    let phase = (rate_per_beat * beat).fract();
-    // Map [0,1]->[-1,1] tri
-    4.0 * (phase - 0.5).abs() - 1.0
-}
-
-fn adsr_envelope_value_t(attack: f32, decay: f32, sustain: f32, release: f32, t: f32) -> f32 {
-    let a = attack.max(0.0);
-    let d = decay.max(0.0);
-    let r = release.max(0.0);
-    let s = sustain.clamp(0.0, 1.0);
-
-    // Normalize phases so that the whole ADSR spans t in [0,1]
-    let total = (a + d + r).max(1e-6);
-    let ap = a / total;
-    let dp = d / total;
-    let rp = r / total;
-
-    if t < ap {
-        // attack (0->1)
-        if ap > 0.0 { t / ap } else { 1.0 }
-    } else if t < ap + dp {
-        // decay (1->sustain)
-        let u = (t - ap) / dp.max(1e-6);
-        1.0 - (1.0 - s) * u
-    } else if t < 1.0 - rp {
-        // sustain
-        s
-    } else {
-        // release (sustain->0)
-        let u = (t - (1.0 - rp)) / rp.max(1e-6);
-        s * (1.0 - u)
-    }
-}
-
-fn eval_mod_func(func: &str, args: &[f32], beat: f32) -> Option<f32> {
-    match func {
-        "lfo.sine" => {
-            let rate = args.first().copied().unwrap_or(1.0);
-            Some(lfo_sine(rate, beat))
-        }
-        "lfo.tri" | "lfo.triangle" => {
-            let rate = args.first().copied().unwrap_or(1.0);
-            Some(lfo_triangle(rate, beat))
-        }
-        // ADSR envelope normalized over t in [0,1]
-        // $mod.envelope(attack, decay, sustain, release, t)
-        "envelope" | "mod.envelope" => {
-            if args.len() >= 5 {
-                Some(adsr_envelope_value_t(
-                    args[0],
-                    args[1],
-                    args[2],
-                    args[3],
-                    args[4].clamp(0.0, 1.0),
-                ))
-            } else {
-                None
-            }
-        }
-        _ => None,
-    }
-}
-
-fn parse_top_level_args(s: &str) -> Vec<&str> {
-    let mut args = Vec::new();
-    let mut depth = 0i32;
-    let mut start = 0usize;
-    for (i, ch) in s.char_indices() {
-        match ch {
-            '(' => depth += 1,
-            ')' => depth -= 1,
-            ',' if depth == 0 => {
-                args.push(s[start..i].trim());
-                start = i + 1;
-            }
-            _ => {}
-        }
-    }
-    let last = s[start..].trim();
-    if !last.is_empty() {
-        args.push(last);
-    }
-    args
-}
-
-// Find and evaluate the first $mod.<fn>(...) occurrence in the string.
-pub fn find_and_eval_first_mod_call<EvalFn>(
-    s: &str,
-    eval: EvalFn,
-    vars: &VariableTable,
-    bpm: f32,
-    beat: f32,
-) -> Option<String>
-where
-    EvalFn: Fn(&str, &VariableTable, f32, f32) -> Option<f32>,
-{
-    let start = s.find("$mod.")?;
-    let open_rel = s[start..].find('(')?;
-    let open = start + open_rel;
-    let func = &s[start + 5..open];
-
-    // matching close
-    let mut depth: i32 = 0;
-    let mut close_abs: Option<usize> = None;
-    for (i, ch) in s[open..].char_indices() {
-        match ch {
-            '(' => depth += 1,
-            ')' => {
-                depth -= 1;
-                if depth == 0 {
-                    close_abs = Some(open + i);
-                    break;
-                }
-            }
-            _ => {}
-        }
-    }
-    let close = close_abs?;
-
-    let inner = &s[open + 1..close];
-    let raw_args = parse_top_level_args(inner);
-    let mut args: Vec<f32> = Vec::with_capacity(raw_args.len());
-    for a in raw_args {
-        args.push(eval(a, vars, bpm, beat)?);
-    }
-
-    let result = eval_mod_func(func, &args, beat)?;
-
-    let mut replaced = String::new();
-    replaced.push_str(&s[..start]);
-    replaced.push_str(&result.to_string());
-    replaced.push_str(&s[close + 1..]);
-    Some(replaced)
-}
+use devalang_types::VariableTable;
+
+fn lfo_sine(rate_per_beat: f32, beat: f32) -> f32 {
+    // Output in [-1,1]
+    (2.0 * std::f32::consts::PI * rate_per_beat * beat).sin()
+}
+
+fn lfo_triangle(rate_per_beat: f32, beat: f32) -> f32 {
+    // Triangle in [-1,1]
+    let phase = (rate_per_beat * beat).fract();
+    // Map [0,1]->[-1,1] tri
+    4.0 * (phase - 0.5).abs() - 1.0
+}
+
+fn adsr_envelope_value_t(attack: f32, decay: f32, sustain: f32, release: f32, t: f32) -> f32 {
+    let a = attack.max(0.0);
+    let d = decay.max(0.0);
+    let r = release.max(0.0);
+    let s = sustain.clamp(0.0, 1.0);
+
+    // Normalize phases so that the whole ADSR spans t in [0,1]
+    let total = (a + d + r).max(1e-6);
+    let ap = a / total;
+    let dp = d / total;
+    let rp = r / total;
+
+    if t < ap {
+        // attack (0->1)
+        if ap > 0.0 { t / ap } else { 1.0 }
+    } else if t < ap + dp {
+        // decay (1->sustain)
+        let u = (t - ap) / dp.max(1e-6);
+        1.0 - (1.0 - s) * u
+    } else if t < 1.0 - rp {
+        // sustain
+        s
+    } else {
+        // release (sustain->0)
+        let u = (t - (1.0 - rp)) / rp.max(1e-6);
+        s * (1.0 - u)
+    }
+}
+
+fn eval_mod_func(func: &str, args: &[f32], beat: f32) -> Option<f32> {
+    match func {
+        "lfo.sine" => {
+            let rate = args.first().copied().unwrap_or(1.0);
+            Some(lfo_sine(rate, beat))
+        }
+        "lfo.tri" | "lfo.triangle" => {
+            let rate = args.first().copied().unwrap_or(1.0);
+            Some(lfo_triangle(rate, beat))
+        }
+        // ADSR envelope normalized over t in [0,1]
+        // $mod.envelope(attack, decay, sustain, release, t)
+        "envelope" | "mod.envelope" => {
+            if args.len() >= 5 {
+                Some(adsr_envelope_value_t(
+                    args[0],
+                    args[1],
+                    args[2],
+                    args[3],
+                    args[4].clamp(0.0, 1.0),
+                ))
+            } else {
+                None
+            }
+        }
+        _ => None,
+    }
+}
+
+fn parse_top_level_args(s: &str) -> Vec<&str> {
+    let mut args = Vec::new();
+    let mut depth = 0i32;
+    let mut start = 0usize;
+    for (i, ch) in s.char_indices() {
+        match ch {
+            '(' => depth += 1,
+            ')' => depth -= 1,
+            ',' if depth == 0 => {
+                args.push(s[start..i].trim());
+                start = i + 1;
+            }
+            _ => {}
+        }
+    }
+    let last = s[start..].trim();
+    if !last.is_empty() {
+        args.push(last);
+    }
+    args
+}
+
+// Find and evaluate the first $mod.<fn>(...) occurrence in the string.
+pub fn find_and_eval_first_mod_call<EvalFn>(
+    s: &str,
+    eval: EvalFn,
+    vars: &VariableTable,
+    bpm: f32,
+    beat: f32,
+) -> Option<String>
+where
+    EvalFn: Fn(&str, &VariableTable, f32, f32) -> Option<f32>,
+{
+    let start = s.find("$mod.")?;
+    let open_rel = s[start..].find('(')?;
+    let open = start + open_rel;
+    let func = &s[start + 5..open];
+
+    // matching close
+    let mut depth: i32 = 0;
+    let mut close_abs: Option<usize> = None;
+    for (i, ch) in s[open..].char_indices() {
+        match ch {
+            '(' => depth += 1,
+            ')' => {
+                depth -= 1;
+                if depth == 0 {
+                    close_abs = Some(open + i);
+                    break;
+                }
+            }
+            _ => {}
+        }
+    }
+    let close = close_abs?;
+
+    let inner = &s[open + 1..close];
+    let raw_args = parse_top_level_args(inner);
+    let mut args: Vec<f32> = Vec::with_capacity(raw_args.len());
+    for a in raw_args {
+        args.push(eval(a, vars, bpm, beat)?);
+    }
+
+    let result = eval_mod_func(func, &args, beat)?;
+
+    let mut replaced = String::new();
+    replaced.push_str(&s[..start]);
+    replaced.push_str(&result.to_string());
+    replaced.push_str(&s[close + 1..]);
+    Some(replaced)
+}

package/rust/core/builder/mod.rs

@@ -1,4 +1,4 @@
-use crate::core::audio::renderer::render_audio_with_modules;
+use crate::core::audio::engine::render_audio_with_modules;
 use crate::core::parser::statement::Statement;
 use crate::core::store::global::GlobalStore;
 use devalang_utils::logger::Logger;
@@ -48,6 +48,8 @@ impl Builder {
         modules: &HashMap<String, Vec<Statement>>,
         normalized_output_dir: &str,
         global_store: &mut GlobalStore,
+        audio_format: Option<String>,
+        sample_rate: Option<u32>,
     ) {
         let logger = Logger::new();
 
@@ -69,7 +71,7 @@ impl Builder {
                 normalized_output_dir, formatted_module_name
             );
 
-            match audio_engine.generate_wav_file(&output_path) {
+            match audio_engine.generate_wav_file(&output_path, audio_format.clone(), sample_rate) {
                 Ok(_) => {}
                 Err(msg) => {
                     logger.log_error_with_stacktrace(
@@ -83,4 +85,45 @@ impl Builder {
             }
         }
     }
+
+    pub fn build_midi(
+        &self,
+        modules: &HashMap<String, Vec<Statement>>,
+        normalized_output_dir: &str,
+        global_store: &mut GlobalStore,
+    ) {
+        let logger = Logger::new();
+
+        let audio_engines =
+            render_audio_with_modules(modules.clone(), normalized_output_dir, global_store);
+
+        create_dir_all(format!("{}/midi", normalized_output_dir))
+            .expect("Failed to create MIDI directory");
+
+        for (module_name, mut audio_engine) in audio_engines {
+            let formatted_module_name = module_name
+                .split('/')
+                .next_back()
+                .unwrap_or(&module_name)
+                .replace(".deva", "");
+
+            let output_path = format!(
+                "{}/midi/{}.mid",
+                normalized_output_dir, formatted_module_name
+            );
+
+            match audio_engine.generate_midi_file(&output_path, None, None) {
+                Ok(_) => {}
+                Err(msg) => {
+                    logger.log_error_with_stacktrace(
+                        &format!(
+                            "Unable to generate MIDI file for module '{}': {}",
+                            formatted_module_name, msg
+                        ),
+                        &module_name,
+                    );
+                }
+            }
+        }
+    }
 }