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

package/rust/config/ops.rs

@@ -1,26 +1,26 @@
-use crate::config::driver::ProjectConfig;
-use std::fs;
-use std::path::Path;
-
-pub fn load_config(path: Option<&Path>) -> Option<ProjectConfig> {
-    let config_path_buf;
-    let config_path = match path {
-        Some(p) => p,
-        None => {
-            config_path_buf = match devalang_utils::path::get_devalang_config_path() {
-                Ok(p) => p,
-                Err(_) => {
-                    return None;
-                }
-            };
-            &config_path_buf
-        }
-    };
-
-    if config_path.exists() {
-        let content = fs::read_to_string(config_path).ok()?;
-        toml::from_str(&content).ok()
-    } else {
-        None
-    }
-}
+use crate::config::driver::ProjectConfig;
+use std::fs;
+use std::path::Path;
+
+pub fn load_config(path: Option<&Path>) -> Option<ProjectConfig> {
+    let config_path_buf;
+    let config_path = match path {
+        Some(p) => p,
+        None => {
+            config_path_buf = match devalang_utils::path::get_devalang_config_path() {
+                Ok(p) => p,
+                Err(_) => {
+                    return None;
+                }
+            };
+            &config_path_buf
+        }
+    };
+
+    if config_path.exists() {
+        let content = fs::read_to_string(config_path).ok()?;
+        toml::from_str(&content).ok()
+    } else {
+        None
+    }
+}

package/rust/config/settings.rs

@@ -1,101 +1,101 @@
-use devalang_types::{TelemetrySettings, UserSettings};
-use serde_json::Value as JsonValue;
-use std::io::Write;
-
-pub fn get_home_dir() -> Option<std::path::PathBuf> {
-    dirs::home_dir()
-}
-
-pub fn get_devalang_homedir() -> std::path::PathBuf {
-    if let Some(home_dir) = get_home_dir() {
-        home_dir.join(".devalang")
-    } else {
-        std::path::PathBuf::from("~/.devalang")
-    }
-}
-
-pub fn get_default_user_config() -> UserSettings {
-    UserSettings {
-        session: "".into(),
-        telemetry: TelemetrySettings {
-            uuid: uuid::Uuid::new_v4().to_string(),
-            enabled: false,
-            level: "basic".into(),
-            stats: false,
-        },
-    }
-}
-
-pub fn get_user_config() -> Option<UserSettings> {
-    if let Some(config_path) = get_devalang_homedir().join("config.json").into() {
-        let file = std::fs::File::open(config_path).ok()?;
-        let settings = serde_json::from_reader(file).ok()?;
-        Some(settings)
-    } else {
-        None
-    }
-}
-
-pub fn write_user_config_file() {
-    if let Some(config_path) = get_devalang_homedir().join("config.json").into() {
-        let settings = get_user_config().unwrap_or_else(get_default_user_config);
-
-        let config_json = serde_json::to_string(&settings).unwrap();
-
-        if let Err(e) = write_config_atomic(&config_path, &config_json) {
-            println!("Could not write config file: {}", e);
-        }
-    } else {
-        println!("Could not create config file");
-    }
-}
-
-pub fn ensure_user_config_file_exists() {
-    if let Some(config_path) = get_devalang_homedir().join("config.json").into() {
-        if !config_path.exists() {
-            write_user_config_file();
-        }
-    }
-}
-
-pub fn set_user_config_value(key: &str, value: JsonValue) {
-    let mut settings = get_user_config().unwrap_or_default();
-
-    match (key, &value) {
-        ("telemetry", JsonValue::Bool(b)) => {
-            settings.telemetry.enabled = *b;
-        }
-        ("session", JsonValue::String(s)) => {
-            settings.session = s.clone();
-        }
-        _ => {
-            println!("Unsupported key or value type for '{}': {:?}", key, value);
-        }
-    }
-
-    if let Some(config_path) = get_devalang_homedir().join("config.json").into() {
-        let config_json = serde_json::to_string(&settings).unwrap();
-        if let Err(e) = write_config_atomic(&config_path, &config_json) {
-            println!("Could not write config file: {}", e);
-        }
-    } else {
-        println!("Could not create config file");
-    }
-}
-
-pub fn write_config_atomic(
-    config_path: &std::path::PathBuf,
-    contents: &str,
-) -> std::io::Result<()> {
-    if let Some(parent) = config_path.parent() {
-        std::fs::create_dir_all(parent)?;
-    }
-
-    let tmp_path = config_path.with_extension("json.tmp");
-    let mut tmp_file = std::fs::File::create(&tmp_path)?;
-    tmp_file.write_all(contents.as_bytes())?;
-    tmp_file.sync_all()?;
-    std::fs::rename(&tmp_path, config_path)?;
-
-    Ok(())
-}
+use devalang_types::{TelemetrySettings, UserSettings};
+use serde_json::Value as JsonValue;
+use std::io::Write;
+
+pub fn get_home_dir() -> Option<std::path::PathBuf> {
+    dirs::home_dir()
+}
+
+pub fn get_devalang_homedir() -> std::path::PathBuf {
+    if let Some(home_dir) = get_home_dir() {
+        home_dir.join(".devalang")
+    } else {
+        std::path::PathBuf::from("~/.devalang")
+    }
+}
+
+pub fn get_default_user_config() -> UserSettings {
+    UserSettings {
+        session: "".into(),
+        telemetry: TelemetrySettings {
+            uuid: uuid::Uuid::new_v4().to_string(),
+            enabled: false,
+            level: "basic".into(),
+            stats: false,
+        },
+    }
+}
+
+pub fn get_user_config() -> Option<UserSettings> {
+    if let Some(config_path) = get_devalang_homedir().join("config.json").into() {
+        let file = std::fs::File::open(config_path).ok()?;
+        let settings = serde_json::from_reader(file).ok()?;
+        Some(settings)
+    } else {
+        None
+    }
+}
+
+pub fn write_user_config_file() {
+    if let Some(config_path) = get_devalang_homedir().join("config.json").into() {
+        let settings = get_user_config().unwrap_or_else(get_default_user_config);
+
+        let config_json = serde_json::to_string(&settings).unwrap();
+
+        if let Err(e) = write_config_atomic(&config_path, &config_json) {
+            println!("Could not write config file: {}", e);
+        }
+    } else {
+        println!("Could not create config file");
+    }
+}
+
+pub fn ensure_user_config_file_exists() {
+    if let Some(config_path) = get_devalang_homedir().join("config.json").into() {
+        if !config_path.exists() {
+            write_user_config_file();
+        }
+    }
+}
+
+pub fn set_user_config_value(key: &str, value: JsonValue) {
+    let mut settings = get_user_config().unwrap_or_default();
+
+    match (key, &value) {
+        ("telemetry", JsonValue::Bool(b)) => {
+            settings.telemetry.enabled = *b;
+        }
+        ("session", JsonValue::String(s)) => {
+            settings.session = s.clone();
+        }
+        _ => {
+            println!("Unsupported key or value type for '{}': {:?}", key, value);
+        }
+    }
+
+    if let Some(config_path) = get_devalang_homedir().join("config.json").into() {
+        let config_json = serde_json::to_string(&settings).unwrap();
+        if let Err(e) = write_config_atomic(&config_path, &config_json) {
+            println!("Could not write config file: {}", e);
+        }
+    } else {
+        println!("Could not create config file");
+    }
+}
+
+pub fn write_config_atomic(
+    config_path: &std::path::PathBuf,
+    contents: &str,
+) -> std::io::Result<()> {
+    if let Some(parent) = config_path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+
+    let tmp_path = config_path.with_extension("json.tmp");
+    let mut tmp_file = std::fs::File::create(&tmp_path)?;
+    tmp_file.write_all(contents.as_bytes())?;
+    tmp_file.sync_all()?;
+    std::fs::rename(&tmp_path, config_path)?;
+
+    Ok(())
+}

package/rust/core/audio/engine/driver.rs

@@ -0,0 +1,237 @@
+use devalang_types::Value;
+use std::collections::HashMap;
+
+// Minimal representation of a MIDI note event for export purposes.
+#[derive(Debug, Clone, PartialEq)]
+pub struct MidiNoteEvent {
+    /// MIDI key number 0-127
+    pub key: u8,
+    /// velocity 0-127
+    pub vel: u8,
+    /// start time in milliseconds (absolute)
+    pub start_ms: u32,
+    /// duration in milliseconds
+    pub duration_ms: u32,
+    /// MIDI channel (0-15)
+    pub channel: u8,
+}
+
+// Sample rate and channel constants used throughout the engine.
+pub const SAMPLE_RATE: u32 = 44100;
+pub const CHANNELS: u16 = 2;
+
+/// AudioEngine holds the generated interleaved stereo buffer and
+/// provides simple utilities to mix/merge buffers and export WAV files.
+///
+/// Notes:
+/// - Buffer is interleaved stereo (L,R,L,R...).
+/// - Methods are synchronous and operate on in-memory buffers.
+///
+#[derive(Debug, Clone, PartialEq)]
+pub struct AudioEngine {
+    /// Master volume multiplier (not automatically applied by helpers).
+    pub volume: f32,
+    /// Interleaved i16 PCM buffer.
+    pub buffer: Vec<i16>,
+    /// Collected MIDI note events for export (non-audio representation).
+    pub midi_events: Vec<MidiNoteEvent>,
+    /// Map target synth -> last inserted note sample ranges (start_sample, total_samples)
+    pub last_notes: std::collections::HashMap<String, Vec<(usize, usize)>>,
+    /// Logical module name used for error traces/diagnostics.
+    pub module_name: String,
+    /// Simple diagnostic counter for inserted notes.
+    pub note_count: usize,
+    /// Sample rate (can be overridden per-engine)
+    pub sample_rate: u32,
+    /// Number of channels (interleaved). Defaults to 2.
+    pub channels: u16,
+}
+
+impl AudioEngine {
+    pub fn new(module_name: String) -> Self {
+        AudioEngine {
+            volume: 1.0,
+            buffer: vec![],
+            midi_events: Vec::new(),
+            module_name,
+            note_count: 0,
+            sample_rate: SAMPLE_RATE,
+            channels: CHANNELS,
+            last_notes: std::collections::HashMap::new(),
+        }
+    }
+
+    pub fn get_buffer(&self) -> &[i16] {
+        &self.buffer
+    }
+
+    pub fn get_normalized_buffer(&self) -> Vec<f32> {
+        self.buffer.iter().map(|&s| (s as f32) / 32768.0).collect()
+    }
+
+    pub fn mix(&mut self, other: &AudioEngine) {
+        let max_len = self.buffer.len().max(other.buffer.len());
+        self.buffer.resize(max_len, 0);
+
+        for (i, &sample) in other.buffer.iter().enumerate() {
+            self.buffer[i] = self.buffer[i].saturating_add(sample);
+        }
+    }
+
+    pub fn merge_with(&mut self, other: AudioEngine) {
+        // If the other buffer is empty, simply return without warning (common for spawns that produced nothing)
+        if other.buffer.is_empty() {
+            return;
+        }
+
+        // If the other buffer is present but contains only zeros, warn and skip merge
+        if other.buffer.iter().all(|&s| s == 0) {
+            eprintln!("⚠️ Skipping merge: other buffer is silent");
+            return;
+        }
+
+        if self.buffer.iter().all(|&s| s == 0) {
+            self.buffer = other.buffer;
+            return;
+        }
+
+        self.mix(&other);
+    }
+
+    pub fn set_duration(&mut self, duration_secs: f32) {
+        let total_samples =
+            (duration_secs * (self.sample_rate as f32) * (self.channels as f32)) as usize;
+
+        if self.buffer.len() < total_samples {
+            self.buffer.resize(total_samples, 0);
+        }
+    }
+
+    pub fn generate_midi_file(
+        &mut self,
+        output_path: &String,
+        bpm: Option<f32>,
+        tpqn: Option<u16>,
+    ) -> Result<(), String> {
+        crate::core::audio::engine::export::generate_midi_file_impl(
+            &self.midi_events,
+            output_path,
+            bpm,
+            tpqn,
+        )
+    }
+
+    pub fn generate_wav_file(
+        &mut self,
+        output_dir: &String,
+        audio_format: Option<String>,
+        sample_rate: Option<u32>,
+    ) -> Result<(), String> {
+        crate::core::audio::engine::export::generate_wav_file_impl(
+            &mut self.buffer,
+            output_dir,
+            audio_format,
+            sample_rate,
+        )
+    }
+
+    pub fn insert_note(
+        &mut self,
+        owner: Option<String>,
+        waveform: String,
+        freq: f32,
+        amp: f32,
+        start_time_ms: f32,
+        duration_ms: f32,
+        synth_params: HashMap<String, Value>,
+        note_params: HashMap<String, Value>,
+        automation: Option<HashMap<String, Value>>,
+    ) -> Vec<(usize, usize)> {
+        // Delegated implementation lives in notes.rs
+        crate::core::audio::engine::notes::insert_note_impl(
+            self,
+            owner,
+            waveform,
+            freq,
+            amp,
+            start_time_ms,
+            duration_ms,
+            synth_params,
+            note_params,
+            automation,
+        )
+    }
+
+    pub fn record_last_note_range(
+        &mut self,
+        owner: &str,
+        start_sample: usize,
+        total_samples: usize,
+    ) {
+        self.last_notes
+            .entry(owner.to_string())
+            .or_default()
+            .push((start_sample, total_samples));
+    }
+
+    // helper extraction functions left in this struct for now
+    pub(crate) 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,
+        }
+    }
+
+    pub(crate) 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,
+        }
+    }
+}
+
+// Parse simple musical fraction strings like "1/16" into seconds using bpm
+pub fn parse_fraction_to_seconds(s: &str, bpm: f32) -> Option<f32> {
+    let trimmed = s.trim();
+    if let Some((num, den)) = trimmed.split_once('/') {
+        if let (Ok(n), Ok(d)) = (num.parse::<f32>(), den.parse::<f32>()) {
+            if d != 0.0 {
+                let beats = n / d; // e.g. 1/16 -> 0.0625 beats
+                let secs_per_beat = 60.0 / bpm.max(1.0);
+                return Some(beats * secs_per_beat);
+            }
+        }
+    }
+    None
+}
+
+// Convert a devalang_types::Duration to seconds using bpm when relevant.
+pub fn duration_to_seconds(d: &devalang_types::Duration, bpm: f32) -> Option<f32> {
+    use devalang_types::Duration as D;
+    match d {
+        D::Number(s) => Some(*s),
+        D::Beat(frac) | D::Identifier(frac) => parse_fraction_to_seconds(frac, bpm),
+        _ => None,
+    }
+}

package/rust/core/audio/engine/export.rs

@@ -0,0 +1,169 @@
+use crate::core::audio::engine::driver::MidiNoteEvent;
+use std::fs::File;
+
+pub fn generate_midi_file_impl(
+    midi_events: &Vec<MidiNoteEvent>,
+    output_path: &String,
+    bpm: Option<f32>,
+    tpqn: Option<u16>,
+) -> Result<(), String> {
+    use midly::num::{u7, u15, u24};
+    use midly::{
+        Format, Header, MetaMessage, MidiMessage, Smf, Timing, TrackEvent, TrackEventKind,
+    };
+
+    if midi_events.is_empty() {
+        return Ok(());
+    }
+
+    let bpm = bpm.unwrap_or(120.0_f32);
+    let tpqn: u16 = tpqn.unwrap_or(480u16);
+    let header = Header {
+        format: Format::SingleTrack,
+        timing: Timing::Metrical(u15::from(tpqn)),
+    };
+
+    #[derive(Clone)]
+    struct AbsEvent {
+        tick: u64,
+        kind: TrackEventKind<'static>,
+    }
+
+    let mut abs_events: Vec<AbsEvent> = Vec::new();
+    let microsecs_per_quarter = (60_000_000.0 / bpm) as u32;
+    abs_events.push(AbsEvent {
+        tick: 0,
+        kind: TrackEventKind::Meta(MetaMessage::Tempo(u24::from(microsecs_per_quarter))),
+    });
+
+    for ev in midi_events {
+        let start_secs = (ev.start_ms as f32) / 1000.0;
+        let dur_secs = (ev.duration_ms as f32) / 1000.0;
+        let start_ticks_f = start_secs * (bpm / 60.0) * (tpqn as f32);
+        let dur_ticks_f = dur_secs * (bpm / 60.0) * (tpqn as f32);
+        let start_tick = start_ticks_f.max(0.0).round() as u64;
+        let off_tick = (start_ticks_f + dur_ticks_f).max(start_tick as f32).round() as u64;
+
+        let key = u7::from(ev.key.min(127));
+        let vel = u7::from(ev.vel.min(127));
+
+        abs_events.push(AbsEvent {
+            tick: start_tick,
+            kind: TrackEventKind::Midi {
+                channel: (ev.channel as u8).into(),
+                message: MidiMessage::NoteOn { key, vel },
+            },
+        });
+
+        abs_events.push(AbsEvent {
+            tick: off_tick,
+            kind: TrackEventKind::Midi {
+                channel: (ev.channel as u8).into(),
+                message: MidiMessage::NoteOff {
+                    key,
+                    vel: u7::from(0),
+                },
+            },
+        });
+    }
+
+    let max_tick = abs_events.iter().map(|e| e.tick).max().unwrap_or(0);
+    abs_events.push(AbsEvent {
+        tick: max_tick + 0,
+        kind: TrackEventKind::Meta(MetaMessage::EndOfTrack),
+    });
+    abs_events.sort_by_key(|e| e.tick);
+
+    let mut track: Vec<TrackEvent> = Vec::new();
+    let mut last_tick: u64 = 0;
+    for e in abs_events {
+        let delta = (e.tick - last_tick) as u32;
+        track.push(TrackEvent {
+            delta: delta.into(),
+            kind: e.kind,
+        });
+        last_tick = e.tick;
+    }
+
+    let smf = Smf {
+        header,
+        tracks: vec![track],
+    };
+
+    if let Ok(mut file) = File::create(output_path) {
+        if let Err(e) = smf.write_std(&mut file) {
+            return Err(format!("Error writing MIDI file: {}", e));
+        }
+    } else {
+        return Err(format!("Cannot create MIDI file at {}", output_path));
+    }
+
+    Ok(())
+}
+
+pub fn generate_wav_file_impl(
+    buffer: &mut Vec<i16>,
+    output_dir: &String,
+    audio_format: Option<String>,
+    sample_rate: Option<u32>,
+) -> Result<(), String> {
+    if buffer.len() % (crate::core::audio::engine::CHANNELS as usize) != 0 {
+        buffer.push(0);
+    }
+
+    let sr = sample_rate.unwrap_or(crate::core::audio::engine::SAMPLE_RATE);
+    let format_str = audio_format.unwrap_or_else(|| "Wav16".to_string());
+    let fmt_low = format_str.to_lowercase();
+
+    match fmt_low.as_str() {
+        "wav16" => {
+            let spec = hound::WavSpec {
+                channels: crate::core::audio::engine::CHANNELS,
+                sample_rate: sr,
+                bits_per_sample: 16,
+                sample_format: hound::SampleFormat::Int,
+            };
+
+            let mut writer = hound::WavWriter::create(output_dir, spec)
+                .map_err(|e| format!("Error creating WAV file: {}", e))?;
+
+            for sample in buffer.iter() {
+                writer
+                    .write_sample(*sample)
+                    .map_err(|e| format!("Error writing sample: {:?}", e))?;
+            }
+
+            writer
+                .finalize()
+                .map_err(|e| format!("Error finalizing WAV: {:?}", e))?;
+        }
+        "wav24" | "wav32" => {
+            let bits = if fmt_low.contains("24") { 24 } else { 32 };
+            let spec = hound::WavSpec {
+                channels: crate::core::audio::engine::CHANNELS,
+                sample_rate: sr,
+                bits_per_sample: bits,
+                sample_format: hound::SampleFormat::Int,
+            };
+
+            let mut writer = hound::WavWriter::create(output_dir, spec)
+                .map_err(|e| format!("Error creating WAV file: {}", e))?;
+
+            for &s in buffer.iter() {
+                let v32 = (s as i32) << (bits - 16);
+                writer
+                    .write_sample(v32)
+                    .map_err(|e| format!("Error writing sample: {:?}", e))?;
+            }
+
+            writer
+                .finalize()
+                .map_err(|e| format!("Error finalizing WAV: {:?}", e))?;
+        }
+        _ => {
+            return Err(format!("Unsupported audio format: {}", format_str));
+        }
+    }
+
+    Ok(())
+}