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

package/rust/core/parser/driver.rs

@@ -7,7 +7,7 @@ use crate::core::{
             bank::parse_bank_token,
             condition::parse_condition_token,
             dot::parse_dot_token,
-            identifier::{function::parse_function_token, parse_identifier_token},
+            identifier::{ function::parse_function_token, parse_identifier_token },
             loop_::parse_loop_token,
             tempo::parse_tempo_token,
         },
@@ -107,7 +107,11 @@ impl Parser {
         tokens: Vec<Token>,
         global_store: &mut GlobalStore
     ) -> Vec<Statement> {
-        self.tokens = tokens;
+        // Filtrer les tokens Whitespace et Newline avant parsing
+        self.tokens = tokens
+            .into_iter()
+            .filter(|t| t.kind != TokenKind::Whitespace && t.kind != TokenKind::Newline)
+            .collect();
         self.token_index = 0;
 
         let mut statements = Vec::new();
@@ -120,6 +124,11 @@ impl Parser {
                 }
             };
 
+            if token.kind == TokenKind::Newline {
+                self.advance();
+                continue;
+            }
+
             let statement = match &token.kind {
                 TokenKind::At => parse_at_token(self, global_store),
                 TokenKind::Identifier => {
@@ -149,7 +158,6 @@ impl Parser {
                 | TokenKind::LBrace
                 | TokenKind::RBrace
                 | TokenKind::Comma
-                | TokenKind::Newline
                 | TokenKind::Dedent
                 | TokenKind::Indent => {
                     self.advance();
@@ -189,17 +197,50 @@ impl Parser {
         let mut map = std::collections::HashMap::new();
 
         while !self.check_token(TokenKind::RBrace) && !self.is_eof() {
+            // Skip newlines, whitespace, indent, dedent before the key
+            while
+                self.check_token(TokenKind::Newline) ||
+                self.check_token(TokenKind::Whitespace) ||
+                self.check_token(TokenKind::Indent) ||
+                self.check_token(TokenKind::Dedent)
+            {
+                self.advance();
+            }
+
+            // Check if we are at the closing brace of the map
+            if self.check_token(TokenKind::RBrace) {
+                break;
+            }
+
             let key = if let Some(token) = self.advance() {
-                token.lexeme.clone()
+                match token.kind {
+                    | TokenKind::Whitespace
+                    | TokenKind::Indent
+                    | TokenKind::Dedent
+                    | TokenKind::Newline => {
+                        continue;
+                    }
+                    _ => token.lexeme.clone(),
+                }
             } else {
                 break;
             };
 
+            // Skip newlines and whitespace before colon
+            while self.check_token(TokenKind::Newline) || self.check_token(TokenKind::Whitespace) {
+                self.advance();
+            }
+
             if !self.match_token(TokenKind::Colon) {
                 println!("Expected ':' after map key '{}'", key);
                 break;
             }
 
+            // Skip newlines and whitespace before value
+            while self.check_token(TokenKind::Newline) || self.check_token(TokenKind::Whitespace) {
+                self.advance();
+            }
+
             let value = if let Some(token) = self.peek_clone() {
                 match token.kind {
                     TokenKind::String => {
@@ -304,7 +345,7 @@ impl Parser {
             }
             collected.push(self.advance().unwrap().clone());
         }
-        
+
         collected
     }
 

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

@@ -54,11 +54,43 @@ pub fn parse_arrow_call(parser: &mut Parser, global_store: &mut GlobalStore) ->
     parser.advance(); // method
 
     let mut args = Vec::new();
+    let mut paren_depth = 0;
+    let mut map_depth = 0;
 
     while let Some(token) = parser.peek_clone() {
         if token.kind == TokenKind::Newline || token.kind == TokenKind::EOF {
             break;
         }
+        if token.kind == TokenKind::LParen {
+            paren_depth += 1;
+        }
+        if token.kind == TokenKind::RParen {
+            if paren_depth > 0 {
+                paren_depth -= 1;
+                parser.advance();
+                if paren_depth == 0 {
+                    break;
+                }
+                continue;
+            } else {
+                break;
+            }
+        }
+        if token.kind == TokenKind::LBrace {
+            map_depth += 1;
+        }
+        if token.kind == TokenKind::RBrace {
+            if map_depth > 0 {
+                map_depth -= 1;
+                parser.advance();
+                if map_depth == 0 {
+                    continue;
+                }
+                continue;
+            } else {
+                break;
+            }
+        }
 
         parser.advance();
 
@@ -79,49 +111,68 @@ pub fn parse_arrow_call(parser: &mut Parser, global_store: &mut GlobalStore) ->
                     }
                     parser.advance(); // consume key token
                     let key = inner_token.lexeme.clone();
-
                     if let Some(colon_token) = parser.peek_clone() {
                         if colon_token.kind == TokenKind::Colon {
                             parser.advance(); // consume colon
                             if let Some(value_token) = parser.peek_clone() {
                                 parser.advance(); // consume value token
                                 let value = match value_token.kind {
-                                    TokenKind::Identifier =>
-                                        Value::Identifier(value_token.lexeme.clone()),
+                                    TokenKind::Identifier => {
+                                        // Interpret bare true/false as booleans
+                                        if value_token.lexeme == "true" {
+                                            Value::Boolean(true)
+                                        } else if value_token.lexeme == "false" {
+                                            Value::Boolean(false)
+                                        } else {
+                                            Value::Identifier(value_token.lexeme.clone())
+                                        }
+                                    },
                                     TokenKind::String => Value::String(value_token.lexeme.clone()),
                                     TokenKind::Number => {
+                                        // Support decimals (e.g., 0.8) and beats (e.g., 1/4)
                                         if let Some(TokenKind::Slash) = parser.peek_kind() {
-                                            parser.advance(); // consume slash
+                                            // Beat fraction
+                                            parser.advance(); // consume '/'
                                             if let Some(denominator_token) = parser.peek_clone() {
                                                 if denominator_token.kind == TokenKind::Number {
                                                     parser.advance(); // consume denominator
-                                                    let denominator =
-                                                        denominator_token.lexeme.clone();
-                                                    Value::Beat(
-                                                        format!(
-                                                            "{}/{}",
-                                                            value_token.lexeme,
-                                                            denominator
-                                                        )
-                                                    )
+                                                    let denominator = denominator_token.lexeme.clone();
+                                                    Value::Beat(format!("{}/{}", value_token.lexeme, denominator))
                                                 } else {
                                                     Value::Unknown
                                                 }
                                             } else {
                                                 Value::Unknown
                                             }
+                                        } else if let Some(next) = parser.peek_clone() {
+                                            // Decimal number handling: NUMBER '.' NUMBER -> f32
+                                            if next.kind == TokenKind::Dot {
+                                                // consume '.'
+                                                parser.advance();
+                                                if let Some(after_dot) = parser.peek_clone() {
+                                                    if after_dot.kind == TokenKind::Number {
+                                                        parser.advance(); // consume fractional digits
+                                                        let combined = format!("{}.{}", value_token.lexeme, after_dot.lexeme);
+                                                        Value::Number(combined.parse::<f32>().unwrap_or(0.0))
+                                                    } else {
+                                                        // Lone dot without number, fallback to integer part
+                                                        Value::Number(value_token.lexeme.parse::<f32>().unwrap_or(0.0))
+                                                    }
+                                                } else {
+                                                    Value::Number(value_token.lexeme.parse::<f32>().unwrap_or(0.0))
+                                                }
+                                            } else {
+                                                // Regular integer number
+                                                Value::Number(value_token.lexeme.parse::<f32>().unwrap_or(0.0))
+                                            }
                                         } else {
-                                            // Regular number without slash
-                                            Value::Number(
-                                                value_token.lexeme.parse::<f32>().unwrap_or(0.0)
-                                            )
+                                            Value::Number(value_token.lexeme.parse::<f32>().unwrap_or(0.0))
                                         }
                                     }
                                     TokenKind::Boolean =>
                                         Value::Boolean(
                                             value_token.lexeme.parse::<bool>().unwrap_or(false)
                                         ),
-
                                     _ => Value::Unknown,
                                 };
                                 map.insert(key, value);
@@ -135,6 +186,15 @@ pub fn parse_arrow_call(parser: &mut Parser, global_store: &mut GlobalStore) ->
         };
 
         args.push(value);
+
+        // Stop if we reach the end of the statement
+        if
+            paren_depth == 0 &&
+            map_depth == 0 &&
+            (token.kind == TokenKind::RParen || token.kind == TokenKind::RBrace)
+        {
+            break;
+        }
     }
 
     Statement {

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

@@ -14,13 +14,41 @@ pub fn parse_bank_token(parser: &mut Parser, _global_store: &mut GlobalStore) ->
 
     let bank_value = if let Some(token) = parser.peek_clone() {
         match token.kind {
-            TokenKind::Identifier => {
-                parser.advance();
-                Value::Identifier(token.lexeme.clone())
-            }
-            TokenKind::Number => {
-                parser.advance();
-                Value::Number(token.lexeme.parse::<f32>().unwrap_or(0.0))
+            TokenKind::Identifier | TokenKind::Number => {
+                parser.advance(); // consume identifier or number
+
+                let mut value = token.lexeme.clone();
+
+                // Support namespaced banks: <author>.<bank_name>
+                if let Some(next) = parser.peek_clone() {
+                    if next.kind == TokenKind::Dot {
+                        parser.advance(); // consume '.'
+                        if let Some(last) = parser.peek_clone() {
+                            match last.kind {
+                                TokenKind::Identifier | TokenKind::Number => {
+                                    parser.advance();
+                                    value = format!("{}.{}", value, last.lexeme);
+                                    Value::String(value)
+                                }
+                                _ => Value::Unknown,
+                            }
+                        } else {
+                            Value::Unknown
+                        }
+                    } else {
+                        match token.kind {
+                            TokenKind::Identifier => Value::Identifier(value),
+                            TokenKind::Number => Value::Number(value.parse::<f32>().unwrap_or(0.0)),
+                            _ => Value::Unknown,
+                        }
+                    }
+                } else {
+                    match token.kind {
+                        TokenKind::Identifier => Value::Identifier(value),
+                        TokenKind::Number => Value::Number(value.parse::<f32>().unwrap_or(0.0)),
+                        _ => Value::Unknown,
+                    }
+                }
             }
             _ => Value::Unknown,
         }

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

@@ -16,13 +16,23 @@ pub fn parse_dot_token(
 
     // Parse a single entity (namespace-friendly, stops at newline)
     let mut parts = Vec::new();
+    let current_line = dot_token.line;
 
     while let Some(token) = parser.peek_clone() {
+        // Ne jamais traverser une nouvelle ligne
+        if token.line != current_line {
+            break;
+        }
         match token.kind {
             TokenKind::Identifier | TokenKind::Number => {
                 parts.push(token.lexeme.clone());
                 parser.advance();
-                if parser.peek_kind() != Some(TokenKind::Dot) {
+                // Le séparateur doit être un '.' sur la même ligne, sinon on s'arrête
+                if let Some(next) = parser.peek_clone() {
+                    if next.line != current_line || next.kind != TokenKind::Dot {
+                        break;
+                    }
+                } else {
                     break;
                 }
             }
@@ -51,42 +61,53 @@ pub fn parse_dot_token(
     let mut value = Value::Null;
 
     if let Some(token) = parser.peek_clone() {
-        match token.kind {
+        // La durée et la map d'effets ne sont valides que sur la même ligne
+        if token.line == current_line {
+            match token.kind {
             TokenKind::Number => {
                 let numerator = token.lexeme.clone();
                 parser.advance();
-                if let Some(TokenKind::Slash) = parser.peek_kind() {
-                    parser.advance();
-                    if let Some(denominator_token) = parser.peek_clone() {
-                        if denominator_token.kind == TokenKind::Number {
-                            let denominator = denominator_token.lexeme.clone();
-                            parser.advance();
-                            duration = Duration::Beat(format!("{}/{}", numerator, denominator));
+                    if let Some(peek) = parser.peek_clone() {
+                        if peek.line == current_line {
+                            if let Some(TokenKind::Slash) = parser.peek_kind() {
+                                parser.advance();
+                                if let Some(denominator_token) = parser.peek_clone() {
+                                    if denominator_token.line == current_line && denominator_token.kind == TokenKind::Number {
+                                        let denominator = denominator_token.lexeme.clone();
+                                        parser.advance();
+                                        duration = Duration::Beat(format!("{}/{}", numerator, denominator));
+                                    }
+                                }
+                            } else {
+                                duration = parse_duration(numerator);
+                            }
+                        } else {
+                            duration = parse_duration(numerator);
                         }
+                    } else {
+                        duration = parse_duration(numerator);
                     }
-                } else {
-                    duration = parse_duration(numerator);
-                }
-                if let Some(next) = parser.peek_clone() {
-                    if next.kind == TokenKind::LBrace {
-                        value = parser.parse_map_value().unwrap_or(Value::Null);
+                    if let Some(next) = parser.peek_clone() {
+                        if next.line == current_line && next.kind == TokenKind::LBrace {
+                            value = parser.parse_map_value().unwrap_or(Value::Null);
+                        }
                     }
-                }
             }
             TokenKind::Identifier => {
                 let id = token.lexeme.clone();
                 parser.advance();
                 duration = parse_duration(id);
-                if let Some(next) = parser.peek_clone() {
-                    if next.kind == TokenKind::LBrace {
-                        value = parser.parse_map_value().unwrap_or(Value::Null);
+                    if let Some(next) = parser.peek_clone() {
+                        if next.line == current_line && next.kind == TokenKind::LBrace {
+                            value = parser.parse_map_value().unwrap_or(Value::Null);
+                        }
                     }
-                }
             }
             TokenKind::LBrace => {
-                value = parser.parse_map_value().unwrap_or(Value::Null);
+                    value = parser.parse_map_value().unwrap_or(Value::Null);
+            }
+                _ => {}
             }
-            _ => {}
         }
     }
 

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

@@ -254,6 +254,8 @@ impl ModuleLoader {
         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_toml_path = bank_path.join("bank.toml");
 
@@ -277,23 +279,23 @@ impl ModuleLoader {
 
             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,
+                    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(module.clone())
     }

package/rust/installer/addon.rs

@@ -0,0 +1,80 @@
+use std::path::Path;
+use crate::{
+    common::{ api::get_api_url },
+    installer::{ bank::install_bank, plugin::install_plugin },
+};
+use dirs::home_dir;
+
+#[derive(Debug, Clone)]
+pub enum AddonType {
+    Bank,
+    Plugin,
+    Preset,
+}
+
+pub async fn install_addon(
+    addon_type: AddonType,
+    name: &str,
+    target_dir: &Path
+) -> Result<(), String> {
+    match addon_type {
+        AddonType::Bank => install_bank(name, target_dir).await,
+        AddonType::Plugin => install_plugin(name, target_dir).await,
+        AddonType::Preset => Err("Preset installation not implemented".into()),
+    }
+}
+
+pub async fn ask_api_for_signed_url(addon_type: AddonType, slug: &str) -> Result<String, String> {
+    let api_url = get_api_url();
+
+    let mut stored_token_path = home_dir().unwrap();
+    stored_token_path.push(".devalang");
+    stored_token_path.push("session_token.json");
+
+    let stored_token = std::fs::read_to_string(&stored_token_path).unwrap_or_default();
+
+    let request_url = format!(
+        "{}/v1/assets/url?type={}&slug={}&token={}",
+        api_url,
+        match addon_type {
+            AddonType::Bank => "bank",
+            AddonType::Plugin => "plugin",
+            AddonType::Preset => "preset",
+        },
+        slug,
+        stored_token
+    );
+
+    let mut headers = reqwest::header::HeaderMap::new();
+
+    headers.insert("Authorization", format!("Bearer {}", stored_token).parse().unwrap());
+
+    let client: reqwest::Client = reqwest::Client
+        ::builder()
+        .default_headers(headers)
+        .build()
+        .map_err(|_| "Failed to build HTTP client".to_string())?;
+
+    let req = client
+        .get(&request_url)
+        .send().await
+        .map_err(|_| "Failed to receive response".to_string())?;
+
+    let response_body: serde_json::Value = req
+        .json().await
+        .map_err(|_| "Failed to read response body".to_string())?;
+
+    let signed_url: String = serde_json
+        ::from_value(
+            response_body
+                .get("payload")
+                .cloned()
+                .unwrap_or_default()
+                .get("url")
+                .cloned()
+                .unwrap_or_default()
+        )
+        .map_err(|_| "Failed to parse response body".to_string())?;
+
+    Ok(signed_url)
+}

package/rust/installer/bank.rs

@@ -1,33 +1,39 @@
 use std::path::{ Path, PathBuf };
 use crate::{
-    common::cdn::get_cdn_url,
     config::loader::{ add_bank_to_config, load_config },
-    installer::utils::{ download_file, extract_archive },
+    installer::{
+        addon::{ ask_api_for_signed_url, AddonType },
+        utils::{ download_file, extract_archive },
+    },
+    utils::logger::{ LogLevel, Logger },
 };
 
 pub async fn install_bank(name: &str, target_dir: &Path) -> Result<(), String> {
-    let cdn_url = get_cdn_url();
-    let url = format!("{}/bank/{}", cdn_url, name);
+    let logger = Logger::new();
+
+    let signed_url = ask_api_for_signed_url(AddonType::Bank, name).await?;
 
     let bank_dir = target_dir.join("bank");
     let archive_path = PathBuf::from(format!("./.deva/tmp/{}.devabank", name));
     let extract_path = bank_dir.join(name);
 
+    download_file(&signed_url, &archive_path).await.map_err(|e|
+        format!("Failed to download: {}", e)
+    )?;
+
     if extract_path.exists() {
-        println!(
-            "Bank '{}' already exists at '{}'. Skipping install.",
-            name,
-            extract_path.display()
+        logger.log_message(
+            LogLevel::Warning,
+            &format!(
+                "Bank '{}' already exists at '{}'. Skipping install.",
+                name,
+                extract_path.display()
+            )
         );
+
         return Ok(());
     }
 
-    download_file(&url, &archive_path).await.map_err(|e| format!("Failed to download: {}", e))?;
-
-    extract_archive(&archive_path, &extract_path).await.map_err(|e|
-        format!("Failed to extract: {}", e)
-    )?;
-
     // Add the bank to the config
     let root_dir = target_dir
         .parent()
@@ -49,6 +55,10 @@ pub async fn install_bank(name: &str, target_dir: &Path) -> Result<(), String> {
 
     let dependency_path = &format!("devalang://bank/{}", name);
 
+    extract_archive(&archive_path, &extract_path).await.map_err(|e|
+        format!("Failed to extract: {}", e)
+    )?;
+
     add_bank_to_config(&mut config, &extract_path, &dependency_path);
 
     Ok(())

package/rust/installer/mod.rs

@@ -1,2 +1,5 @@
 pub mod bank;
-pub mod utils;
+pub mod plugin;
+
+pub mod utils;
+pub mod addon;