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

package/rust/macros/src/lib.rs

@@ -0,0 +1,52 @@
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{ parse_macro_input, ItemFn, LitStr };
+
+#[proc_macro_attribute]
+pub fn export_plugin(args: TokenStream, item: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(item as ItemFn);
+
+    // default export name = function name
+    let export_name = if args.is_empty() {
+        input.sig.ident.to_string()
+    } else {
+        // accept single string literal: #[export_plugin("synth")]
+        let s = parse_macro_input!(args as LitStr);
+        s.value()
+    };
+
+    let fn_ident = &input.sig.ident;
+    let vis = &input.vis;
+    let sig = &input.sig;
+    let block = &input.block;
+
+    let wrapper_ident = syn::Ident::new(&export_name, fn_ident.span());
+
+    let expanded =
+        quote! {
+        #vis #sig #block
+
+        #[no_mangle]
+        pub extern "C" fn #wrapper_ident(
+            out_ptr: *mut f32,
+            out_len: i32,
+            freq: f32,
+            amp: f32,
+            duration_ms: i32,
+            sample_rate: i32,
+            channels: i32,
+        ) {
+            if out_ptr.is_null() { return; }
+            let out_len_usz = out_len.max(0) as usize;
+            let ch = channels.max(1) as usize;
+            let frames = (out_len_usz / ch) as u32;
+            let params = devalang_bindings::BufferParams { sample_rate: sample_rate.max(1) as u32, channels: channels.max(1) as u32, frames };
+            unsafe {
+                let out = core::slice::from_raw_parts_mut(out_ptr, out_len_usz);
+                #fn_ident(out, params, devalang_bindings::Note::default(), freq, amp, duration_ms.max(1) as u32);
+            }
+        }
+    };
+
+    TokenStream::from(expanded)
+}

package/rust/main.rs

@@ -5,38 +5,38 @@ pub mod config;
 pub mod core;
 pub mod web;
 pub use devalang_utils as utils;
-use devalang_utils::path::ensure_deva_dir;
 
+use crate::cli::addon::commands::handle_install_addon_command;
+use crate::cli::addon::commands::handle_list_addon_command;
+use crate::cli::addon::commands::handle_remove_addon_command;
+use crate::cli::addon::commands::handle_update_addon_command;
+use crate::cli::me::commands::handle_me_command;
+use crate::cli::parser::AddonCommand;
 use crate::cli::telemetry::send::send_telemetry_event;
 use crate::config::settings::ensure_user_config_file_exists;
 use crate::config::settings::write_user_config_file;
 use crate::{
     cli::{
-        bank::{
-            handle_bank_available_command, handle_bank_info_command, handle_bank_list_command,
-            handle_remove_bank_command, handle_update_bank_command,
-        },
         build::commands::handle_build_command,
         check::handle_check_command,
         discover::commands::handle_discover_command,
         init::commands::handle_init_command,
-        install::commands::handle_install_command,
         login::commands::handle_login_command,
-        parser::{BankCommand, Cli, Commands, InstallCommand, TelemetryCommand, TemplateCommand},
+        parser::{Cli, Commands, TelemetryCommand, TemplateCommand},
         play::commands::handle_play_command,
         telemetry::{
             commands::{handle_telemetry_disable_command, handle_telemetry_enable_command},
             event_creator::{TelemetryEventCreator, TelemetryEventExt},
         },
         template::commands::{handle_template_info_command, handle_template_list_command},
-        update::commands::handle_update_command,
     },
     config::driver::ProjectConfig,
     utils::first_usage::check_is_first_usage,
 };
 use clap::CommandFactory;
 use clap::FromArgMatches;
-use devalang_types::{AddonType, TelemetryErrorLevel};
+use devalang_types::TelemetryErrorLevel;
+use devalang_utils::path::ensure_deva_dir;
 use std::io;
 
 #[tokio::main]
@@ -107,7 +107,7 @@ async fn main() -> io::Result<()> {
                 let logger = devalang_utils::logger::Logger::new();
                 logger.log_message(
                     devalang_utils::logger::LogLevel::Error,
-                    &format!("❌ Check failed: {}", err),
+                    &format!("[error] Check failed: {}", err),
                 );
                 had_error = true;
                 last_error_message = Some(format!("check failed: {}", err));
@@ -121,12 +121,25 @@ async fn main() -> io::Result<()> {
             watch,
             debug,
             compress,
+            output_format,
+            audio_format,
+            sample_rate,
         } => {
-            if let Err(err) = handle_build_command(config, entry, output, watch, debug, compress) {
+            if let Err(err) = handle_build_command(
+                config,
+                entry,
+                output,
+                output_format,
+                audio_format,
+                sample_rate,
+                watch,
+                debug,
+                compress,
+            ) {
                 let logger = devalang_utils::logger::Logger::new();
                 logger.log_message(
                     devalang_utils::logger::LogLevel::Error,
-                    &format!("❌ Build failed: {}", err),
+                    &format!("[error] Build failed: {}", err),
                 );
                 had_error = true;
                 last_error_message = Some(format!("build failed: {}", err));
@@ -137,15 +150,26 @@ async fn main() -> io::Result<()> {
         Commands::Play {
             entry,
             output,
+            sample_rate,
             watch,
             repeat,
             debug,
+            audio_format,
         } => {
-            if let Err(err) = handle_play_command(config, entry, output, watch, repeat, debug) {
+            if let Err(err) = handle_play_command(
+                config,
+                entry,
+                output,
+                audio_format,
+                sample_rate,
+                watch,
+                repeat,
+                debug,
+            ) {
                 let logger = devalang_utils::logger::Logger::new();
                 logger.log_message(
                     devalang_utils::logger::LogLevel::Error,
-                    &format!("❌ Play failed: {}", err),
+                    &format!("[error] Play failed: {}", err),
                 );
                 had_error = true;
                 last_error_message = Some(format!("play failed: {}", err));
@@ -153,144 +177,300 @@ async fn main() -> io::Result<()> {
             }
         }
 
-        Commands::Install { command } => match command {
-            InstallCommand::Template { name } => {
-                if let Err(err) = handle_install_command(name, AddonType::Template).await {
-                    let logger = devalang_utils::logger::Logger::new();
-                    logger.log_message(
-                        devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to install template: {}", err),
-                    );
-                    had_error = true;
-                    last_error_message = Some(format!("install template failed: {}", err));
-                    exit_code = Some(1);
-                }
-            }
-            InstallCommand::Bank { name } => {
-                if let Err(err) = handle_install_command(name, AddonType::Bank).await {
-                    let logger = devalang_utils::logger::Logger::new();
-                    logger.log_message(
-                        devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to install bank: {}", err),
-                    );
-                    had_error = true;
-                    last_error_message = Some(format!("install bank failed: {}", err));
-                    exit_code = Some(1);
-                }
-            }
-            InstallCommand::Plugin { name } => {
-                if let Err(err) = handle_install_command(name, AddonType::Plugin).await {
-                    let logger = devalang_utils::logger::Logger::new();
-                    logger.log_message(
-                        devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to install plugin: {}", err),
-                    );
-                    had_error = true;
-                    last_error_message = Some(format!("install plugin failed: {}", err));
-                    exit_code = Some(1);
-                }
-            }
-            InstallCommand::Preset { name } => {
-                if let Err(err) = handle_install_command(name, AddonType::Preset).await {
-                    let logger = devalang_utils::logger::Logger::new();
-                    logger.log_message(
-                        devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to install preset: {}", err),
-                    );
-                    had_error = true;
-                    last_error_message = Some(format!("install preset failed: {}", err));
-                    exit_code = Some(1);
-                }
-            }
-        },
-
-        Commands::Bank { command } => match command {
-            BankCommand::List => {
-                if let Err(err) = handle_bank_list_command().await {
-                    let logger = devalang_utils::logger::Logger::new();
-                    logger.log_message(
-                        devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to list local banks: {}", err),
-                    );
-                    had_error = true;
-                    last_error_message = Some(format!("bank list failed: {}", err));
-                    exit_code = Some(1);
-                }
-            }
-
-            BankCommand::Available => {
-                if let Err(err) = handle_bank_available_command().await {
-                    let logger = devalang_utils::logger::Logger::new();
-                    logger.log_message(
-                        devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to list available banks: {}", err),
-                    );
-                    had_error = true;
-                    last_error_message = Some(format!("bank available failed: {}", err));
-                    exit_code = Some(1);
+        Commands::Addon { command } => {
+            match command {
+                AddonCommand::Install { name, no_clear_tmp } => {
+                    if let Err(err) = handle_install_addon_command(name, no_clear_tmp).await {
+                        let logger = devalang_utils::logger::Logger::new();
+                        logger.log_message(
+                            devalang_utils::logger::LogLevel::Error,
+                            &format!("[error] Failed to install addon: {}", err),
+                        );
+                        had_error = true;
+                        last_error_message = Some(format!("install addon failed: {}", err));
+                        exit_code = Some(1);
+                    }
                 }
-            }
 
-            BankCommand::Info { name } => {
-                if let Err(err) = handle_bank_info_command(name).await {
-                    let logger = devalang_utils::logger::Logger::new();
-                    logger.log_message(
-                        devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to get bank info: {}", err),
-                    );
-                    had_error = true;
-                    last_error_message = Some(format!("bank info failed: {}", err));
-                    exit_code = Some(1);
+                AddonCommand::Update { name } => {
+                    if let Err(err) = handle_update_addon_command(name).await {
+                        let logger = devalang_utils::logger::Logger::new();
+                        logger.log_message(
+                            devalang_utils::logger::LogLevel::Error,
+                            &format!("[error] Failed to update addon: {}", err),
+                        );
+                        had_error = true;
+                        last_error_message = Some(format!("update addon failed: {}", err));
+                        exit_code = Some(1);
+                    }
                 }
-            }
-
-            BankCommand::Remove { name } => {
-                if let Err(err) = handle_remove_bank_command(name).await {
-                    let logger = devalang_utils::logger::Logger::new();
-                    logger.log_message(
-                        devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to remove bank: {}", err),
-                    );
-                    had_error = true;
-                    last_error_message = Some(format!("bank remove failed: {}", err));
-                    exit_code = Some(1);
-                }
-            }
 
-            BankCommand::Update { name } => {
-                if let Err(err) = handle_update_bank_command(name).await {
-                    let logger = devalang_utils::logger::Logger::new();
-                    logger.log_message(
-                        devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to update bank: {}", err),
-                    );
-                    had_error = true;
-                    last_error_message = Some(format!("bank update failed: {}", err));
-                    exit_code = Some(1);
+                AddonCommand::List {} => {
+                    if let Err(err) = handle_list_addon_command().await {
+                        let logger = devalang_utils::logger::Logger::new();
+                        logger.log_message(
+                            devalang_utils::logger::LogLevel::Error,
+                            &format!("[error] Failed to list local addons: {}", err),
+                        );
+                        had_error = true;
+                        last_error_message = Some(format!("addon list failed: {}", err));
+                        exit_code = Some(1);
+                    }
                 }
-            }
-        },
 
-        Commands::Update { only } => {
-            if let Err(err) = handle_update_command(only).await {
-                let logger = devalang_utils::logger::Logger::new();
-                logger.log_message(
-                    devalang_utils::logger::LogLevel::Error,
-                    &format!("❌ Update failed: {}", err),
-                );
-                had_error = true;
-                last_error_message = Some(format!("update failed: {}", err));
-                exit_code = Some(1);
+                AddonCommand::Remove { name } => {
+                    if let Err(err) = handle_remove_addon_command(name).await {
+                        let logger = devalang_utils::logger::Logger::new();
+                        logger.log_message(
+                            devalang_utils::logger::LogLevel::Error,
+                            &format!("[error] Failed to remove addon: {}", err),
+                        );
+                        had_error = true;
+                        last_error_message = Some(format!("remove addon failed: {}", err));
+                        exit_code = Some(1);
+                    }
+                } // AddonCommand::Bank { command } => {
+                  //     match command {
+                  //         BankCommand::List => {
+                  //             if let Err(err) = handle_bank_list_command().await {
+                  //                 let logger = devalang_utils::logger::Logger::new();
+                  //                 logger.log_message(
+                  //                     devalang_utils::logger::LogLevel::Error,
+                  //                     &format!("[error] Failed to list local banks: {}", err)
+                  //                 );
+                  //                 had_error = true;
+                  //                 last_error_message = Some(format!("bank list failed: {}", err));
+                  //                 exit_code = Some(1);
+                  //             }
+                  //         }
+
+                  //         BankCommand::Available => {
+                  //             if let Err(err) = handle_bank_available_command().await {
+                  //                 let logger = devalang_utils::logger::Logger::new();
+                  //                 logger.log_message(
+                  //                     devalang_utils::logger::LogLevel::Error,
+                  //                     &format!("[error] Failed to list available banks: {}", err)
+                  //                 );
+                  //                 had_error = true;
+                  //                 last_error_message = Some(
+                  //                     format!("bank available failed: {}", err)
+                  //                 );
+                  //                 exit_code = Some(1);
+                  //             }
+                  //         }
+
+                  //         // BankCommand::Info { name } => {
+                  //         //     if let Err(err) = handle_bank_info_command(name).await {
+                  //         //         let logger = devalang_utils::logger::Logger::new();
+                  //         //         logger.log_message(
+                  //         //             devalang_utils::logger::LogLevel::Error,
+                  //         //             &format!("[error] Failed to get bank info: {}", err)
+                  //         //         );
+                  //         //         had_error = true;
+                  //         //         last_error_message = Some(format!("bank info failed: {}", err));
+                  //         //         exit_code = Some(1);
+                  //         //     }
+                  //         // }
+
+                  //         // BankCommand::Remove { name } => {
+                  //         //     if let Err(err) = handle_remove_bank_command(name).await {
+                  //         //         let logger = devalang_utils::logger::Logger::new();
+                  //         //         logger.log_message(
+                  //         //             devalang_utils::logger::LogLevel::Error,
+                  //         //             &format!("[error] Failed to remove bank: {}", err)
+                  //         //         );
+                  //         //         had_error = true;
+                  //         //         last_error_message = Some(format!("bank remove failed: {}", err));
+                  //         //         exit_code = Some(1);
+                  //         //     }
+                  //         // }
+
+                  //         // BankCommand::Update { name } => {
+                  //         //     if let Err(err) = handle_update_bank_command(name).await {
+                  //         //         let logger = devalang_utils::logger::Logger::new();
+                  //         //         logger.log_message(
+                  //         //             devalang_utils::logger::LogLevel::Error,
+                  //         //             &format!("[error] Failed to update bank: {}", err)
+                  //         //         );
+                  //         //         had_error = true;
+                  //         //         last_error_message = Some(format!("bank update failed: {}", err));
+                  //         //         exit_code = Some(1);
+                  //         //     }
+                  //         // }
+                  //     }
+                  // }
+
+                  // AddonCommand::Plugin { command} => {
+                  //     match command {
+                  //         PluginCommand::List => {
+                  //             if let Err(err) = handle_plugin_list_command().await {
+                  //                 let logger = devalang_utils::logger::Logger::new();
+                  //                 logger.log_message(
+                  //                     devalang_utils::logger::LogLevel::Error,
+                  //                     &format!("[error] Failed to list local plugins: {}", err)
+                  //                 );
+                  //                 had_error = true;
+                  //                 last_error_message = Some(format!("plugin list failed: {}", err));
+                  //                 exit_code = Some(1);
+                  //             }
+                  //         }
+
+                  //         PluginCommand::Available => {
+                  //             if let Err(err) = handle_plugin_available_command().await {
+                  //                 let logger = devalang_utils::logger::Logger::new();
+                  //                 logger.log_message(
+                  //                     devalang_utils::logger::LogLevel::Error,
+                  //                     &format!("[error] Failed to list available plugins: {}", err)
+                  //                 );
+                  //                 had_error = true;
+                  //                 last_error_message = Some(
+                  //                     format!("plugin available failed: {}", err)
+                  //                 );
+                  //                 exit_code = Some(1);
+                  //             }
+                  //         }
+                  //     }
+                  // }
             }
         }
 
+        // Commands::Install { command } => match command {
+        //     InstallCommand::Template { name } => {
+        //         if let Err(err) = handle_install_command(name, AddonType::Template).await {
+        //             let logger = devalang_utils::logger::Logger::new();
+        //             logger.log_message(
+        //                 devalang_utils::logger::LogLevel::Error,
+        //                 &format!("[error] Failed to install template: {}", err),
+        //             );
+        //             had_error = true;
+        //             last_error_message = Some(format!("install template failed: {}", err));
+        //             exit_code = Some(1);
+        //         }
+        //     }
+        //     InstallCommand::Bank { name } => {
+        //         if let Err(err) = handle_install_command(name, AddonType::Bank).await {
+        //             let logger = devalang_utils::logger::Logger::new();
+        //             logger.log_message(
+        //                 devalang_utils::logger::LogLevel::Error,
+        //                 &format!("[error] Failed to install bank: {}", err),
+        //             );
+        //             had_error = true;
+        //             last_error_message = Some(format!("install bank failed: {}", err));
+        //             exit_code = Some(1);
+        //         }
+        //     }
+        //     InstallCommand::Plugin { name } => {
+        //         if let Err(err) = handle_install_command(name, AddonType::Plugin).await {
+        //             let logger = devalang_utils::logger::Logger::new();
+        //             logger.log_message(
+        //                 devalang_utils::logger::LogLevel::Error,
+        //                 &format!("[error] Failed to install plugin: {}", err),
+        //             );
+        //             had_error = true;
+        //             last_error_message = Some(format!("install plugin failed: {}", err));
+        //             exit_code = Some(1);
+        //         }
+        //     }
+        //     InstallCommand::Preset { name } => {
+        //         if let Err(err) = handle_install_command(name, AddonType::Preset).await {
+        //             let logger = devalang_utils::logger::Logger::new();
+        //             logger.log_message(
+        //                 devalang_utils::logger::LogLevel::Error,
+        //                 &format!("[error] Failed to install preset: {}", err),
+        //             );
+        //             had_error = true;
+        //             last_error_message = Some(format!("install preset failed: {}", err));
+        //             exit_code = Some(1);
+        //         }
+        //     }
+        // },
+
+        // Commands::Bank { command } => match command {
+        //     BankCommand::List => {
+        //         if let Err(err) = handle_bank_list_command().await {
+        //             let logger = devalang_utils::logger::Logger::new();
+        //             logger.log_message(
+        //                 devalang_utils::logger::LogLevel::Error,
+        //                 &format!("[error] Failed to list local banks: {}", err),
+        //             );
+        //             had_error = true;
+        //             last_error_message = Some(format!("bank list failed: {}", err));
+        //             exit_code = Some(1);
+        //         }
+        //     }
+
+        //     BankCommand::Available => {
+        //         if let Err(err) = handle_bank_available_command().await {
+        //             let logger = devalang_utils::logger::Logger::new();
+        //             logger.log_message(
+        //                 devalang_utils::logger::LogLevel::Error,
+        //                 &format!("[error] Failed to list available banks: {}", err),
+        //             );
+        //             had_error = true;
+        //             last_error_message = Some(format!("bank available failed: {}", err));
+        //             exit_code = Some(1);
+        //         }
+        //     }
+
+        //     BankCommand::Info { name } => {
+        //         if let Err(err) = handle_bank_info_command(name).await {
+        //             let logger = devalang_utils::logger::Logger::new();
+        //             logger.log_message(
+        //                 devalang_utils::logger::LogLevel::Error,
+        //                 &format!("[error] Failed to get bank info: {}", err),
+        //             );
+        //             had_error = true;
+        //             last_error_message = Some(format!("bank info failed: {}", err));
+        //             exit_code = Some(1);
+        //         }
+        //     }
+
+        //     BankCommand::Remove { name } => {
+        //         if let Err(err) = handle_remove_bank_command(name).await {
+        //             let logger = devalang_utils::logger::Logger::new();
+        //             logger.log_message(
+        //                 devalang_utils::logger::LogLevel::Error,
+        //                 &format!("[error] Failed to remove bank: {}", err),
+        //             );
+        //             had_error = true;
+        //             last_error_message = Some(format!("bank remove failed: {}", err));
+        //             exit_code = Some(1);
+        //         }
+        //     }
+
+        //     BankCommand::Update { name } => {
+        //         if let Err(err) = handle_update_bank_command(name).await {
+        //             let logger = devalang_utils::logger::Logger::new();
+        //             logger.log_message(
+        //                 devalang_utils::logger::LogLevel::Error,
+        //                 &format!("[error] Failed to update bank: {}", err),
+        //             );
+        //             had_error = true;
+        //             last_error_message = Some(format!("bank update failed: {}", err));
+        //             exit_code = Some(1);
+        //         }
+        //     }
+        // },
+
+        // Commands::Update { only } => {
+        //     if let Err(err) = handle_update_command(only).await {
+        //         let logger = devalang_utils::logger::Logger::new();
+        //         logger.log_message(
+        //             devalang_utils::logger::LogLevel::Error,
+        //             &format!("[error] Update failed: {}", err)
+        //         );
+        //         had_error = true;
+        //         last_error_message = Some(format!("update failed: {}", err));
+        //         exit_code = Some(1);
+        //     }
+        // }
         Commands::Telemetry { command } => match command {
             TelemetryCommand::Enable { .. } => {
                 if let Err(err) = handle_telemetry_enable_command().await {
                     let logger = devalang_utils::logger::Logger::new();
                     logger.log_message(
                         devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to enable telemetry: {}", err),
+                        &format!("[error] Failed to enable telemetry: {}", err),
                     );
                     had_error = true;
                     last_error_message = Some(format!("telemetry enable failed: {}", err));
@@ -302,7 +482,7 @@ async fn main() -> io::Result<()> {
                     let logger = devalang_utils::logger::Logger::new();
                     logger.log_message(
                         devalang_utils::logger::LogLevel::Error,
-                        &format!("❌ Failed to disable telemetry: {}", err),
+                        &format!("[error] Failed to disable telemetry: {}", err),
                     );
                     had_error = true;
                     last_error_message = Some(format!("telemetry disable failed: {}", err));
@@ -311,12 +491,12 @@ async fn main() -> io::Result<()> {
             }
         },
 
-        Commands::Discover {} => {
-            if let Err(err) = handle_discover_command().await {
+        Commands::Discover { no_clear_tmp } => {
+            if let Err(err) = handle_discover_command(no_clear_tmp).await {
                 let logger = devalang_utils::logger::Logger::new();
                 logger.log_message(
                     devalang_utils::logger::LogLevel::Error,
-                    &format!("❌ Failed to discover: {}", err),
+                    &format!("[error] Failed to discover: {}", err),
                 );
                 had_error = true;
                 last_error_message = Some(format!("discover failed: {}", err));
@@ -329,7 +509,7 @@ async fn main() -> io::Result<()> {
                 let logger = devalang_utils::logger::Logger::new();
                 logger.log_message(
                     devalang_utils::logger::LogLevel::Error,
-                    &format!("❌ Login failed: {}", err),
+                    &format!("[error] Login failed: {}", err),
                 );
                 had_error = true;
                 last_error_message = Some(format!("login failed: {}", err));
@@ -337,11 +517,24 @@ async fn main() -> io::Result<()> {
             }
         }
 
+        Commands::Me {} => {
+            if let Err(err) = handle_me_command().await {
+                let logger = devalang_utils::logger::Logger::new();
+                logger.log_message(
+                    devalang_utils::logger::LogLevel::Error,
+                    &format!("[error] Me command failed: {}", err),
+                );
+                had_error = true;
+                last_error_message = Some(format!("me command failed: {}", err));
+                exit_code = Some(1);
+            }
+        }
+
         Commands::Logout { .. } => {
             let logger = devalang_utils::logger::Logger::new();
             logger.log_message(
                 devalang_utils::logger::LogLevel::Error,
-                "❌ Logout command is not implemented yet.",
+                "[error] Logout command is not implemented yet.",
             );
             had_error = true;
             last_error_message = Some("logout not implemented".to_string());

package/rust/types/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "devalang_types"
-version = "0.0.2"
+version = "0.0.4"
 description = "Types and traits for Devalang"
 license = "MIT"
 authors = ["Devaloop <contact@devaloop.com>"]