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

package/rust/core/parser/statement.rs

@@ -1,11 +1,10 @@
-use crate::core::lexer::token::Token;
-
-pub use devalang_types::{Duration, Statement, StatementKind, Value};
-
-pub fn unknown_from_token(token: &Token) -> Statement {
-    Statement::unknown_with_pos(token.indent, token.line, token.column)
-}
-
-pub fn error_from_token(token: Token, message: String) -> Statement {
-    Statement::error_with_pos(token.indent, token.line, token.column, message)
-}
+use crate::core::lexer::token::Token;
+pub use devalang_types::{Duration, Statement, StatementKind, Value};
+
+pub fn unknown_from_token(token: &Token) -> Statement {
+    Statement::unknown_with_pos(token.indent, token.line, token.column)
+}
+
+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,137 +1,137 @@
-use devalang_types::{PluginExport, 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/runner/mod.rs

@@ -0,0 +1,11 @@
+#[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.rs → runner/non_wasm.rs}

@@ -1,24 +1,20 @@
+use devalang_utils::logger::{LogLevel, Logger};
 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();
@@ -95,7 +91,11 @@ impl WasmPluginRunner {
             .get_memory(&mut store, "memory")
             .ok_or_else(|| "WASM memory export not found".to_string())?;
 
-        // Try specific function first
+        // Try specific + generic entry points in order of preference.
+        // 1) render_note_<name>
+        // 2) render_note
+        // 3) synth_<name>
+        // 4) synth
         let mut func_opt: Option<RenderFunc> = None;
         if let Some(name) = synth_name {
             let specific = format!("render_note_{}", name);
@@ -106,7 +106,6 @@ impl WasmPluginRunner {
             }
         }
         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",
@@ -114,9 +113,27 @@ impl WasmPluginRunner {
                 func_opt = Some(f);
             }
         }
+        if func_opt.is_none() {
+            if let Some(name) = synth_name {
+                let specific = format!("synth_{}", 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, "synth")
+            {
+                func_opt = Some(f);
+            }
+        }
 
-        let func =
-            func_opt.ok_or_else(|| "Exported function `render_note` not found".to_string())?;
+        let func = func_opt.ok_or_else(|| {
+            "Exported function not found: tried render_note[_<name>] and synth[_<name>]".to_string()
+        })?;
 
         // Copy host buffer into wasm memory
         let byte_len = std::mem::size_of_val(buffer) as i32;
@@ -171,6 +188,7 @@ impl WasmPluginRunner {
         channels: i32,
         params_num: &HashMap<String, f32>,
         params_str: Option<&HashMap<String, String>>,
+        exported_names: Option<&[String]>,
     ) -> Result<(), String> {
         let module = Module::new(&self.engine, wasm_bytes)
             .map_err(|e| format!("Failed to compile wasm: {e}"))?;
@@ -187,32 +205,175 @@ impl WasmPluginRunner {
             .ok_or_else(|| "WASM memory export not found".to_string())?;
 
         // Call numeric setters if present: set_<param>(f32)
+        let logger = Logger::new();
         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);
+            // Candidate patterns in order of preference
+            let candidates = [
+                format!("set_synth_{}", k),
+                format!("set_{}", k),
+                format!("set_note_{}", k),
+            ];
+
+            let mut any_called = false;
+
+            // If exported_names provided, try only declared exports first
+            if let Some(exports) = exported_names {
+                logger.log_message(
+                    LogLevel::Debug,
+                    &format!("Plugin exports provided ({} names)", exports.len()),
+                );
+                for c in &candidates {
+                    if exports.iter().any(|e| e == c) {
+                        match instance.get_typed_func::<f32, ()>(&mut store, c) {
+                            Ok(setter) => {
+                                let _ = setter.call(&mut store, *v);
+                                any_called = true;
+                                logger.log_message(
+                                    LogLevel::Debug,
+                                    &format!("Called setter '{}' with {}", c, v),
+                                );
+                            }
+                            Err(_) => {
+                                logger.log_message(
+                                    LogLevel::Debug,
+                                    &format!("Export '{}' declared but signature lookup failed", c),
+                                );
+                            }
+                        }
+                    }
+                }
+            }
+
+            // If nothing was called using the metadata, fall back to dynamic lookup
+            if !any_called {
+                for fname in &candidates {
+                    match instance.get_typed_func::<f32, ()>(&mut store, fname) {
+                        Ok(setter) => {
+                            let _ = setter.call(&mut store, *v);
+                            any_called = true;
+                            logger.log_message(
+                                LogLevel::Debug,
+                                &format!("Dynamically called setter '{}' with {}", fname, v),
+                            );
+                        }
+                        Err(_) => {
+                            // no-op, continue
+                        }
+                    }
+                }
+            }
+
+            if !any_called {
+                logger.log_message(
+                    LogLevel::Warning,
+                    &format!("No setter found/called for numeric param '{}'", k),
+                );
             }
         }
 
-        // Call string setters if present: set_<param>_str(ptr: i32, len: i32)
+        // Call string setters if present: support set_synth_<param>_str, set_<param>_str, set_note_<param>_str
         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));
+                let candidates = [
+                    format!("set_synth_{}_str", k),
+                    format!("set_{}_str", k),
+                    format!("set_note_{}_str", k),
+                ];
+
+                let logger = Logger::new();
+                for (k, v) in smap.iter() {
+                    let candidates = [
+                        format!("set_synth_{}_str", k),
+                        format!("set_{}_str", k),
+                        format!("set_note_{}_str", k),
+                    ];
+
+                    let mut any_called = false;
+
+                    if let Some(exports) = exported_names {
+                        for c in &candidates {
+                            if exports.iter().any(|e| e == c) {
+                                match instance.get_typed_func::<(i32, i32), ()>(&mut store, c) {
+                                    Ok(setter) => {
+                                        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));
+                                        any_called = true;
+                                        logger.log_message(
+                                            LogLevel::Debug,
+                                            &format!("Called string setter '{}' with '{}'", c, v),
+                                        );
+                                    }
+                                    Err(_) => {
+                                        logger.log_message(
+                                            LogLevel::Debug,
+                                            &format!(
+                                                "Export '{}' declared but signature lookup failed",
+                                                c
+                                            ),
+                                        );
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    if !any_called {
+                        for fname in &candidates {
+                            if let Ok(setter) =
+                                instance.get_typed_func::<(i32, i32), ()>(&mut store, fname)
+                            {
+                                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));
+                                any_called = true;
+                                logger.log_message(
+                                    LogLevel::Debug,
+                                    &format!(
+                                        "Dynamically called string setter '{}' with '{}'",
+                                        fname, v
+                                    ),
+                                );
+                            }
+                        }
+                    }
+
+                    if !any_called {
+                        logger.log_message(
+                            LogLevel::Warning,
+                            &format!("No string setter found/called for param '{}'", k),
+                        );
+                    }
                 }
             }
         }
 
-        // Try specific or generic render function
+        // Try specific + generic entry points in order of preference.
+        // 1) render_note_<name>
+        // 2) render_note
+        // 3) synth_<name>
+        // 4) synth
         let mut func_opt: Option<RenderFunc> = None;
         if let Some(name) = synth_name {
             let specific = format!("render_note_{}", name);
@@ -230,8 +391,26 @@ impl WasmPluginRunner {
                 func_opt = Some(f);
             }
         }
-        let func =
-            func_opt.ok_or_else(|| "Exported function `render_note` not found".to_string())?;
+        if func_opt.is_none() {
+            if let Some(name) = synth_name {
+                let specific = format!("synth_{}", 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, "synth")
+            {
+                func_opt = Some(f);
+            }
+        }
+        let func = func_opt.ok_or_else(|| {
+            "Exported function not found: tried render_note[_<name>] and synth[_<name>]".to_string()
+        })?;
 
         // Copy host buffer into wasm memory
         let byte_len = std::mem::size_of_val(buffer) as i32;
@@ -300,48 +479,3 @@ 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())
-    }
-}