@devaloop/devalang 0.0.1-beta.3 → 0.1.1

package/rust/core/audio/interpreter/statements/arrow_call/methods/effects.rs

@@ -1,323 +0,0 @@
-use crate::core::audio::engine::AudioEngine;
-use devalang_types::Value;
-use devalang_utils::logger::{LogLevel, Logger};
-use std::collections::HashMap;
-
-fn parse_value_to_f32(v: &Value) -> Option<f32> {
-    match v {
-        Value::Number(n) => Some(*n as f32),
-        Value::String(s) => s.parse::<f32>().ok(),
-        Value::Identifier(s) => s.parse::<f32>().ok(),
-        Value::Boolean(b) => Some(if *b { 1.0 } else { 0.0 }),
-        _ => None,
-    }
-}
-
-// Simple nearest-neighbour resampler that produces an output with the same frame count
-// while applying a time-scaling factor per frame. channels = interleaved channel count.
-fn resample_segment_nearest(
-    src: &[i16],
-    channels: usize,
-    start_rate: f32,
-    end_rate: f32,
-) -> Vec<i16> {
-    if src.is_empty() || channels == 0 {
-        return Vec::new();
-    }
-
-    let frames = src.len() / channels;
-    if frames == 0 {
-        return Vec::new();
-    }
-
-    // Copy source into frames x channels matrix access via frame*channels + ch
-    let mut out = vec![0i16; frames * channels];
-
-    for f in 0..frames {
-        let t = if frames > 1 {
-            f as f32 / (frames - 1) as f32
-        } else {
-            0.0
-        };
-        let rate = start_rate + t * (end_rate - start_rate);
-        let inv_rate = if rate == 0.0 { 1.0 } else { 1.0 / rate };
-
-        // determine source frame position (nearest)
-        let src_frame_pos = (f as f32 * inv_rate).clamp(0.0, (frames - 1) as f32);
-        let src_idx = src_frame_pos.round() as usize;
-
-        for ch in 0..channels {
-            let s_idx = src_idx.saturating_mul(channels).saturating_add(ch);
-            let o_idx = f.saturating_mul(channels).saturating_add(ch);
-            let sample = if s_idx < src.len() { src[s_idx] } else { 0 };
-            out[o_idx] = sample;
-        }
-    }
-
-    out
-}
-
-// Basic effect application for chainable effects. This is intentionally minimal:
-// - Accepts a target synth name and args parsed from the arrow call.
-// - Applies effects by mutating the AudioEngine or scheduling transforms.
-// Current effects implemented: echo, reverb, slide (as parameter modifiers).
-
-pub fn apply_effect_chain(
-    method: &str,
-    args: &Vec<Value>,
-    target: &str,
-    audio_engine: &mut AudioEngine,
-    variable_table: &devalang_types::VariableTable,
-) {
-    match method {
-        "echo" => apply_echo(args, target, audio_engine, variable_table),
-        "reverb" => apply_reverb(args, target, audio_engine, variable_table),
-        "slide" => apply_slide(args, target, audio_engine, variable_table),
-        "arp" => apply_arp_effect(args, target, audio_engine, variable_table),
-        _ => {
-            let logger = Logger::new();
-            logger.log_message(
-                LogLevel::Error,
-                &format!("Unknown chainable effect '{}' on '{}'.", method, target),
-            );
-        }
-    }
-}
-
-fn parse_map_arg(args: &Vec<Value>) -> Option<HashMap<String, Value>> {
-    // Typical usage: method({ key: value }) -> args[0] is a Map
-    if let Some(Value::Map(m)) = args.first() {
-        return Some(m.clone());
-    }
-    None
-}
-
-fn apply_echo(
-    args: &Vec<Value>,
-    _target: &str,
-    engine: &mut AudioEngine,
-    _variable_table: &devalang_types::VariableTable,
-) {
-    let map = parse_map_arg(args);
-    let mut delay_ms = 250.0_f32;
-    let mut feedback = 0.5_f32;
-
-    if let Some(m) = map {
-        if let Some(Value::Number(n)) = m.get("delay") {
-            delay_ms = *n as f32;
-        }
-        if let Some(Value::Number(n)) = m.get("feedback") {
-            feedback = *n as f32;
-        }
-    }
-
-    // Very small and cheap echo: we will add a delayed, attenuated copy of the buffer
-    let sample_rate = engine.sample_rate as f32;
-    let channels = engine.channels as usize;
-    let delay_samples = ((delay_ms / 1000.0) * sample_rate) as usize * channels;
-
-    if delay_samples == 0 || engine.buffer.is_empty() {
-        return;
-    }
-
-    // Mix a single echo pass
-    let mut out = engine.buffer.clone();
-    for i in delay_samples..engine.buffer.len() {
-        let src = engine.buffer[i - delay_samples] as f32;
-        let added = (src * feedback)
-            .round()
-            .clamp(i16::MIN as f32, i16::MAX as f32) as i16;
-        out[i] = out[i].saturating_add(added);
-    }
-
-    engine.buffer = out;
-}
-
-fn apply_reverb(
-    args: &Vec<Value>,
-    _target: &str,
-    engine: &mut AudioEngine,
-    _variable_table: &devalang_types::VariableTable,
-) {
-    let map = parse_map_arg(args);
-    let mut room_size = 0.5_f32;
-    if let Some(m) = map {
-        if let Some(Value::Number(n)) = m.get("room_size") {
-            room_size = *n as f32;
-        }
-    }
-
-    // Cheap reverb: multiple short comb filters (very approximate)
-    if engine.buffer.is_empty() {
-        return;
-    }
-
-    let sample_rate = engine.sample_rate as f32;
-    let channels = engine.channels as usize;
-    let reverb_delay_samples = ((0.03 * room_size) * sample_rate) as usize * channels;
-    if reverb_delay_samples == 0 {
-        return;
-    }
-
-    let mut out = engine.buffer.clone();
-    for i in reverb_delay_samples..engine.buffer.len() {
-        let src = engine.buffer[i - reverb_delay_samples] as f32;
-        let added = (src * room_size * 0.5)
-            .round()
-            .clamp(i16::MIN as f32, i16::MAX as f32) as i16;
-        out[i] = out[i].saturating_add(added);
-    }
-
-    engine.buffer = out;
-}
-
-fn apply_slide(
-    args: &Vec<Value>,
-    _target: &str,
-    _engine: &mut AudioEngine,
-    _variable_table: &devalang_types::VariableTable,
-) {
-    // Slide: apply a linear pitch glide across the most recently recorded note ranges
-    let map = parse_map_arg(args);
-    let mut from_semitones = 0.0_f32;
-    let mut to_semitones = 0.0_f32;
-
-    if let Some(m) = map {
-        if let Some(v) = m.get("from") {
-            if let Some(f) = parse_value_to_f32(v) {
-                from_semitones = f;
-            }
-        }
-        if let Some(v) = m.get("to") {
-            if let Some(t) = parse_value_to_f32(v) {
-                to_semitones = t;
-            }
-        }
-    }
-
-    // Compute rate multipliers from semitone offsets
-    let start_rate = 2f32.powf(from_semitones / 12.0);
-    let end_rate = 2f32.powf(to_semitones / 12.0);
-
-    let channels = _engine.channels as usize;
-    if channels == 0 {
-        return;
-    }
-
-    // For each recorded last note range for the target, apply a per-frame resample glide
-    if let Some(ranges) = _engine.last_notes.get(_target) {
-        for (start_sample, total_samples) in ranges.iter() {
-            if *total_samples == 0 {
-                continue;
-            }
-            // clamp range
-            let end = (*start_sample)
-                .saturating_add(*total_samples)
-                .min(_engine.buffer.len());
-            if *start_sample >= end {
-                continue;
-            }
-
-            // work on a copy of the segment
-            let seg = _engine.buffer[*start_sample..end].to_vec();
-            let processed = resample_segment_nearest(&seg, channels, start_rate, end_rate);
-
-            // Mix processed back into buffer (replace to preserve duration)
-            for i in 0..processed.len().min(seg.len()) {
-                _engine.buffer[*start_sample + i] = processed[i];
-            }
-        }
-    } else {
-        let logger = Logger::new();
-        logger.log_message(
-            LogLevel::Warning,
-            "Slide requested but no recent notes found for target",
-        );
-    }
-}
-
-fn apply_arp_effect(
-    args: &Vec<Value>,
-    _target: &str,
-    _engine: &mut AudioEngine,
-    _variable_table: &devalang_types::VariableTable,
-) {
-    // Arp effect: split the last note into N slices and re-pitch each slice across a spread
-    let map = parse_map_arg(args);
-    let mut steps: usize = 4;
-    let mut spread_semitones: f32 = 0.0;
-
-    if let Some(m) = map {
-        if let Some(v) = m.get("steps") {
-            if let Some(s) = parse_value_to_f32(v) {
-                steps = (s as usize).max(1);
-            }
-        }
-        if let Some(v) = m.get("spread") {
-            if let Some(s) = parse_value_to_f32(v) {
-                spread_semitones = s;
-            }
-        }
-    }
-
-    let channels = _engine.channels as usize;
-    if channels == 0 {
-        return;
-    }
-
-    if let Some(ranges) = _engine.last_notes.get(_target) {
-        for (start_sample, total_samples) in ranges.iter() {
-            if *total_samples == 0 {
-                continue;
-            }
-            let end_sample = (*start_sample)
-                .saturating_add(*total_samples)
-                .min(_engine.buffer.len());
-            if *start_sample >= end_sample {
-                continue;
-            }
-
-            let seg = _engine.buffer[*start_sample..end_sample].to_vec();
-            let frames = seg.len() / channels;
-            if frames == 0 {
-                continue;
-            }
-
-            // For each step, compute semitone and pitch multiplier and place slice at computed offset
-            for step in 0..steps {
-                let t = if steps > 1 {
-                    step as f32 / (steps - 1) as f32
-                } else {
-                    0.0
-                };
-                let semis = t * spread_semitones;
-                let rate = 2f32.powf(semis / 12.0);
-
-                // Resample the entire segment to the same duration using nearest approach with rate
-                let processed = resample_segment_nearest(&seg, channels, rate, rate);
-
-                // place the processed slice starting at fractional positions across original segment
-                let offset_frames =
-                    ((t * frames as f32).round() as usize).min(frames.saturating_sub(1));
-                let offset_samples = offset_frames.saturating_mul(channels);
-
-                // mix into engine buffer
-                for i in 0..processed.len() {
-                    let dst_idx = *start_sample + offset_samples + i;
-                    if dst_idx >= _engine.buffer.len() {
-                        break;
-                    }
-                    // simple additive mix and clamp
-                    let sum = (_engine.buffer[dst_idx] as i32) + (processed[i] as i32);
-                    _engine.buffer[dst_idx] = sum.clamp(i16::MIN as i32, i16::MAX as i32) as i16;
-                }
-            }
-        }
-    } else {
-        let logger = Logger::new();
-        logger.log_message(
-            LogLevel::Warning,
-            "Arp effect requested but no recent notes found for target",
-        );
-    }
-}

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

@@ -1,3 +0,0 @@
-pub mod chord;
-pub mod effects;
-pub mod note;

package/rust/core/audio/interpreter/statements/arrow_call/methods/note.rs

@@ -1,371 +0,0 @@
-use crate::core::{audio::engine::AudioEngine, plugin::runner::WasmPluginRunner};
-use devalang_types::Value;
-use devalang_utils::logger::{LogLevel, Logger};
-use std::collections::HashMap;
-
-pub fn interprete_note_method(
-    args: &Vec<devalang_types::Value>,
-    target: &str,
-    audio_engine: &mut AudioEngine,
-    variable_table: &devalang_types::VariableTable,
-    global_store: &crate::core::store::global::GlobalStore,
-    waveform_str: &str,
-    synth_params: &HashMap<String, devalang_types::Value>,
-    amp: f32,
-    base_bpm: f32,
-    base_duration: f32,
-    max_end_time: &mut f32,
-    mut cursor_time: Option<&mut f32>,
-    cursor_copy: f32,
-    update_cursor: bool,
-) -> (f32, f32) {
-    let filtered_args: Vec<_> = args
-        .iter()
-        .filter(|arg| !matches!(arg, Value::Unknown))
-        .collect();
-
-    let Some(Value::Identifier(note_name)) = filtered_args.first().map(|v| (*v).clone()) else {
-        println!(
-            "❌ Invalid or missing argument for 'note' method on '{}'.",
-            target
-        );
-        return (*max_end_time, cursor_copy);
-    };
-
-    let mut note_params = HashMap::new();
-    if let Some(arg1) = filtered_args.get(1) {
-        if let Value::Map(map) = (*arg1).clone() {
-            for (key, value) in map {
-                note_params.insert(key, value);
-            }
-        }
-    }
-
-    // Note parameters and calculations
-    let amp_note = extract_f32(&note_params, "amp", base_bpm).unwrap_or(amp);
-    let duration_ms =
-        extract_f32(&note_params, "duration", base_bpm).unwrap_or(base_duration * 1000.0);
-
-    let duration_secs = duration_ms / 1000.0;
-    let final_freq = note_to_freq(&note_name);
-    let start_time = cursor_copy;
-    let end_time = start_time + duration_secs;
-
-    // Fetch automation map if present:
-    // - Global (per-synth): key "<target>__automation" => map with key "params"
-    // - Per-note: note parameter "automate" => map
-    let auto_key = format!("{}__automation", target);
-    let synth_automation = match variable_table.get(&auto_key) {
-        Some(Value::Map(map)) => match map.get("params") {
-            Some(Value::Map(p)) => Some(p.clone()),
-            _ => None,
-        },
-        _ => None,
-    };
-
-    let note_automation = match note_params.get("automate") {
-        Some(Value::Map(m)) => Some(m.clone()),
-        _ => None,
-    };
-
-    // Merge: per-note overrides synth automation per key (volume/pan/pitch)
-    let automation = match (synth_automation, note_automation) {
-        (Some(mut a), Some(n)) => {
-            for (k, v) in n {
-                a.insert(k, v);
-            }
-            Some(a)
-        }
-        (None, Some(n)) => Some(n),
-        (Some(a), None) => Some(a),
-        _ => None,
-    };
-
-    // If waveform references a plugin alias (e.g., alias.synth), use the WASM plugin runner
-    if waveform_str.contains('.') && waveform_str.ends_with(".synth") {
-        let alias = waveform_str.split('.').next().unwrap_or("");
-        if let Some(Value::String(uri)) = variable_table.get(alias) {
-            if let Some(id) = uri.strip_prefix("devalang://plugin/") {
-                let mut parts = id.split('/');
-                let author = parts.next().unwrap_or("");
-                let name = parts.next().unwrap_or("");
-                let key = format!("{}:{}", author, name);
-                if let Some((info, wasm_bytes)) = global_store.plugins.get(&key) {
-                    // Prepare buffer (stereo f32)
-                    let sample_rate = 44100.0_f32;
-                    let total_samples = ((duration_ms / 1000.0) * sample_rate) as usize;
-                    let channels = 2usize;
-                    let start_index = ((start_time * sample_rate) as usize) * channels;
-                    let required_len = start_index + total_samples * channels;
-                    if audio_engine.buffer.len() < required_len {
-                        audio_engine.buffer.resize(required_len, 0);
-                    }
-                    let mut fbuf = vec![0.0f32; total_samples * channels];
-                    let runner = WasmPluginRunner::new();
-                    let mut params_num: std::collections::HashMap<String, f32> =
-                        std::collections::HashMap::new();
-                    let mut params_str: std::collections::HashMap<String, String> =
-                        std::collections::HashMap::new();
-                    for (k, v) in synth_params.iter() {
-                        match v {
-                            Value::Number(n) => {
-                                params_num.insert(k.clone(), *n);
-                            }
-                            Value::String(s) => {
-                                params_str.insert(k.clone(), s.clone());
-                            }
-                            Value::Identifier(s) => {
-                                params_str.insert(k.clone(), s.clone());
-                            }
-                            _ => {}
-                        }
-                    }
-
-                    // collect exported names to pass to the runner (preference list)
-                    let exported_names_vec: Vec<String> =
-                        info.exports.iter().map(|e| e.name.clone()).collect();
-
-                    // Debug log: exported names and synth param keys
-                    {
-                        let logger = devalang_utils::logger::Logger::new();
-                        logger.log_message(
-                            devalang_utils::logger::LogLevel::Debug,
-                            &format!(
-                                "Calling plugin runner for '{}' with {} exported names and {} synth params",
-                                key,
-                                exported_names_vec.len(),
-                                synth_params.len()
-                            )
-                        );
-                    }
-
-                    let _ = runner.render_note_with_params_in_place(
-                        wasm_bytes,
-                        &mut fbuf,
-                        None,
-                        final_freq,
-                        amp_note,
-                        duration_ms as i32,
-                        44100,
-                        2,
-                        &params_num,
-                        Some(&params_str),
-                        Some(&exported_names_vec),
-                    );
-
-                    for (i, sample) in fbuf.iter().enumerate().take(total_samples * channels) {
-                        let s = (sample.clamp(-1.0, 1.0) * (i16::MAX as f32)) as i16;
-                        let idx = start_index + i;
-                        audio_engine.buffer[idx] = audio_engine.buffer[idx].saturating_add(s);
-                    }
-                } else {
-                    let logger = Logger::new();
-                    logger.log_message(
-                        LogLevel::Warning,
-                        &format!(
-                            "Plugin bytes not found for key '{}' (alias '{}').",
-                            key, alias
-                        ),
-                    );
-                }
-            } else {
-                let logger = Logger::new();
-                logger.log_message(
-                    LogLevel::Warning,
-                    &format!("Invalid plugin URI in alias '{}': {}", alias, uri),
-                );
-            }
-        } else {
-            let logger = Logger::new();
-            logger.log_message(
-                LogLevel::Warning,
-                &format!("Plugin alias '{}' not found in variable table.", alias),
-            );
-        }
-    } else {
-        // Allow types to adjust per-note scheduling/params
-        let start_ms = start_time * 1000.0;
-        let mut final_amp = amp_note;
-        let mut final_note_params = note_params.clone();
-
-        let mut handled = false;
-        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 {
-                "arp" => {
-                    // compute a step (ms) from synth params (rate/step). compute_arp_step
-                    // will interpret `rate` as number of notes across the provided duration
-                    let step_ms =
-                        crate::core::audio::interpreter::statements::arrow_call::types::arp::compute_arp_step(
-                            duration_ms,
-                            1,
-                            &synth_params
-                        );
-                    let steps = if step_ms > 0.0 {
-                        ((duration_ms / step_ms).ceil() as usize).max(1)
-                    } else {
-                        1usize
-                    };
-
-                    // For each arp step, call prepare_note to get per-step params and schedule it
-                    for idx in 0..steps {
-                        let (start_abs_ms, freq_step, amp_out, params_out) =
-                            crate::core::audio::interpreter::statements::arrow_call::types::arp::prepare_note(
-                                &note_name,
-                                idx,
-                                steps,
-                                start_ms,
-                                duration_ms,
-                                amp_note,
-                                &synth_params,
-                                &final_note_params,
-                                &automation
-                            );
-
-                        // sub-note duration: default to step_ms so arp steps are audible and sequenced
-                        let sub_duration_ms = if step_ms > 0.0 { step_ms } else { duration_ms };
-
-                        let _ranges = audio_engine.insert_note(
-                            Some(target.to_string()),
-                            waveform_str.to_string(),
-                            freq_step,
-                            amp_out,
-                            start_abs_ms,
-                            sub_duration_ms,
-                            synth_params.clone(),
-                            params_out.clone(),
-                            automation.clone(),
-                        );
-                        // Apply per-note effects if present in synth_params or note params
-                        if let Some(ev) = params_out.get("effects") {
-                            // for now expect effects as array of maps or identifiers
-                            match ev {
-                                Value::Array(arr) => {
-                                    for eff in arr.iter() {
-                                        if let Value::Map(_m) = eff {
-                                            // each map may have single key -> value
-                                        }
-                                    }
-                                }
-                                _ => {}
-                            }
-                        }
-                    }
-
-                    // mark handled to avoid the unconditional insert below
-                    handled = true;
-                }
-                "pluck" => {
-                    let (_s, _f, amp_out, params_out) =
-                        crate::core::audio::interpreter::statements::arrow_call::types::pluck::prepare_note(
-                            &note_name,
-                            0,
-                            1,
-                            start_ms,
-                            duration_ms,
-                            amp_note,
-                            &synth_params,
-                            &final_note_params,
-                            &automation
-                        );
-                    final_amp = amp_out;
-                    final_note_params = params_out;
-                }
-                "pad" => {
-                    let (_s, _f, amp_out, params_out) =
-                        crate::core::audio::interpreter::statements::arrow_call::types::pad::prepare_note(
-                            &note_name,
-                            0,
-                            1,
-                            start_ms,
-                            duration_ms,
-                            amp_note,
-                            &synth_params,
-                            &final_note_params,
-                            &automation
-                        );
-                    final_amp = amp_out;
-                    final_note_params = params_out;
-                }
-                _ => {}
-            }
-        }
-
-        if !handled {
-            let ranges = audio_engine.insert_note(
-                Some(target.to_string()),
-                waveform_str.to_string(),
-                final_freq,
-                final_amp,
-                start_ms,
-                duration_ms,
-                synth_params.clone(),
-                final_note_params.clone(),
-                automation.clone(),
-            );
-            // apply per-note effects specified in final_note_params
-            if let Some(Value::Map(eff_map)) = final_note_params.get("effects") {
-                // delegate to effects module per range
-                for (_start, _len) in ranges.iter() {
-                    // for simplicity apply using engine buffer ranges via effects module
-                    crate::core::audio::interpreter::statements::arrow_call::methods::effects::apply_effect_chain(
-                        "echo",
-                        &vec![Value::Map(eff_map.clone())],
-                        target,
-                        audio_engine,
-                        variable_table
-                    );
-                }
-            }
-        }
-    }
-
-    *max_end_time = (*max_end_time).max(end_time);
-
-    if update_cursor {
-        if let Some(c) = cursor_time.as_mut() {
-            **c = end_time;
-        }
-    }
-
-    return (*max_end_time, end_time);
-}
-
-fn extract_f32(map: &HashMap<String, Value>, key: &str, base_bpm: f32) -> Option<f32> {
-    map.get(key).and_then(|v| match v {
-        Value::Number(n) => Some(*n),
-        Value::Beat(beat_str) => {
-            let parts: Vec<&str> = beat_str.split('/').collect();
-            if parts.len() == 2 {
-                let numerator = parts[0].parse::<f32>().ok()?;
-                let denominator = parts[1].parse::<f32>().ok()?;
-
-                Some((numerator / denominator) * ((60.0 / base_bpm) * 1000.0))
-            } else {
-                None
-            }
-        }
-        _ => None,
-    })
-}
-
-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/mod.rs

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