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

package/rust/core/parser/handler/identifier/synth.rs

@@ -1,135 +1,171 @@
-use std::collections::HashMap;
-
-use devalang_types::Value;
-
-use crate::core::{
-    lexer::token::Token,
-    parser::{
-        driver::parser::Parser,
-        handler::dot::parse_dot_token,
-        statement::{Statement, StatementKind},
-    },
-    store::global::GlobalStore,
-};
-
-pub fn parse_synth_token(
-    parser: &mut Parser,
-    _current_token: Token,
-    _global_store: &mut GlobalStore,
-) -> Statement {
-    parser.advance(); // consume 'synth'
-
-    let Some(synth_token) = parser.previous_clone() else {
-        return Statement::unknown();
-    };
-
-    // Expect a provider/waveform identifier (can be dotted: alias.synth)
-    // Also accept a dot-led entity by delegating to the dot parser (e.g. .module.export)
-    let synth_waveform = if let Some(first_token) = parser.peek_clone() {
-        use crate::core::lexer::token::TokenKind;
-
-        if first_token.kind == TokenKind::Dot {
-            // Parse dot-entity and extract its entity string
-            let dot_stmt = parse_dot_token(parser, _global_store);
-            // Extract entity if the parsed statement is a Trigger
-            match dot_stmt.kind {
-                StatementKind::Trigger { entity, .. } => entity,
-                _ => String::new(),
-            }
-        } else {
-            if first_token.kind != crate::core::lexer::token::TokenKind::Identifier
-                && first_token.kind != crate::core::lexer::token::TokenKind::Number
-                && first_token.kind != crate::core::lexer::token::TokenKind::Synth
-            {
-                return crate::core::parser::statement::error_from_token(
-                    first_token.clone(),
-                    "Expected identifier after 'synth'".to_string(),
-                );
-            }
-
-            // Collect dotted parts on the same line
-            let mut parts: Vec<String> = Vec::new();
-            let current_line = first_token.line;
-            loop {
-                let Some(tok) = parser.peek_clone() else {
-                    break;
-                };
-                if tok.line != current_line {
-                    break;
-                }
-                match tok.kind {
-                    crate::core::lexer::token::TokenKind::Identifier
-                    | crate::core::lexer::token::TokenKind::Number
-                    | crate::core::lexer::token::TokenKind::Synth => {
-                        parts.push(tok.lexeme.clone());
-                        parser.advance();
-                        // If next isn't a dot on same line, stop
-                        if let Some(next) = parser.peek_clone() {
-                            if !(next.line == current_line
-                                && next.kind == crate::core::lexer::token::TokenKind::Dot)
-                            {
-                                break;
-                            }
-                        } else {
-                            break;
-                        }
-                    }
-                    crate::core::lexer::token::TokenKind::Dot => {
-                        parser.advance();
-                    }
-                    _ => break,
-                }
-            }
-
-            parts.join(".")
-        }
-    } else {
-        return crate::core::parser::statement::error_from_token(
-            synth_token,
-            "Expected identifier after 'synth'".to_string(),
-        );
-    };
-
-    // Skip formatting before optional parameters map
-    while parser.check_token(crate::core::lexer::token::TokenKind::Newline)
-        || parser.check_token(crate::core::lexer::token::TokenKind::Indent)
-        || parser.check_token(crate::core::lexer::token::TokenKind::Dedent)
-        || parser.check_token(crate::core::lexer::token::TokenKind::Whitespace)
-    {
-        parser.advance();
-    }
-
-    // Expect synth optional parameters map
-    let parameters = if let Some(params) = parser.parse_map_value() {
-        // If parameters are provided, we expect a map
-        if let Value::Map(map) = params {
-            map
-        } else {
-            return crate::core::parser::statement::error_from_token(
-                synth_token,
-                "Expected a map for synth parameters".to_string(),
-            );
-        }
-    } else {
-        // If no parameters are provided, we can still create the statement with an empty map
-        HashMap::new()
-    };
-
-    Statement {
-        kind: StatementKind::Synth,
-        value: Value::Map(HashMap::from([
-            ("entity".to_string(), Value::String("synth".to_string())),
-            (
-                "value".to_string(),
-                Value::Map(HashMap::from([
-                    // Store waveform as identifier to allow resolution from variables/exports
-                    ("waveform".to_string(), Value::Identifier(synth_waveform)),
-                    ("parameters".to_string(), Value::Map(parameters)),
-                ])),
-            ),
-        ])),
-        indent: synth_token.indent,
-        line: synth_token.line,
-        column: synth_token.column,
-    }
-}
+use std::collections::HashMap;
+
+use devalang_types::Value;
+
+use crate::core::{
+    lexer::token::Token,
+    parser::{
+        driver::parser::Parser,
+        handler::dot::parse_dot_token,
+        statement::{Statement, StatementKind},
+    },
+    store::global::GlobalStore,
+};
+
+pub fn parse_synth_token(
+    parser: &mut Parser,
+    _current_token: Token,
+    _global_store: &mut GlobalStore,
+) -> Statement {
+    parser.advance(); // consume 'synth'
+
+    let Some(synth_token) = parser.previous_clone() else {
+        return Statement::unknown();
+    };
+
+    // Expect a provider or waveform identifier (can be dotted: alias.synth)
+    // Also accept a dot-led entity by delegating to the dot parser (e.g. .module.export)
+    // Support optional explicit waveform after a dotted provider: `synth alias.synth saw {}`
+    let synth_waveform = if let Some(first_token) = parser.peek_clone() {
+        use crate::core::lexer::token::TokenKind;
+
+        if first_token.kind == TokenKind::Dot {
+            // Parse dot-entity and extract its entity string
+            let dot_stmt = parse_dot_token(parser, _global_store);
+            // Extract entity if the parsed statement is a Trigger
+            match dot_stmt.kind {
+                StatementKind::Trigger { entity, .. } => entity,
+                _ => String::new(),
+            }
+        } else {
+            if first_token.kind != crate::core::lexer::token::TokenKind::Identifier
+                && first_token.kind != crate::core::lexer::token::TokenKind::Number
+                && first_token.kind != crate::core::lexer::token::TokenKind::Synth
+            {
+                return crate::core::parser::statement::error_from_token(
+                    first_token.clone(),
+                    "Expected identifier after 'synth'".to_string(),
+                );
+            }
+
+            // Collect dotted parts on the same line
+            let mut parts: Vec<String> = Vec::new();
+            let current_line = first_token.line;
+            loop {
+                let Some(tok) = parser.peek_clone() else {
+                    break;
+                };
+                if tok.line != current_line {
+                    break;
+                }
+                match tok.kind {
+                    crate::core::lexer::token::TokenKind::Identifier
+                    | crate::core::lexer::token::TokenKind::Number
+                    | crate::core::lexer::token::TokenKind::Synth => {
+                        parts.push(tok.lexeme.clone());
+                        parser.advance();
+                        // If next isn't a dot on same line, stop
+                        if let Some(next) = parser.peek_clone() {
+                            if !(next.line == current_line
+                                && next.kind == crate::core::lexer::token::TokenKind::Dot)
+                            {
+                                break;
+                            }
+                        } else {
+                            break;
+                        }
+                    }
+                    crate::core::lexer::token::TokenKind::Dot => {
+                        parser.advance();
+                    }
+                    _ => break,
+                }
+            }
+
+            // The joined parts form either:
+            // - a simple waveform name (e.g. "sine")
+            // - a provider entity (e.g. "author.synth")
+            let first = parts.join(".");
+
+            // If this looks like a dotted provider, try to consume an optional explicit
+            // waveform identifier on the same line (e.g. `synth author.synth saw`). If none
+            // is provided, fall back to the original behaviour (use the joined string as
+            // the waveform identifier) to remain backward-compatible.
+            if first.contains('.') {
+                // peek next token on same line
+                if let Some(next_tok) = parser.peek_clone() {
+                    if next_tok.line == current_line
+                        && matches!(
+                            next_tok.kind,
+                            crate::core::lexer::token::TokenKind::Identifier
+                                | crate::core::lexer::token::TokenKind::Number
+                                | crate::core::lexer::token::TokenKind::Synth
+                        )
+                    {
+                        // consume waveform token
+                        let waveform = next_tok.lexeme.clone();
+                        parser.advance();
+                        // store as "provider.waveform" style? keep only waveform for compatibility
+                        waveform
+                    } else {
+                        // no explicit waveform -> use the provider string (old behaviour)
+                        first
+                    }
+                } else {
+                    first
+                }
+            } else {
+                // simple waveform name
+                first
+            }
+        }
+    } else {
+        return crate::core::parser::statement::error_from_token(
+            synth_token,
+            "Expected identifier after 'synth'".to_string(),
+        );
+    };
+
+    // Skip formatting before optional parameters map
+    while parser.check_token(crate::core::lexer::token::TokenKind::Newline)
+        || parser.check_token(crate::core::lexer::token::TokenKind::Indent)
+        || parser.check_token(crate::core::lexer::token::TokenKind::Dedent)
+        || parser.check_token(crate::core::lexer::token::TokenKind::Whitespace)
+    {
+        parser.advance();
+    }
+
+    // Expect synth optional parameters map
+    let parameters = if let Some(params) = parser.parse_map_value() {
+        // If parameters are provided, we expect a map
+        if let Value::Map(map) = params {
+            map
+        } else {
+            return crate::core::parser::statement::error_from_token(
+                synth_token,
+                "Expected a map for synth parameters".to_string(),
+            );
+        }
+    } else {
+        // If no parameters are provided, we can still create the statement with an empty map
+        HashMap::new()
+    };
+
+    Statement {
+        kind: StatementKind::Synth,
+        value: Value::Map(HashMap::from([
+            ("entity".to_string(), Value::String("synth".to_string())),
+            (
+                "value".to_string(),
+                Value::Map(HashMap::from([
+                    // Store waveform as identifier to allow resolution from variables/exports
+                    ("waveform".to_string(), Value::Identifier(synth_waveform)),
+                    ("parameters".to_string(), Value::Map(parameters)),
+                ])),
+            ),
+        ])),
+        indent: synth_token.indent,
+        line: synth_token.line,
+        column: synth_token.column,
+    }
+}

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

@@ -1,9 +1,9 @@
-pub mod arrow_call;
-pub mod at;
-pub mod bank;
-pub mod condition;
-pub mod dot;
-pub mod identifier;
-pub mod loop_;
-pub mod pattern;
-pub mod tempo;
+pub mod arrow_call;
+pub mod at;
+pub mod bank;
+pub mod condition;
+pub mod dot;
+pub mod identifier;
+pub mod loop_;
+pub mod pattern;
+pub mod tempo;

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

@@ -52,6 +52,12 @@ pub fn parse_pattern_token(parser: &mut Parser, _global_store: &mut GlobalStore)
         }
     }
 
+    // optional inline options map like { swing: 0.08 }
+    let mut options: Option<Value> = None;
+    if parser.check_token(TokenKind::LBrace) {
+        options = parser.parse_map_value();
+    }
+
     // optional '=' and pattern string
     let mut value: Value = Value::Null;
     if parser.peek_is("=") {
@@ -59,9 +65,26 @@ pub fn parse_pattern_token(parser: &mut Parser, _global_store: &mut GlobalStore)
         if let Some(tok3) = parser.peek_clone() {
             if tok3.kind == TokenKind::String {
                 parser.advance();
-                value = Value::String(tok3.lexeme.clone());
+                let pat_str = Value::String(tok3.lexeme.clone());
+                if let Some(opts) = options {
+                    // merge options map with pattern key
+                    if let Value::Map(mut m) = opts {
+                        m.insert("pattern".to_string(), pat_str);
+                        value = Value::Map(m);
+                    } else {
+                        // unexpected, wrap into a map
+                        let mut m = std::collections::HashMap::new();
+                        m.insert("pattern".to_string(), pat_str);
+                        value = Value::Map(m);
+                    }
+                } else {
+                    value = Value::String(tok3.lexeme.clone());
+                }
             }
         }
+    } else if let Some(opts) = options {
+        // only options were provided, store them as the value
+        value = opts;
     }
 
     Statement {

package/rust/core/plugin/loader.rs

@@ -1,137 +1,137 @@
-use devalang_types::{plugin::PluginExport, plugin::PluginInfo as SharedPluginInfo};
-use devalang_utils::path as path_utils;
-use serde::Deserialize;
-use toml::Value as TomlValue;
-
-#[derive(Debug, Deserialize, Clone)]
-struct LocalExportEntry {
-    pub name: String,
-    #[serde(rename = "type")]
-    pub kind: String,
-    #[serde(default)]
-    pub default: Option<TomlValue>,
-}
-
-#[derive(Debug, Deserialize, Clone)]
-struct LocalPluginFile {
-    pub plugin: LocalPluginInfo,
-    #[serde(default)]
-    pub export: Vec<LocalExportEntry>,
-}
-
-#[derive(Debug, Deserialize, Clone)]
-struct LocalPluginInfo {
-    pub name: String,
-    pub version: Option<String>,
-    pub description: Option<String>,
-    pub author: Option<String>,
-}
-
-pub fn load_plugin(author: &str, name: &str) -> Result<(SharedPluginInfo, Vec<u8>), String> {
-    let root = path_utils::get_deva_dir()?;
-    let plugin_dir_preferred = root.join("plugins").join(format!("{}.{}", author, name));
-    let toml_path_preferred = plugin_dir_preferred.join("plugin.toml");
-    let wasm_path_preferred_bg = plugin_dir_preferred.join(format!("{}_bg.wasm", name));
-    let wasm_path_preferred_plain = plugin_dir_preferred.join(format!("{}.wasm", name));
-
-    // Legacy layout (fallback): ./.deva/plugin/<author>/<name>/
-    let plugin_dir_fallback = root.join("plugins").join(author).join(name);
-    let toml_path_fallback = plugin_dir_fallback.join("plugin.toml");
-    let wasm_path_fallback_bg = plugin_dir_fallback.join(format!("{}_bg.wasm", name));
-    let wasm_path_fallback_plain = plugin_dir_fallback.join(format!("{}.wasm", name));
-
-    // Resolve actual paths to use
-    let (toml_path, wasm_path) = if toml_path_preferred.exists() && wasm_path_preferred_bg.exists()
-    {
-        (toml_path_preferred, wasm_path_preferred_bg)
-    } else if toml_path_preferred.exists() && wasm_path_preferred_plain.exists() {
-        (toml_path_preferred, wasm_path_preferred_plain)
-    } else if toml_path_fallback.exists() && wasm_path_fallback_bg.exists() {
-        (toml_path_fallback, wasm_path_fallback_bg)
-    } else if toml_path_fallback.exists() && wasm_path_fallback_plain.exists() {
-        (toml_path_fallback, wasm_path_fallback_plain)
-    } else {
-        // If either file is missing in both layouts, produce specific errors for missing files in preferred layout
-        if !toml_path_preferred.exists() {
-            return Err(format!(
-                "❌ Plugin file not found: {}",
-                toml_path_preferred.display()
-            ));
-        }
-        if !wasm_path_preferred_bg.exists() && !wasm_path_preferred_plain.exists() {
-            return Err(format!(
-                "❌ Plugin wasm not found: '{}' or '{}'",
-                wasm_path_preferred_bg.display(),
-                wasm_path_preferred_plain.display()
-            ));
-        }
-        unreachable!();
-    };
-
-    let toml_content = std::fs::read_to_string(&toml_path)
-        .map_err(|e| format!("Failed to read '{}': {}", toml_path.display(), e))?;
-    let plugin_file: LocalPluginFile = 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))?;
-
-    // Map local parsed plugin info to shared PluginInfo
-    let mut exports: Vec<PluginExport> = Vec::new();
-    for e in plugin_file.export.iter() {
-        exports.push(PluginExport {
-            name: e.name.clone(),
-            kind: e.kind.clone(),
-            default: e.default.clone(),
-        });
-    }
-
-    let info = SharedPluginInfo {
-        author: plugin_file
-            .plugin
-            .author
-            .unwrap_or_else(|| author.to_string()),
-        name: plugin_file.plugin.name.clone(),
-        version: plugin_file.plugin.version.clone(),
-        description: plugin_file.plugin.description.clone(),
-        exports,
-    };
-
-    Ok((info, wasm_bytes))
-}
-
-/// Load a plugin from dot notation: "author.name"
-pub fn load_plugin_from_dot(dot: &str) -> Result<(SharedPluginInfo, Vec<u8>), String> {
-    let mut parts = dot.split('.');
-    let author = parts
-        .next()
-        .ok_or_else(|| "Invalid plugin name, missing author".to_string())?;
-    let name = parts
-        .next()
-        .ok_or_else(|| "Invalid plugin name, missing name".to_string())?;
-    if parts.next().is_some() {
-        return Err("Invalid plugin name format, expected <author>.<name>".into());
-    }
-    load_plugin(author, name)
-}
-
-pub fn load_plugin_from_uri(uri: &str) -> Result<(SharedPluginInfo, Vec<u8>), String> {
-    if !uri.starts_with("devalang://plugin/") {
-        return Err("Invalid plugin URI".into());
-    }
-
-    // Expect format: devalang://plugin/author.name
-    let payload = uri.trim_start_matches("devalang://plugin/");
-    let mut parts = payload.split('.');
-    let author = parts
-        .next()
-        .ok_or_else(|| "Invalid plugin URI, missing author".to_string())?;
-    let name = parts
-        .next()
-        .ok_or_else(|| "Invalid plugin URI, missing name".to_string())?;
-    if parts.next().is_some() {
-        return Err("Invalid plugin URI format, expected devalang://plugin/<author>.<name>".into());
-    }
-
-    load_plugin(author, name)
-}
+use devalang_types::{plugin::PluginExport, plugin::PluginInfo as SharedPluginInfo};
+use devalang_utils::path as path_utils;
+use serde::Deserialize;
+use toml::Value as TomlValue;
+
+#[derive(Debug, Deserialize, Clone)]
+struct LocalExportEntry {
+    pub name: String,
+    // Local plugin.toml uses 'kind' to describe export type (e.g. "func", "number")
+    pub kind: String,
+    #[serde(default)]
+    pub default: Option<TomlValue>,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+struct LocalPluginFile {
+    pub plugin: LocalPluginInfo,
+    #[serde(rename = "exports", default)]
+    pub exports: Vec<LocalExportEntry>,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+struct LocalPluginInfo {
+    pub name: String,
+    pub version: Option<String>,
+    pub description: Option<String>,
+    pub author: Option<String>,
+}
+
+pub fn load_plugin(author: &str, name: &str) -> Result<(SharedPluginInfo, Vec<u8>), String> {
+    let root = path_utils::get_deva_dir()?;
+    let plugin_dir_preferred = root.join("plugins").join(format!("{}.{}", author, name));
+    let toml_path_preferred = plugin_dir_preferred.join("plugin.toml");
+    let wasm_path_preferred_bg = plugin_dir_preferred.join(format!("{}_bg.wasm", name));
+    let wasm_path_preferred_plain = plugin_dir_preferred.join(format!("{}.wasm", name));
+
+    // Legacy layout (fallback): ./.deva/plugin/<author>/<name>/
+    let plugin_dir_fallback = root.join("plugins").join(author).join(name);
+    let toml_path_fallback = plugin_dir_fallback.join("plugin.toml");
+    let wasm_path_fallback_bg = plugin_dir_fallback.join(format!("{}_bg.wasm", name));
+    let wasm_path_fallback_plain = plugin_dir_fallback.join(format!("{}.wasm", name));
+
+    // Resolve actual paths to use
+    let (toml_path, wasm_path) = if toml_path_preferred.exists() && wasm_path_preferred_bg.exists()
+    {
+        (toml_path_preferred, wasm_path_preferred_bg)
+    } else if toml_path_preferred.exists() && wasm_path_preferred_plain.exists() {
+        (toml_path_preferred, wasm_path_preferred_plain)
+    } else if toml_path_fallback.exists() && wasm_path_fallback_bg.exists() {
+        (toml_path_fallback, wasm_path_fallback_bg)
+    } else if toml_path_fallback.exists() && wasm_path_fallback_plain.exists() {
+        (toml_path_fallback, wasm_path_fallback_plain)
+    } else {
+        // If either file is missing in both layouts, produce specific errors for missing files in preferred layout
+        if !toml_path_preferred.exists() {
+            return Err(format!(
+                "❌ Plugin file not found: {}",
+                toml_path_preferred.display()
+            ));
+        }
+        if !wasm_path_preferred_bg.exists() && !wasm_path_preferred_plain.exists() {
+            return Err(format!(
+                "❌ Plugin wasm not found: '{}' or '{}'",
+                wasm_path_preferred_bg.display(),
+                wasm_path_preferred_plain.display()
+            ));
+        }
+        unreachable!();
+    };
+
+    let toml_content = std::fs::read_to_string(&toml_path)
+        .map_err(|e| format!("Failed to read '{}': {}", toml_path.display(), e))?;
+    let plugin_file: LocalPluginFile = 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))?;
+
+    // Map local parsed plugin info to shared PluginInfo
+    let mut exports: Vec<PluginExport> = Vec::new();
+    for e in plugin_file.exports.iter() {
+        exports.push(PluginExport {
+            name: e.name.clone(),
+            kind: e.kind.clone(),
+            default: e.default.clone(),
+        });
+    }
+
+    let info = SharedPluginInfo {
+        author: plugin_file
+            .plugin
+            .author
+            .unwrap_or_else(|| author.to_string()),
+        name: plugin_file.plugin.name.clone(),
+        version: plugin_file.plugin.version.clone(),
+        description: plugin_file.plugin.description.clone(),
+        exports,
+    };
+
+    Ok((info, wasm_bytes))
+}
+
+/// Load a plugin from dot notation: "author.name"
+pub fn load_plugin_from_dot(dot: &str) -> Result<(SharedPluginInfo, Vec<u8>), String> {
+    let mut parts = dot.split('.');
+    let author = parts
+        .next()
+        .ok_or_else(|| "Invalid plugin name, missing author".to_string())?;
+    let name = parts
+        .next()
+        .ok_or_else(|| "Invalid plugin name, missing name".to_string())?;
+    if parts.next().is_some() {
+        return Err("Invalid plugin name format, expected <author>.<name>".into());
+    }
+    load_plugin(author, name)
+}
+
+pub fn load_plugin_from_uri(uri: &str) -> Result<(SharedPluginInfo, Vec<u8>), String> {
+    if !uri.starts_with("devalang://plugin/") {
+        return Err("Invalid plugin URI".into());
+    }
+
+    // Expect format: devalang://plugin/author.name
+    let payload = uri.trim_start_matches("devalang://plugin/");
+    let mut parts = payload.split('.');
+    let author = parts
+        .next()
+        .ok_or_else(|| "Invalid plugin URI, missing author".to_string())?;
+    let name = parts
+        .next()
+        .ok_or_else(|| "Invalid plugin URI, missing name".to_string())?;
+    if parts.next().is_some() {
+        return Err("Invalid plugin URI format, expected devalang://plugin/<author>.<name>".into());
+    }
+
+    load_plugin(author, name)
+}

package/rust/core/plugin/mod.rs

@@ -1,2 +1,2 @@
-pub mod loader;
-pub mod runner;
+pub mod loader;
+pub mod runner;