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

package/rust/config/loader.rs

@@ -1,6 +1,5 @@
 use std::{ fs, path::Path };
-use std::collections::HashMap;
-use crate::config::driver::{ BankEntry, Config };
+use crate::config::driver::{ BankEntry, BankMetadata, Config };
 
 pub fn load_config(path: Option<&Path>) -> Option<Config> {
     let config_path = path.unwrap_or_else(|| Path::new(".devalang"));
@@ -56,6 +55,59 @@ pub fn remove_bank_from_config(config: &mut Config, dependency: &str) {
     }
 }
 
+pub fn add_plugin_to_config(config: &mut Config, real_path: &Path, dependency: &str) {
+    if config.plugins.is_none() {
+        config.plugins = Some(Vec::new());
+    }
+
+    let plugins = config.plugins.as_mut().unwrap();
+
+    let exists = plugins.iter().any(|p| p.path == dependency);
+    if exists {
+        println!("Plugin '{}' already in config", dependency);
+        return;
+    }
+
+    let metadata_path = Path::new(real_path).join("plugin.toml");
+
+    if !metadata_path.exists() {
+        eprintln!("❌ Plugin metadata file '{}' does not exist", metadata_path.display());
+        return;
+    }
+
+    let metadata_content = std::fs
+        ::read_to_string(&metadata_path)
+        .expect("Failed to read plugin metadata file");
+
+    let metadata: std::collections::HashMap<String, String> = toml
+        ::from_str(&metadata_content)
+        .expect("Failed to parse plugin metadata file");
+
+    let plugin_entry = crate::config::driver::PluginEntry {
+        path: dependency.to_string(),
+        version: metadata
+            .get("version")
+            .cloned()
+            .unwrap_or_else(|| "0.0.1".to_string()),
+        author: metadata
+            .get("author")
+            .cloned()
+            .unwrap_or_else(|| "unknown".to_string()),
+        access: metadata
+            .get("access")
+            .cloned()
+            .unwrap_or_else(|| "public".to_string()),
+    };
+
+    plugins.push(plugin_entry);
+
+    if let Err(e) = config.write(config) {
+        eprintln!("❌ Failed to write config: {}", e);
+    } else {
+        println!("✅ Plugin '{}' added to config", dependency);
+    }
+}
+
 pub fn add_bank_to_config(config: &mut Config, real_path: &Path, dependency: &str) {
     if config.banks.is_none() {
         config.banks = Some(Vec::new());
@@ -80,24 +132,18 @@ pub fn add_bank_to_config(config: &mut Config, real_path: &Path, dependency: &st
         ::read_to_string(&metadata_path)
         .expect("Failed to read bank metadata file");
 
-    let metadata: HashMap<String, String> = toml
+    let metadata: BankMetadata = toml
         ::from_str(&metadata_content)
         .expect("Failed to parse bank metadata file");
 
     let bank_to_insert = BankEntry {
         path: dependency.to_string(),
         version: Some(
-            metadata
+            metadata.bank
                 .get("version")
                 .cloned()
                 .unwrap_or_else(|| "0.0.1".to_string())
         ),
-        author: Some(
-            metadata
-                .get("author")
-                .cloned()
-                .unwrap_or_else(|| "unknown".to_string())
-        ),
     };
 
     banks.push(bank_to_insert);

package/rust/core/audio/engine.rs

@@ -100,30 +100,141 @@ impl AudioEngine {
         freq: f32,
         amp: f32,
         start_time_ms: f32,
-        duration_ms: f32
+        duration_ms: f32,
+        synth_params: HashMap<String, Value>,
+        note_params: HashMap<String, Value>
     ) {
+        let valid_synth_params = vec!["attack", "decay", "sustain", "release"];
+        let valid_note_params = vec![
+            "duration",
+            "velocity",
+            "glide",
+            "slide",
+            "amp",
+            "target_freq",
+            "target_amp",
+            "modulation",
+            "expression"
+        ];
+
+        // Synth params validation
+        for key in synth_params.keys() {
+            if !valid_synth_params.contains(&key.as_str()) {
+                eprintln!("⚠️ Unknown synth parameter: '{}'", key);
+            }
+        }
+
+        // Note params validation
+        for key in note_params.keys() {
+            if !valid_note_params.contains(&key.as_str()) {
+                eprintln!("⚠️ Unknown note parameter: '{}'", key);
+            }
+        }
+
+    // Synth parameters
+    let attack = self.extract_f32(&synth_params, "attack").unwrap_or(0.0);
+    let decay = self.extract_f32(&synth_params, "decay").unwrap_or(0.0);
+    let sustain = self.extract_f32(&synth_params, "sustain").unwrap_or(0.0);
+    let release = self.extract_f32(&synth_params, "release").unwrap_or(0.0);
+    let attack_s = if attack > 10.0 { attack / 1000.0 } else { attack };
+    let decay_s = if decay > 10.0 { decay / 1000.0 } else { decay };
+    let release_s = if release > 10.0 { release / 1000.0 } else { release };
+    let sustain_level = if sustain > 1.0 { (sustain / 100.0).clamp(0.0, 1.0) } else { sustain.clamp(0.0, 1.0) };
+
+        // Note parameters
+    let duration_ms = self.extract_f32(&note_params, "duration").unwrap_or(duration_ms);
+    let velocity = self.extract_f32(&note_params, "velocity").unwrap_or(1.0);
+        let glide = self.extract_boolean(&note_params, "glide").unwrap_or(false);
+        let slide = self.extract_boolean(&note_params, "slide").unwrap_or(false);
+
+    let _amplitude = (i16::MAX as f32) * amp.clamp(0.0, 1.0) * velocity.clamp(0.0, 1.0);
+
+        // Logic for glide and slide
+    let freq_start = freq;
+        let mut freq_end = freq;
+    let amp_start = amp * velocity.clamp(0.0, 1.0);
+        let mut amp_end = amp_start;
+
+        if glide {
+            if let Some(Value::Number(target_freq)) = note_params.get("target_freq") {
+                freq_end = *target_freq;
+            } else {
+                freq_end = freq * 1.5; // Par défaut, glide vers une quinte
+            }
+        }
+
+        if slide {
+            if let Some(Value::Number(target_amp)) = note_params.get("target_amp") {
+                amp_end = *target_amp * velocity.clamp(0.0, 1.0);
+            } else {
+                amp_end = amp_start * 0.5; // Par défaut, slide vers la moitié
+            }
+        }
+
         let sample_rate = SAMPLE_RATE as f32;
         let channels = CHANNELS as usize;
 
         let total_samples = ((duration_ms / 1000.0) * sample_rate) as usize;
         let start_sample = ((start_time_ms / 1000.0) * sample_rate) as usize;
-        let amplitude = (i16::MAX as f32) * amp.clamp(0.0, 1.0);
 
         let mut samples = Vec::with_capacity(total_samples);
-        let fade_len = (sample_rate * 0.01) as usize; // 10 ms fade
+    let fade_len = (sample_rate * 0.01) as usize; // 10 ms fade
+
+    let attack_samples = (attack_s * sample_rate) as usize;
+    let decay_samples = (decay_s * sample_rate) as usize;
+    let release_samples = (release_s * sample_rate) as usize;
+        let sustain_samples = if total_samples > attack_samples + decay_samples + release_samples {
+            total_samples - attack_samples - decay_samples - release_samples
+        } else {
+            0
+        };
 
         for i in 0..total_samples {
             let t = ((start_sample + i) as f32) / sample_rate;
-            let phase = 2.0 * std::f32::consts::PI * freq * t;
+
+            // Glide
+            let current_freq = if glide {
+                freq_start + ((freq_end - freq_start) * (i as f32)) / (total_samples as f32)
+            } else {
+                freq
+            };
+
+            // Slide
+            let current_amp = if slide {
+                amp_start + ((amp_end - amp_start) * (i as f32)) / (total_samples as f32)
+            } else {
+                amp_start
+            };
+
+            let phase = 2.0 * std::f32::consts::PI * current_freq * t;
 
             let mut value = match waveform.as_str() {
                 "sine" => phase.sin(),
-                "square" => if phase.sin() >= 0.0 { 1.0 } else { -1.0 }
-                "saw" => 2.0 * (freq * t - (freq * t + 0.5).floor()),
-                "triangle" => (2.0 * (2.0 * (freq * t).fract() - 1.0)).abs() * 2.0 - 1.0,
+                "square" => if phase.sin() >= 0.0 { 1.0 } else { -1.0 },
+                "saw" => 2.0 * (current_freq * t - (current_freq * t + 0.5).floor()),
+                "triangle" => (2.0 * (2.0 * (current_freq * t).fract() - 1.0)).abs() * 2.0 - 1.0,
                 _ => 0.0,
             };
 
+            // ADSR envelope
+            let envelope = if i < attack_samples {
+                (i as f32) / (attack_samples as f32)
+            } else if i < attack_samples + decay_samples {
+                1.0 -
+                    (1.0 - sustain_level) * (((i - attack_samples) as f32) / (decay_samples as f32))
+            } else if i < attack_samples + decay_samples + sustain_samples {
+                sustain_level
+            } else {
+                if release_samples > 0 {
+                    sustain_level *
+                        (1.0 -
+                            ((i - attack_samples - decay_samples - sustain_samples) as f32) /
+                                (release_samples as f32))
+                } else {
+                    0.0
+                }
+            };
+
             // Fade in/out
             if i < fade_len {
                 value *= (i as f32) / (fade_len as f32);
@@ -131,7 +242,9 @@ impl AudioEngine {
                 value *= ((total_samples - i) as f32) / (fade_len as f32);
             }
 
-            samples.push((value * amplitude) as i16);
+            value *= envelope;
+            // Application de l'amplitude dynamique (slide + velocity)
+            samples.push((value * (i16::MAX as f32) * current_amp) as i16);
         }
 
         // Convert to stereo
@@ -148,8 +261,9 @@ impl AudioEngine {
         }
 
         for (i, sample) in stereo_samples.iter().enumerate() {
-            if *sample != 0 {
-            }
+            // Debug: note si on rencontre des samples non nuls
+            // (pour traquer les buffers silencieux)
+            // if i == 0 { eprintln!("[debug] first stereo sample: {}", sample); }
             self.buffer[offset + i] = self.buffer[offset + i].saturating_add(*sample);
         }
     }
@@ -168,8 +282,8 @@ impl AudioEngine {
         }
 
         let root = Path::new(env!("CARGO_MANIFEST_DIR"));
-        let module_root = Path::new(&self.module_name);
-        let mut resolved_path = String::new();
+    let module_root = Path::new(&self.module_name);
+    let resolved_path: String;
 
         // Get the variable path from the variable table
         let mut var_path = filepath.to_string();
@@ -179,41 +293,14 @@ impl AudioEngine {
             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;
-                }
-
-                resolved_path = root
-                    .join(".deva")
-                    .join("bank")
-                    .join(bank_name)
-                    .join(format!("{}.wav", entity_name))
-                    .to_string_lossy()
-                    .to_string();
-            } else {
-                eprintln!("❌ Invalid namespace format: {}", var_path);
-                return;
-            }
-        } else if var_path.starts_with("devalang://") {
+        // Handle devalang:// protocol
+        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>"
+                    "❌ Invalid devalang:// path format. Expected devalang://<type>/<author>.<bank>/<entity>"
                 );
                 return;
             }
@@ -405,4 +492,27 @@ impl AudioEngine {
             }
         }
     }
+
+    fn extract_f32(&self, map: &HashMap<String, Value>, key: &str) -> Option<f32> {
+        match map.get(key) {
+            Some(Value::Number(n)) => Some(*n),
+            Some(Value::String(s)) => s.parse::<f32>().ok(),
+            Some(Value::Boolean(b)) => Some(if *b { 1.0 } else { 0.0 }),
+            _ => None,
+        }
+    }
+
+    fn extract_boolean(&self, map: &HashMap<String, Value>, key: &str) -> Option<bool> {
+        match map.get(key) {
+            Some(Value::Boolean(b)) => Some(*b),
+            Some(Value::Number(n)) => Some(*n != 0.0),
+            Some(Value::Identifier(s)) => {
+                if s == "true" { Some(true) } else if s == "false" { Some(false) } else { None }
+            }
+            Some(Value::String(s)) => {
+                if s == "true" { Some(true) } else if s == "false" { Some(false) } else { None }
+            }
+            _ => None,
+        }
+    }
 }

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

@@ -23,11 +23,16 @@ pub fn interprete_call_arrow_statement(
         .unwrap_or(0.0);
 
     if let StatementKind::ArrowCall { target, method, args } = &stmt.kind {
-        let Some(Value::Map(synth_map)) = variable_table.get(target) else {
+        let Some(Value::Statement(synth_stmt)) = variable_table.get(target) else {
             println!("❌ Synth '{}' not found in variable table", target);
             return (*max_end_time, cursor_copy);
         };
 
+        let Value::Map(synth_map) = &synth_stmt.value else {
+            println!("❌ Invalid synth statement for '{}', expected a map.", target);
+            return (*max_end_time, cursor_copy);
+        };
+
         let Some(Value::String(entity)) = synth_map.get("entity") else {
             println!("❌ Missing 'entity' key in synth '{}'.", target);
             return (*max_end_time, cursor_copy);
@@ -53,37 +58,51 @@ pub fn interprete_call_arrow_statement(
             return (*max_end_time, cursor_copy);
         };
 
-        let freq = extract_f32(params, "freq", base_bpm).unwrap_or(440.0);
-        let amp = extract_f32(params, "amp", base_bpm).unwrap_or(1.0);
+        // Synth parameters
+    let synth_params = params.clone();
+    let amp = extract_f32(&synth_params, "amp", base_bpm).unwrap_or(1.0);
 
         if method == "note" {
-            let Some(Value::Identifier(note_name)) = args.get(0) else {
+            let filtered_args: Vec<_> = args
+                .iter()
+                .filter(|arg| !matches!(arg, Value::Unknown))
+                .collect();
+
+            let Some(Value::Identifier(note_name)) = filtered_args.get(0).map(|v| (*v).clone()) else {
                 println!("❌ Invalid or missing argument for 'note' method on '{}'.", target);
                 return (*max_end_time, cursor_copy);
             };
 
-            let mut final_note_params = HashMap::new();
-            if let Some(Value::Map(note_params)) = args.get(1) {
-                for (key, value) in note_params {
-                    final_note_params.insert(key.clone(), value.clone());
+            let mut note_params = HashMap::new();
+            if let Some(arg1) = filtered_args.get(1) {
+                match (*arg1).clone() {
+                    Value::Map(map) => {
+                        for (key, value) in map {
+                            note_params.insert(key, value);
+                        }
+                    }
+                    _ => {}
                 }
             }
 
-            let duration_ms = extract_f32(&final_note_params, "duration", base_bpm).unwrap_or(
-                base_duration
-            );
+            // 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 final_freq = note_to_freq(&note_name);
             let start_time = cursor_copy;
             let end_time = start_time + duration_secs;
 
             audio_engine.insert_note(
                 waveform.clone(),
                 final_freq,
-                amp,
+                amp_note,
                 start_time * 1000.0,
-                duration_ms
+                duration_ms,
+                synth_params,
+                note_params
             );
 
             *max_end_time = (*max_end_time).max(end_time);

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

@@ -18,7 +18,7 @@ pub fn interprete_call_statement(
 ) -> (f32, f32) {
     match &stmt.kind {
         StatementKind::Call { name, args } => {
-            // ✅ 1. Cas : fonction classique
+            // Classic function call case
             if let Some(func) = functions.functions.get(name) {
                 if func.parameters.len() != args.len() {
                     eprintln!(
@@ -48,7 +48,7 @@ pub fn interprete_call_statement(
                 );
             }
 
-            // ✅ 2. Cas : group dans le scope local OU global
+            // Group case
             if let Some(group_stmt) = find_group(name, variable_table, global_store) {
                 if let Value::Map(map) = &group_stmt.value {
                     if let Some(Value::Block(body)) = map.get("body") {

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

@@ -52,8 +52,8 @@ pub fn run_audio_program(
 pub fn execute_audio_block(
     audio_engine: &mut AudioEngine,
     global_store: &GlobalStore,
-    variable_table: VariableTable,
-    functions_table: FunctionTable,
+    mut variable_table: VariableTable,
+    mut functions_table: FunctionTable,
     statements: Vec<Statement>,
     mut base_bpm: f32,
     mut base_duration: f32,
@@ -68,20 +68,21 @@ pub fn execute_audio_block(
     for stmt in others {
         match &stmt.kind {
             StatementKind::Load { .. } => {
-                if
-                    let Some(new_table) = interprete_load_statement(
-                        &stmt,
-                        &mut variable_table.clone()
-                    )
-                {
-                    // Extend the variable_table if necessary
+                if let Some(new_table) = interprete_load_statement(&stmt, &mut variable_table) {
+                    variable_table = new_table;
                 }
             }
             StatementKind::Let { .. } => {
-                interprete_let_statement(&stmt, &mut variable_table.clone());
+                if let Some(new_table) = interprete_let_statement(&stmt, &mut variable_table) {
+                    variable_table = new_table;
+                }
             }
             StatementKind::Function { .. } => {
-                interprete_function_statement(&stmt, &mut functions_table.clone());
+                if let Some(new_functions) =
+                    interprete_function_statement(&stmt, &mut functions_table)
+                {
+                    functions_table = new_functions;
+                }
             }
             StatementKind::Tempo => {
                 if let Some((new_bpm, new_duration)) = interprete_tempo_statement(&stmt) {
@@ -129,7 +130,7 @@ pub fn execute_audio_block(
                 max_end_time = new_max;
             }
             StatementKind::Call { .. } => {
-                let (new_max, new_cursor) = interprete_call_statement(
+                let (new_max, _) = interprete_call_statement(
                     &stmt,
                     audio_engine,
                     &variable_table,
@@ -140,7 +141,7 @@ pub fn execute_audio_block(
                     max_end_time,
                     cursor_time,
                 );
-                cursor_time = new_cursor;
+                cursor_time = new_max;
                 max_end_time = new_max;
             }
             StatementKind::ArrowCall { .. } => {
@@ -154,8 +155,12 @@ pub fn execute_audio_block(
                     Some(&mut cursor_time),
                     true
                 );
+
                 cursor_time = new_cursor;
-                max_end_time = new_max;
+                
+                if new_max > max_end_time {
+                    max_end_time = new_max;
+                }
             }
             _ => {}
         }

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

@@ -20,7 +20,7 @@ pub fn interprete_spawn_statement(
         StatementKind::Spawn { name, args } => {
             let mut local_engine = AudioEngine::new(audio_engine.module_name.clone());
 
-            // ✅ 1. Cas : fonction
+            // Function case
             if let Some(func) = functions.functions.get(name) {
                 if func.parameters.len() != args.len() {
                     eprintln!(
@@ -53,7 +53,7 @@ pub fn interprete_spawn_statement(
                 return (spawn_max.max(max_end_time), cursor_time);
             }
 
-            // ✅ 2. Cas : group dans variable_table ou global_store
+            // Group case
             if let Some(group_stmt) = find_group(name, variable_table, global_store) {
                 if let Value::Map(map) = &group_stmt.value {
                     if let Some(Value::Block(body)) = map.get("body") {

package/rust/core/builder/mod.rs

@@ -3,7 +3,6 @@ use crate::core::parser::statement::Statement;
 use crate::core::store::global::GlobalStore;
 use std::{ collections::HashMap, fs::create_dir_all };
 use std::io::Write;
-
 use crate::utils::logger::Logger;
 
 pub struct Builder {}
@@ -13,7 +12,12 @@ impl Builder {
         Builder {}
     }
 
-    pub fn build_ast(&self, modules: &HashMap<String, Vec<Statement>>, out_dir: &str) {
+    pub fn build_ast(
+        &self,
+        modules: &HashMap<String, Vec<Statement>>,
+        out_dir: &str,
+        compress: bool
+    ) {
         for (name, statements) in modules {
             let formatted_name = name.split("/").last().unwrap_or(name);
             let formatted_name = formatted_name.replace(".deva", "");
@@ -22,10 +26,11 @@ impl Builder {
 
             let file_path = format!("{}/ast/{}.json", out_dir, formatted_name);
             let mut file = std::fs::File::create(file_path).expect("Failed to create AST file");
-
-            let content = serde_json
-                ::to_string_pretty(&statements)
-                .expect("Failed to serialize AST");
+            let content = if compress {
+                serde_json::to_string(&statements).expect("Failed to serialize AST")
+            } else {
+                serde_json::to_string_pretty(&statements).expect("Failed to serialize AST")
+            };
 
             file.write_all(content.as_bytes()).expect("Failed to write AST to file");
         }

package/rust/core/lexer/handler/indent.rs

@@ -16,10 +16,24 @@ pub fn handle_indent_lexer(
             *current_indent += 1;
             chars.next();
             col += 1;
+            tokens.push(Token {
+                kind: TokenKind::Whitespace,
+                lexeme: " ".to_string(),
+                line: *line,
+                column: col,
+                indent: *current_indent,
+            });
         } else if c == '\t' {
             *current_indent += 4;
             chars.next();
             col += 4;
+            tokens.push(Token {
+                kind: TokenKind::Whitespace,
+                lexeme: "\t".to_string(),
+                line: *line,
+                column: col,
+                indent: *current_indent,
+            });
         } else {
             break;
         }
@@ -32,7 +46,7 @@ pub fn handle_indent_lexer(
         indent_stack.push(*current_indent);
         tokens.push(Token {
             kind: TokenKind::Indent,
-            lexeme: String::new(),
+            lexeme: String::from("<INDENT>"),
             line: *line,
             column: *column,
             indent: *current_indent,
@@ -42,7 +56,7 @@ pub fn handle_indent_lexer(
             indent_stack.pop();
             tokens.push(Token {
                 kind: TokenKind::Dedent,
-                lexeme: String::new(),
+                lexeme: String::from("<DEDENT>"),
                 line: *line,
                 column: *column,
                 indent: *current_indent,

package/rust/core/lexer/token.rs

@@ -84,6 +84,7 @@ pub enum TokenKind {
     ElseIf,
 
     // ───── Special / Internal ─────
+    Whitespace,
     Unknown,
     Error(String),
     EOF,

package/rust/core/mod.rs

@@ -7,4 +7,5 @@ pub mod debugger;
 pub mod utils;
 pub mod builder;
 pub mod error;
-pub mod audio;
+pub mod audio;
+pub mod plugin;