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

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,6 +1,6 @@
 [package]
 name = "devalang"
-version = "0.0.1-alpha.11"
+version = "0.0.1-alpha.13"
 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"
@@ -20,14 +20,14 @@ required-features = ["cli"]
 
 [lib]
 path = "rust/lib.rs"
-crate-type = ["cdylib"]
+crate-type = ["cdylib", "rlib"]
 
 [profile.release]
 opt-level = "s"
 
 [features]
 default = ["cli"]
-cli = ["crossterm", "indicatif", "inquire"]
+cli = ["crossterm", "indicatif", "inquire", "zip", "reqwest", "flate2", "tokio"]
 
 [dependencies]
 clap = { version = "4.5", features = ["derive"] }
@@ -47,8 +47,8 @@ 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"
+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 }
+rayon = "1.10.0"

package/README.md

@@ -27,7 +27,7 @@ Compose loops, control samples, render and play audio — all in clean, readable
 
 From studio sketches to live sets, Devalang gives you rhythmic control — with the elegance of code.
 
-> 🚧 **v0.0.1-alpha.11 Notice** 🚧
+> 🚧 **v0.0.1-alpha.13 Notice** 🚧
 >
 > NEW: Devalang is available in your browser at [playground.devalang.com](https://playground.devalang.com) !
 >
@@ -119,22 +119,9 @@ devalang play --repeat
 
 ### Please refer to the [online documentation](https://docs.devalang.com) for detailed information on syntax, features, and usage examples.
 
-## 📜 Changelog Highlights
-
-For a complete list of changes, see [docs/CHANGELOG.md](./docs/CHANGELOG.md)
-
-- Implemented beat durations in `triggers` and `arrow_calls` statements
-- Implemented `bank` resolver to resolve banks of sounds in the code
-  - Support for namespaced banks of sounds (e.g. `.808.myTrigger`)
-- Implemented multiple commands for `bank` management
-  - `bank list`, `bank available`, `bank info <bank_name>`, `bank remove <bank_name>`, `bank update`, `bank update <bank_name>`
-- Implemented `install` command to install banks of sounds
-  - `install bank <bank_name>`
-
 ## 🧯 Known issues
 
 - No smart modules yet, all groups, variables, and samples must be explicitly imported where used
-- No support yet for `pattern`, `function`, ... statements
 - No support yet for cross-platform builds (Linux, macOS)
 
 ## 🧪 Roadmap Highlights

package/docs/CHANGELOG.md

@@ -4,6 +4,50 @@
 
 # Changelog
 
+## Version 0.0.1-alpha.13 (2025-07-26)
+
+### 🧩 Language Features
+
+- Added support for `fn` directive to define functions in Devalang.
+  - Example: `fn myFunction(param1, param2):`
+  
+### 🧠 Core Engine
+
+- Patched `trigger`, `call`, and `spawn`, `renderer` to handle correct cursor time in the audio interpreter.
+- Refactored audio engine and interpreter to handle correct timing and execution while using `loop`, `call`, and `spawn` statements.
+- Refactored `trigger` effects to apply more effects to triggers.
+  - Example: `.myTrigger auto { reverb: 0.25, pitch: 0.75, gain: 0.8 }`
+- Refactored `preprocessor` to handle correct namespaced banks of sounds and triggers.
+- Refactored `collect_errors_recursively` to provide detailed error reporting across nested statements.
+- Optimized the `renderer` to handle silent buffers and improve performance.
+
+### 🛠️ Utilities
+
+- Added the `extract_loop_body_statements` utility for better loop handling.
+- Improved logging for module variables and functions.
+
+### 🧩 Web Assembly
+
+- Patched `lib.rs` dependencies to ensure compatibility with the latest Rust and WASM standards.
+
+## 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/docs/TODO.md

@@ -44,7 +44,7 @@ This is a list of tasks and features to be implemented in Devalang. Note that th
 - [x] @export
 - [x] @load
 - [ ] @include
-- [ ] function
+- [x] function
 - [ ] pattern
 - [x] group
 - [x] call

package/examples/index.deva

@@ -1,16 +1,15 @@
 # This file demonstrates the use of main features in Devalang.
+bpm 135
 
-@import { duration, default_bank, params, loopCount, tempo } from "./variables.deva"
-@import { myLead } from "./synth.deva"
-@import { myLoop } from "./loop.deva"
+bank 808
 
-@load "./samples/kick-808.wav" as kickCustom
-@load "./samples/hat-808.wav" as hatCustom
+let entityTest1 = .808.kick auto
+let entityTest2 = .808.clap auto
+let entityTest3 = .808.snare auto
 
-bpm tempo
+fn myFirstGroup(entity1, entity2, entity3):
+    .entity1
+    .entity2
+    .entity3
 
-group myTrack:
-    spawn myLoop
-    spawn myLead
-
-call myTrack
+call myFirstGroup(entityTest1, entityTest2, entityTest3)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@devaloop/devalang",
   "private": false,
-  "version": "0.0.1-alpha.11",
+  "version": "0.0.1-alpha.13",
   "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.13",
   "channel": "alpha",
-  "lastCommit": "f643b05f7c5d97c5d22cb255c3641cfc9e385ea2",
-  "build": 10
+  "lastCommit": "f25a91c6efe3dca91cc8fa3bfa829d3fc2271855",
+  "build": 12
 }

package/rust/cli/build.rs

@@ -4,8 +4,9 @@ use crate::{
         builder::Builder,
         debugger::{
             lexer::write_lexer_log_file,
+            module::{ write_module_function_log_file, write_module_variable_log_file },
             preprocessor::write_preprocessor_log_file,
-            store::write_store_log_file,
+            store::{ write_function_log_file, write_variables_log_file },
         },
         preprocessor::loader::ModuleLoader,
         store::global::GlobalStore,
@@ -111,13 +112,35 @@ fn begin_build(entry: String, output: String) {
     let (modules_tokens, modules_statements) = module_loader.load_all_modules(&mut global_store);
 
     // SECTION Write logs
+    for (module_path, module) in global_store.modules.clone() {
+        write_module_variable_log_file(
+            &normalized_output_dir,
+            &module_path,
+            &module.variable_table
+        );
+        write_module_function_log_file(
+            &normalized_output_dir,
+            &module_path,
+            &module.function_table
+        );
+    }
+
     write_lexer_log_file(&normalized_output_dir, "lexer_tokens.log", modules_tokens.clone());
     write_preprocessor_log_file(
         &normalized_output_dir,
         "resolved_statements.log",
         modules_statements.clone()
     );
-    write_store_log_file(&normalized_output_dir, "global_store.log", global_store.modules.clone());
+    write_variables_log_file(
+        &normalized_output_dir,
+        "global_variables.log",
+        global_store.variables.clone()
+    );
+    write_function_log_file(
+        &normalized_output_dir,
+        "global_functions.log",
+        global_store.functions.clone()
+    );
 
     // SECTION Building AST and Audio
     let builder = Builder::new();

package/rust/cli/check.rs

@@ -5,7 +5,12 @@ use crate::{
         store::global::GlobalStore,
         utils::path::{ find_entry_file, normalize_path },
     },
-    utils::{ logger::{ LogLevel, Logger }, spinner::with_spinner, watcher::watch_directory },
+    utils::{
+        collect_errors_recursively,
+        logger::{ LogLevel, Logger },
+        spinner::with_spinner,
+        watcher::watch_directory,
+    },
 };
 use std::{ thread, time::Duration };
 
@@ -104,7 +109,26 @@ fn begin_check(entry: String, output: String) {
     // NOTE: We don't use modules in the check command, but we still need to load them
     let modules = module_loader.load_all_modules(&mut global_store);
 
-    // TODO: Implement debugging
+    // Debugging: Log loaded modules and errors
+    let logger = Logger::new();
+    logger.log_message(LogLevel::Info, "Loaded modules:");
+    for (module_name, _) in &modules.0 {
+        logger.log_message(LogLevel::Info, &format!("- {}", module_name));
+    }
+
+    let mut all_errors = Vec::new();
+    for (_, statements) in &modules.1 {
+        all_errors.extend(collect_errors_recursively(statements));
+    }
+
+    if !all_errors.is_empty() {
+        logger.log_message(LogLevel::Error, "Errors detected during check:");
+        for error in all_errors {
+            logger.log_message(LogLevel::Error, &format!("- {}", error.message));
+        }
+    } else {
+        logger.log_message(LogLevel::Success, "No errors detected.");
+    }
 
     let success_message = format!(
         "Check completed successfully in {:.2?}. Output files written to: '{}'",
@@ -112,6 +136,5 @@ fn begin_check(entry: String, output: String) {
         normalized_output_dir
     );
 
-    let logger = Logger::new();
     logger.log_message(LogLevel::Success, &success_message);
 }

package/rust/cli/play.rs

@@ -127,7 +127,7 @@ pub fn handle_play_command(
     } else {
         // Single execution
         begin_play(&config, &entry_file, &output_path);
-        
+
         logger.log_message(LogLevel::Info, "🎵 Playback started (once mode)...");
 
         audio_player.play_file_once(&audio_file);

package/rust/core/audio/engine.rs

@@ -1,10 +1,10 @@
 use std::{ collections::HashMap, fs::File, io::BufReader, path::Path };
 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 },
+    utils::path::normalize_path,
 };
 
 const SAMPLE_RATE: u32 = 44100;
@@ -13,7 +13,6 @@ const CHANNELS: u16 = 2;
 #[derive(Debug, Clone, PartialEq)]
 pub struct AudioEngine {
     pub volume: f32,
-    pub variables: VariableTable,
     pub buffer: Vec<i16>,
     pub module_name: String,
 }
@@ -23,7 +22,6 @@ impl AudioEngine {
         AudioEngine {
             volume: 1.0,
             buffer: vec![],
-            variables: VariableTable::new(),
             module_name,
         }
     }
@@ -56,12 +54,10 @@ impl AudioEngine {
 
         if self.buffer.iter().all(|&s| s == 0) {
             self.buffer = other.buffer;
-            self.variables.variables.extend(other.variables.variables);
             return;
         }
 
         self.mix(&other);
-        self.variables.variables.extend(other.variables.variables);
     }
 
     pub fn set_duration(&mut self, duration_secs: f32) {
@@ -72,10 +68,6 @@ impl AudioEngine {
         }
     }
 
-    pub fn set_variables(&mut self, variables: VariableTable) {
-        self.variables = variables;
-    }
-
     pub fn generate_wav_file(&mut self, output_dir: &String) -> Result<(), String> {
         if self.buffer.len() % (CHANNELS as usize) != 0 {
             self.buffer.push(0);
@@ -167,75 +159,249 @@ impl AudioEngine {
         filepath: &str,
         time_secs: f32,
         dur_sec: f32,
-        effects: Option<HashMap<String, f32>>
+        effects: Option<HashMap<String, Value>>,
+        variable_table: &VariableTable
     ) {
         if filepath.is_empty() {
             eprintln!("❌ Empty file path provided for audio sample.");
             return;
         }
 
+        let root = Path::new(env!("CARGO_MANIFEST_DIR"));
+        let module_root = Path::new(&self.module_name);
         let mut resolved_path = String::new();
 
-        if filepath.starts_with("devalang://") {
-            let root = Path::new(env!("CARGO_MANIFEST_DIR"));
-            let parts = filepath.split("devalang://").collect::<Vec<&str>>();
-            let object_parts = parts.get(1).unwrap_or(&"").split("/").collect::<Vec<&str>>();
-            let object_type = object_parts.get(0).unwrap_or(&"").to_lowercase();
-            let object_dir = object_parts.get(1).unwrap_or(&"").to_string();
-            let object_name = object_parts.get(2).unwrap_or(&"").to_string();
+        // Get the variable path from the variable table
+        let mut var_path = filepath.to_string();
+        if let Some(Value::String(variable_path)) = variable_table.variables.get(filepath) {
+            var_path = variable_path.clone();
+        } else if let Some(Value::Sample(sample_path)) = variable_table.variables.get(filepath) {
+            var_path = sample_path.clone();
+        }
+
+        // If it's a namespace
+        if var_path.contains(".") {
+            let parts: Vec<&str> = var_path.trim_start_matches('.').split('.').collect();
+            if parts.len() == 2 {
+                let bank_name = parts[0];
+                let entity_name = parts[1];
+
+                // Verifies if the bank is declared
+                if !variable_table.variables.contains_key(bank_name) {
+                    eprintln!(
+                        "❌ Bank '{}' not declared. Please declare it first using : 'bank {}'",
+                        bank_name,
+                        bank_name
+                    );
+                    return;
+                }
 
-            if object_type.contains("bank") {
                 resolved_path = root
                     .join(".deva")
                     .join("bank")
-                    .join(object_dir)
-                    .join(format!("{}.wav", object_name))
-                    .to_str()
-                    .unwrap_or("")
+                    .join(bank_name)
+                    .join(format!("{}.wav", entity_name))
+                    .to_string_lossy()
                     .to_string();
             } else {
-                eprintln!("❌ Unsupported devalang:// object type: {}", object_type);
+                eprintln!("❌ Invalid namespace format: {}", var_path);
+                return;
+            }
+        } else if var_path.starts_with("devalang://") {
+            let path_after_protocol = var_path.replace("devalang://", "");
+            let parts: Vec<&str> = path_after_protocol.split('/').collect();
+
+            if parts.len() < 3 {
+                eprintln!(
+                    "❌ Invalid devalang:// path format. Expected devalang://<type>/<bank>/<entity>"
+                );
                 return;
             }
+
+            let obj_type = parts[0];
+            let bank_name = parts[1];
+            let entity_name = parts[2];
+
+            resolved_path = root
+                .join(".deva")
+                .join(obj_type)
+                .join(bank_name)
+                .join(format!("{}.wav", entity_name))
+                .to_string_lossy()
+                .to_string();
+        } else {
+            // Else, resolve as a relative path
+            let entry_dir = module_root.parent().unwrap_or(root);
+            let absolute_path = root.join(entry_dir).join(&var_path);
+
+            resolved_path = normalize_path(absolute_path.to_string_lossy().to_string());
+        }
+
+        // Verify if the file exists
+        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 decoder = Decoder::new(file).expect("Failed to decode audio file");
+        let file = match File::open(&resolved_path) {
+            Ok(f) => BufReader::new(f),
+            Err(e) => {
+                eprintln!("❌ Failed to open audio file {}: {}", resolved_path, e);
+                return;
+            }
+        };
+
+        let decoder = match Decoder::new(file) {
+            Ok(d) => d,
+            Err(e) => {
+                eprintln!("❌ Failed to decode audio file {}: {}", resolved_path, e);
+                return;
+            }
+        };
 
-        // Mono or stereo reading possible here, we will duplicate in L/R
         let max_mono_samples = (dur_sec * (SAMPLE_RATE as f32)) as usize;
         let samples: Vec<i16> = decoder.convert_samples().take(max_mono_samples).collect();
 
         if samples.is_empty() {
-            eprintln!("No samples found in the audio file: {}", filepath);
+            eprintln!("❌ No samples read from {}", resolved_path);
             return;
         }
 
-        // TODO Apply effects here if needed
+        // Calculate buffer offset and size
         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 {
-            required_len + 1
-        } else {
-            required_len
-        };
+        if self.buffer.len() < required_len {
+            self.buffer.resize(required_len, 0);
+        }
 
-        self.buffer.resize(padded_required_len, 0);
-        self.pad_samples(&samples, time_secs);
+        // Apply effects and mix
+        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;
+        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 f32)) as usize;
+        let fade_out_samples = (fade_out * (SAMPLE_RATE as f32)) as usize;
+
+        let delay_samples = if delay > 0.0 { (delay * (SAMPLE_RATE as f32)) as usize } else { 0 };
+        let mut delay_buffer: Vec<f32> = vec![0.0; total_samples + delay_samples];
+
+        for i in 0..total_samples {
+            // PITCH FIRST
+            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
+            };
+
+            // GAIN
+            adjusted *= gain;
+
+            // FADE IN/OUT
+            if fade_in_samples > 0 && i < fade_in_samples {
+                adjusted *= (i as f32) / (fade_in_samples as f32);
+            }
+            if fade_out_samples > 0 && i >= total_samples.saturating_sub(fade_out_samples) {
+                adjusted *= ((total_samples - i) as f32) / (fade_out_samples as f32);
+            }
+
+            // DRIVE (soft)
+            if drive > 0.0 {
+                let normalized = adjusted / (i16::MAX as f32);
+                let pre_gain = (10f32).powf(drive / 20.0); // dB mapping
+                let driven = (normalized * pre_gain).tanh();
+                adjusted = driven * (i16::MAX as f32);
+            }
+
+            // DELAY
+            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;
+            }
+
+            // REVERB
+            if reverb > 0.0 {
+                let reverb_delay = (0.03 * (SAMPLE_RATE as f32)) as usize;
+                if i >= reverb_delay {
+                    adjusted += (self.buffer[offset + i - reverb_delay] as f32) * reverb;
+                }
+            }
+
+            // CLAMP
+            let adjusted_sample = adjusted.round().clamp(i16::MIN as f32, i16::MAX as f32) as i16;
+
+            // PAN
+            let left_gain = 1.0 - pan.max(0.0); // Pan > 0 => reduce left
+            let right_gain = 1.0 + pan.min(0.0); // Pan < 0 => reduce right
 
-        for (i, &sample) in samples.iter().enumerate() {
-            let adjusted_sample = ((sample as f32) * self.volume).round() as i16;
+            let left = ((adjusted_sample as f32) * left_gain) as i16;
+            let right = ((adjusted_sample as f32) * right_gain) 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);
             }
         }
     }