@devaloop/devalang 0.0.1-alpha.16-hotfix.1 → 0.0.1-alpha.17

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())
+    }
+}

package/rust/core/preprocessor/loader.rs

@@ -1,24 +1,25 @@
+#[cfg(feature = "cli")]
 use crate::core::preprocessor::resolver::driver::{
     resolve_all_modules, resolve_and_flatten_all_modules,
 };
+#[cfg(feature = "cli")]
 use crate::core::utils::path::resolve_relative_path;
-use crate::{
-    config::loader::load_config,
-    core::{
-        error::ErrorHandler,
-        lexer::{Lexer, token::Token},
-        parser::{
-            driver::Parser,
-            statement::{Statement, StatementKind},
-        },
-        plugin::loader::load_plugin,
-        preprocessor::{module::Module, processor::process_modules},
-        shared::{bank::BankFile, value::Value},
-        store::global::GlobalStore,
-        utils::path::normalize_path,
+#[cfg_attr(not(feature = "cli"), allow(unused_imports))]
+use crate::core::{
+    error::ErrorHandler,
+    lexer::{Lexer, token::Token},
+    parser::{
+        driver::Parser,
+        statement::{Statement, StatementKind},
     },
-    utils::logger::Logger,
+    plugin::loader::load_plugin,
+    preprocessor::{module::Module, processor::process_modules},
+    store::global::GlobalStore,
+    utils::path::normalize_path,
 };
+use devalang_types::{BankFile, Value};
+#[cfg(feature = "cli")]
+use devalang_utils::logger::{LogLevel, Logger};
 use std::{collections::HashMap, path::Path};
 
 pub struct ModuleLoader {
@@ -38,7 +39,7 @@ impl ModuleLoader {
         Self {
             entry: entry.to_string(),
             output: output.to_string(),
-            base_dir: base_dir,
+            base_dir,
         }
     }
 
@@ -50,9 +51,12 @@ impl ModuleLoader {
     ) -> Self {
         let normalized_entry_path = normalize_path(entry_path);
 
-        let mut module = Module::new(&entry_path);
+        let mut module = Module::new(entry_path);
         module.content = content.to_string();
 
+        // Insert a module stub containing the provided content into the
+        // global store. This is used by the WASM APIs and tests which
+        // operate on in-memory sources instead of files on disk.
         global_store.insert_module(normalized_entry_path.to_string(), module);
 
         Self {
@@ -145,6 +149,17 @@ impl ModuleLoader {
             return Err(format!("Failed to inject bank triggers: {}", e));
         }
 
+        // Insert the updated module into the global store before processing so
+        // process_modules can operate on it and populate variable_table, imports,
+        // and other derived structures.
+        global_store
+            .modules
+            .insert(self.entry.clone(), updated_module.clone());
+
+        // Process modules to populate module.variable_table, import/export tables,
+        // and other derived structures so runtime execution can resolve groups/synths.
+        process_modules(self, global_store);
+
         for (plugin_name, alias) in self.extract_plugin_uses(&updated_module.statements) {
             self.load_plugin_and_register(&mut updated_module, &plugin_name, &alias, global_store);
         }
@@ -153,10 +168,32 @@ impl ModuleLoader {
         let mut error_handler = ErrorHandler::new();
         error_handler.detect_from_statements(&mut parser, &updated_module.statements);
 
-        // Final step : insert the updated module back into the global store
-        global_store
-            .modules
-            .insert(self.entry.clone(), updated_module);
+        // Final step : also expose module-level variables and functions into the global store
+        // so runtime evaluation (render_audio) can find group/synth definitions.
+        // Use the module instance that was actually processed by `process_modules`
+        // (it lives in `global_store.modules`) because `updated_module` is a local
+        // clone and won't contain the mutations applied by `process_modules`.
+        if let Some(stored_module) = global_store.modules.get(&self.entry) {
+            global_store
+                .variables
+                .variables
+                .extend(stored_module.variable_table.variables.clone());
+            global_store
+                .functions
+                .functions
+                .extend(stored_module.function_table.functions.clone());
+        } else {
+            // Fallback to the local updated_module if for any reason the module
+            // wasn't inserted into the store (defensive programming).
+            global_store
+                .variables
+                .variables
+                .extend(updated_module.variable_table.variables.clone());
+            global_store
+                .functions
+                .functions
+                .extend(updated_module.function_table.functions.clone());
+        }
 
         Ok(())
     }
@@ -193,7 +230,14 @@ impl ModuleLoader {
         }
 
         let lexer = Lexer::new();
-        let tokens = lexer.lex_tokens(&path);
+        let tokens = match lexer.lex_tokens(&path) {
+            Ok(t) => t,
+            Err(e) => {
+                let logger = Logger::new();
+                logger.log_message(LogLevel::Error, &format!("Failed to lex '{}': {}", path, e));
+                return HashMap::new();
+            }
+        };
 
         let mut parser = Parser::new();
         parser.set_current_module(path.clone());
@@ -295,10 +339,17 @@ impl ModuleLoader {
         bank_name: &str,
         alias_override: Option<String>,
     ) -> Result<Module, String> {
-        let default_alias = bank_name.split('.').last().unwrap_or(bank_name).to_string();
+        let default_alias = bank_name
+            .split('.')
+            .next_back()
+            .unwrap_or(bank_name)
+            .to_string();
         let alias_ref = alias_override.as_deref().unwrap_or(&default_alias);
 
-        let bank_path = Path::new("./.deva/bank").join(bank_name);
+        let bank_path = match devalang_utils::path::get_deva_dir() {
+            Ok(dir) => dir.join("banks").join(bank_name),
+            Err(_) => Path::new("./.deva").join("banks").join(bank_name),
+        };
         let bank_toml_path = bank_path.join("bank.toml");
 
         if !bank_toml_path.exists() {
@@ -314,9 +365,18 @@ impl ModuleLoader {
         let mut bank_map = HashMap::new();
 
         for bank_trigger in parsed_bankfile.triggers.unwrap_or_default() {
-            let trigger_name = bank_trigger.name.clone().replace("./", "");
-            let bank_trigger_path = format!("devalang://bank/{}/{}", bank_name, trigger_name);
-
+            // Use the configured path from the bank file as the entity reference so
+            // that bank entries can point to files or nested paths. Clean common
+            // local prefixes like "./" to keep the URI tidy.
+            let entity_ref = bank_trigger
+                .path
+                .clone()
+                .replace("\\", "/")
+                .replace("./", "");
+            let bank_trigger_path = format!("devalang://bank/{}/{}", bank_name, entity_ref);
+
+            // Keep the trigger key as declared (bank_trigger.name) but expose its
+            // value as a devalang://bank URI pointing to the configured path.
             bank_map.insert(
                 bank_trigger.name.clone(),
                 Value::String(bank_trigger_path.clone()),
@@ -344,6 +404,7 @@ impl ModuleLoader {
         Ok(module.clone())
     }
 
+    #[cfg_attr(not(feature = "cli"), allow(dead_code))]
     fn extract_bank_decls(&self, statements: &[Statement]) -> Vec<(String, Option<String>)> {
         let mut banks = Vec::new();
 
@@ -371,7 +432,7 @@ impl ModuleLoader {
             if let StatementKind::Use { name, alias } = &stmt.kind {
                 let alias_name = alias
                     .clone()
-                    .unwrap_or_else(|| name.split('.').last().unwrap_or(name).to_string());
+                    .unwrap_or_else(|| name.split('.').next_back().unwrap_or(name).to_string());
                 plugins.push((name.clone(), alias_name));
             }
         }
@@ -415,16 +476,19 @@ impl ModuleLoader {
         let expected_uri = format!("devalang://plugin/{}.{}", author, name);
 
         // Detect local presence (preferred and legacy layouts)
-        let root = Path::new("./.deva");
-        let plugin_dir_preferred = root.join("plugin").join(format!("{}.{}", author, name));
+        let root = match devalang_utils::path::get_deva_dir() {
+            Ok(dir) => dir,
+            Err(_) => Path::new("./.deva").to_path_buf(),
+        };
+        let plugin_dir_preferred = root.join("plugins").join(format!("{}.{}", author, name));
         let toml_path_preferred = plugin_dir_preferred.join("plugin.toml");
-        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 exists_locally = toml_path_preferred.exists() || toml_path_fallback.exists();
 
         if exists_locally {
             // Load config and verify plugin is declared
-            let cfg_opt = load_config(None);
+            let cfg_opt = crate::config::ops::load_config(None);
             let mut declared = false;
             if let Some(cfg) = cfg_opt {
                 if let Some(list) = cfg.plugins {
@@ -457,6 +521,11 @@ impl ModuleLoader {
                 module
                     .variable_table
                     .set(alias.to_string(), Value::String(uri.clone()));
+                // Also expose alias at global level so runtime can resolve it
+                global_store
+                    .variables
+                    .set(alias.to_string(), Value::String(uri.clone()));
+
                 if let Some((plugin_info, _)) =
                     global_store.plugins.get(&format!("{}:{}", author, name))
                 {
@@ -504,7 +573,60 @@ impl ModuleLoader {
                                     Value::String(format!("{}.{}", alias, exp.name)),
                                 );
                             }
-                            _ => {}
+                            _ => {
+                                // Fallback: if default is present, map it to a Value dynamically
+                                if let Some(def) = &exp.default {
+                                    let val = match def {
+                                        toml::Value::String(s) => Value::String(s.clone()),
+                                        toml::Value::Integer(i) => Value::Number(*i as f32),
+                                        toml::Value::Float(f) => Value::Number(*f as f32),
+                                        toml::Value::Boolean(b) => Value::Boolean(*b),
+                                        toml::Value::Array(arr) => Value::Array(
+                                            arr.iter()
+                                                .map(|v| match v {
+                                                    toml::Value::String(s) => {
+                                                        Value::String(s.clone())
+                                                    }
+                                                    toml::Value::Integer(i) => {
+                                                        Value::Number(*i as f32)
+                                                    }
+                                                    toml::Value::Float(f) => {
+                                                        Value::Number(*f as f32)
+                                                    }
+                                                    toml::Value::Boolean(b) => Value::Boolean(*b),
+                                                    _ => Value::Null,
+                                                })
+                                                .collect(),
+                                        ),
+                                        toml::Value::Table(t) => {
+                                            let mut m = std::collections::HashMap::new();
+                                            for (k, v) in t.iter() {
+                                                let vv = match v {
+                                                    toml::Value::String(s) => {
+                                                        Value::String(s.clone())
+                                                    }
+                                                    toml::Value::Integer(i) => {
+                                                        Value::Number(*i as f32)
+                                                    }
+                                                    toml::Value::Float(f) => {
+                                                        Value::Number(*f as f32)
+                                                    }
+                                                    toml::Value::Boolean(b) => Value::Boolean(*b),
+                                                    _ => Value::Null,
+                                                };
+                                                m.insert(k.clone(), vv);
+                                            }
+                                            Value::Map(m)
+                                        }
+                                        _ => Value::Null,
+                                    };
+                                    if val != Value::Null {
+                                        module
+                                            .variable_table
+                                            .set(format!("{}.{}", alias, exp.name), val);
+                                    }
+                                }
+                            }
                         }
                     }
                 }

package/rust/core/preprocessor/processor.rs

@@ -3,10 +3,10 @@ use std::{collections::HashMap, path::Path};
 use crate::core::{
     parser::statement::StatementKind,
     preprocessor::loader::ModuleLoader,
-    shared::value::Value,
     store::global::GlobalStore,
     utils::path::{normalize_path, resolve_relative_path},
 };
+use devalang_types::Value;
 
 pub fn process_modules(_module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
     for module in global_store.modules.values_mut() {
@@ -46,7 +46,7 @@ pub fn process_modules(_module_loader: &ModuleLoader, global_store: &mut GlobalS
                 StatementKind::Load { source, alias } => {
                     let module_dir = Path::new(&module.path).parent().unwrap_or(Path::new(""));
 
-                    let resolved_path = normalize_path(&module_dir.join(source));
+                    let resolved_path = normalize_path(module_dir.join(source));
 
                     module
                         .variable_table

package/rust/core/preprocessor/resolver/bank.rs

@@ -1,12 +1,10 @@
-use crate::{
-    core::{
-        parser::statement::{Statement, StatementKind},
-        preprocessor::module::Module,
-        shared::value::Value,
-        store::global::GlobalStore,
-    },
-    utils::logger::Logger,
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::module::Module,
+    store::global::GlobalStore,
 };
+use devalang_types::Value;
+use devalang_utils::logger::Logger;
 
 pub fn resolve_bank(
     stmt: &Statement,