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

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

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

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

@@ -1,47 +1,53 @@
-use crate::core::{
-    lexer::token::TokenKind,
-    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
-    shared::value::Value,
-    store::global::GlobalStore,
-};
-
-pub fn parse_tempo_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
-    parser.advance(); // consume 'bpm'
-
-    let Some(tempo_token) = parser.previous_clone() else {
-        return Statement::unknown();
-    };
-
-    // Expect a number or identifier
-    let Some(value_token) = parser.peek_clone() else {
-        return Statement::error(
-            tempo_token,
-            "Expected a number or identifier after 'bpm'".to_string()
-        );
-    };
-
-    let value = match value_token.kind {
-        TokenKind::Number => {
-            parser.advance();
-            Value::Number(value_token.lexeme.parse().unwrap_or(0.0))
-        }
-        TokenKind::Identifier => {
-            parser.advance();
-            Value::Identifier(value_token.lexeme.clone())
-        }
-        _ => {
-            return Statement::error(
-                value_token.clone(),
-                format!("Expected a number or identifier after 'bpm', got {:?}", value_token.kind)
-            );
-        }
-    };
-
-    Statement {
-        kind: StatementKind::Tempo,
-        value,
-        indent: tempo_token.indent,
-        line: tempo_token.line,
-        column: tempo_token.column,
-    }
-}
+use crate::core::{
+    lexer::token::TokenKind,
+    parser::{
+        driver::Parser,
+        statement::{Statement, StatementKind},
+    },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+pub fn parse_tempo_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
+    parser.advance(); // consume 'bpm'
+
+    let Some(tempo_token) = parser.previous_clone() else {
+        return Statement::unknown();
+    };
+
+    // Expect a number or identifier
+    let Some(value_token) = parser.peek_clone() else {
+        return Statement::error(
+            tempo_token,
+            "Expected a number or identifier after 'bpm'".to_string(),
+        );
+    };
+
+    let value = match value_token.kind {
+        TokenKind::Number => {
+            parser.advance();
+            Value::Number(value_token.lexeme.parse().unwrap_or(0.0))
+        }
+        TokenKind::Identifier => {
+            parser.advance();
+            Value::Identifier(value_token.lexeme.clone())
+        }
+        _ => {
+            return Statement::error(
+                value_token.clone(),
+                format!(
+                    "Expected a number or identifier after 'bpm', got {:?}",
+                    value_token.kind
+                ),
+            );
+        }
+    };
+
+    Statement {
+        kind: StatementKind::Tempo,
+        value,
+        indent: tempo_token.indent,
+        line: tempo_token.line,
+        column: tempo_token.column,
+    }
+}

package/rust/core/parser/mod.rs

@@ -1,4 +1,4 @@
-pub mod driver;
-
-pub mod statement;
-pub mod handler;
+pub mod driver;
+
+pub mod handler;
+pub mod statement;

package/rust/core/parser/statement.rs

@@ -1,113 +1,142 @@
-use serde::{ Deserialize, Serialize };
-use crate::core::{ lexer::token::Token, shared::{ duration::Duration, value::Value } };
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct Statement {
-    pub kind: StatementKind,
-    pub value: Value,
-    pub indent: usize,
-    pub line: usize,
-    pub column: usize,
-}
-
-impl Statement {
-    pub fn unknown() -> Self {
-        Statement {
-            kind: StatementKind::Unknown,
-            value: Value::Null,
-            indent: 0,
-            line: 0,
-            column: 0,
-        }
-    }
-
-    pub fn error(token: Token, message: String) -> Self {
-        Statement {
-            kind: StatementKind::Error { message },
-            value: Value::Null,
-            indent: token.indent,
-            line: token.line,
-            column: token.column,
-        }
-    }
-}
-
-#[derive(Debug, Serialize, Clone, Deserialize, PartialEq)]
-pub enum StatementKind {
-    // ───── Core Instructions ─────
-    Tempo,
-    Bank,
-    Print,
-    Load {
-        source: String,
-        alias: String,
-    },
-    Let {
-        name: String,
-    },
-    // Automation of parameters over time (percent-based envelopes)
-    Automate {
-        target: String,
-    },
-    ArrowCall {
-        target: String,
-        method: String,
-        args: Vec<Value>,
-    },
-    Function {
-        name: String,
-        parameters: Vec<String>,
-        body: Vec<Statement>,
-    },
-
-    // ───── Instruments ─────
-    Synth,
-
-    // ───── Playback / Scheduling ─────
-    Trigger {
-        entity: String,
-        duration: Duration,
-        effects: Option<Value>,
-    },
-    Sleep,
-    Call {
-        name: String,
-        args: Vec<Value>,
-    },
-    Spawn {
-        name: String,
-        args: Vec<Value>,
-    },
-    Loop,
-
-    // ───── Structure & Logic ─────
-    Group,
-
-    // ───── Module System ─────
-    Include(String),
-    Export {
-        names: Vec<String>,
-        source: String,
-    },
-    Import {
-        names: Vec<String>,
-        source: String,
-    },
-
-    // ───── Conditions ─────
-    If,
-    Else,
-    ElseIf,
-
-    // ───── Internal / Utility ─────
-    Comment,
-    Indent,
-    Dedent,
-    NewLine,
-
-    // ───── Error Handling ─────
-    Unknown,
-    Error {
-        message: String,
-    },
-}
+use crate::core::{
+    lexer::token::Token,
+    shared::{duration::Duration, value::Value},
+};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct Statement {
+    pub kind: StatementKind,
+    pub value: Value,
+    pub indent: usize,
+    pub line: usize,
+    pub column: usize,
+}
+
+impl Statement {
+    pub fn unknown() -> Self {
+        Statement {
+            kind: StatementKind::Unknown,
+            value: Value::Null,
+            indent: 0,
+            line: 0,
+            column: 0,
+        }
+    }
+
+    pub fn unknown_from_token(token: &Token) -> Self {
+        Statement {
+            kind: StatementKind::Unknown,
+            value: Value::Null,
+            indent: token.indent,
+            line: token.line,
+            column: token.column,
+        }
+    }
+
+    pub fn error(token: Token, message: String) -> Self {
+        Statement {
+            kind: StatementKind::Error { message },
+            value: Value::Null,
+            indent: token.indent,
+            line: token.line,
+            column: token.column,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Clone, Deserialize, PartialEq)]
+pub enum StatementKind {
+    // ───── Core Instructions ─────
+    Tempo,
+    Bank {
+        alias: Option<String>,
+    },
+    Print,
+    Load {
+        source: String,
+        alias: String,
+    },
+    Use {
+        name: String,
+        alias: Option<String>,
+    },
+    Let {
+        name: String,
+    },
+    Automate {
+        target: String,
+    },
+    ArrowCall {
+        target: String,
+        method: String,
+        args: Vec<Value>,
+    },
+    Function {
+        name: String,
+        parameters: Vec<String>,
+        body: Vec<Statement>,
+    },
+
+    // ───── Instruments ─────
+    Synth,
+
+    // ───── Playback / Scheduling ─────
+    Trigger {
+        entity: String,
+        duration: Duration,
+        effects: Option<Value>,
+    },
+    Sleep,
+    Call {
+        name: String,
+        args: Vec<Value>,
+    },
+    Spawn {
+        name: String,
+        args: Vec<Value>,
+    },
+    Loop,
+
+    // ───── Structure & Logic ─────
+    Group,
+
+    // ───── Module System ─────
+    Include(String),
+    Export {
+        names: Vec<String>,
+        source: String,
+    },
+    Import {
+        names: Vec<String>,
+        source: String,
+    },
+
+    // ───── Conditions ─────
+    If,
+    Else,
+    ElseIf,
+
+    // ───── Internal / Utility ─────
+    Comment,
+    Indent,
+    Dedent,
+    NewLine,
+
+    // ───── Events / Live coding ─────
+    On {
+        event: String,
+        args: Option<Vec<Value>>,
+        body: Vec<Statement>,
+    },
+    Emit {
+        event: String,
+        payload: Option<Value>,
+    },
+
+    // ───── Error Handling ─────
+    Unknown,
+    Error {
+        message: String,
+    },
+}

package/rust/core/plugin/loader.rs

@@ -1,48 +1,123 @@
-use std::path::Path;
-use serde::Deserialize;
-
-#[derive(Debug, Deserialize, Clone)]
-pub struct PluginInfo {
-    pub name: String,
-    pub version: Option<String>,
-    pub description: Option<String>,
-    pub author: Option<String>,
-}
-
-#[derive(Debug, Deserialize, Clone)]
-pub struct PluginFile {
-    pub plugin: PluginInfo,
-}
-
-pub fn load_plugin(name: &str) -> Result<(PluginInfo, Vec<u8>), String> {
-    let root = Path::new(env!("CARGO_MANIFEST_DIR"));
-    let plugin_dir = root.join(".deva").join("plugin").join(name);
-    let toml_path = plugin_dir.join("plugin.toml");
-    let wasm_path = plugin_dir.join(format!("{}_bg.wasm", name));
-
-    if !toml_path.exists() {
-        return Err(format!("❌ Plugin file not found: {}", toml_path.display()));
-    }
-    if !wasm_path.exists() {
-        return Err(format!("❌ Plugin wasm not found: {}", wasm_path.display()));
-    }
-
-    let toml_content = std::fs::read_to_string(&toml_path)
-        .map_err(|e| format!("Failed to read '{}': {}", toml_path.display(), e))?;
-    let plugin_file: PluginFile = toml::from_str(&toml_content)
-        .map_err(|e| format!("Failed to parse '{}': {}", toml_path.display(), e))?;
-
-    let wasm_bytes = std::fs::read(&wasm_path)
-        .map_err(|e| format!("Failed to read '{}': {}", wasm_path.display(), e))?;
-
-    Ok((plugin_file.plugin, wasm_bytes))
-}
-
-pub fn load_plugin_from_uri(uri: &str) -> Result<(PluginInfo, Vec<u8>), String> {
-    if !uri.starts_with("devalang://plugin/") {
-        return Err("Invalid plugin URI".into());
-    }
-
-    let name = uri.trim_start_matches("devalang://plugin/");
-    load_plugin(name)
-}
+use serde::Deserialize;
+use std::path::Path;
+use toml::Value as TomlValue;
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct PluginInfo {
+    pub name: String,
+    pub version: Option<String>,
+    pub description: Option<String>,
+    pub author: Option<String>,
+    #[serde(skip)]
+    pub exports: Vec<ExportEntry>,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct ExportEntry {
+    pub name: String,
+    #[serde(rename = "type")]
+    pub kind: String,
+    #[serde(default)]
+    pub default: Option<TomlValue>,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct PluginFile {
+    pub plugin: PluginInfo,
+    #[serde(default)]
+    pub export: Vec<ExportEntry>,
+}
+
+/// Load a plugin from local .deva directory given author and name
+pub fn load_plugin(author: &str, name: &str) -> Result<(PluginInfo, Vec<u8>), String> {
+    // Align with other loaders (banks) that use relative ./.deva paths
+    let root = Path::new("./.deva");
+    // Preferred layout: ./.deva/plugin/<author>.<name>/
+    let plugin_dir_preferred = root.join("plugin").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("plugin").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: PluginFile = toml::from_str(&toml_content)
+        .map_err(|e| format!("Failed to parse '{}': {}", toml_path.display(), e))?;
+
+    let wasm_bytes = std::fs::read(&wasm_path)
+        .map_err(|e| format!("Failed to read '{}': {}", wasm_path.display(), e))?;
+
+    let mut info = plugin_file.plugin.clone();
+    info.exports = plugin_file.export.clone();
+
+    Ok((info, wasm_bytes))
+}
+
+/// Load a plugin from dot notation: "author.name"
+pub fn load_plugin_from_dot(dot: &str) -> Result<(PluginInfo, 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<(PluginInfo, 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 +1,2 @@
-pub mod loader;
+pub mod loader;
+pub mod runner;