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

package/rust/core/audio/engine/sample/insert.rs

@@ -1,7 +1,9 @@
+use crate::config::ops::load_config;
 use devalang_types::Value;
 use devalang_types::VariableTable;
 use devalang_utils::path::normalize_path;
 use rodio::{Decoder, Source};
+use std::path::PathBuf;
 use std::{collections::HashMap, fs::File, io::BufReader, path::Path};
 
 pub fn insert_sample_impl(
@@ -63,65 +65,164 @@ pub fn insert_sample_impl(
             other => other,
         };
 
-        // Determine the bank audio base directory. Prefer an optional
-        // `audioPath` declared in the bank's bank.toml (supports keys
-        // `audioPath` or `audio_path`). If absent, fall back to `audio/`.
-        let mut audio_dir = deva_dir.join(subdir).join(bank_name).join("audio");
-        // Try to read bank.toml to get audioPath
-        let bank_toml = deva_dir.join(subdir).join(bank_name).join("bank.toml");
-        if bank_toml.exists() {
-            if let Ok(content) = std::fs::read_to_string(&bank_toml) {
-                if let Ok(parsed) = toml::from_str::<toml::Value>(&content) {
-                    if let Some(ap) = parsed
-                        .get("audioPath")
-                        .or_else(|| parsed.get("audio_path"))
-                        .and_then(|v| v.as_str())
-                    {
-                        // normalize separators
-                        let ap_norm = ap.replace("\\", "/");
-                        audio_dir = deva_dir.join(subdir).join(bank_name).join(ap_norm);
+        // Try both plural and singular folder names (some installs use 'bank' instead of 'banks')
+        let singular = if subdir.ends_with('s') {
+            &subdir[..subdir.len() - 1]
+        } else {
+            subdir
+        };
+
+        // Build a list of candidate addon roots to support different layouts:
+        // - legacy flat: .deva/<subdir>/<publisher>.<name>
+        // - nested: .deva/<subdir>/<publisher>/<name>
+        // Test both plural and singular folder names.
+        let mut candidate_roots: Vec<PathBuf> = Vec::new();
+        for sd in &[subdir, singular] {
+            let base = deva_dir.join(sd).join(bank_name);
+            candidate_roots.push(base.clone());
+
+            if bank_name.contains('.') {
+                let mut it = bank_name.splitn(2, '.');
+                let pubr = it.next().unwrap_or("");
+                let nm = it.next().unwrap_or("");
+                candidate_roots.push(deva_dir.join(sd).join(pubr).join(nm));
+            }
+        }
+
+        // If none of the candidate roots yields the asset, we will also
+        // try to lookup referenced addons from the project config.
+
+        // Helper to resolve audio path for a given addon root
+        let resolve_from_root = |root: &PathBuf| -> Option<String> {
+            // Determine audio dir: prefer audioPath in bank.toml, else audio/
+            let mut audio_dir = root.join("audio");
+            let bank_toml = root.join("bank.toml");
+            if bank_toml.exists() {
+                if let Ok(content) = std::fs::read_to_string(&bank_toml) {
+                    if let Ok(parsed) = toml::from_str::<toml::Value>(&content) {
+                        if let Some(ap) = parsed
+                            .get("audioPath")
+                            .or_else(|| parsed.get("audio_path"))
+                            .and_then(|v| v.as_str())
+                        {
+                            let ap_norm = ap.replace("\\", "/");
+                            audio_dir = root.join(ap_norm);
+                        }
                     }
                 }
             }
-        }
-        // Force looking into the computed audio_dir. If the entity_name
-        // already contains an extension (e.g. .wav/.mp3) or a nested path,
-        // preserve it as-is. Otherwise, try with a .wav extension.
-        let bank_base = audio_dir;
-        let candidate = bank_base.join(&entity_name);
-
-        if candidate.exists() {
-            resolved_path = candidate.to_string_lossy().to_string();
-        } else {
-            // Detect whether the provided entity already includes an extension.
-            let has_extension = std::path::Path::new(&entity_name).extension().is_some();
 
+            let candidate = audio_dir.join(&entity_name);
+            if candidate.exists() {
+                return Some(candidate.to_string_lossy().to_string());
+            }
+
+            let has_extension = std::path::Path::new(&entity_name).extension().is_some();
             if !has_extension {
-                // Try appending .wav as a fallback for shorthand names without extension
-                let wav_candidate = bank_base.join(format!("{}.wav", entity_name));
+                let wav_candidate = audio_dir.join(format!("{}.wav", entity_name));
                 if wav_candidate.exists() {
-                    resolved_path = wav_candidate.to_string_lossy().to_string();
-                } else {
-                    // Last resort: use the legacy location (no audio/), also with .wav
-                    resolved_path = deva_dir
-                        .join(subdir)
-                        .join(bank_name)
-                        .join(format!("{}.wav", entity_name))
-                        .to_string_lossy()
-                        .to_string();
+                    return Some(wav_candidate.to_string_lossy().to_string());
                 }
-            } else {
-                // If an extension was specified, don't append .wav; try legacy location
-                let legacy_candidate = deva_dir.join(subdir).join(bank_name).join(&entity_name);
 
+                let legacy_candidate = root.join(format!("{}.wav", entity_name));
                 if legacy_candidate.exists() {
-                    resolved_path = legacy_candidate.to_string_lossy().to_string();
-                } else {
-                    // No file found; fall back to the audio candidate path (even if missing)
-                    resolved_path = candidate.to_string_lossy().to_string();
+                    return Some(legacy_candidate.to_string_lossy().to_string());
                 }
+            } else {
+                let legacy_candidate = root.join(&entity_name);
+                if legacy_candidate.exists() {
+                    return Some(legacy_candidate.to_string_lossy().to_string());
+                }
+            }
+
+            None
+        };
+
+        let mut found: Option<String> = None;
+        for root in &candidate_roots {
+            if let Some(p) = resolve_from_root(root) {
+                found = Some(p);
+                break;
             }
         }
+
+        // If not found in typical layouts, try to find the addon referenced in the project config
+        if found.is_none() {
+            if let Ok(config_path) = devalang_utils::path::get_devalang_config_path() {
+                if let Some(cfg) = load_config(Some(&config_path)) {
+                    // Scan banks or plugins depending on obj_type
+                    if obj_type == "bank" {
+                        if let Some(banks) = cfg.banks {
+                            for b in banks {
+                                if let Some(name_in_path) = b.path.strip_prefix("devalang://bank/")
+                                {
+                                    // match by exact, suffix, or dot notation
+                                    if name_in_path == bank_name
+                                        || name_in_path.ends_with(bank_name)
+                                    {
+                                        let root = deva_dir.join(subdir).join(name_in_path);
+                                        if let Some(p) = resolve_from_root(&root) {
+                                            found = Some(p);
+                                            break;
+                                        }
+                                        // try nested layout
+                                        if name_in_path.contains('.') {
+                                            let mut it = name_in_path.splitn(2, '.');
+                                            let pubr = it.next().unwrap_or("");
+                                            let nm = it.next().unwrap_or("");
+                                            let root2 = deva_dir.join(subdir).join(pubr).join(nm);
+                                            if let Some(p) = resolve_from_root(&root2) {
+                                                found = Some(p);
+                                                break;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    } else if obj_type == "plugin" {
+                        if let Some(plugins) = cfg.plugins {
+                            for p in plugins {
+                                if let Some(name_in_path) =
+                                    p.path.strip_prefix("devalang://plugin/")
+                                {
+                                    if name_in_path == bank_name
+                                        || name_in_path.ends_with(bank_name)
+                                    {
+                                        let root = deva_dir.join(subdir).join(name_in_path);
+                                        if let Some(path_found) = resolve_from_root(&root) {
+                                            found = Some(path_found);
+                                            break;
+                                        }
+                                        if name_in_path.contains('.') {
+                                            let mut it = name_in_path.splitn(2, '.');
+                                            let pubr = it.next().unwrap_or("");
+                                            let nm = it.next().unwrap_or("");
+                                            let root2 = deva_dir.join(subdir).join(pubr).join(nm);
+                                            if let Some(path_found) = resolve_from_root(&root2) {
+                                                found = Some(path_found);
+                                                break;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if let Some(p) = found {
+            resolved_path = p;
+        } else {
+            // Not found; fallback to legacy candidate for error message
+            let legacy = deva_dir
+                .join(subdir)
+                .join(bank_name)
+                .join(format!("{}.wav", entity_name));
+            resolved_path = legacy.to_string_lossy().to_string();
+        }
     } else {
         let entry_dir = module_root.parent().unwrap_or(&root);
         let absolute_path = root.join(entry_dir).join(&var_path);

package/rust/core/audio/engine/sample/mod.rs

@@ -1,40 +1,40 @@
-pub mod insert;
-pub mod padding;
-
-use devalang_types::Value;
-use devalang_types::VariableTable;
-use std::collections::HashMap;
-
-impl super::driver::AudioEngine {
-    pub fn insert_sample(
-        &mut self,
-        filepath: &str,
-        time_secs: f32,
-        dur_sec: f32,
-        effects: Option<HashMap<String, Value>>,
-        variable_table: &VariableTable,
-    ) {
-        crate::core::audio::engine::sample::insert::insert_sample_impl(
-            self,
-            filepath,
-            time_secs,
-            dur_sec,
-            effects,
-            variable_table,
-        );
-    }
-
-    pub fn pad_samples(
-        &mut self,
-        samples: &[i16],
-        time_secs: f32,
-        effects_map: Option<HashMap<String, Value>>,
-    ) {
-        crate::core::audio::engine::sample::padding::pad_samples_impl(
-            self,
-            samples,
-            time_secs,
-            effects_map,
-        );
-    }
-}
+pub mod insert;
+pub mod padding;
+
+use devalang_types::Value;
+use devalang_types::VariableTable;
+use std::collections::HashMap;
+
+impl super::driver::AudioEngine {
+    pub fn insert_sample(
+        &mut self,
+        filepath: &str,
+        time_secs: f32,
+        dur_sec: f32,
+        effects: Option<HashMap<String, Value>>,
+        variable_table: &VariableTable,
+    ) {
+        crate::core::audio::engine::sample::insert::insert_sample_impl(
+            self,
+            filepath,
+            time_secs,
+            dur_sec,
+            effects,
+            variable_table,
+        );
+    }
+
+    pub fn pad_samples(
+        &mut self,
+        samples: &[i16],
+        time_secs: f32,
+        effects_map: Option<HashMap<String, Value>>,
+    ) {
+        crate::core::audio::engine::sample::padding::pad_samples_impl(
+            self,
+            samples,
+            time_secs,
+            effects_map,
+        );
+    }
+}

package/rust/core/audio/engine/sample/padding.rs

@@ -1,170 +1,170 @@
-use devalang_types::Value;
-use std::collections::HashMap;
-
-pub fn pad_samples_impl(
-    engine: &mut crate::core::audio::engine::driver::AudioEngine,
-    samples: &[i16],
-    time_secs: f32,
-    effects_map: Option<HashMap<String, Value>>,
-) {
-    let sample_rate = engine.sample_rate as f32;
-    let channels = engine.channels as usize;
-
-    let offset = (time_secs * (sample_rate) * (channels as f32)) as usize;
-    let total_samples = samples.len();
-
-    let mut gain = 1.0;
-    let mut pan = 0.0;
-    let mut fade_in = 0.0;
-    let mut fade_out = 0.0;
-    let mut pitch = 1.0;
-    let mut drive = 0.0;
-    let mut reverb = 0.0;
-    let mut delay = 0.0; // delay time in seconds
-    let delay_feedback = 0.35; // default feedback
-
-    if let Some(map) = &effects_map {
-        for (key, val) in map {
-            match (key.as_str(), val) {
-                ("gain", Value::Number(v)) => {
-                    gain = *v;
-                }
-                ("pan", Value::Number(v)) => {
-                    pan = *v;
-                }
-                ("fadeIn", Value::Number(v)) => {
-                    fade_in = *v;
-                }
-                ("fadeOut", Value::Number(v)) => {
-                    fade_out = *v;
-                }
-                ("pitch", Value::Number(v)) => {
-                    pitch = *v;
-                }
-                ("drive", Value::Number(v)) => {
-                    drive = *v;
-                }
-                ("reverb", Value::Number(v)) => {
-                    reverb = *v;
-                }
-                ("delay", Value::Number(v)) => {
-                    delay = *v;
-                }
-                _ => eprintln!("⚠️ Unknown or invalid effect '{}'", key),
-            }
-        }
-    }
-
-    let fade_in_samples = (fade_in * (sample_rate)) as usize;
-    let fade_out_samples = (fade_out * (sample_rate)) as usize;
-
-    // If no fade specified, apply a tiny default fade (2 ms) when sample boundaries are non-zero
-    let default_boundary_fade_ms = 1.0_f32; // 1 ms
-    let default_fade_samples = (default_boundary_fade_ms * (sample_rate)) as usize;
-    let mut effective_fade_in = fade_in_samples;
-    let mut effective_fade_out = fade_out_samples;
-    if effective_fade_in == 0 {
-        if let Some(&first) = samples.first() {
-            if first.abs() > 64 {
-                // increased threshold to detect only strong abrupt starts
-                effective_fade_in = default_fade_samples.max(1);
-            }
-        }
-    }
-    if effective_fade_out == 0 {
-        if let Some(&last) = samples.last() {
-            if last.abs() > 64 {
-                // increased threshold to detect only strong abrupt ends
-                effective_fade_out = default_fade_samples.max(1);
-            }
-        }
-    }
-
-    // Ensure fades do not exceed half the sample length to avoid silencing short samples
-    if total_samples > 0 {
-        let cap = total_samples / 2;
-        if effective_fade_in > cap {
-            effective_fade_in = cap.max(1);
-        }
-        if effective_fade_out > cap {
-            effective_fade_out = cap.max(1);
-        }
-    }
-
-    let delay_samples = if delay > 0.0 {
-        (delay * (sample_rate)) as usize
-    } else {
-        0
-    };
-    let mut delay_buffer: Vec<f32> = vec![0.0; total_samples + delay_samples];
-
-    for i in 0..total_samples {
-        let pitch_index = if pitch != 1.0 {
-            ((i as f32) / pitch) as usize
-        } else {
-            i
-        };
-
-        let mut adjusted = if pitch_index < total_samples {
-            samples[pitch_index] as f32
-        } else {
-            0.0
-        };
-
-        adjusted *= gain;
-
-        if effective_fade_in > 0 && i < effective_fade_in {
-            if effective_fade_in == 1 {
-                adjusted *= 0.0;
-            } else {
-                adjusted *= (i as f32) / (effective_fade_in as f32);
-            }
-        }
-        if effective_fade_out > 0 && i >= total_samples.saturating_sub(effective_fade_out) {
-            if effective_fade_out == 1 {
-                adjusted *= 0.0;
-            } else {
-                adjusted *= ((total_samples - 1 - i) as f32) / ((effective_fade_out - 1) as f32);
-            }
-        }
-
-        if drive > 0.0 {
-            let normalized = adjusted / (i16::MAX as f32);
-            let pre_gain = (10f32).powf(drive / 20.0);
-            let driven = (normalized * pre_gain).tanh();
-            adjusted = driven * (i16::MAX as f32);
-        }
-
-        if delay_samples > 0 && i >= delay_samples {
-            let echo = delay_buffer[i - delay_samples] * delay_feedback;
-            adjusted += echo;
-        }
-        if delay_samples > 0 {
-            delay_buffer[i] = adjusted;
-        }
-
-        if reverb > 0.0 {
-            let reverb_delay = (0.03 * (sample_rate)) as usize;
-            if i >= reverb_delay {
-                adjusted += (engine.buffer[offset + i - reverb_delay] as f32) * reverb;
-            }
-        }
-
-        let adjusted_sample = adjusted.round().clamp(i16::MIN as f32, i16::MAX as f32) as i16;
-
-        let (left_gain, right_gain) = crate::core::audio::engine::helpers::pan_gains(pan);
-
-        let left = ((adjusted_sample as f32) * left_gain) as i16;
-        let right = ((adjusted_sample as f32) * right_gain) as i16;
-
-        // For interleaved buffer with `channels` channels, each frame has `channels` samples.
-        // left channel at frame i is at offset + i * channels, right at +1.
-        let left_pos = offset + i * channels;
-        let right_pos = left_pos + 1;
-
-        if right_pos < engine.buffer.len() {
-            engine.buffer[left_pos] = engine.buffer[left_pos].saturating_add(left);
-            engine.buffer[right_pos] = engine.buffer[right_pos].saturating_add(right);
-        }
-    }
-}
+use devalang_types::Value;
+use std::collections::HashMap;
+
+pub fn pad_samples_impl(
+    engine: &mut crate::core::audio::engine::driver::AudioEngine,
+    samples: &[i16],
+    time_secs: f32,
+    effects_map: Option<HashMap<String, Value>>,
+) {
+    let sample_rate = engine.sample_rate as f32;
+    let channels = engine.channels as usize;
+
+    let offset = (time_secs * (sample_rate) * (channels as f32)) as usize;
+    let total_samples = samples.len();
+
+    let mut gain = 1.0;
+    let mut pan = 0.0;
+    let mut fade_in = 0.0;
+    let mut fade_out = 0.0;
+    let mut pitch = 1.0;
+    let mut drive = 0.0;
+    let mut reverb = 0.0;
+    let mut delay = 0.0; // delay time in seconds
+    let delay_feedback = 0.35; // default feedback
+
+    if let Some(map) = &effects_map {
+        for (key, val) in map {
+            match (key.as_str(), val) {
+                ("gain", Value::Number(v)) => {
+                    gain = *v;
+                }
+                ("pan", Value::Number(v)) => {
+                    pan = *v;
+                }
+                ("fadeIn", Value::Number(v)) => {
+                    fade_in = *v;
+                }
+                ("fadeOut", Value::Number(v)) => {
+                    fade_out = *v;
+                }
+                ("pitch", Value::Number(v)) => {
+                    pitch = *v;
+                }
+                ("drive", Value::Number(v)) => {
+                    drive = *v;
+                }
+                ("reverb", Value::Number(v)) => {
+                    reverb = *v;
+                }
+                ("delay", Value::Number(v)) => {
+                    delay = *v;
+                }
+                _ => eprintln!("⚠️ Unknown or invalid effect '{}'", key),
+            }
+        }
+    }
+
+    let fade_in_samples = (fade_in * (sample_rate)) as usize;
+    let fade_out_samples = (fade_out * (sample_rate)) as usize;
+
+    // If no fade specified, apply a tiny default fade (2 ms) when sample boundaries are non-zero
+    let default_boundary_fade_ms = 1.0_f32; // 1 ms
+    let default_fade_samples = (default_boundary_fade_ms * (sample_rate)) as usize;
+    let mut effective_fade_in = fade_in_samples;
+    let mut effective_fade_out = fade_out_samples;
+    if effective_fade_in == 0 {
+        if let Some(&first) = samples.first() {
+            if first.abs() > 64 {
+                // increased threshold to detect only strong abrupt starts
+                effective_fade_in = default_fade_samples.max(1);
+            }
+        }
+    }
+    if effective_fade_out == 0 {
+        if let Some(&last) = samples.last() {
+            if last.abs() > 64 {
+                // increased threshold to detect only strong abrupt ends
+                effective_fade_out = default_fade_samples.max(1);
+            }
+        }
+    }
+
+    // Ensure fades do not exceed half the sample length to avoid silencing short samples
+    if total_samples > 0 {
+        let cap = total_samples / 2;
+        if effective_fade_in > cap {
+            effective_fade_in = cap.max(1);
+        }
+        if effective_fade_out > cap {
+            effective_fade_out = cap.max(1);
+        }
+    }
+
+    let delay_samples = if delay > 0.0 {
+        (delay * (sample_rate)) as usize
+    } else {
+        0
+    };
+    let mut delay_buffer: Vec<f32> = vec![0.0; total_samples + delay_samples];
+
+    for i in 0..total_samples {
+        let pitch_index = if pitch != 1.0 {
+            ((i as f32) / pitch) as usize
+        } else {
+            i
+        };
+
+        let mut adjusted = if pitch_index < total_samples {
+            samples[pitch_index] as f32
+        } else {
+            0.0
+        };
+
+        adjusted *= gain;
+
+        if effective_fade_in > 0 && i < effective_fade_in {
+            if effective_fade_in == 1 {
+                adjusted *= 0.0;
+            } else {
+                adjusted *= (i as f32) / (effective_fade_in as f32);
+            }
+        }
+        if effective_fade_out > 0 && i >= total_samples.saturating_sub(effective_fade_out) {
+            if effective_fade_out == 1 {
+                adjusted *= 0.0;
+            } else {
+                adjusted *= ((total_samples - 1 - i) as f32) / ((effective_fade_out - 1) as f32);
+            }
+        }
+
+        if drive > 0.0 {
+            let normalized = adjusted / (i16::MAX as f32);
+            let pre_gain = (10f32).powf(drive / 20.0);
+            let driven = (normalized * pre_gain).tanh();
+            adjusted = driven * (i16::MAX as f32);
+        }
+
+        if delay_samples > 0 && i >= delay_samples {
+            let echo = delay_buffer[i - delay_samples] * delay_feedback;
+            adjusted += echo;
+        }
+        if delay_samples > 0 {
+            delay_buffer[i] = adjusted;
+        }
+
+        if reverb > 0.0 {
+            let reverb_delay = (0.03 * (sample_rate)) as usize;
+            if i >= reverb_delay {
+                adjusted += (engine.buffer[offset + i - reverb_delay] as f32) * reverb;
+            }
+        }
+
+        let adjusted_sample = adjusted.round().clamp(i16::MIN as f32, i16::MAX as f32) as i16;
+
+        let (left_gain, right_gain) = crate::core::audio::engine::helpers::pan_gains(pan);
+
+        let left = ((adjusted_sample as f32) * left_gain) as i16;
+        let right = ((adjusted_sample as f32) * right_gain) as i16;
+
+        // For interleaved buffer with `channels` channels, each frame has `channels` samples.
+        // left channel at frame i is at offset + i * channels, right at +1.
+        let left_pos = offset + i * channels;
+        let right_pos = left_pos + 1;
+
+        if right_pos < engine.buffer.len() {
+            engine.buffer[left_pos] = engine.buffer[left_pos].saturating_add(left);
+            engine.buffer[right_pos] = engine.buffer[right_pos].saturating_add(right);
+        }
+    }
+}