@devaloop/devalang 0.0.1-beta.2 → 0.1.1

package/rust/core/plugin/loader.rs

@@ -1,137 +0,0 @@
-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)
-}

package/rust/core/plugin/mod.rs

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

package/rust/core/plugin/runner/mod.rs

@@ -1,11 +0,0 @@
-#[cfg(not(target_arch = "wasm32"))]
-mod non_wasm;
-
-#[cfg(target_arch = "wasm32")]
-mod wasm32;
-
-#[cfg(not(target_arch = "wasm32"))]
-pub use non_wasm::WasmPluginRunner;
-
-#[cfg(target_arch = "wasm32")]
-pub use wasm32::WasmPluginRunner;

package/rust/core/plugin/runner/non_wasm.rs

@@ -1,297 +0,0 @@
-use std::collections::HashMap;
-
-use wasmtime::{Engine, Instance, Linker, Module, Store, TypedFunc};
-
-type RenderFunc = TypedFunc<(i32, i32, f32, f32, i32, i32, i32), ()>;
-
-pub struct WasmPluginRunner {
-    engine: Engine,
-}
-
-impl Default for WasmPluginRunner {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-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);
-
-        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())?;
-
-        let func = instance
-            .get_typed_func::<(i32, i32), ()>(&mut store, "process")
-            .map_err(|_| "Exported function `process(i32,i32)` not found".to_string())?;
-
-        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())?;
-
-        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);
-
-        func.call(&mut store, (ptr, buffer.len() as i32))
-            .map_err(|e| format!("Error calling `process`: {e}"))?;
-
-        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(())
-    }
-
-    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<RenderFunc> = 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 = 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())?;
-        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<RenderFunc> = 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 = 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())?;
-        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).div_ceil(0x10000) as u64; // 64KiB pages
-        let current_pages = memory.size(&mut *store);
-        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}"))?;
-        }
-        Ok(current_len)
-    }
-}

package/rust/core/plugin/runner/wasm32.rs

@@ -1,43 +0,0 @@
-use std::collections::HashMap;
-
-pub struct WasmPluginRunner;
-
-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())
-    }
-}