@devaloop/devalang 0.0.1-beta.2 → 0.1.1

package/rust/core/audio/loader/trigger.rs

@@ -1,98 +0,0 @@
-use crate::core::parser::statement::StatementKind;
-use devalang_types::store::VariableTable;
-use devalang_types::{Duration, Value};
-
-pub fn load_trigger(
-    trigger: &Value,
-    duration: &Duration,
-    _effects: &Option<Value>,
-    base_duration: f32,
-    variable_table: VariableTable,
-) -> (String, f32) {
-    let mut trigger_path = String::new();
-    let mut duration_as_secs = 0.0;
-
-    match trigger {
-        Value::String(src) => {
-            trigger_path = src.to_string();
-        }
-        Value::Identifier(src) => {
-            trigger_path = src.to_string();
-        }
-
-        Value::Map(map) => {
-            if let Some(Value::String(src)) = map.get("entity") {
-                trigger_path = format!("devalang://bank/{}", src);
-            } else if let Some(Value::Identifier(src)) = map.get("entity") {
-                trigger_path = format!("devalang://bank/{}", src);
-            } else {
-                eprintln!(
-                    "❌ Trigger map must contain an 'entity' key with a string or identifier value."
-                );
-            }
-        }
-        Value::Sample(src) => {
-            trigger_path = src.to_string();
-        }
-        Value::Statement(stmt) => {
-            if let StatementKind::Trigger {
-                entity,
-                duration: _,
-                effects: _,
-            } = &stmt.kind
-            {
-                trigger_path = entity.clone();
-            } else {
-                eprintln!(
-                    "❌ Trigger statement must be of type 'Trigger', found: {:?}",
-                    stmt.kind
-                );
-            }
-        }
-        _ => {
-            eprintln!(
-                "❌ Invalid trigger type. Expected a string or identifier variable, found: {:?}",
-                trigger
-            );
-        }
-    }
-
-    match duration {
-        Duration::Identifier(duration_identifier) => {
-            if duration_identifier == "auto" {
-                duration_as_secs = base_duration;
-            } else if let Some(Value::Number(num)) = variable_table.get(duration_identifier) {
-                duration_as_secs = *num;
-            } else if let Some(Value::String(num_str)) = variable_table.get(duration_identifier) {
-                duration_as_secs = num_str.parse::<f32>().unwrap_or(base_duration);
-            } else if let Some(Value::Identifier(num_str)) = variable_table.get(duration_identifier)
-            {
-                duration_as_secs = num_str.parse::<f32>().unwrap_or(base_duration);
-            } else {
-                eprintln!("❌ Invalid duration identifier: {}", duration_identifier);
-            }
-        }
-
-        Duration::Number(num) => {
-            duration_as_secs = *num;
-        }
-
-        Duration::Auto => {
-            duration_as_secs = base_duration;
-        }
-
-        Duration::Beat(beat_str) => {
-            let parts: Vec<&str> = beat_str.split('/').collect();
-
-            if parts.len() == 2 {
-                let numerator: f32 = parts[0].parse().unwrap_or(1.0);
-                let denominator: f32 = parts[1].parse().unwrap_or(1.0);
-                duration_as_secs = (numerator / denominator) * base_duration;
-            } else {
-                eprintln!("❌ Invalid beat duration format: {}", beat_str);
-            }
-        }
-    }
-
-    (trigger_path, duration_as_secs)
-}

package/rust/core/audio/mod.rs

@@ -1,6 +0,0 @@
-pub mod engine;
-pub mod evaluator;
-pub mod interpreter;
-pub mod loader;
-pub mod player;
-pub mod special;

package/rust/core/audio/player.rs

@@ -1,70 +0,0 @@
-use rodio::{Decoder, OutputStream, OutputStreamHandle, Sink, Source};
-use std::{fs::File, io::BufReader};
-
-pub struct AudioPlayer {
-    _stream: OutputStream,
-    handle: OutputStreamHandle,
-    sink: Sink,
-    last_path: Option<String>,
-}
-
-impl Default for AudioPlayer {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl AudioPlayer {
-    pub fn new() -> Self {
-        let (stream, handle) = OutputStream::try_default().unwrap();
-        let sink = Sink::try_new(&handle).unwrap();
-
-        Self {
-            _stream: stream,
-            handle,
-            sink,
-            last_path: None,
-        }
-    }
-
-    fn load_source(&self, path: &str) -> Option<impl Source<Item = f32> + Send + 'static> {
-        if let Ok(file) = File::open(path) {
-            let reader = BufReader::new(file);
-            match Decoder::new(reader) {
-                Ok(decoder) => Some(decoder.convert_samples()),
-                Err(e) => {
-                    eprintln!("❌ Failed to decode audio file '{}': {}", path, e);
-                    None
-                }
-            }
-        } else {
-            eprintln!("❌ Could not open audio file: {}", path);
-            None
-        }
-    }
-
-    pub fn play_file_once(&mut self, path: &str) {
-        self.sink.stop();
-        self.sink = Sink::try_new(&self.handle).unwrap();
-        self.sink.set_volume(1.0);
-
-        if let Some(source) = self.load_source(path) {
-            self.sink.append(source);
-            self.last_path = Some(path.to_string());
-        } else {
-            eprintln!("⚠️ Skipping playback: failed to load '{}'", path);
-        }
-    }
-
-    pub fn replay_last(&mut self) {
-        if let Some(path) = self.last_path.clone() {
-            self.play_file_once(&path);
-        } else {
-            eprintln!("⚠️ No previous audio to replay.");
-        }
-    }
-
-    pub fn wait_until_end(&self) {
-        self.sink.sleep_until_end();
-    }
-}

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

@@ -1,189 +0,0 @@
-use devalang_types::VariableTable;
-
-// Basic easing functions operating on t in [0,1]
-fn easing_value(func: &str, t: f32) -> Option<f32> {
-    let x = t.clamp(0.0, 1.0);
-    match func {
-        "linear" => Some(x),
-        "easeInQuad" => Some(x * x),
-        "easeOutQuad" => Some(x * (2.0 - x)),
-        "easeInOutQuad" => {
-            if x < 0.5 {
-                Some(2.0 * x * x)
-            } else {
-                Some(-1.0 + (4.0 - 2.0 * x) * x)
-            }
-        }
-        // Cubic
-        "easeInCubic" => Some(x * x * x),
-        "easeOutCubic" => Some(1.0 - (1.0 - x).powi(3)),
-        "easeInOutCubic" => {
-            if x < 0.5 {
-                Some(4.0 * x * x * x)
-            } else {
-                Some(1.0 - (-2.0 * x + 2.0).powi(3) / 2.0)
-            }
-        }
-        // Quartic
-        "easeInQuart" => Some(x.powi(4)),
-        "easeOutQuart" => Some(1.0 - (1.0 - x).powi(4)),
-        "easeInOutQuart" => {
-            if x < 0.5 {
-                Some(8.0 * x.powi(4))
-            } else {
-                Some(1.0 - (-2.0 * x + 2.0).powi(4) / 2.0)
-            }
-        }
-        // Exponential
-        "easeInExpo" => Some(if x <= 0.0 {
-            0.0
-        } else {
-            2.0_f32.powf(10.0 * x - 10.0)
-        }),
-        "easeOutExpo" => Some(if x >= 1.0 {
-            1.0
-        } else {
-            1.0 - 2.0_f32.powf(-10.0 * x)
-        }),
-        "easeInOutExpo" => Some(if x <= 0.0 {
-            0.0
-        } else if x >= 1.0 {
-            1.0
-        } else if x < 0.5 {
-            2.0_f32.powf(20.0 * x - 10.0) / 2.0
-        } else {
-            (2.0 - 2.0_f32.powf(-20.0 * x + 10.0)) / 2.0
-        }),
-        // Back (overshoot c ~ 1.70158)
-        "easeInBack" => {
-            let c = 1.70158;
-            Some((c + 1.0) * x * x * x - c * x * x)
-        }
-        "easeOutBack" => {
-            let c = 1.70158;
-            let y = 1.0 - x;
-            Some(1.0 - ((c + 1.0) * y * y * y - c * y * y))
-        }
-        "easeInOutBack" => {
-            let c1 = 1.70158;
-            let c2 = c1 * 1.525;
-            let x2 = x * 2.0;
-            if x2 < 1.0 {
-                Some((x2 * x2 * ((c2 + 1.0) * x2 - c2)) / 2.0)
-            } else {
-                let x2 = x2 - 2.0;
-                Some((x2 * x2 * ((c2 + 1.0) * x2 + c2)) / 2.0 + 1.0)
-            }
-        }
-        // Elastic
-        "easeInElastic" => {
-            if x == 0.0 {
-                Some(0.0)
-            } else if x == 1.0 {
-                Some(1.0)
-            } else {
-                let c = 2.0 * std::f32::consts::PI / 3.0;
-                Some(-(2.0_f32.powf(10.0 * x - 10.0)) * ((x * 10.0 - 10.75) * c).sin())
-            }
-        }
-        "easeOutElastic" => {
-            if x == 0.0 {
-                Some(0.0)
-            } else if x == 1.0 {
-                Some(1.0)
-            } else {
-                let c = 2.0 * std::f32::consts::PI / 3.0;
-                Some(2.0_f32.powf(-10.0 * x) * ((x * 10.0 - 0.75) * c).sin() + 1.0)
-            }
-        }
-        "easeInOutElastic" => {
-            if x == 0.0 {
-                Some(0.0)
-            } else if x == 1.0 {
-                Some(1.0)
-            } else {
-                let c = 2.0 * std::f32::consts::PI / 4.5;
-                if x < 0.5 {
-                    Some(-(2.0_f32.powf(20.0 * x - 10.0)) * ((20.0 * x - 11.125) * c).sin() / 2.0)
-                } else {
-                    Some(
-                        2.0_f32.powf(-20.0 * x + 10.0) * ((20.0 * x - 11.125) * c).sin() / 2.0
-                            + 1.0,
-                    )
-                }
-            }
-        }
-        // Bounce helpers
-        "easeInBounce" => Some(1.0 - bounce_out(1.0 - x)),
-        "easeOutBounce" => Some(bounce_out(x)),
-        "easeInOutBounce" => Some(if x < 0.5 {
-            (1.0 - bounce_out(1.0 - 2.0 * x)) / 2.0
-        } else {
-            (1.0 + bounce_out(2.0 * x - 1.0)) / 2.0
-        }),
-        _ => None,
-    }
-}
-
-fn bounce_out(x: f32) -> f32 {
-    let n1 = 7.5625;
-    let d1 = 2.75;
-    if x < 1.0 / d1 {
-        n1 * x * x
-    } else if x < 2.0 / d1 {
-        let x = x - 1.5 / d1;
-        n1 * x * x + 0.75
-    } else if x < 2.5 / d1 {
-        let x = x - 2.25 / d1;
-        n1 * x * x + 0.9375
-    } else {
-        let x = x - 2.625 / d1;
-        n1 * x * x + 0.984375
-    }
-}
-
-// Find and evaluate the first $easing.<fn>(...) occurrence in the string.
-// Accepts a single argument expression producing t in [0,1].
-pub fn find_and_eval_first_easing_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("$easing.")?;
-    let open_rel = s[start..].find('(')?;
-    let open = start + open_rel;
-    let func = &s[start + 9..open];
-
-    // Find matching close parenthesis
-    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 t = eval(inner, vars, bpm, beat)?;
-    let result = easing_value(func, t)?;
-
-    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/env.rs

@@ -1,45 +0,0 @@
-use devalang_types::Value;
-
-use devalang_types::VariableTable;
-use std::sync::OnceLock;
-use std::time::{SystemTime, UNIX_EPOCH};
-
-static SESSION_SEED: OnceLock<f32> = OnceLock::new();
-
-pub fn get_session_seed() -> f32 {
-    *SESSION_SEED.get_or_init(|| {
-        let now = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .unwrap_or_default();
-        // Build a stable 0..1 seed from nanos
-        let nanos = now.subsec_nanos();
-        ((nanos as f32) / 1_000_000_000.0).clamp(0.0, 1.0)
-    })
-}
-
-// Resolve special environment variables like $env.bpm, $env.beat, $env.position
-// For now, $env.position is treated as an alias of beat.
-pub fn resolve_env_atom(atom: &str, bpm: f32, beat: f32) -> Option<f32> {
-    match atom {
-        "$env.bpm" => Some(bpm),
-        "$env.beat" => Some(beat),
-        "$env.position" => Some(beat),
-        // Optional seed for deterministic randomness
-        "$env.seed" => Some(get_session_seed()),
-        _ => None,
-    }
-}
-
-// Utility: resolve an identifier or numeric literal to f32 using the variable table
-pub fn resolve_atom_or_var(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
-}

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

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