@devaloop/devalang 0.0.1-beta.2 → 0.1.1

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

@@ -1,116 +0,0 @@
-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 +0,0 @@
-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,57 +0,0 @@
-use crate::core::{parser::statement::Statement, preprocessor::module::Module};
-use devalang_types::{FunctionTable, VariableTable, plugin::PluginInfo};
-use std::collections::HashMap;
-
-#[derive(Debug, Clone)]
-pub struct GlobalStore {
-    pub modules: HashMap<String, Module>,
-    pub variables: VariableTable,
-    pub functions: FunctionTable,
-    pub events: HashMap<String, Vec<Statement>>,
-    pub plugins: HashMap<String, (PluginInfo, Vec<u8>)>,
-}
-
-impl Default for GlobalStore {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl GlobalStore {
-    pub fn new() -> Self {
-        GlobalStore {
-            modules: HashMap::new(),
-            functions: FunctionTable::new(),
-            variables: VariableTable::new(),
-            events: HashMap::new(),
-            plugins: HashMap::new(),
-        }
-    }
-
-    pub fn insert_module(&mut self, path: String, module: Module) {
-        self.modules.insert(path, module);
-    }
-
-    pub fn modules_mut(&mut self) -> &mut HashMap<String, Module> {
-        &mut self.modules
-    }
-
-    pub fn get_module(&self, path: &str) -> Option<&Module> {
-        self.modules.get(path)
-    }
-
-    pub fn remove_module(&mut self, path: &str) -> Option<Module> {
-        self.modules.remove(path)
-    }
-
-    pub fn register_event_handler(&mut self, event: &str, handler: Statement) {
-        self.events
-            .entry(event.to_string())
-            .or_default()
-            .push(handler);
-    }
-
-    pub fn get_event_handlers(&self, event: &str) -> Option<&Vec<Statement>> {
-        self.events.get(event)
-    }
-}

package/rust/core/store/mod.rs

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

package/rust/lib.rs

@@ -1,323 +0,0 @@
-pub mod config;
-pub mod core;
-
-use crate::core::{
-    audio::{engine::AudioEngine, interpreter::driver::run_audio_program},
-    parser::statement::{Statement, StatementKind},
-    preprocessor::loader::ModuleLoader,
-    store::global::GlobalStore,
-};
-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::*;
-
-#[derive(Serialize, Deserialize)]
-struct ParseResult {
-    ok: bool,
-    ast: String,
-    errors: Vec<ErrorResult>,
-}
-
-#[derive(Serialize, Deserialize)]
-struct ErrorResult {
-    message: String,
-    line: usize,
-    column: usize,
-}
-
-#[wasm_bindgen]
-pub fn parse(entry_path: &str, source: &str) -> Result<JsValue, JsValue> {
-    let statements = parse_internal_from_string(entry_path, source);
-
-    match statements {
-        Ok(value) => {
-            let ast_string = value;
-            to_value(&ast_string)
-                .map_err(|e| JsValue::from_str(&format!("Error converting AST to JS value: {}", e)))
-        }
-        Err(e) => Err(JsValue::from_str(&format!("Error: {}", e))),
-    }
-}
-
-#[wasm_bindgen]
-pub fn debug_render(user_code: &str) -> Result<JsValue, JsValue> {
-    console_error_panic_hook::set_once();
-
-    let entry_path = normalize_path("playground.deva");
-    let output_path = normalize_path("./temp");
-
-    let mut global_store = GlobalStore::new();
-
-    let loader =
-        ModuleLoader::from_raw_source(&entry_path, &output_path, user_code, &mut global_store);
-
-    loader
-        .load_wasm_module(&mut global_store)
-        .map_err(|e| JsValue::from_str(&format!("Module loading error: {}", e)))?;
-
-    let all_statements_map = loader.extract_statements_map(&global_store);
-
-    let main_statements = all_statements_map
-        .get(&entry_path)
-        .ok_or(JsValue::from_str("No statements found for entry module"))?
-        .clone();
-
-    let mut audio_engine = AudioEngine::new("wasm_output".to_string());
-
-    let _ = run_audio_program(
-        &main_statements,
-        &mut audio_engine,
-        "playground".to_string(),
-        "wasm_output".to_string(),
-        VariableTable::new(),
-        FunctionTable::new(),
-        &mut global_store,
-    );
-
-    // Inspect buffer to detect if any audio was produced. In test/CI
-    // environments it's common to produce no audio (silent program);
-    // callers rely on this flag for diagnostics.
-    let samples = audio_engine.get_normalized_buffer();
-    let any_nonzero = samples.iter().any(|&s| s != 0.0);
-
-    // Build parsed AST for diagnostics
-    let ast_res = parse_internal_from_string("playground.deva", user_code);
-    let ast_str = match ast_res {
-        Ok(p) => p.ast,
-        Err(_) => "".to_string(),
-    };
-
-    #[derive(Serialize)]
-    struct DebugResult {
-        samples_len: usize,
-        any_nonzero: bool,
-        ast: String,
-        note_count: usize,
-        global_vars: Vec<String>,
-        statements_count: usize,
-    }
-
-    let out = DebugResult {
-        samples_len: samples.len(),
-        any_nonzero,
-        ast: ast_str,
-        note_count: audio_engine.note_count,
-        global_vars: global_store.variables.variables.keys().cloned().collect(),
-        statements_count: main_statements.len(),
-    };
-
-    to_value(&out).map_err(|e| JsValue::from_str(&format!("Error converting debug result: {}", e)))
-}
-
-#[wasm_bindgen]
-pub fn render_audio(user_code: &str) -> Result<js_sys::Float32Array, JsValue> {
-    console_error_panic_hook::set_once();
-
-    let entry_path = normalize_path("playground.deva");
-    let output_path = normalize_path("./temp");
-
-    let mut global_store = GlobalStore::new();
-
-    let loader =
-        ModuleLoader::from_raw_source(&entry_path, &output_path, user_code, &mut global_store);
-
-    loader
-        .load_wasm_module(&mut global_store)
-        .map_err(|e| JsValue::from_str(&format!("Module loading error: {}", e)))?;
-
-    let all_statements_map = loader.extract_statements_map(&global_store);
-
-    let main_statements = all_statements_map
-        .get(&entry_path)
-        .ok_or(JsValue::from_str("No statements found for entry module"))?
-        .clone();
-
-    let mut audio_engine = AudioEngine::new("wasm_output".to_string());
-
-    let _ = run_audio_program(
-        &main_statements,
-        &mut audio_engine,
-        "playground".to_string(),
-        "wasm_output".to_string(),
-        VariableTable::new(),
-        FunctionTable::new(),
-        &mut global_store,
-    );
-
-    let samples = audio_engine.get_normalized_buffer();
-
-    if samples.is_empty() {
-        // For test environments where no audio was scheduled, return a small
-        // silent buffer instead of failing. This helps tests proceed in CI.
-        let silent = vec![0.0f32; 1024];
-        return Ok(js_sys::Float32Array::from(silent.as_slice()));
-    }
-
-    Ok(js_sys::Float32Array::from(samples.as_slice()))
-}
-
-#[wasm_bindgen]
-#[allow(unused_variables)]
-pub fn register_playhead_callback(cb: &js_sys::Function) {
-    // Register a JS callback to receive playhead events during real-time
-    // playback. This is a no-op on non-wasm targets to keep the bindings
-    // portable for native builds.
-    // Only register if target supports wasm callbacks
-    #[cfg(target_arch = "wasm32")]
-    {
-        crate::core::audio::interpreter::driver::register_playhead_callback(cb.clone());
-    }
-}
-
-#[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")]
-    {
-        crate::core::audio::interpreter::driver::unregister_playhead_callback();
-    }
-}
-
-fn parse_internal_from_string(virtual_path: &str, source: &str) -> Result<ParseResult, String> {
-    let entry_path = normalize_path(virtual_path);
-    let output_path = normalize_path("./temp");
-
-    let mut global_store = GlobalStore::new();
-    let loader =
-        ModuleLoader::from_raw_source(&entry_path, &output_path, source, &mut global_store);
-
-    let module = loader
-        .load_single_module(&mut global_store)
-        .map_err(|e| format!("Error loading module: {}", e))?;
-
-    let raw_ast = ast_to_string(module.statements.clone());
-
-    let found_errors = collect_errors_recursively(&module.statements);
-
-    let result = ParseResult {
-        ok: true,
-        ast: raw_ast,
-        errors: found_errors,
-    };
-
-    Ok(result)
-}
-
-fn collect_errors_recursively(statements: &[Statement]) -> Vec<ErrorResult> {
-    let mut errors: Vec<ErrorResult> = Vec::new();
-
-    for stmt in statements {
-        match &stmt.kind {
-            StatementKind::Unknown => {
-                errors.push(ErrorResult {
-                    message: format!("Unknown statement at line {}:{}", stmt.line, stmt.column),
-                    line: stmt.line,
-                    column: stmt.column,
-                });
-            }
-            StatementKind::Error { message } => {
-                errors.push(ErrorResult {
-                    message: message.clone(),
-                    line: stmt.line,
-                    column: stmt.column,
-                });
-            }
-            StatementKind::Loop => {
-                if let Some(body_statements) = extract_loop_body_statements(&stmt.value) {
-                    errors.extend(collect_errors_recursively(body_statements));
-                }
-            }
-            _ => {}
-        }
-    }
-
-    errors
-}
-
-fn extract_loop_body_statements(value: &Value) -> Option<&[Statement]> {
-    if let Value::Map(map) = value {
-        if let Some(Value::Block(statements)) = map.get("body") {
-            return Some(statements);
-        }
-    }
-    None
-}
-
-fn ast_to_string(statements: Vec<Statement>) -> String {
-    serde_json::to_string_pretty(&statements).expect("Failed to serialize AST")
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use devalang_types::{Statement, StatementKind, Value};
-
-    #[test]
-    fn test_extract_loop_body_statements_none() {
-        let v = Value::Map(std::collections::HashMap::new());
-        assert!(extract_loop_body_statements(&v).is_none());
-    }
-
-    #[test]
-    fn test_extract_loop_body_statements_some() {
-        let stmt = Statement::unknown();
-        let mut map = std::collections::HashMap::new();
-        map.insert("body".to_string(), Value::Block(vec![stmt.clone(), stmt]));
-
-        let v = Value::Map(map);
-        let res = extract_loop_body_statements(&v);
-        assert!(res.is_some());
-        let slice = res.unwrap();
-        assert_eq!(slice.len(), 2);
-    }
-
-    #[test]
-    fn test_collect_errors_recursively_detection() {
-        let mut statements: Vec<Statement> = Vec::new();
-
-        // Unknown statement should be reported
-        let s1 = Statement::unknown_with_pos(0, 10, 2);
-        statements.push(s1.clone());
-
-        // Error statement
-        let s2 = Statement::error_with_pos(0, 20, 4, "boom".to_string());
-        statements.push(s2.clone());
-
-        // Loop with body containing unknown
-        let body_stmt = Statement::unknown_with_pos(1, 30, 5);
-        let mut loop_map = std::collections::HashMap::new();
-        loop_map.insert("body".to_string(), Value::Block(vec![body_stmt.clone()]));
-
-        let loop_stmt = Statement {
-            kind: StatementKind::Loop,
-            value: Value::Map(loop_map),
-            indent: 0,
-            line: 15,
-            column: 1,
-        };
-        statements.push(loop_stmt);
-
-        let errors = collect_errors_recursively(&statements);
-        // expect three errors: s1 unknown, s2 error, body unknown
-        assert_eq!(errors.len(), 3);
-        assert!(errors.iter().any(|e| e.line == 10));
-        assert!(errors.iter().any(|e| e.line == 20));
-        assert!(errors.iter().any(|e| e.line == 30));
-    }
-}