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

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;

package/rust/core/plugin/runner.rs

@@ -0,0 +1,296 @@
+use std::collections::HashMap;
+use wasmtime::{Engine, Instance, Linker, Module, Store, TypedFunc};
+
+pub struct WasmPluginRunner {
+    engine: Engine,
+}
+
+impl WasmPluginRunner {
+    pub fn new() -> Self {
+        let engine = Engine::default();
+        Self { engine }
+    }
+
+    pub fn process_in_place(&self, wasm_bytes: &[u8], buffer: &mut [f32]) -> Result<(), String> {
+        let module = Module::new(&self.engine, wasm_bytes)
+            .map_err(|e| format!("Failed to compile wasm: {e}"))?;
+
+        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 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))
+            .ok_or_else(|| "Failed to get memory slice after".to_string())?;
+        let dst_bytes = unsafe {
+            std::slice::from_raw_parts_mut(buffer.as_mut_ptr() as *mut u8, byte_len as usize)
+        };
+        dst_bytes.copy_from_slice(mem_slice_after);
+
+        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],
+        buffer: &mut [f32],
+        synth_name: Option<&str>,
+        freq: f32,
+        amp: f32,
+        duration_ms: i32,
+        sample_rate: i32,
+        channels: i32,
+    ) -> Result<(), String> {
+        let module = Module::new(&self.engine, wasm_bytes)
+            .map_err(|e| format!("Failed to compile wasm: {e}"))?;
+
+        let mut store = Store::new(&self.engine, ());
+        let linker = Linker::new(&self.engine);
+
+        let instance = linker
+            .instantiate(&mut store, &module)
+            .map_err(|e| format!("Failed to instantiate wasm: {e}"))?;
+
+        let memory = instance
+            .get_memory(&mut store, "memory")
+            .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;
+        if let Some(name) = synth_name {
+            let specific = format!("render_note_{}", name);
+            if let Ok(f) = instance
+                .get_typed_func::<(i32, i32, f32, f32, i32, i32, i32), ()>(&mut store, &specific)
+            {
+                func_opt = Some(f);
+            }
+        }
+        if func_opt.is_none() {
+            // fallback to generic name
+            if let Ok(f) = instance.get_typed_func::<(i32, i32, f32, f32, i32, i32, i32), ()>(
+                &mut store,
+                "render_note",
+            ) {
+                func_opt = Some(f);
+            }
+        }
+
+        let func =
+            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 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())?;
+        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 render
+        func.call(
+            &mut store,
+            (
+                ptr,
+                buffer.len() as i32,
+                freq,
+                amp,
+                duration_ms,
+                sample_rate,
+                channels,
+            ),
+        )
+        .map_err(|e| format!("Error calling `render_note`: {e}"))?;
+
+        // Copy back
+        let mem_slice_after = memory
+            .data(&store)
+            .get(ptr as usize..(ptr as usize) + (byte_len as usize))
+            .ok_or_else(|| "Failed to get memory slice after".to_string())?;
+        let dst_bytes = unsafe {
+            std::slice::from_raw_parts_mut(buffer.as_mut_ptr() as *mut u8, byte_len as usize)
+        };
+        dst_bytes.copy_from_slice(mem_slice_after);
+
+        Ok(())
+    }
+
+    /// Same as render_note_in_place, but first tries to call exported setters `set_<param>(f32)`
+    /// for each provided param before rendering. Ignored if setter is missing.
+    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> {
+        let module = Module::new(&self.engine, wasm_bytes)
+            .map_err(|e| format!("Failed to compile wasm: {e}"))?;
+
+        let mut store = Store::new(&self.engine, ());
+        let linker = Linker::new(&self.engine);
+
+        let instance = linker
+            .instantiate(&mut store, &module)
+            .map_err(|e| format!("Failed to instantiate wasm: {e}"))?;
+
+        let memory = instance
+            .get_memory(&mut store, "memory")
+            .ok_or_else(|| "WASM memory export not found".to_string())?;
+
+        // Call numeric setters if present: set_<param>(f32)
+        for (k, v) in params_num.iter() {
+            let fname = format!("set_{}", k);
+            if let Ok(setter) = instance.get_typed_func::<f32, ()>(&mut store, &fname) {
+                let _ = setter.call(&mut store, *v);
+            }
+        }
+
+        // Call string setters if present: set_<param>_str(ptr: i32, len: i32)
+        if let Some(smap) = params_str {
+            for (k, v) in smap.iter() {
+                let fname = format!("set_{}_str", k);
+                if let Ok(setter) = instance.get_typed_func::<(i32, i32), ()>(&mut store, &fname) {
+                    // Allocate and copy UTF-8 bytes into wasm memory
+                    let bytes = v.as_bytes();
+                    let ptr = Self::alloc_temp(&mut store, &instance, &memory, bytes.len())? as i32;
+                    let mem_slice = memory
+                        .data_mut(&mut store)
+                        .get_mut(ptr as usize..(ptr as usize) + bytes.len())
+                        .ok_or_else(|| "Failed to get memory slice for string".to_string())?;
+                    mem_slice.copy_from_slice(bytes);
+                    let _ = setter.call(&mut store, (ptr, bytes.len() as i32));
+                }
+            }
+        }
+
+        // Try specific or generic render function
+        let mut func_opt: Option<TypedFunc<(i32, i32, f32, f32, i32, i32, i32), ()>> = None;
+        if let Some(name) = synth_name {
+            let specific = format!("render_note_{}", name);
+            if let Ok(f) = instance
+                .get_typed_func::<(i32, i32, f32, f32, i32, i32, i32), ()>(&mut store, &specific)
+            {
+                func_opt = Some(f);
+            }
+        }
+        if func_opt.is_none() {
+            if let Ok(f) = instance.get_typed_func::<(i32, i32, f32, f32, i32, i32, i32), ()>(
+                &mut store,
+                "render_note",
+            ) {
+                func_opt = Some(f);
+            }
+        }
+        let func =
+            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 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())?;
+        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 render
+        func.call(
+            &mut store,
+            (
+                ptr,
+                buffer.len() as i32,
+                freq,
+                amp,
+                duration_ms,
+                sample_rate,
+                channels,
+            ),
+        )
+        .map_err(|e| format!("Error calling `render_note`: {e}"))?;
+
+        // Copy back
+        let mem_slice_after = memory
+            .data(&store)
+            .get(ptr as usize..(ptr as usize) + (byte_len as usize))
+            .ok_or_else(|| "Failed to get memory slice after".to_string())?;
+        let dst_bytes = unsafe {
+            std::slice::from_raw_parts_mut(buffer.as_mut_ptr() as *mut u8, byte_len as usize)
+        };
+        dst_bytes.copy_from_slice(mem_slice_after);
+
+        Ok(())
+    }
+
+    fn alloc_temp(
+        store: &mut Store<()>,
+        instance: &Instance,
+        memory: &wasmtime::Memory,
+        size: usize,
+    ) -> Result<usize, String> {
+        // Try to use an exported `__wbindgen_malloc` if present; otherwise, grow memory manually.
+        if let Ok(malloc) = instance.get_typed_func::<i32, i32>(&mut *store, "__wbindgen_malloc") {
+            let ptr = malloc
+                .call(&mut *store, size as i32)
+                .map_err(|e| format!("malloc failed: {e}"))? as usize;
+            return Ok(ptr);
+        }
+
+        // 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 current_pages = memory.size(&mut *store);
+        if pages_needed > (current_pages as u64) {
+            let to_grow = pages_needed - (current_pages as u64);
+            memory
+                .grow(&mut *store, to_grow)
+                .map_err(|e| format!("memory.grow failed: {e}"))?;
+        }
+        Ok(current_len)
+    }
+}