@devaloop/devalang 0.0.1-alpha.11 → 0.0.1-alpha.12

package/.devalang

@@ -1,9 +1,9 @@
-[defaults]
-entry = "./examples"
-output = "./output"
-watch = false
-
-[[banks]]
-path = "devalang://bank/808"
-version = "0.0.1"
+[defaults]
+entry = "./examples"
+output = "./output"
+watch = false
+
+[[banks]]
+path = "devalang://bank/808"
+version = "0.0.1"
 author = "devaloop"

package/Cargo.toml

@@ -1,54 +1,53 @@
-[package]
-name = "devalang"
-version = "0.0.1-alpha.11"
-authors = ["Devaloop <contact@devaloop.com>"]
-description = "Write music like code. Devalang is a domain-specific language (DSL) for sound designers and music hackers. Compose, automate, and control sound — in plain text."
-license = "MIT"
-repository = "https://github.com/devaloop-labs/devalang"
-keywords = ["music", "dsl", "audio", "cli"]
-categories = ["command-line-utilities", "development-tools", "parser-implementations"]
-readme = "README.md"
-homepage = "https://devalang.com"
-documentation = "https://docs.devalang.com/"
-license-file = "LICENSE"
-edition = "2024"
-
-[[bin]]
-name = "devalang"
-path = "rust/main.rs"
-required-features = ["cli"]
-
-[lib]
-path = "rust/lib.rs"
-crate-type = ["cdylib"]
-
-[profile.release]
-opt-level = "s"
-
-[features]
-default = ["cli"]
-cli = ["crossterm", "indicatif", "inquire"]
-
-[dependencies]
-clap = { version = "4.5", features = ["derive"] }
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-rodio = "0.17"
-hound = "3.4.0"
-toml = "0.8"
-notify = "6.1"
-fs_extra = "1.3"
-include_dir = "0.7"
-wasm-bindgen = "0.2"
-serde-wasm-bindgen = "0.4"
-nom_locate = "4.0.0"
-chrono = "0.4"
-crossterm =  { version = "0.27", optional = true }
-indicatif = { version = "0.17", optional = true }
-inquire = { version = "0.7.5", optional = true }
-js-sys = "0.3"
-reqwest = { version = "0.12.22", features = ["json"] }
-flate2 = "1.0"
-tar = "0.4"
-tokio = { version = "1", features = ["full"] }
-zip = "4.3.0"
+[package]
+name = "devalang"
+version = "0.0.1-alpha.12"
+authors = ["Devaloop <contact@devaloop.com>"]
+description = "Write music like code. Devalang is a domain-specific language (DSL) for sound designers and music hackers. Compose, automate, and control sound — in plain text."
+license = "MIT"
+repository = "https://github.com/devaloop-labs/devalang"
+keywords = ["music", "dsl", "audio", "cli"]
+categories = ["command-line-utilities", "development-tools", "parser-implementations"]
+readme = "README.md"
+homepage = "https://devalang.com"
+documentation = "https://docs.devalang.com/"
+license-file = "LICENSE"
+edition = "2024"
+
+[[bin]]
+name = "devalang"
+path = "rust/main.rs"
+required-features = ["cli"]
+
+[lib]
+path = "rust/lib.rs"
+crate-type = ["cdylib"]
+
+[profile.release]
+opt-level = "s"
+
+[features]
+default = ["cli"]
+cli = ["crossterm", "indicatif", "inquire", "zip", "reqwest", "flate2", "tokio"]
+
+[dependencies]
+clap = { version = "4.5", features = ["derive"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+rodio = "0.17"
+hound = "3.4.0"
+toml = "0.8"
+notify = "6.1"
+fs_extra = "1.3"
+include_dir = "0.7"
+wasm-bindgen = "0.2"
+serde-wasm-bindgen = "0.4"
+nom_locate = "4.0.0"
+chrono = "0.4"
+crossterm =  { version = "0.27", optional = true }
+indicatif = { version = "0.17", optional = true }
+inquire = { version = "0.7.5", optional = true }
+js-sys = "0.3"
+reqwest = { version = "0.12.22", optional = true, features = ["json"] }
+flate2 = { version = "1.0", optional = true }
+tokio = { version = "1", features = ["full"], optional = true }
+zip = { version = "4.3.0", optional = true }

package/docs/CHANGELOG.md

@@ -4,6 +4,24 @@
 
 # Changelog
 
+## Version 0.0.1-alpha.12 (2025-07-21)
+
+### 🧩 Language Features
+
+- Implemented `trigger` effects to apply effects to triggers, allowing for more dynamic sound manipulation.
+  - Example: `.myTrigger auto { reverb: 1.0, pitch: 1.5, gain: 0.8 }`
+
+### 🧠 Core Engine
+
+- Moved `utils::installer` to `installer::utils` to better organize the project structure.
+- Set CLI dependencies as optional in `Cargo.toml` to allow for a cleaner build without CLI features.
+- Patched `@load` relative path resolution to ensure correct loading of external resources.
+- Patched `trigger` statement that was not correctly parsed when using namespaced banks of sounds.
+
+### 🧩 Web Assembly
+
+- Patched `lib.rs` dependencies to ensure compatibility with the latest Rust and WASM standards.
+
 ## Version 0.0.1-alpha.11 (2025-07-20)
 
 ### 📖 Documentation

package/examples/index.deva

@@ -7,10 +7,12 @@
 @load "./samples/kick-808.wav" as kickCustom
 @load "./samples/hat-808.wav" as hatCustom
 
-bpm tempo
+# bpm tempo
 
-group myTrack:
-    spawn myLoop
-    spawn myLead
+# group myTrack:
+#     spawn myLoop
+#     spawn myLead
 
-call myTrack
+# call myTrack
+
+.kickCustom duration { gain: 1, pitch: 1.25 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@devaloop/devalang",
   "private": false,
-  "version": "0.0.1-alpha.11",
+  "version": "0.0.1-alpha.12",
   "description": "Write music like code. Devalang is a domain-specific language (DSL) for sound designers and music hackers. Compose, automate, and control sound — in plain text.",
   "main": "out-tsc/index.js",
   "bin": {
@@ -11,6 +11,7 @@
     "prepublish": "cargo build --release && npm run script:postbuild",
     "rust:dev:build": "cargo run build --entry examples --output output",
     "rust:dev:check": "cargo run check --entry examples --output output",
+    "rust:dev:play": "cargo run play --entry examples --output output --repeat",
     "rust:wasm:web": "wasm-pack build --target=web --no-default-features",
     "rust:wasm:node": "wasm-pack build --target=nodejs --no-default-features",
     "script:postbuild": "tsc && node out-tsc/scripts/postbuild.js",

package/project-version.json

@@ -1,6 +1,6 @@
 {
-  "version": "0.0.1-alpha.11",
+  "version": "0.0.1-alpha.12",
   "channel": "alpha",
-  "lastCommit": "f643b05f7c5d97c5d22cb255c3641cfc9e385ea2",
-  "build": 10
+  "lastCommit": "e16a21167693d0265195bf4256b3f8ec0ed1e55f",
+  "build": 11
 }

package/rust/core/audio/engine.rs

@@ -3,6 +3,7 @@ use hound::{ SampleFormat, WavSpec, WavWriter };
 use rodio::{ Decoder, Source };
 
 use crate::core::{
+    shared::value::Value,
     store::variable::VariableTable,
     utils::path::{ normalize_path, resolve_relative_path },
 };
@@ -167,7 +168,7 @@ impl AudioEngine {
         filepath: &str,
         time_secs: f32,
         dur_sec: f32,
-        effects: Option<HashMap<String, f32>>
+        effects: Option<HashMap<String, Value>>
     ) {
         if filepath.is_empty() {
             eprintln!("❌ Empty file path provided for audio sample.");
@@ -197,9 +198,26 @@ impl AudioEngine {
                 eprintln!("❌ Unsupported devalang:// object type: {}", object_type);
                 return;
             }
+        } else {
+            let module_path = &self.module_name;
+            let root = Path::new(module_path).parent();
+
+            if let Some(root_path) = root {
+                resolved_path = root_path.join(filepath).to_str().unwrap_or("").to_string();
+            } else {
+                eprintln!("❌ Could not resolve root path for module: {}", module_path);
+                return;
+            }
+        }
+
+        if !Path::new(&resolved_path).exists() {
+            eprintln!("❌ Audio file not found at: {}", resolved_path);
+            return;
         }
 
-        let file = BufReader::new(File::open(resolved_path).expect("Failed to open audio file"));
+        let file = BufReader::new(
+            File::open(&resolved_path).expect(&format!("Failed to open audio file {}", filepath))
+        );
         let decoder = Decoder::new(file).expect("Failed to decode audio file");
 
         // Mono or stereo reading possible here, we will duplicate in L/R
@@ -211,7 +229,7 @@ impl AudioEngine {
             return;
         }
 
-        // TODO Apply effects here if needed
+        // Pad the buffer to ensure it can accommodate the new samples
         let offset = (time_secs * (SAMPLE_RATE as f32) * (CHANNELS as f32)) as usize;
         let required_len = offset + samples.len() * (CHANNELS as usize);
         let padded_required_len = if required_len % 2 == 1 {
@@ -221,21 +239,116 @@ impl AudioEngine {
         };
 
         self.buffer.resize(padded_required_len, 0);
-        self.pad_samples(&samples, time_secs);
+
+        // Apply effects
+        if let Some(effects_map) = effects {
+            self.pad_samples(&samples, time_secs, Some(effects_map));
+        } else {
+            self.pad_samples(&samples, time_secs, None);
+        }
     }
 
-    fn pad_samples(&mut self, samples: &[i16], time_secs: f32) {
+    fn pad_samples(
+        &mut self,
+        samples: &[i16],
+        time_secs: f32,
+        effects_map: Option<HashMap<String, Value>>
+    ) {
         let offset = (time_secs * (SAMPLE_RATE as f32) * (CHANNELS as f32)) as usize;
+        let total_samples = samples.len();
+
+        // Default values
+        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;
+
+        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 effect can be implemented here if needed
+                        drive = *v;
+                    }
+                    ("reverb", Value::Number(v)) => {
+                        reverb = *v;
+                    }
+                    _ => eprintln!("⚠️ Unknown or invalid effect '{}'", key),
+                }
+            }
+        }
+
+        let fade_in_samples = (fade_in * (SAMPLE_RATE as f32)) as usize;
+        let fade_out_samples = (fade_out * (SAMPLE_RATE as f32)) as usize;
 
         for (i, &sample) in samples.iter().enumerate() {
-            let adjusted_sample = ((sample as f32) * self.volume).round() as i16;
+            // Gain
+            let mut adjusted = (sample as f32) * gain;
+
+            // Fade in
+            if fade_in_samples > 0 && i < fade_in_samples {
+                adjusted *= (i as f32) / (fade_in_samples as f32);
+            }
+
+            // Fade out
+            if fade_out_samples > 0 && i >= total_samples.saturating_sub(fade_out_samples) {
+                adjusted *= ((total_samples - i) as f32) / (fade_out_samples as f32);
+            }
+
+            // Pitch adjustment
+            if pitch != 1.0 {
+                let pitch_adjusted_index = ((i as f32) / pitch) as usize;
+                if pitch_adjusted_index < total_samples {
+                    adjusted = (samples[pitch_adjusted_index] as f32) * gain;
+                } else {
+                    adjusted = 0.0; // Out of bounds, set to zero
+                }
+            }
+
+            // Drive effect
+            if drive > 0.0 {
+                adjusted = adjusted.tanh() * (1.0 + drive);
+            }
+
+            // Reverb effect
+            if reverb > 0.0 {
+                let reverb_delay = (reverb * (SAMPLE_RATE as f32)) as usize;
+                if i >= reverb_delay {
+                    adjusted += self.buffer[offset + i - reverb_delay] as f32 * 0.5; // Simple feedback
+                }
+            }
+
+            // Clamp
+            let adjusted_sample = adjusted.round().clamp(i16::MIN as f32, i16::MAX as f32) as i16;
+
+            // Pan (L/R split)
+            let left = ((adjusted_sample as f32) * (1.0 - pan.clamp(0.0, 1.0))) as i16;
+            let right = ((adjusted_sample as f32) * (1.0 + pan.clamp(-1.0, 0.0)).abs()) as i16;
 
             let left_pos = offset + i * 2;
             let right_pos = left_pos + 1;
 
             if right_pos < self.buffer.len() {
-                self.buffer[left_pos] = self.buffer[left_pos].saturating_add(adjusted_sample); // gauche
-                self.buffer[right_pos] = self.buffer[right_pos].saturating_add(adjusted_sample); // droite
+                self.buffer[left_pos] = self.buffer[left_pos].saturating_add(left);
+                self.buffer[right_pos] = self.buffer[right_pos].saturating_add(right);
             }
         }
     }

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

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use crate::core::{
     audio::{ engine::AudioEngine, loader::trigger::load_trigger },
     parser::statement::{ Statement, StatementKind },
@@ -67,8 +69,13 @@ pub fn interprete_trigger_statement(
                 variable_table.clone()
             );
 
+            if let Some(effects) = extract_effects(stmt.value.clone()) {
+                audio_engine.insert_sample(&src, cursor_time, duration_final, Some(effects));
+            } else {
+                audio_engine.insert_sample(&src, cursor_time, duration_final, None);
+            }
+
             let mut updated_engine = audio_engine.clone();
-            updated_engine.insert_sample(&src, cursor_time, duration_final, None);
 
             let new_cursor_time = cursor_time + duration_final;
             let new_max_end_time = new_cursor_time.max(max_end_time);
@@ -100,3 +107,17 @@ fn resolve_namespaced_variable<'a>(path: &str, variables: &'a VariableTable) ->
 
     current
 }
+
+fn extract_effects(value: Value) -> Option<HashMap<String, Value>> {
+    if let Value::Map(map) = value.clone() {
+        let mut effects = HashMap::new();
+
+        for (key, val) in map {
+            effects.insert(key.clone(), val);
+        }
+
+        Some(effects)
+    } else {
+        None
+    }
+}

package/rust/core/parser/driver.rs

@@ -206,9 +206,35 @@ impl Parser {
                         Value::String(token.lexeme.clone())
                     }
                     TokenKind::Number => {
-                        self.advance();
-                        Value::Number(token.lexeme.parse().unwrap_or(0.0))
+                        let mut number_str = token.lexeme.clone();
+                        self.advance(); // consume the first number
+
+                        if let Some(dot_token) = self.peek_clone() {
+                            if dot_token.kind == TokenKind::Dot {
+                                self.advance(); // consume the dot
+
+                                if let Some(decimal_token) = self.peek_clone() {
+                                    if decimal_token.kind == TokenKind::Number {
+                                        self.advance(); // consume the number after the dot
+                                        number_str.push('.');
+                                        number_str.push_str(&decimal_token.lexeme);
+                                    } else {
+                                        println!(
+                                            "Expected number after dot, got {:?}",
+                                            decimal_token
+                                        );
+                                        return Some(Value::Null);
+                                    }
+                                } else {
+                                    println!("Expected number after dot, but reached EOF");
+                                    return Some(Value::Null);
+                                }
+                            }
+                        }
+
+                        Value::Number(number_str.parse::<f32>().unwrap_or(0.0))
                     }
+
                     TokenKind::Identifier => {
                         self.advance();
                         Value::Identifier(token.lexeme.clone())

package/rust/core/parser/handler/dot.rs

@@ -15,15 +15,10 @@ pub fn parse_dot_token(parser: &mut Parser, _global_store: &mut GlobalStore) ->
     // Parse namespaced identifier: .808.kick.snare
     let mut parts = Vec::new();
 
-    loop {
-        let Some(token) = parser.peek_clone() else {
-            break;
-        };
-
+    while let Some(token) = parser.peek_clone() {
         match token.kind {
-            // Stop if we encounter a likely duration keyword
             TokenKind::Number => {
-                // If there's a slash after the number, it's probably a fraction (1/4)
+                // Stop if it's part of a duration
                 if let Some(TokenKind::Slash) = parser.peek_nth_kind(1) {
                     break;
                 }
@@ -33,7 +28,11 @@ pub fn parse_dot_token(parser: &mut Parser, _global_store: &mut GlobalStore) ->
             }
 
             TokenKind::Identifier => {
-                // Stop if it's the duration keyword "auto"
+                // Stop parsing entity name if next token is ':' or if already have one ident and current might be a param
+                if parts.len() >= 1 {
+                    break; // we've already got the entity
+                }
+
                 if token.lexeme == "auto" {
                     break;
                 }
@@ -43,7 +42,7 @@ pub fn parse_dot_token(parser: &mut Parser, _global_store: &mut GlobalStore) ->
             }
 
             TokenKind::Dot => {
-                parser.advance(); // consume dot
+                parser.advance(); // continue chaining
             }
 
             _ => {
@@ -52,7 +51,7 @@ pub fn parse_dot_token(parser: &mut Parser, _global_store: &mut GlobalStore) ->
         }
     }
 
-    let entity = parts.join(".");
+    let entity = if parts.len() == 1 { parts[0].clone() } else { parts[..=1].join(".") };
 
     if entity.is_empty() {
         return Statement {

package/rust/installer/bank.rs

@@ -2,7 +2,7 @@ use std::path::{ Path, PathBuf };
 use crate::{
     common::cdn::get_cdn_url,
     config::loader::{ add_bank_to_config, load_config },
-    utils::installer::{ download_file, extract_archive },
+    installer::utils::{ download_file, extract_archive },
 };
 
 pub async fn install_bank(name: &str, target_dir: &Path) -> Result<(), String> {

package/rust/installer/mod.rs

@@ -1 +1,2 @@
-pub mod bank;
+pub mod bank;
+pub mod utils;

package/rust/lib.rs

@@ -1,7 +1,6 @@
 pub mod core;
 pub mod utils;
 pub mod config;
-pub mod common;
 
 use serde::{ Deserialize, Serialize };
 use wasm_bindgen::prelude::*;

package/rust/utils/mod.rs

@@ -3,5 +3,4 @@ pub mod signature;
 pub mod spinner;
 pub mod watcher;
 pub mod file;
-pub mod logger;
-pub mod installer;
+pub mod logger;