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

package/rust/core/parser/statement.rs

@@ -37,6 +37,7 @@ pub enum StatementKind {
     // ───── Core Instructions ─────
     Tempo,
     Bank,
+    Print,
     Load {
         source: String,
         alias: String,
@@ -44,6 +45,10 @@ pub enum StatementKind {
     Let {
         name: String,
     },
+    // Automation of parameters over time (percent-based envelopes)
+    Automate {
+        target: String,
+    },
     ArrowCall {
         target: String,
         method: 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

@@ -188,7 +188,7 @@ impl ModuleLoader {
 
         // Inject triggers for each bank used in module
         for bank_name in self.extract_bank_names(&statements) {
-            self.inject_bank_triggers(&mut module, &bank_name);
+            let _ = self.inject_bank_triggers(&mut module, &bank_name);
         }
 
         // Inject module variables and functions into global store
@@ -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/core/preprocessor/processor.rs

@@ -1,14 +1,14 @@
 use std::{ collections::HashMap, path::Path };
 
 use crate::core::{
-    parser::{ driver::Parser, statement::StatementKind },
-    preprocessor::{ loader::ModuleLoader, resolver::group },
+    parser::statement::StatementKind,
+    preprocessor::loader::ModuleLoader,
     shared::value::Value,
     store::global::GlobalStore,
     utils::path::{ normalize_path, resolve_relative_path },
 };
 
-pub fn process_modules(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
+pub fn process_modules(_module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
     for module in global_store.modules.values_mut() {
         for stmt in &module.statements {
             match &stmt.kind {
@@ -52,7 +52,7 @@ pub fn process_modules(module_loader: &ModuleLoader, global_store: &mut GlobalSt
                     );
                 }
 
-                StatementKind::Export { names, source } => {
+                StatementKind::Export { names, source: _ } => {
                     for name in names {
                         if let Some(val) = module.variable_table.get(name) {
                             module.export_table.add_export(name.clone(), val.clone());

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

@@ -11,12 +11,11 @@ use crate::{
 pub fn resolve_bank(
     stmt: &Statement,
     module: &Module,
-    path: &str,
+    _path: &str,
     _global_store: &GlobalStore
 ) -> Statement {
     let mut new_stmt = stmt.clone();
     let logger = Logger::new();
-
     match &stmt.value {
         Value::Identifier(ident) => {
             if let Some(val) = module.variable_table.get(ident) {

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

@@ -1,7 +1,7 @@
 use crate::{
     core::{
         parser::statement::{ Statement, StatementKind },
-        preprocessor::{ module::Module, resolver::driver::resolve_statement },
+        preprocessor::module::Module,
         shared::value::Value,
         store::global::GlobalStore,
     },
@@ -13,7 +13,7 @@ pub fn resolve_call(
     name: String,
     args: Vec<Value>,
     module: &Module,
-    path: &str,
+    _path: &str,
     global_store: &mut GlobalStore
 ) -> Statement {
     let logger = Logger::new();
@@ -78,23 +78,24 @@ pub fn resolve_call(
                 ..stmt.clone()
             }
         }
-        _ => error_stmt(&logger, module, stmt, "Expected StatementKind::Call in resolve_call()"),
-    }
-}
-
-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 {
-    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
-    logger.log_message(LogLevel::Error, &format!("{message}\n  → at {stacktrace}"));
+        _ => {
+            let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
+            logger.log_message(
+                LogLevel::Error,
+                &format!(
+                    "Expected StatementKind::Call in resolve_call()\n  → at {stacktrace}"
+                )
+            );
 
-    Statement {
-        kind: StatementKind::Error {
-            message: message.to_string(),
+            Statement {
+                kind: StatementKind::Error {
+                    message: "Expected StatementKind::Call in resolve_call()".to_string(),
+                },
+                value: Value::Null,
+                ..stmt.clone()
+            }
         },
-        value: Value::Null,
-        ..stmt.clone()
     }
 }
+
+// (removed unused helpers get_group_body, error_stmt)

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

@@ -25,7 +25,7 @@ use crate::{
 };
 
 pub fn resolve_all_modules(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
-    for module in global_store.clone().modules.values_mut() {
+    for _module in global_store.clone().modules.values_mut() {
         resolve_imports(module_loader, global_store);
     }
 }
@@ -80,10 +80,12 @@ fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore)
                 return resolve_value(&export_val, module, global_store);
             }
 
-            eprintln!("⚠️ Unresolved identifier '{}'", name);
-            Value::Null
+            // Leave unresolved identifiers as-is; they might be runtime-bound (e.g., foreach vars)
+            Value::Identifier(name.clone())
         }
 
+        Value::String(s) => Value::String(s.clone()),
+
         Value::Beat(beat_str) => {
             println!("[warn] '{:?}': unresolved beat '{}'", module.path, beat_str);
             Value::Beat(beat_str.clone())
@@ -118,7 +120,7 @@ fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
     None
 }
 
-pub fn resolve_imports(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
+pub fn resolve_imports(_module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
     for (module_path, module) in global_store.clone().modules.iter_mut() {
         for (name, source_path) in &module.import_table.imports {
             match source_path {
@@ -260,7 +262,7 @@ pub fn resolve_and_flatten_all_modules(
                     resolved.push(resolved_stmt);
                 }
 
-                StatementKind::Function { name, parameters, body } => {
+                StatementKind::Function { name: _, parameters: _, body: _ } => {
                     let resolved_function = resolve_function(&stmt, &module, &path, global_store);
                     resolved.push(resolved_function);
                 }

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

@@ -1,13 +1,12 @@
-use std::collections::HashMap;
 
 use crate::{
     core::{
         parser::statement::{ Statement, StatementKind },
         preprocessor::{ module::Module, resolver::driver::resolve_statement },
         shared::value::Value,
-        store::{ function::FunctionDef, global::GlobalStore, variable::VariableTable },
+        store::{ function::FunctionDef, global::GlobalStore },
     },
-    utils::logger::{ LogLevel, Logger },
+    
 };
 
 pub fn resolve_function(
@@ -66,13 +65,4 @@ fn resolve_block_statements(
         .collect()
 }
 
-fn type_error(logger: &Logger, module: &Module, stmt: &Statement, message: String) -> Statement {
-    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
-    logger.log_error_with_stacktrace(&message, &stacktrace);
-
-    Statement {
-        kind: StatementKind::Error { message },
-        value: Value::Null,
-        ..stmt.clone()
-    }
-}
+// (removed unused helper type_error)

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

@@ -32,6 +32,36 @@ pub fn resolve_loop(
         resolved_map.insert(key.clone(), resolve_value(val, module, global_store));
     }
 
+    // Foreach form takes precedence if present
+    if let (Some(Value::Identifier(var_name)), Some(array_val)) = (resolved_map.get("foreach"), resolved_map.get("array")) {
+        // Resolve array elements
+        let resolved_array = match array_val {
+            Value::Array(items) => Value::Array(items.iter().map(|v| resolve_value(v, module, global_store)).collect()),
+            other => resolve_value(other, module, global_store),
+        };
+
+        let body_value = match resolved_map.get("body") {
+            Some(Value::Block(stmts)) => {
+                let resolved = stmts
+                    .iter()
+                    .map(|s| resolve_statement(s, module, path, global_store))
+                    .collect();
+                Value::Block(resolved)
+            }
+            _ => {
+                error_value(&logger, module, stmt, "Invalid or missing loop body");
+                Value::Block(vec![])
+            }
+        };
+
+        let mut final_map = HashMap::new();
+        final_map.insert("foreach".to_string(), Value::Identifier(var_name.clone()));
+        final_map.insert("array".to_string(), resolved_array);
+        final_map.insert("body".to_string(), body_value);
+
+        return Statement { kind: StatementKind::Loop, value: Value::Map(final_map), ..stmt.clone() };
+    }
+
     let iterator_value = match resolved_map.get("iterator") {
         Some(Value::Number(n)) => Value::Number(*n),
         Some(other) => {
@@ -49,7 +79,7 @@ pub fn resolve_loop(
         }
     };
 
-    let body_value = match resolved_map.remove("body") {
+    let body_value = match resolved_map.get("body") {
         Some(Value::Block(stmts)) => {
             let resolved = stmts
                 .iter()

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

@@ -1,11 +1,7 @@
 use crate::{
     core::{
         parser::statement::{ Statement, StatementKind },
-        preprocessor::{
-            module::Module,
-            resolver::driver::resolve_statement,
-            resolver::value::resolve_value,
-        },
+        preprocessor::module::Module,
         shared::value::Value,
         store::global::GlobalStore,
     },
@@ -17,7 +13,7 @@ pub fn resolve_spawn(
     name: String,
     args: Vec<Value>,
     module: &Module,
-    path: &str,
+    _path: &str,
     global_store: &mut GlobalStore
 ) -> Statement {
     let logger = Logger::new();
@@ -74,19 +70,4 @@ pub fn resolve_spawn(
     }
 }
 
-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 {
-    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
-    logger.log_message(LogLevel::Error, &format!("{message}\n  → at {stacktrace}"));
-
-    Statement {
-        kind: StatementKind::Error {
-            message: message.to_string(),
-        },
-        value: Value::Null,
-        ..stmt.clone()
-    }
-}
+// (removed unused helpers get_group_body, error_stmt)

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

@@ -11,7 +11,7 @@ use crate::{
 pub fn resolve_tempo(
     stmt: &Statement,
     module: &Module,
-    path: &str,
+    _path: &str,
     _global_store: &GlobalStore
 ) -> Statement {
     let mut new_stmt = stmt.clone();

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

@@ -14,7 +14,7 @@ pub fn resolve_trigger(
     stmt: &Statement,
     entity: &str,
     duration: &mut Duration,
-    effects: Option<Value>,
+    _effects: Option<Value>,
     module: &Module,
     path: &str,
     global_store: &GlobalStore
@@ -22,7 +22,6 @@ pub fn resolve_trigger(
     let logger = Logger::new();
 
     let mut final_duration = duration.clone();
-    let mut final_value = stmt.value.clone();
 
     // Duration resolution
     if let Duration::Identifier(ident) = duration {
@@ -43,7 +42,7 @@ pub fn resolve_trigger(
     }
 
     // Params value resolution
-    final_value = match &stmt.value {
+    let final_value = match &stmt.value {
         Value::Identifier(ident) => {
             println!("Resolving identifier: {}", ident);
 

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

@@ -1,14 +1,10 @@
 use std::collections::HashMap;
 
-use crate::{
-    core::{
-        parser::statement::{ Statement, StatementKind },
+use crate::core::{
         preprocessor::{ module::Module, resolver::driver::resolve_statement },
         shared::value::Value,
-        store::{ global::GlobalStore, variable::VariableTable },
-    },
-    utils::logger::{ LogLevel, Logger },
-};
+        store::global::GlobalStore,
+    };
 
 fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
     for (_path, module) in &global_store.modules {
@@ -23,8 +19,7 @@ fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
 pub fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore) -> Value {
     match value {
         Value::String(s) => {
-            println!("Resolving value: {}", s);
-
+            // Keep raw strings as-is; they may be runtime-evaluated (e.g., expressions)
             Value::String(s.clone())
         },
 
@@ -37,9 +32,8 @@ pub fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalSt
                 return resolve_value(&export_val, module, global_store);
             }
 
-            println!("⚠️ Unresolved identifier '{}'", name);
-
-            Value::Null
+            // Leave unresolved identifiers as-is; may be runtime-bound (e.g., foreach variable)
+            Value::Identifier(name.clone())
         }
 
         Value::Map(map) => {

package/rust/core/shared/bank.rs

@@ -1,4 +1,4 @@
-use serde::{ Deserialize, Serialize };
+use serde::Deserialize;
 
 #[derive(Debug, Deserialize)]
 pub struct BankInfo {

package/rust/core/utils/path.rs

@@ -1,4 +1,4 @@
-use std::path::{ Component, Path, PathBuf };
+use std::path::{ Path, PathBuf };
 
 pub fn find_entry_file(entry: &str) -> Option<String> {
     let path = Path::new(entry);

package/rust/core/utils/validation.rs

@@ -1,4 +1,3 @@
-use crate::core::{ preprocessor::module::Module, shared::value::Value, store::global::GlobalStore };
 
 // NOTE: Deprecated functions, kept for reference
 

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,7 +55,11 @@ pub async fn install_bank(name: &str, target_dir: &Path) -> Result<(), String> {
 
     let dependency_path = &format!("devalang://bank/{}", name);
 
-    add_bank_to_config(&mut config, &extract_path, &dependency_path);
+    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;