@devaloop/devalang 0.0.1-alpha.16-hotfix.3 → 0.0.1-alpha.18

package/rust/core/parser/statement.rs

@@ -1,142 +1,11 @@
-use crate::core::{
-    lexer::token::Token,
-    shared::{duration::Duration, value::Value},
-};
-use serde::{Deserialize, Serialize};
+use crate::core::lexer::token::Token;
 
-#[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 use devalang_types::{Duration, Statement, StatementKind, Value};
 
-    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,
-        }
-    }
+pub fn unknown_from_token(token: &Token) -> Statement {
+    Statement::unknown_with_pos(token.indent, token.line, 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,
-    },
+pub fn error_from_token(token: Token, message: String) -> Statement {
+    Statement::error_with_pos(token.indent, token.line, token.column, message)
 }

package/rust/core/plugin/loader.rs

@@ -1,19 +1,10 @@
+use devalang_types::{PluginExport, PluginInfo as SharedPluginInfo};
+use devalang_utils::path as path_utils;
 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 {
+struct LocalExportEntry {
     pub name: String,
     #[serde(rename = "type")]
     pub kind: String,
@@ -22,24 +13,29 @@ pub struct ExportEntry {
 }
 
 #[derive(Debug, Deserialize, Clone)]
-pub struct PluginFile {
-    pub plugin: PluginInfo,
+struct LocalPluginFile {
+    pub plugin: LocalPluginInfo,
     #[serde(default)]
-    pub export: Vec<ExportEntry>,
+    pub export: Vec<LocalExportEntry>,
 }
 
-/// 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));
+#[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("plugin").join(author).join(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));
@@ -74,20 +70,38 @@ pub fn load_plugin(author: &str, name: &str) -> Result<(PluginInfo, Vec<u8>), St
 
     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)
+    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))?;
 
-    let mut info = plugin_file.plugin.clone();
-    info.exports = plugin_file.export.clone();
+    // 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<(PluginInfo, Vec<u8>), String> {
+pub fn load_plugin_from_dot(dot: &str) -> Result<(SharedPluginInfo, Vec<u8>), String> {
     let mut parts = dot.split('.');
     let author = parts
         .next()
@@ -101,7 +115,7 @@ pub fn load_plugin_from_dot(dot: &str) -> Result<(PluginInfo, Vec<u8>), String>
     load_plugin(author, name)
 }
 
-pub fn load_plugin_from_uri(uri: &str) -> Result<(PluginInfo, Vec<u8>), String> {
+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());
     }

package/rust/core/plugin/runner.rs

@@ -1,10 +1,24 @@
 use std::collections::HashMap;
+
+#[cfg(not(target_arch = "wasm32"))]
 use wasmtime::{Engine, Instance, Linker, Module, Store, TypedFunc};
 
+#[cfg(not(target_arch = "wasm32"))]
+type RenderFunc = TypedFunc<(i32, i32, f32, f32, i32, i32, i32), ()>;
+
+#[cfg(not(target_arch = "wasm32"))]
 pub struct WasmPluginRunner {
     engine: Engine,
 }
 
+#[cfg(not(target_arch = "wasm32"))]
+impl Default for WasmPluginRunner {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
 impl WasmPluginRunner {
     pub fn new() -> Self {
         let engine = Engine::default();
@@ -18,38 +32,32 @@ impl WasmPluginRunner {
         let mut store = Store::new(&self.engine, ());
         let linker = Linker::new(&self.engine);
 
-        // Instantiate
         let instance = linker
             .instantiate(&mut store, &module)
             .map_err(|e| format!("Failed to instantiate wasm: {e}"))?;
 
-        // Get exports
         let memory = instance
             .get_memory(&mut store, "memory")
             .ok_or_else(|| "WASM memory export not found".to_string())?;
 
-        // wasm-bindgen usually exports a function taking (ptr: i32, len: i32) to represent &mut [f32]
         let func = instance
             .get_typed_func::<(i32, i32), ()>(&mut store, "process")
             .map_err(|_| "Exported function `process(i32,i32)` not found".to_string())?;
 
-        // Copy host buffer into wasm memory
-        let byte_len = (buffer.len() * std::mem::size_of::<f32>()) as i32;
+        let byte_len = std::mem::size_of_val(buffer) as i32;
         let ptr = Self::alloc_temp(&mut store, &instance, &memory, byte_len as usize)? as i32;
         let mem_slice = memory
             .data_mut(&mut store)
             .get_mut(ptr as usize..(ptr as usize) + (byte_len as usize))
             .ok_or_else(|| "Failed to get memory slice".to_string())?;
-        // Safety: same alignment/layout
+
         let src_bytes =
             unsafe { std::slice::from_raw_parts(buffer.as_ptr() as *const u8, byte_len as usize) };
         mem_slice.copy_from_slice(src_bytes);
 
-        // Call process
         func.call(&mut store, (ptr, buffer.len() as i32))
             .map_err(|e| format!("Error calling `process`: {e}"))?;
 
-        // Copy back
         let mem_slice_after = memory
             .data(&store)
             .get(ptr as usize..(ptr as usize) + (byte_len as usize))
@@ -62,8 +70,6 @@ impl WasmPluginRunner {
         Ok(())
     }
 
-    /// Render a note by invoking either `render_note_<name>` or a generic `render_note(ptr,len,freq,amp,duration_ms,sample_rate,channels)`.
-    /// The buffer is interleaved stereo if channels=2. The buffer is modified in place.
     pub fn render_note_in_place(
         &self,
         wasm_bytes: &[u8],
@@ -90,7 +96,7 @@ impl WasmPluginRunner {
             .ok_or_else(|| "WASM memory export not found".to_string())?;
 
         // Try specific function first
-        let mut func_opt: Option<TypedFunc<(i32, i32, f32, f32, i32, i32, i32), ()>> = None;
+        let mut func_opt: Option<RenderFunc> = None;
         if let Some(name) = synth_name {
             let specific = format!("render_note_{}", name);
             if let Ok(f) = instance
@@ -113,7 +119,7 @@ impl WasmPluginRunner {
             func_opt.ok_or_else(|| "Exported function `render_note` not found".to_string())?;
 
         // Copy host buffer into wasm memory
-        let byte_len = (buffer.len() * std::mem::size_of::<f32>()) as i32;
+        let byte_len = std::mem::size_of_val(buffer) as i32;
         let ptr = Self::alloc_temp(&mut store, &instance, &memory, byte_len as usize)? as i32;
         let mem_slice = memory
             .data_mut(&mut store)
@@ -207,7 +213,7 @@ impl WasmPluginRunner {
         }
 
         // Try specific or generic render function
-        let mut func_opt: Option<TypedFunc<(i32, i32, f32, f32, i32, i32, i32), ()>> = None;
+        let mut func_opt: Option<RenderFunc> = None;
         if let Some(name) = synth_name {
             let specific = format!("render_note_{}", name);
             if let Ok(f) = instance
@@ -228,7 +234,7 @@ impl WasmPluginRunner {
             func_opt.ok_or_else(|| "Exported function `render_note` not found".to_string())?;
 
         // Copy host buffer into wasm memory
-        let byte_len = (buffer.len() * std::mem::size_of::<f32>()) as i32;
+        let byte_len = std::mem::size_of_val(buffer) as i32;
         let ptr = Self::alloc_temp(&mut store, &instance, &memory, byte_len as usize)? as i32;
         let mem_slice = memory
             .data_mut(&mut store)
@@ -283,10 +289,10 @@ impl WasmPluginRunner {
         // Fallback: grow memory and use end of memory as scratch space
         let current_len = memory.data_size(&mut *store);
         let need = size;
-        let pages_needed = ((current_len + need + 0xffff) / 0x10000) as u64; // 64KiB pages
+        let pages_needed = (current_len + need).div_ceil(0x10000) as u64; // 64KiB pages
         let current_pages = memory.size(&mut *store);
-        if pages_needed > (current_pages as u64) {
-            let to_grow = pages_needed - (current_pages as u64);
+        if pages_needed > current_pages {
+            let to_grow = pages_needed - current_pages;
             memory
                 .grow(&mut *store, to_grow)
                 .map_err(|e| format!("memory.grow failed: {e}"))?;
@@ -294,3 +300,48 @@ impl WasmPluginRunner {
         Ok(current_len)
     }
 }
+
+// Provide a minimal stub for wasm32 target so the crate compiles there.
+#[cfg(target_arch = "wasm32")]
+pub struct WasmPluginRunner;
+
+#[cfg(target_arch = "wasm32")]
+impl WasmPluginRunner {
+    pub fn new() -> Self {
+        WasmPluginRunner
+    }
+
+    pub fn process_in_place(&self, _wasm_bytes: &[u8], _buffer: &mut [f32]) -> Result<(), String> {
+        Err("Wasm plugin execution is not available in wasm builds".to_string())
+    }
+
+    pub fn render_note_in_place(
+        &self,
+        _wasm_bytes: &[u8],
+        _buffer: &mut [f32],
+        _synth_name: Option<&str>,
+        _freq: f32,
+        _amp: f32,
+        _duration_ms: i32,
+        _sample_rate: i32,
+        _channels: i32,
+    ) -> Result<(), String> {
+        Err("Wasm plugin rendering is not available in wasm builds".to_string())
+    }
+
+    pub fn render_note_with_params_in_place(
+        &self,
+        _wasm_bytes: &[u8],
+        _buffer: &mut [f32],
+        _synth_name: Option<&str>,
+        _freq: f32,
+        _amp: f32,
+        _duration_ms: i32,
+        _sample_rate: i32,
+        _channels: i32,
+        _params_num: &HashMap<String, f32>,
+        _params_str: Option<&HashMap<String, String>>,
+    ) -> Result<(), String> {
+        Err("Wasm plugin rendering is not available in wasm builds".to_string())
+    }
+}