@devaloop/devalang 0.0.1-alpha.16-hotfix.1 → 0.0.1-alpha.17

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

@@ -1,12 +1,10 @@
-use crate::{
-    core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::module::Module,
-        shared::value::Value,
-        store::global::GlobalStore,
-    },
-    utils::logger::{LogLevel, Logger},
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::module::Module,
+    store::global::GlobalStore,
 };
+use devalang_types::Value;
+use devalang_utils::logger::{LogLevel, Logger};
 
 pub fn resolve_call(
     stmt: &Statement,
@@ -44,23 +42,21 @@ pub fn resolve_call(
             }
 
             // 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()));
+            if let Some(Value::Statement(stmt_box)) = global_store.variables.variables.get(&name) {
+                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()));
 
-                                return Statement {
-                                    kind: StatementKind::Call { name, args },
-                                    value: Value::Map(resolved_map),
-                                    ..stmt.clone()
-                                };
-                            }
+                            return Statement {
+                                kind: StatementKind::Call { name, args },
+                                value: Value::Map(resolved_map),
+                                ..stmt.clone()
+                            };
                         }
                     }
                 }

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

@@ -1,12 +1,10 @@
-use crate::{
-    core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::{module::Module, resolver::driver::resolve_statement},
-        shared::value::Value,
-        store::global::GlobalStore,
-    },
-    utils::logger::Logger,
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::{module::Module, resolver::driver::resolve_statement},
+    store::global::GlobalStore,
 };
+use devalang_types::Value;
+use devalang_utils::logger::Logger;
 
 pub fn resolve_condition(
     stmt: &Statement,

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

@@ -1,21 +1,19 @@
-use crate::{
-    core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::{
-            loader::ModuleLoader,
-            module::Module,
-            resolver::{
-                bank::resolve_bank, call::resolve_call, condition::resolve_condition,
-                function::resolve_function, group::resolve_group, let_::resolve_let,
-                loop_::resolve_loop, spawn::resolve_spawn, tempo::resolve_tempo,
-                trigger::resolve_trigger,
-            },
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::{
+        loader::ModuleLoader,
+        module::Module,
+        resolver::{
+            bank::resolve_bank, call::resolve_call, condition::resolve_condition,
+            function::resolve_function, group::resolve_group, let_::resolve_let,
+            loop_::resolve_loop, spawn::resolve_spawn, tempo::resolve_tempo,
+            trigger::resolve_trigger,
         },
-        shared::value::Value,
-        store::global::GlobalStore,
     },
-    utils::logger::Logger,
+    store::global::GlobalStore,
 };
+use devalang_types::Value;
+use devalang_utils::logger::Logger;
 use std::collections::HashMap;
 
 pub fn resolve_all_modules(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
@@ -134,7 +132,7 @@ fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore)
 }
 
 fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
-    for (_path, module) in &global_store.modules {
+    for module in global_store.modules.values() {
         if let Some(val) = module.export_table.get_export(name) {
             return Some(val.clone());
         }

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

@@ -1,9 +1,9 @@
 use crate::core::{
     parser::statement::{Statement, StatementKind},
     preprocessor::{module::Module, resolver::driver::resolve_statement},
-    shared::value::Value,
     store::{function::FunctionDef, global::GlobalStore},
 };
+use devalang_types::Value;
 
 pub fn resolve_function(
     stmt: &Statement,
@@ -17,7 +17,7 @@ pub fn resolve_function(
         body,
     } = &stmt.kind
     {
-        let resolved_body = resolve_block_statements(body, &module, path, global_store);
+        let resolved_body = resolve_block_statements(body, module, path, global_store);
 
         global_store.functions.add_function(FunctionDef {
             name: name.clone(),
@@ -35,7 +35,7 @@ pub fn resolve_function(
             eprintln!("[resolve_statement] ❌ Module path not found: {path}");
         }
 
-        return Statement {
+        Statement {
             kind: StatementKind::Function {
                 name: name.clone(),
                 parameters: parameters.clone(),
@@ -43,15 +43,15 @@ pub fn resolve_function(
             },
             value: Value::Null,
             ..stmt.clone()
-        };
+        }
     } else {
-        return Statement {
+        Statement {
             kind: StatementKind::Error {
                 message: "Expected a function statement".to_string(),
             },
             value: Value::Null,
             ..stmt.clone()
-        };
+        }
     }
 }
 

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

@@ -1,12 +1,10 @@
-use crate::{
-    core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::{module::Module, resolver::driver::resolve_statement},
-        shared::value::Value,
-        store::global::GlobalStore,
-    },
-    utils::logger::{LogLevel, Logger},
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::{module::Module, resolver::driver::resolve_statement},
+    store::global::GlobalStore,
 };
+use devalang_types::Value;
+use devalang_utils::logger::{LogLevel, Logger};
 
 pub fn resolve_group(
     stmt: &Statement,

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

@@ -1,17 +1,15 @@
 use std::collections::HashMap;
 
-use crate::{
-    core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::{
-            module::Module,
-            resolver::{driver::resolve_statement, value::resolve_value},
-        },
-        shared::value::Value,
-        store::global::GlobalStore,
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::{
+        module::Module,
+        resolver::{driver::resolve_statement, value::resolve_value},
     },
-    utils::logger::Logger,
+    store::global::GlobalStore,
 };
+use devalang_types::Value;
+use devalang_utils::logger::Logger;
 
 pub fn resolve_loop(
     stmt: &Statement,

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

@@ -1,12 +1,10 @@
-use crate::{
-    core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::module::Module,
-        shared::value::Value,
-        store::global::GlobalStore,
-    },
-    utils::logger::{LogLevel, Logger},
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::module::Module,
+    store::global::GlobalStore,
 };
+use devalang_types::Value;
+use devalang_utils::logger::{LogLevel, Logger};
 
 pub fn resolve_spawn(
     stmt: &Statement,
@@ -33,22 +31,20 @@ pub fn resolve_spawn(
     }
 
     // If it's a group stored in variables
-    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()));
+    if let Some(Value::Statement(stmt_box)) = global_store.variables.variables.get(&name) {
+        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()));
 
-                        return Statement {
-                            kind: StatementKind::Spawn { name, args },
-                            value: Value::Map(resolved_map),
-                            ..stmt.clone()
-                        };
-                    }
+                    return Statement {
+                        kind: StatementKind::Spawn { name, args },
+                        value: Value::Map(resolved_map),
+                        ..stmt.clone()
+                    };
                 }
             }
         }

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

@@ -1,12 +1,10 @@
-use crate::{
-    core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::{module::Module, resolver::driver::resolve_statement},
-        shared::value::Value,
-        store::global::GlobalStore,
-    },
-    utils::logger::{LogLevel, Logger},
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::{module::Module, resolver::driver::resolve_statement},
+    store::global::GlobalStore,
 };
+use devalang_types::Value;
+use devalang_utils::logger::{LogLevel, Logger};
 
 pub fn resolve_synth(
     stmt: &Statement,

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

@@ -1,12 +1,10 @@
-use crate::{
-    core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::module::Module,
-        shared::value::Value,
-        store::global::GlobalStore,
-    },
-    utils::logger::Logger,
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::module::Module,
+    store::global::GlobalStore,
 };
+use devalang_types::Value;
+use devalang_utils::logger::Logger;
 
 pub fn resolve_tempo(
     stmt: &Statement,

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

@@ -1,14 +1,11 @@
-use std::collections::HashMap;
-
-use crate::{
-    core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::module::Module,
-        shared::{duration::Duration, value::Value},
-        store::global::GlobalStore,
-    },
-    utils::logger::Logger,
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::module::Module,
+    store::global::GlobalStore,
 };
+use devalang_types::{Duration, Value};
+use devalang_utils::logger::Logger;
+use std::collections::HashMap;
 
 pub fn resolve_trigger(
     stmt: &Statement,
@@ -44,15 +41,21 @@ pub fn resolve_trigger(
     // Params value resolution
     let final_value = match &stmt.value {
         Value::Identifier(ident) => {
-            println!("Resolving identifier: {}", ident);
+            logger.log_message(
+                devalang_utils::logger::LogLevel::Debug,
+                &format!("Resolving identifier: {}", ident),
+            );
 
-            resolve_identifier(ident, module, global_store).unwrap_or_else(|| {
-                logger.log_error_with_stacktrace(
-                    &format!("'{path}': value identifier '{ident}' not found"),
-                    &format!("{}:{}:{}", module.path, stmt.line, stmt.column),
-                );
-                Value::Null
-            })
+            match resolve_identifier(ident, module, global_store) {
+                Some(v) => v,
+                None => {
+                    logger.log_error_with_stacktrace(
+                        &format!("'{path}': value identifier '{ident}' not found"),
+                        &format!("{}:{}:{}", module.path, stmt.line, stmt.column),
+                    );
+                    Value::Null
+                }
+            }
         }
         Value::Map(map) => {
             let mut resolved_map = HashMap::new();
@@ -88,7 +91,7 @@ fn resolve_identifier(ident: &str, module: &Module, global_store: &GlobalStore)
         return Some(resolve_value(val, module, global_store));
     }
 
-    for (_, other_mod) in &global_store.modules {
+    for other_mod in global_store.modules.values() {
         if let Some(val) = other_mod.variable_table.get(ident) {
             return Some(resolve_value(val, other_mod, global_store));
         }

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

@@ -1,13 +1,15 @@
 use std::collections::HashMap;
+use toml::Value as TomlValue;
 
 use crate::core::{
     preprocessor::{module::Module, resolver::driver::resolve_statement},
-    shared::value::Value,
     store::global::GlobalStore,
 };
 
+use devalang_types::Value;
+
 fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
-    for (_path, module) in &global_store.modules {
+    for module in global_store.modules.values() {
         if let Some(val) = module.export_table.get_export(name) {
             return Some(val.clone());
         }
@@ -51,9 +53,102 @@ pub fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalSt
                             .map(|p| resolve_value(p, module, global_store))
                             .unwrap_or(Value::Map(HashMap::new()));
 
+                        // If waveform refers to a plugin synth (e.g., alias.synth),
+                        // merge plugin-exported defaults (dynamic) into parameters and
+                        // allow 'waveform' override from parameters map.
+                        let mut final_waveform = resolved_waveform.clone();
+                        let mut params_map = match resolved_params.clone() {
+                            Value::Map(m) => m,
+                            _ => HashMap::new(),
+                        };
+
+                        // Helper: convert TomlValue into runtime Value
+                        fn toml_to_value(tv: &TomlValue) -> Value {
+                            match tv {
+                                TomlValue::String(s) => Value::String(s.clone()),
+                                TomlValue::Integer(i) => Value::Number(*i as f32),
+                                TomlValue::Float(f) => Value::Number(*f as f32),
+                                TomlValue::Boolean(b) => Value::Boolean(*b),
+                                TomlValue::Array(arr) => {
+                                    Value::Array(arr.iter().map(toml_to_value).collect())
+                                }
+                                TomlValue::Table(t) => {
+                                    let mut m = HashMap::new();
+                                    for (k, v) in t.iter() {
+                                        m.insert(k.clone(), toml_to_value(v));
+                                    }
+                                    Value::Map(m)
+                                }
+                                _ => Value::Null,
+                            }
+                        }
+
+                        // Detect plugin alias from waveform string like "alias.synth" OR just "alias"
+                        let (alias_opt, explicit_synth_export) = match &final_waveform {
+                            Value::String(s) | Value::Identifier(s) => {
+                                let parts: Vec<&str> = s.split('.').collect();
+                                if parts.len() >= 2 && parts[1] == "synth" {
+                                    (Some(parts[0].to_string()), true)
+                                } else if parts.len() == 1 {
+                                    (Some(parts[0].to_string()), false)
+                                } else {
+                                    (None, false)
+                                }
+                            }
+                            _ => (None, false),
+                        };
+
+                        if let Some(alias) = alias_opt {
+                            // Resolve alias -> plugin uri -> plugin info
+                            if let Some(Value::String(uri)) = module.variable_table.get(&alias) {
+                                if let Some(id) = uri.strip_prefix("devalang://plugin/") {
+                                    let mut parts = id.split('.');
+                                    let author = parts.next().unwrap_or("");
+                                    let pname = parts.next().unwrap_or("");
+                                    let key = format!("{}:{}", author, pname);
+                                    if let Some((plugin_info, _wasm)) =
+                                        global_store.plugins.get(&key)
+                                    {
+                                        // Merge defaults dynamically from exports
+                                        for exp in &plugin_info.exports {
+                                            // Skip entry named 'synth' which is used as the flag
+                                            if exp.name == "synth" {
+                                                continue;
+                                            }
+                                            if let Some(def) = &exp.default {
+                                                let val = toml_to_value(def);
+                                                // only apply if not overridden by user params
+                                                params_map.entry(exp.name.clone()).or_insert(val);
+                                            }
+                                        }
+
+                                        // If 'waveform' is provided in params (by user or default), use it
+                                        if let Some(wf_val) = params_map.remove("waveform") {
+                                            final_waveform =
+                                                resolve_value(&wf_val, module, global_store);
+                                        } else if let Some(wf_default) = plugin_info
+                                            .exports
+                                            .iter()
+                                            .find(|e| e.name == "waveform")
+                                            .and_then(|e| e.default.as_ref())
+                                        {
+                                            final_waveform = toml_to_value(wf_default);
+                                        } else if explicit_synth_export {
+                                            // keep as alias.synth if no default waveform
+                                        } else {
+                                            // If no explicit .synth in waveform, but alias is a plugin,
+                                            // treat it as alias.synth by default to enable plugin synth usage
+                                            final_waveform =
+                                                Value::String(format!("{}.synth", alias));
+                                        }
+                                    }
+                                }
+                            }
+                        }
+
                         let mut result = HashMap::new();
-                        result.insert("waveform".to_string(), resolved_waveform);
-                        result.insert("parameters".to_string(), resolved_params);
+                        result.insert("waveform".to_string(), final_waveform);
+                        result.insert("parameters".to_string(), Value::Map(params_map));
 
                         return Value::Map(result);
                     }

package/rust/core/store/export.rs

@@ -1,28 +1,28 @@
-use std::collections::HashMap;
-
-use crate::core::shared::value::Value;
-
-#[derive(Debug, Default, Clone, PartialEq)]
-pub struct ExportTable {
-    pub exports: HashMap<String, Value>,
-}
-
-impl ExportTable {
-    pub fn new() -> Self {
-        ExportTable {
-            exports: HashMap::new(),
-        }
-    }
-
-    pub fn add_export(&mut self, name: String, value: Value) {
-        self.exports.insert(name, value);
-    }
-
-    pub fn get_export(&self, name: &str) -> Option<&Value> {
-        self.exports.get(name)
-    }
-
-    pub fn remove_export(&mut self, name: &str) -> Option<Value> {
-        self.exports.remove(name)
-    }
-}
+use std::collections::HashMap;
+
+use devalang_types::Value;
+
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct ExportTable {
+    pub exports: HashMap<String, Value>,
+}
+
+impl ExportTable {
+    pub fn new() -> Self {
+        ExportTable {
+            exports: HashMap::new(),
+        }
+    }
+
+    pub fn add_export(&mut self, name: String, value: Value) {
+        self.exports.insert(name, value);
+    }
+
+    pub fn get_export(&self, name: &str) -> Option<&Value> {
+        self.exports.get(name)
+    }
+
+    pub fn remove_export(&mut self, name: &str) -> Option<Value> {
+        self.exports.remove(name)
+    }
+}

package/rust/core/store/function.rs

@@ -13,6 +13,12 @@ pub struct FunctionTable {
     pub functions: HashMap<String, FunctionDef>,
 }
 
+impl Default for FunctionTable {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl FunctionTable {
     pub fn new() -> Self {
         FunctionTable {

package/rust/core/store/global.rs

@@ -1,9 +1,9 @@
 use crate::core::{
     parser::statement::Statement,
-    plugin::loader::PluginInfo,
     preprocessor::module::Module,
     store::{function::FunctionTable, variable::VariableTable},
 };
+use devalang_types::PluginInfo;
 use std::collections::HashMap;
 
 #[derive(Debug, Clone)]
@@ -15,6 +15,12 @@ pub struct GlobalStore {
     pub plugins: HashMap<String, (PluginInfo, Vec<u8>)>,
 }
 
+impl Default for GlobalStore {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl GlobalStore {
     pub fn new() -> Self {
         GlobalStore {

package/rust/core/store/import.rs

@@ -1,28 +1,28 @@
-use std::collections::HashMap;
-
-use crate::core::shared::value::Value;
-
-#[derive(Debug, Default, Clone, PartialEq)]
-pub struct ImportTable {
-    pub imports: HashMap<String, Value>,
-}
-
-impl ImportTable {
-    pub fn new() -> Self {
-        ImportTable {
-            imports: HashMap::new(),
-        }
-    }
-
-    pub fn add_import(&mut self, name: String, value: Value) {
-        self.imports.insert(name, value);
-    }
-
-    pub fn get_import(&self, name: &str) -> Option<&Value> {
-        self.imports.get(name)
-    }
-
-    pub fn remove_import(&mut self, name: &str) -> Option<Value> {
-        self.imports.remove(name)
-    }
-}
+use std::collections::HashMap;
+
+use devalang_types::Value;
+
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct ImportTable {
+    pub imports: HashMap<String, Value>,
+}
+
+impl ImportTable {
+    pub fn new() -> Self {
+        ImportTable {
+            imports: HashMap::new(),
+        }
+    }
+
+    pub fn add_import(&mut self, name: String, value: Value) {
+        self.imports.insert(name, value);
+    }
+
+    pub fn get_import(&self, name: &str) -> Option<&Value> {
+        self.imports.get(name)
+    }
+
+    pub fn remove_import(&mut self, name: &str) -> Option<Value> {
+        self.imports.remove(name)
+    }
+}

package/rust/core/store/variable.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use crate::core::shared::value::Value;
+use devalang_types::Value;
 
 #[derive(Debug, Default, Clone, PartialEq)]
 pub struct VariableTable {