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

package/rust/core/parser/handler/identifier/spawn.rs

@@ -8,34 +8,81 @@ use crate::core::{
 pub fn parse_spawn_token(
     parser: &mut Parser,
     current_token: Token,
-    global_store: &mut GlobalStore
+    _global_store: &mut GlobalStore
 ) -> Statement {
-        parser.advance(); // consume "spawn"
-
-        let value = if let Some(token) = parser.peek_clone() {
-            parser.advance();
-            match token.kind {
-                TokenKind::Identifier => Value::Identifier(token.lexeme.clone()),
-                TokenKind::String => Value::String(token.lexeme.clone()),
-                _ => {
-                    return Statement::error(
-                        token,
-                        "Expected identifier or string after 'spawn'".to_string()
-                    );
-                }
-            }
-        } else {
+    parser.advance(); // consume "spawn"
+
+    // Expect function name
+    let name_token = match parser.peek_clone() {
+        Some(t) => t,
+        None => {
             return Statement::error(
                 current_token,
-                "Expected identifier or string after 'spawn'".to_string()
+                "Expected function name after 'spawn'".to_string()
             );
-        };
-
-        return Statement {
-            kind: StatementKind::Spawn,
-            value,
-            indent: current_token.indent,
-            line: current_token.line,
-            column: current_token.column,
-        };
-}
+        }
+    };
+
+    if name_token.kind != TokenKind::Identifier {
+        return Statement::error(
+            name_token,
+            "Expected function name to be an identifier".to_string()
+        );
+    }
+
+    let func_name = name_token.lexeme.clone();
+    parser.advance(); // consume function name
+
+    // Expect '('
+    let mut args: Vec<Value> = Vec::new();
+    if let Some(open_paren) = parser.peek_clone() {
+        if open_paren.kind == TokenKind::LParen {
+            parser.advance(); // consume '('
+
+            // Collect args until ')'
+            while let Some(token) = parser.peek_clone() {
+                if token.kind == TokenKind::RParen {
+                    parser.advance(); // consume ')'
+                    break;
+                }
+
+                match token.kind {
+                    TokenKind::Number => {
+                        if let Ok(num) = token.lexeme.parse::<f32>() {
+                            args.push(Value::Number(num));
+                        }
+                        parser.advance();
+                    }
+                    TokenKind::String => {
+                        args.push(Value::String(token.lexeme.clone()));
+                        parser.advance();
+                    }
+                    TokenKind::Identifier => {
+                        args.push(Value::Identifier(token.lexeme.clone()));
+                        parser.advance();
+                    }
+                    TokenKind::Comma => {
+                        parser.advance(); // skip comma
+                    }
+                    _ => {
+                        return Statement::error(
+                            token,
+                            "Unexpected token in spawn arguments".to_string()
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    Statement {
+        kind: StatementKind::Spawn {
+            name: func_name,
+            args,
+        },
+        value: Value::Null,
+        indent: current_token.indent,
+        line: current_token.line,
+        column: current_token.column,
+    }
+}

package/rust/core/parser/statement.rs

@@ -49,6 +49,11 @@ pub enum StatementKind {
         method: String,
         args: Vec<Value>,
     },
+    Function {
+        name: String,
+        parameters: Vec<String>,
+        body: Vec<Statement>,
+    },
 
     // ───── Instruments ─────
     Synth,
@@ -57,12 +62,19 @@ pub enum StatementKind {
     Trigger {
         entity: String,
         duration: Duration,
+        effects: Option<Value>,
     },
     Sleep,
-    Call,
-    Spawn,
+    Call {
+        name: String,
+        args: Vec<Value>,
+    },
+    Spawn {
+        name: String,
+        args: Vec<Value>,
+    },
     Loop,
-    
+
     // ───── Structure & Logic ─────
     Group,
 
@@ -93,4 +105,4 @@ pub enum StatementKind {
     Error {
         message: String,
     },
-}
+}

package/rust/core/plugin/loader.rs

@@ -0,0 +1,48 @@
+use std::path::Path;
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct PluginInfo {
+    pub name: String,
+    pub version: Option<String>,
+    pub description: Option<String>,
+    pub author: Option<String>,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct PluginFile {
+    pub plugin: PluginInfo,
+}
+
+pub fn load_plugin(name: &str) -> Result<(PluginInfo, Vec<u8>), String> {
+    let root = Path::new(env!("CARGO_MANIFEST_DIR"));
+    let plugin_dir = root.join(".deva").join("plugin").join(name);
+    let toml_path = plugin_dir.join("plugin.toml");
+    let wasm_path = plugin_dir.join(format!("{}_bg.wasm", name));
+
+    if !toml_path.exists() {
+        return Err(format!("❌ Plugin file not found: {}", toml_path.display()));
+    }
+    if !wasm_path.exists() {
+        return Err(format!("❌ Plugin wasm not found: {}", wasm_path.display()));
+    }
+
+    let toml_content = std::fs::read_to_string(&toml_path)
+        .map_err(|e| format!("Failed to read '{}': {}", toml_path.display(), e))?;
+    let plugin_file: PluginFile = toml::from_str(&toml_content)
+        .map_err(|e| format!("Failed to parse '{}': {}", toml_path.display(), e))?;
+
+    let wasm_bytes = std::fs::read(&wasm_path)
+        .map_err(|e| format!("Failed to read '{}': {}", wasm_path.display(), e))?;
+
+    Ok((plugin_file.plugin, wasm_bytes))
+}
+
+pub fn load_plugin_from_uri(uri: &str) -> Result<(PluginInfo, Vec<u8>), String> {
+    if !uri.starts_with("devalang://plugin/") {
+        return Err("Invalid plugin URI".into());
+    }
+
+    let name = uri.trim_start_matches("devalang://plugin/");
+    load_plugin(name)
+}

package/rust/core/plugin/mod.rs

@@ -0,0 +1 @@
+pub mod loader;

package/rust/core/preprocessor/loader.rs

@@ -127,6 +127,11 @@ impl ModuleLoader {
         updated_module.tokens = tokens;
         updated_module.statements = statements;
 
+        // Step four : Injecting bank triggers if any
+        if let Err(e) = self.inject_bank_triggers(&mut updated_module, "808") {
+            return Err(format!("Failed to inject bank triggers: {}", e));
+        }
+
         // Step four : error handling
         let mut error_handler = ErrorHandler::new();
         error_handler.detect_from_statements(&mut parser, &updated_module.statements);
@@ -143,16 +148,16 @@ impl ModuleLoader {
         global_store: &mut GlobalStore
     ) -> (HashMap<String, Vec<Token>>, HashMap<String, Vec<Statement>>) {
         // SECTION Load the entry module and its dependencies
-
         let tokens_by_module = self.load_module_recursively(&self.entry, global_store);
 
         // SECTION Process and resolve modules
         process_modules(self, global_store);
         resolve_all_modules(self, global_store);
 
-        let statemnts_by_module = resolve_and_flatten_all_modules(global_store);
+        // SECTION Flatten all modules to get statements (+ injects)
+        let statements_by_module = resolve_and_flatten_all_modules(global_store);
 
-        (tokens_by_module, statemnts_by_module)
+        (tokens_by_module, statements_by_module)
     }
 
     #[cfg(feature = "cli")]
@@ -182,12 +187,15 @@ impl ModuleLoader {
         module.statements = statements.clone();
 
         // Inject triggers for each bank used in module
-        for bank_name in ModuleLoader::extract_bank_names(&statements) {
-            if let Err(e) = self.inject_bank_triggers(&mut module, &bank_name) {
-                return HashMap::new(); // Return empty map on error
-            }
+        for bank_name in self.extract_bank_names(&statements) {
+            self.inject_bank_triggers(&mut module, &bank_name);
         }
 
+        // Inject module variables and functions into global store
+        global_store.variables.variables.extend(module.variable_table.variables.clone());
+        global_store.functions.functions.extend(module.function_table.functions.clone());
+
+        // Inject the module into the global store
         global_store.insert_module(path.clone(), module);
 
         // Load dependencies
@@ -241,65 +249,75 @@ impl ModuleLoader {
         }
     }
 
-    pub fn inject_bank_triggers(&self, module: &mut Module, bank_name: &str) -> Result<(), String> {
+    pub fn inject_bank_triggers(
+        &self,
+        module: &mut Module,
+        bank_name: &str
+    ) -> Result<Module, String> {
+        let alias = bank_name.split('.').last().unwrap_or(bank_name);
+
         let bank_path = Path::new("./.deva/bank").join(bank_name);
-        let bank_file_path = bank_path.join("bank.toml");
+        let bank_toml_path = bank_path.join("bank.toml");
 
-        if !bank_file_path.exists() {
-            return Ok(()); // Pas d'erreur si la banque n'existe pas encore
+        if !bank_toml_path.exists() {
+            return Ok(module.clone());
         }
 
         let content = std::fs
-            ::read_to_string(&bank_file_path)
-            .map_err(|e| format!("Failed to read '{}': {}", bank_file_path.display(), e))?;
+            ::read_to_string(&bank_toml_path)
+            .map_err(|e| format!("Failed to read '{}': {}", bank_toml_path.display(), e))?;
 
-        let parsed: BankFile = toml
+        let parsed_bankfile: BankFile = toml
             ::from_str(&content)
-            .map_err(|e| format!("Failed to parse '{}': {}", bank_file_path.display(), e))?;
+            .map_err(|e| format!("Failed to parse '{}': {}", bank_toml_path.display(), e))?;
 
         let mut bank_map = HashMap::new();
 
-        for bank_trigger in parsed.triggers.unwrap_or_default() {
+        for bank_trigger in parsed_bankfile.triggers.unwrap_or_default() {
             let trigger_name = bank_trigger.name.clone().replace("./", "");
             let bank_trigger_path = format!("devalang://bank/{}/{}", bank_name, trigger_name);
 
             bank_map.insert(bank_trigger.name.clone(), Value::String(bank_trigger_path.clone()));
 
-            if module.variable_table.variables.contains_key(bank_name) {
+            if module.variable_table.variables.contains_key(alias) {
                 eprintln!(
                     "⚠️ Trigger '{}' already defined in module '{}', skipping injection.",
-                    bank_name, module.path
+                    alias,
+                    module.path
                 );
                 continue;
             }
 
             module.variable_table.set(
-                format!("{}.{}", bank_name, bank_trigger.name),
+                format!("{}.{}", alias, bank_trigger.name),
                 Value::String(bank_trigger_path.clone())
             );
         }
 
         // Inject the map under the bank name
-        module.variable_table.set(bank_name.to_string(), Value::Map(bank_map));
+        module.variable_table.set(alias.to_string(), Value::Map(bank_map));
 
-        Ok(())
+        Ok(module.clone())
     }
 
-    fn extract_bank_names(statements: &[Statement]) -> HashSet<String> {
+    fn extract_bank_names(&self, statements: &[Statement]) -> HashSet<String> {
         let mut banks = HashSet::new();
 
         for stmt in statements {
-            if let StatementKind::Trigger { entity, .. } = &stmt.kind {
-                let parts: Vec<&str> = entity.split('.').collect();
-                if parts.len() >= 2 {
-                    banks.insert(parts[0].to_string()); // "808.kick" → "808"
-                }
-            }
-
-            if let StatementKind::Bank = &stmt.kind {
-                if let Value::String(name) = &stmt.value {
-                    banks.insert(name.clone());
+            match &stmt.kind {
+                // Extract only bank declarations
+                StatementKind::Bank => {
+                    if let Value::String(name) = &stmt.value {
+                        banks.insert(name.clone());
+                    }
+                    if let Value::Number(num) = &stmt.value {
+                        banks.insert(num.to_string());
+                    }
+                    if let Value::Identifier(name) = &stmt.value {
+                        banks.insert(name.clone());
+                    }
                 }
+                _ => {}
             }
         }
 

package/rust/core/preprocessor/module.rs

@@ -1,7 +1,7 @@
 use crate::core::{
     lexer::token::Token,
     parser::statement::Statement,
-    store::{ export::ExportTable, import::ImportTable, variable::VariableTable },
+    store::{ export::ExportTable, function::FunctionTable, import::ImportTable, variable::VariableTable },
 };
 
 #[derive(Debug, Clone)]
@@ -11,6 +11,7 @@ pub struct Module {
     pub tokens: Vec<Token>,
     pub statements: Vec<Statement>,
     pub variable_table: VariableTable,
+    pub function_table: FunctionTable,
     pub export_table: ExportTable,
     pub import_table: ImportTable,
     pub content: String,
@@ -24,6 +25,7 @@ impl Module {
             tokens: Vec::new(),
             statements: Vec::new(),
             variable_table: VariableTable::new(),
+            function_table: FunctionTable::new(),
             export_table: ExportTable::new(),
             import_table: ImportTable::new(),
             resolved: false,

package/rust/core/preprocessor/processor.rs

@@ -5,7 +5,7 @@ use crate::core::{
     preprocessor::{ loader::ModuleLoader, resolver::group },
     shared::value::Value,
     store::global::GlobalStore,
-    utils::path::{normalize_path, resolve_relative_path},
+    utils::path::{ normalize_path, resolve_relative_path },
 };
 
 pub fn process_modules(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
@@ -13,6 +13,31 @@ pub fn process_modules(module_loader: &ModuleLoader, global_store: &mut GlobalSt
         for stmt in &module.statements {
             match &stmt.kind {
                 StatementKind::Let { name } => {
+                    if let Value::Null = stmt.value {
+                        eprintln!("❌ Variable '{}' is declared but not initialized.", name);
+                        
+                        module.variable_table.variables.insert(
+                            name.clone(),
+                            Value::StatementKind(Box::new(stmt.kind.clone()))
+                        );
+
+                        continue;
+                    }
+
+                    if module.variable_table.get(name).is_some() {
+                        eprintln!("❌ Variable '{}' is already defined in this scope.", name);
+                        continue;
+                    }
+
+                    if let Some(module_variable) = module.variable_table.variables.get(name) {
+                        eprintln!(
+                            "❌ Variable '{}' is already defined globally with value: {:?}",
+                            name,
+                            module_variable
+                        );
+                        continue;
+                    }
+
                     module.variable_table.variables.insert(name.clone(), stmt.value.clone());
                 }
 

package/rust/core/preprocessor/resolver/call.rs

@@ -10,103 +10,80 @@ use crate::{
 
 pub fn resolve_call(
     stmt: &Statement,
+    name: String,
+    args: Vec<Value>,
     module: &Module,
     path: &str,
     global_store: &mut GlobalStore
 ) -> Statement {
     let logger = Logger::new();
 
-    match &stmt.value {
-        Value::Identifier(ident) => {
-            match module.variable_table.get(ident) {
-                Some(Value::String(group_name)) =>
-                    resolve_group_by_name(group_name, stmt, module, path, global_store, &logger),
-                Some(Value::Map(group_map)) =>
-                    resolved_call(stmt, group_map, module, path, global_store),
-                Some(other) =>
-                    error_stmt(
-                        &logger,
-                        module,
-                        stmt,
-                        &format!(
-                            "Identifier '{ident}' must resolve to a group name or map, found {:?}",
-                            other
-                        )
-                    ),
-                None =>
-                    error_stmt(
-                        &logger,
-                        module,
-                        stmt,
-                        &format!("Identifier '{ident}' not found in variable table")
-                    ),
-            }
-        }
+    match &stmt.kind {
+        StatementKind::Call { .. } => {
+            // Check if it's a function
+            if let Some(func) = global_store.functions.functions.get(&name) {
+                let mut call_map = std::collections::HashMap::new();
+                call_map.insert("name".to_string(), Value::Identifier(name.clone()));
+                call_map.insert(
+                    "parameters".to_string(),
+                    Value::Array(
+                        func.parameters
+                            .iter()
+                            .map(|p| Value::Identifier(p.clone()))
+                            .collect()
+                    )
+                );
+                call_map.insert("args".to_string(), Value::Array(args.clone()));
+                call_map.insert("body".to_string(), Value::Block(func.body.clone()));
 
-        Value::String(name) =>
-            resolve_group_by_name(name, stmt, module, path, global_store, &logger),
+                return Statement {
+                    kind: StatementKind::Call { name, args },
+                    value: Value::Map(call_map),
+                    ..stmt.clone()
+                };
+            }
 
-        Value::Map(group_map) => resolved_call(stmt, group_map, module, path, global_store),
+            // Otherwise, check if it's a variable (e.g. group)
+            if let Some(variable) = global_store.variables.variables.get(&name) {
+                if let Value::Statement(stmt_box) = variable {
+                    if let StatementKind::Group = stmt_box.kind {
+                        if let Value::Map(map) = &stmt_box.value {
+                            if let Some(Value::Block(body)) = map.get("body") {
+                                let mut resolved_map = std::collections::HashMap::new();
+                                resolved_map.insert(
+                                    "identifier".to_string(),
+                                    Value::String(name.clone())
+                                );
+                                resolved_map.insert("args".to_string(), Value::Array(args.clone()));
+                                resolved_map.insert("body".to_string(), Value::Block(body.clone()));
 
-        other =>
-            error_stmt(
-                &logger,
-                module,
-                stmt,
-                &format!("Call expects a group name as string or identifier, found {:?}", other)
-            ),
-    }
-}
+                                return Statement {
+                                    kind: StatementKind::Call { name, args },
+                                    value: Value::Map(resolved_map),
+                                    ..stmt.clone()
+                                };
+                            }
+                        }
+                    }
+                }
+            }
 
-fn resolve_group_by_name(
-    name: &str,
-    stmt: &Statement,
-    module: &Module,
-    path: &str,
-    global_store: &mut GlobalStore,
-    logger: &Logger
-) -> Statement {
-    match module.variable_table.get(name) {
-        Some(Value::Map(group_map)) => resolved_call(stmt, group_map, module, path, global_store),
-        Some(other) =>
-            error_stmt(
-                logger,
-                module,
-                stmt,
-                &format!("Expected a group for '{}', but found {:?}", name, other)
-            ),
-        None =>
-            error_stmt(
-                logger,
-                module,
-                stmt,
-                &format!("Group '{}' not found in module '{}'", name, module.path)
-            ),
+            // Otherwise, log an error
+            logger.log_message(LogLevel::Error, &format!("Function or group '{}' not found", name));
+            Statement {
+                kind: StatementKind::Error {
+                    message: format!("Function or group '{}' not found", name),
+                },
+                value: Value::Null,
+                ..stmt.clone()
+            }
+        }
+        _ => error_stmt(&logger, module, stmt, "Expected StatementKind::Call in resolve_call()"),
     }
 }
 
-fn resolved_call(
-    stmt: &Statement,
-    group_map: &std::collections::HashMap<String, Value>,
-    module: &Module,
-    path: &str,
-    global_store: &mut GlobalStore
-) -> Statement {
-    let mut cloned_map = group_map.clone();
-
-    if let Some(Value::Block(stmts)) = group_map.get("body") {
-        let resolved = stmts
-            .iter()
-            .map(|s| resolve_statement(s, module, path, global_store))
-            .collect();
-        cloned_map.insert("body".to_string(), Value::Block(resolved));
-    }
-
-    Statement {
-        kind: StatementKind::Call,
-        value: Value::Map(cloned_map),
-        ..stmt.clone()
-    }
+fn get_group_body(stmt_box: &Statement) -> Vec<Statement> {
+    if let Value::Block(body) = &stmt_box.value { body.clone() } else { vec![] }
 }
 
 fn error_stmt(logger: &Logger, module: &Module, stmt: &Statement, message: &str) -> Statement {

package/rust/core/preprocessor/resolver/condition.rs

@@ -1,7 +1,7 @@
 use crate::{
     core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::{module::Module, resolver::driver::resolve_statement},
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::{ module::Module, resolver::driver::resolve_statement },
         shared::value::Value,
         store::global::GlobalStore,
     },
@@ -12,12 +12,17 @@ pub fn resolve_condition(
     stmt: &Statement,
     module: &Module,
     path: &str,
-    global_store: &mut GlobalStore,
+    global_store: &mut GlobalStore
 ) -> Statement {
     let logger = Logger::new();
 
     let Value::Map(condition_map) = &stmt.value else {
-        return type_error(&logger, module, stmt, "Expected a map in condition statement".to_string());
+        return type_error(
+            &logger,
+            module,
+            stmt,
+            "Expected a map in condition statement".to_string()
+        );
     };
 
     let mut resolved_map = condition_map.clone();
@@ -60,13 +65,13 @@ fn resolve_block_statements(
     body: &[Statement],
     module: &Module,
     path: &str,
-    global_store: &mut GlobalStore,
+    global_store: &mut GlobalStore
 ) -> Vec<Statement> {
     body.iter()
         .flat_map(|stmt| {
             let resolved = resolve_statement(stmt, module, path, global_store);
 
-            if let StatementKind::Call = resolved.kind {
+            if let StatementKind::Call { .. } = resolved.kind {
                 if let Value::Block(inner) = &resolved.value {
                     return inner
                         .iter()