@devaloop/devalang 0.0.1-beta.1 → 0.0.1-beta.2

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

@@ -1,116 +1,116 @@
-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,
-    entity: &str,
-    duration: &mut Duration,
-    _effects: Option<Value>,
-    module: &Module,
-    path: &str,
-    global_store: &GlobalStore,
-) -> Statement {
-    let logger = Logger::new();
-
-    let mut final_duration = duration.clone();
-
-    // Duration resolution
-    if let Duration::Identifier(ident) = duration {
-        if let Some(val) = resolve_identifier(ident, module, global_store) {
-            match val {
-                Value::Number(n) => {
-                    final_duration = Duration::Number(n);
-                }
-                Value::String(s) => {
-                    final_duration = Duration::Identifier(s);
-                }
-                Value::Identifier(s) if s == "auto" => {
-                    final_duration = Duration::Auto;
-                }
-                _ => {}
-            }
-        }
-    }
-
-    // Params value resolution
-    let final_value = match &stmt.value {
-        Value::Identifier(ident) => {
-            logger.log_message(
-                devalang_utils::logger::LogLevel::Debug,
-                &format!("Resolving identifier: {}", ident),
-            );
-
-            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();
-            for (k, v) in map {
-                let resolved = match v {
-                    Value::Identifier(id) => {
-                        resolve_identifier(id, module, global_store).unwrap_or(Value::Null)
-                    }
-                    other => other.clone(),
-                };
-                resolved_map.insert(k.clone(), resolved);
-            }
-            Value::Map(resolved_map)
-        }
-        other => other.clone(),
-    };
-
-    Statement {
-        kind: StatementKind::Trigger {
-            entity: entity.to_string(),
-            duration: final_duration.clone(),
-            effects: Some(final_value.clone()),
-        },
-        value: Value::Null,
-        line: stmt.line,
-        column: stmt.column,
-        indent: stmt.indent,
-    }
-}
-
-fn resolve_identifier(ident: &str, module: &Module, global_store: &GlobalStore) -> Option<Value> {
-    if let Some(val) = module.variable_table.get(ident) {
-        return Some(resolve_value(val, module, global_store));
-    }
-
-    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));
-        }
-    }
-
-    None
-}
-
-fn resolve_value(val: &Value, module: &Module, global_store: &GlobalStore) -> Value {
-    match val {
-        Value::Identifier(inner) => resolve_identifier(inner, module, global_store)
-            .unwrap_or(Value::Identifier(inner.clone())),
-        Value::Map(map) => {
-            let mut resolved = HashMap::new();
-            for (k, v) in map {
-                resolved.insert(k.clone(), resolve_value(v, module, global_store));
-            }
-            Value::Map(resolved)
-        }
-        other => other.clone(),
-    }
-}
+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,
+    entity: &str,
+    duration: &mut Duration,
+    _effects: Option<Value>,
+    module: &Module,
+    path: &str,
+    global_store: &GlobalStore,
+) -> Statement {
+    let logger = Logger::new();
+
+    let mut final_duration = duration.clone();
+
+    // Duration resolution
+    if let Duration::Identifier(ident) = duration {
+        if let Some(val) = resolve_identifier(ident, module, global_store) {
+            match val {
+                Value::Number(n) => {
+                    final_duration = Duration::Number(n);
+                }
+                Value::String(s) => {
+                    final_duration = Duration::Identifier(s);
+                }
+                Value::Identifier(s) if s == "auto" => {
+                    final_duration = Duration::Auto;
+                }
+                _ => {}
+            }
+        }
+    }
+
+    // Params value resolution
+    let final_value = match &stmt.value {
+        Value::Identifier(ident) => {
+            logger.log_message(
+                devalang_utils::logger::LogLevel::Debug,
+                &format!("Resolving identifier: {}", ident),
+            );
+
+            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();
+            for (k, v) in map {
+                let resolved = match v {
+                    Value::Identifier(id) => {
+                        resolve_identifier(id, module, global_store).unwrap_or(Value::Null)
+                    }
+                    other => other.clone(),
+                };
+                resolved_map.insert(k.clone(), resolved);
+            }
+            Value::Map(resolved_map)
+        }
+        other => other.clone(),
+    };
+
+    Statement {
+        kind: StatementKind::Trigger {
+            entity: entity.to_string(),
+            duration: final_duration.clone(),
+            effects: Some(final_value.clone()),
+        },
+        value: Value::Null,
+        line: stmt.line,
+        column: stmt.column,
+        indent: stmt.indent,
+    }
+}
+
+fn resolve_identifier(ident: &str, module: &Module, global_store: &GlobalStore) -> Option<Value> {
+    if let Some(val) = module.variable_table.get(ident) {
+        return Some(resolve_value(val, module, global_store));
+    }
+
+    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));
+        }
+    }
+
+    None
+}
+
+fn resolve_value(val: &Value, module: &Module, global_store: &GlobalStore) -> Value {
+    match val {
+        Value::Identifier(inner) => resolve_identifier(inner, module, global_store)
+            .unwrap_or(Value::Identifier(inner.clone())),
+        Value::Map(map) => {
+            let mut resolved = HashMap::new();
+            for (k, v) in map {
+                resolved.insert(k.clone(), resolve_value(v, module, global_store));
+            }
+            Value::Map(resolved)
+        }
+        other => other.clone(),
+    }
+}

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

@@ -1,176 +1,176 @@
-use std::collections::HashMap;
-use toml::Value as TomlValue;
-
-use crate::core::{
-    preprocessor::{module::Module, resolver::driver::resolve_statement},
-    store::global::GlobalStore,
-};
-
-use devalang_types::Value;
-
-fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
-    for module in global_store.modules.values() {
-        if let Some(val) = module.export_table.get_export(name) {
-            return Some(val.clone());
-        }
-    }
-
-    None
-}
-
-pub fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore) -> Value {
-    match value {
-        Value::String(s) => {
-            // Keep raw strings as-is; they may be runtime-evaluated (e.g., expressions)
-            Value::String(s.clone())
-        }
-
-        Value::Identifier(name) => {
-            if let Some(original_val) = module.variable_table.get(name) {
-                return resolve_value(original_val, module, global_store);
-            }
-
-            if let Some(export_val) = find_export_value(name, global_store) {
-                return resolve_value(&export_val, module, global_store);
-            }
-
-            // Leave unresolved identifiers as-is; may be runtime-bound (e.g., foreach variable)
-            Value::Identifier(name.clone())
-        }
-
-        Value::Map(map) => {
-            if let Some(Value::Identifier(entity)) = map.get("entity") {
-                // SECTION Synth
-                if entity == "synth" {
-                    if let Some(Value::Map(synth_data)) = map.get("value") {
-                        let resolved_waveform = synth_data
-                            .get("waveform")
-                            .map(|wf| resolve_value(wf, module, global_store))
-                            .unwrap_or(Value::Null);
-
-                        let resolved_params = synth_data
-                            .get("parameters")
-                            .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(), final_waveform);
-                        result.insert("parameters".to_string(), Value::Map(params_map));
-
-                        return Value::Map(result);
-                    }
-                }
-            }
-
-            let mut resolved = HashMap::new();
-            for (k, v) in map {
-                resolved.insert(k.clone(), resolve_value(v, module, global_store));
-            }
-
-            Value::Map(resolved)
-        }
-
-        Value::Block(stmts) => {
-            let resolved_stmts = stmts
-                .iter()
-                .map(|stmt| resolve_statement(stmt, module, &module.path, global_store))
-                .collect();
-            Value::Block(resolved_stmts)
-        }
-
-        other => other.clone(),
-    }
-}
+use std::collections::HashMap;
+use toml::Value as TomlValue;
+
+use crate::core::{
+    preprocessor::{module::Module, resolver::driver::resolve_statement},
+    store::global::GlobalStore,
+};
+
+use devalang_types::Value;
+
+fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
+    for module in global_store.modules.values() {
+        if let Some(val) = module.export_table.get_export(name) {
+            return Some(val.clone());
+        }
+    }
+
+    None
+}
+
+pub fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore) -> Value {
+    match value {
+        Value::String(s) => {
+            // Keep raw strings as-is; they may be runtime-evaluated (e.g., expressions)
+            Value::String(s.clone())
+        }
+
+        Value::Identifier(name) => {
+            if let Some(original_val) = module.variable_table.get(name) {
+                return resolve_value(original_val, module, global_store);
+            }
+
+            if let Some(export_val) = find_export_value(name, global_store) {
+                return resolve_value(&export_val, module, global_store);
+            }
+
+            // Leave unresolved identifiers as-is; may be runtime-bound (e.g., foreach variable)
+            Value::Identifier(name.clone())
+        }
+
+        Value::Map(map) => {
+            if let Some(Value::Identifier(entity)) = map.get("entity") {
+                // SECTION Synth
+                if entity == "synth" {
+                    if let Some(Value::Map(synth_data)) = map.get("value") {
+                        let resolved_waveform = synth_data
+                            .get("waveform")
+                            .map(|wf| resolve_value(wf, module, global_store))
+                            .unwrap_or(Value::Null);
+
+                        let resolved_params = synth_data
+                            .get("parameters")
+                            .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(), final_waveform);
+                        result.insert("parameters".to_string(), Value::Map(params_map));
+
+                        return Value::Map(result);
+                    }
+                }
+            }
+
+            let mut resolved = HashMap::new();
+            for (k, v) in map {
+                resolved.insert(k.clone(), resolve_value(v, module, global_store));
+            }
+
+            Value::Map(resolved)
+        }
+
+        Value::Block(stmts) => {
+            let resolved_stmts = stmts
+                .iter()
+                .map(|stmt| resolve_statement(stmt, module, &module.path, global_store))
+                .collect();
+            Value::Block(resolved_stmts)
+        }
+
+        other => other.clone(),
+    }
+}

package/rust/core/store/global.rs

@@ -1,9 +1,5 @@
-use crate::core::{
-    parser::statement::Statement,
-    preprocessor::module::Module,
-    store::{function::FunctionTable, variable::VariableTable},
-};
-use devalang_types::PluginInfo;
+use crate::core::{parser::statement::Statement, preprocessor::module::Module};
+use devalang_types::{FunctionTable, VariableTable, plugin::PluginInfo};
 use std::collections::HashMap;
 
 #[derive(Debug, Clone)]

package/rust/core/store/mod.rs

@@ -1,5 +1 @@
-pub mod export;
-pub mod function;
-pub mod global;
-pub mod import;
-pub mod variable;
+pub mod global;

package/rust/lib.rs

@@ -5,10 +5,10 @@ use crate::core::{
     audio::{engine::AudioEngine, interpreter::driver::run_audio_program},
     parser::statement::{Statement, StatementKind},
     preprocessor::loader::ModuleLoader,
-    store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
-    utils::path::normalize_path,
+    store::global::GlobalStore,
 };
-use devalang_types::Value;
+use devalang_types::{FunctionTable, Value, VariableTable};
+use devalang_utils::path::normalize_path;
 use serde::{Deserialize, Serialize};
 use serde_wasm_bindgen::to_value;
 use wasm_bindgen::prelude::*;
@@ -171,6 +171,21 @@ pub fn register_playhead_callback(cb: &js_sys::Function) {
     }
 }
 
+#[wasm_bindgen]
+#[allow(unused_variables)]
+pub fn collect_playhead_events() -> Result<JsValue, JsValue> {
+    #[cfg(target_arch = "wasm32")]
+    {
+        let events = crate::core::audio::interpreter::driver::collect_playhead_events();
+        to_value(&events).map_err(|e| JsValue::from_str(&format!("Error converting events: {}", e)))
+    }
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        // On non-wasm targets, return an empty array
+        to_value(&Vec::<String>::new()).map_err(|e| JsValue::from_str(&format!("Error: {}", e)))
+    }
+}
+
 #[wasm_bindgen]
 pub fn unregister_playhead_callback() {
     #[cfg(target_arch = "wasm32")]