@devaloop/devalang 0.0.1-alpha.4 → 0.0.1-alpha.5

package/Cargo.toml

@@ -1,20 +1,22 @@
 [package]
 name = "devalang"
-version = "0.0.1-alpha.4"
+version = "0.0.1-alpha.5"
 authors = ["Devaloop <contact@devaloop.com>"]
 description = "Write music like code. Devalang is a domain-specific language (DSL) for sound designers and music hackers. Compose, automate, and control sound — in plain text."
 license = "MIT"
 repository = "https://github.com/devaloop-labs/devalang"
 keywords = ["music", "dsl", "audio", "cli"]
-categories = ["command-line-utilities", "audio", "development-tools"]
+categories = ["command-line-utilities", "development-tools", "parser-implementations"]
 readme = "README.md"
 homepage = "https://devalang.com"
 documentation = "https://docs.devalang.com/"
+license-file = "LICENSE"
 edition = "2024"
 
 [[bin]]
 name = "devalang"
 path = "rust/main.rs"
+required-features = ["cli"]
 
 [lib]
 path = "rust/lib.rs"
@@ -25,7 +27,7 @@ opt-level = "s"
 
 [features]
 default = ["cli"]
-cli = ["crossterm"]
+cli = ["crossterm", "indicatif", "inquire"]
 
 [dependencies]
 clap = { version = "4.5", features = ["derive"] }
@@ -42,5 +44,5 @@ serde-wasm-bindgen = "0.4"
 nom_locate = "4.0.0"
 chrono = "0.4"
 crossterm =  { version = "0.27", optional = true }
-indicatif = "0.17"
-inquire = "0.7.5"
+indicatif = { version = "0.17", optional = true }
+inquire = { version = "0.7.5", optional = true }

package/README.md

@@ -12,6 +12,10 @@
 ![Platform](https://img.shields.io/badge/platform-Windows-blue)
 
 ![npm](https://img.shields.io/npm/dt/@devaloop/devalang)
+![crates](https://img.shields.io/crates/d/devalang)
+
+[![VSCode Extension](https://img.shields.io/visual-studio-marketplace/v/devaloop.devalang-vscode?label=VSCode%20Extension)](https://marketplace.visualstudio.com/items?itemName=devaloop.devalang-vscode)
+
 
 ## 🎼 Devalang, by **Devaloop Labs**
 
@@ -24,9 +28,10 @@ Compose loops, control samples, render and play audio — all in clean, readable
 
 From studio sketches to live sets, Devalang gives you rhythmic control — with the elegance of code.
 
-> 🚧 **v0.0.1-alpha.4 Notice** 🚧
+> 🚧 **v0.0.1-alpha.5 Notice** 🚧
 >
-> **Audio Engine** is now integrated, enabling audio playback and rendering capabilities.
+> NEW: Devalang VSCode extension is now available !
+> [Get it here](https://marketplace.visualstudio.com/items?itemName=devaloop.devalang-vscode).
 >
 > Currently, Devalang CLI is only available for **Windows**.  
 > Linux and macOS binaries will be added in future releases via cross-platform builds.
@@ -37,6 +42,8 @@ From studio sketches to live sets, Devalang gives you rhythmic control — with
 
 - [📖 Documentation](./docs/)
 - [💡 Examples](./examples/)
+- [🧩 VSCode Extension](https://marketplace.visualstudio.com/items?itemName=devaloop.devalang-vscode)
+- [🎨 Prettier Plugin](https://www.npmjs.com/package/@devaloop/prettier-plugin-devalang)
 - [🌐 Project Website](https://devalang.com)
 
 ## 🚀 Features

package/docs/CHANGELOG.md

@@ -4,6 +4,19 @@
 
 # Changelog
 
+## Version 0.0.1-alpha.5 (2025-07-05)
+
+### Syntax
+
+- Fixed block parsing issues caused by missing or incorrect `Indent` / `Dedent` token detection.
+- Indentation handling now triggers correctly at each newline.
+- Improved reliability of nested blocks (e.g., inside `loop`) with consistent `Dedent` termination.
+
+### Core Components
+
+- Added full **WebAssembly (WASM)** support — Devalang can now be compiled for browser or Node.js environments.
+- Prepared the ground for future IDE integrations (e.g., VSCode extension) by stabilizing core syntax parsing.
+
 ## Version 0.0.1-alpha.4 (2025-07-03)
 
 ### Audio Engine
@@ -15,11 +28,11 @@
 ### Commands
 
 - Implemented `play` command to play Devalang files.
+
   - Added `--watch` option to watch for changes in files and automatically rebuild and play them. (once)
   - Added `--repeat` option to repeat the playback of the audio file. (infinite)
-  
+
   Note : You cannot use `--watch` and `--repeat` options together. Use `--repeat` instead.
-  
 
 ## Version 0.0.1-alpha.3 (2025-07-01)
 

package/docs/ROADMAP.md

@@ -6,7 +6,7 @@
 
 Devalang is a work in progress. Here’s what we’re planning next:
 
-### Stable
+## Completed
 
 - ✅ **Audio engine**: Integrate the audio engine for sound playback. 
 - ✅ **Basic syntax**: Implement the core syntax for Devalang, including data types and basic statements.
@@ -20,11 +20,11 @@ Devalang is a work in progress. Here’s what we’re planning next:
 - ✅ **Instruction calls**: Add support for instruction calls with parameters (e.g. `.kick auto {reverb:10, decay:20}`).
 - ✅ **Let assignments**: Implement `let` assignments for storing reusable values.
 - ✅ **Sample loading**: Add `@load` assignment to load samples (.mp3, .wav) for use as values.
+- ✅ **WASM support**: Compile Devalang to WebAssembly for use in web applications and other environments.
 
-### Upcoming
+## Upcoming
 
 - ⏳ **VSCode extension**: Create a VSCode extension for syntax highlighting and code completion.
-- ⏳ **WASM support**: Compile Devalang to WebAssembly for use in web applications.
 - ⏳ **Other statements**: Implement `if`, `else`, and other control structures.
 - ⏳ **Pattern and group statements**: Add support for `@pattern` and `@group` to organize code.
 - ⏳ **Functions**: Add support for defining and calling functions.

package/examples/index.deva

@@ -1,16 +1,17 @@
 @import { duration, default_bank, params, loopCount, tempo } from "./examples/exported.deva"
 
-@load "./examples/samples/kick-808.wav" as sample
-@load "./examples/samples/hat-808.wav" as hat
+@load "./examples/samples/kick-808.wav" as kickCustom
+@load "./examples/samples/hat-808.wav" as hatCustom
 
 bpm tempo
 
 bank default_bank
 
 loop loopCount:
-    .sample duration params
+    .kickCustom duration params
 
     # Uncomment the next line (.hat) while executing "play" command 
     # with `--repeat` option to see magic happen !
 
-    # .hat duration params
+    # .hatCustom duration params
+    

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@devaloop/devalang",
   "private": false,
-  "version": "0.0.1-alpha.4",
+  "version": "0.0.1-alpha.5",
   "description": "Write music like code. Devalang is a domain-specific language (DSL) for sound designers and music hackers. Compose, automate, and control sound — in plain text.",
   "main": "out-tsc/index.js",
   "bin": {
@@ -11,6 +11,8 @@
     "prepublish": "cargo build --release && npm run script:postbuild",
     "rust:dev:build": "cargo run build --entry examples --output output",
     "rust:dev:check": "cargo run check --entry examples --output output",
+    "rust:wasm:web": "wasm-pack build --target=web --no-default-features",
+    "rust:wasm:node": "wasm-pack build --target=nodejs --no-default-features",
     "script:postbuild": "tsc && node out-tsc/scripts/postbuild.js",
     "script:version:bump": "tsc && node out-tsc/scripts/version/index.js"
   },
@@ -39,4 +41,4 @@
   "dependencies": {
     "@types/node": "^24.0.3"
   }
-}
+}

package/project-version.json

@@ -1,6 +1,6 @@
 {
-  "version": "0.0.1-alpha.4",
+  "version": "0.0.1-alpha.5",
   "channel": "alpha",
-  "lastCommit": "ca5336b3cd3f2189971e9e99a93a66042faff007",
-  "build": 3
+  "lastCommit": "1df08dbb62484586f67fbf42d34d6011cf019a12",
+  "build": 4
 }

package/rust/audio/engine.rs

@@ -2,11 +2,7 @@ use std::{ collections::HashMap, fs::File, io::BufReader };
 use hound::{ SampleFormat, WavSpec, WavWriter };
 use rodio::{ Decoder, Source };
 
-use crate::core::{
-    parser::statement::Statement,
-    store::variable::VariableTable,
-    utils::path::normalize_path,
-};
+use crate::core::{ store::variable::VariableTable, utils::path::normalize_path };
 
 const SAMPLE_RATE: u32 = 44100;
 const CHANNELS: u16 = 2;

package/rust/cli/build.rs

@@ -12,6 +12,7 @@ use crate::{
 };
 use std::{ thread, time::Duration };
 
+#[cfg(feature = "cli")]
 pub fn handle_build_command(
     config: Option<Config>,
     entry: Option<String>,
@@ -104,7 +105,7 @@ fn begin_build(entry: String, output: String) {
 
     // SECTION Load
     // NOTE: We use modules in the build command, so we need to load them
-    let (modules_tokens, modules_statements) = module_loader.load_all(&mut global_store);
+    let (modules_tokens, modules_statements) = module_loader.load_all_modules(&mut global_store);
 
     // SECTION Write logs
     write_lexer_log_file(&normalized_output_dir, "lexer_tokens.log", modules_tokens.clone());
@@ -116,12 +117,12 @@ fn begin_build(entry: String, output: String) {
 
     // SECTION Building AST and Audio
     let builder = Builder::new();
-    builder.build_ast(&modules_statements);
+    builder.build_ast(&modules_statements, &normalized_output_dir);
     builder.build_audio(&modules_statements, &normalized_output_dir, &mut global_store);
 
     // SECTION Logging
     let logger = Logger::new();
-    
+
     let success_message = format!(
         "Build completed successfully in {:.2?}. Output files written to: '{}'",
         duration.elapsed(),

package/rust/cli/check.rs

@@ -9,6 +9,7 @@ use crate::{
 };
 use std::{ thread, time::Duration };
 
+#[cfg(feature = "cli")]
 pub fn handle_check_command(
     config: Option<Config>,
     entry: Option<String>,
@@ -101,7 +102,7 @@ fn begin_check(entry: String, output: String) {
 
     // SECTION Load
     // NOTE: We don't use modules in the check command, but we still need to load them
-    let modules = module_loader.load_all(&mut global_store);
+    let modules = module_loader.load_all_modules(&mut global_store);
 
     // TODO: Implement debugging
 

package/rust/cli/init.rs

@@ -1,11 +1,13 @@
 use std::{ fs, path::Path };
 use include_dir::{ include_dir, Dir };
-use inquire::{ Select, Confirm };
-
 use crate::{ cli::template::get_available_templates, utils::file::copy_dir_recursive };
 
+#[cfg(feature = "cli")]
+use inquire::{ Select, Confirm };
+
 static TEMPLATES_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/templates");
 
+#[cfg(feature = "cli")]
 pub fn handle_init_command(name: Option<String>, template: Option<String>) {
     let current_dir = std::env::current_dir().unwrap();
     let project_name = name

package/rust/cli/play.rs

@@ -15,6 +15,7 @@ use std::{ path::Path, sync::mpsc::channel, thread, time::Duration };
 use std::fs;
 use std::collections::HashMap;
 
+#[cfg(feature = "cli")]
 pub fn handle_play_command(
     config: Option<Config>,
     entry: Option<String>,
@@ -144,7 +145,7 @@ fn begin_play(config: &Option<Config>, entry_file: &str, output: &str) {
     let duration = std::time::Instant::now();
     let mut global_store = GlobalStore::new();
     let loader = ModuleLoader::new(&normalized_entry, &normalized_output_dir);
-    let (modules_tokens, modules_statements) = loader.load_all(&mut global_store);
+    let (modules_tokens, modules_statements) = loader.load_all_modules(&mut global_store);
 
     // SECTION Write logs
     write_lexer_log_file(&normalized_output_dir, "lexer_tokens.log", modules_tokens.clone());
@@ -156,7 +157,7 @@ fn begin_play(config: &Option<Config>, entry_file: &str, output: &str) {
 
     // SECTION Building AST and Audio
     let builder = Builder::new();
-    builder.build_ast(&modules_statements);
+    builder.build_ast(&modules_statements, &output);
     builder.build_audio(&modules_statements, &output, &mut global_store);
 
     // SECTION Logging

package/rust/cli/template.rs

@@ -1,9 +1,9 @@
 use include_dir::{ include_dir, Dir, DirEntry };
-
 use crate::utils::file::format_file_size;
 
 static TEMPLATES_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/templates");
 
+#[cfg(feature = "cli")]
 pub fn handle_template_list_command() {
     let available_templates = get_available_templates();
 
@@ -16,6 +16,7 @@ pub fn handle_template_list_command() {
     println!("\nUsage : devalang init --name <project-name> --template <template-name>");
 }
 
+#[cfg(feature = "cli")]
 pub fn handle_template_info_command(name: String) {
     let template_dir = TEMPLATES_DIR.get_dir(name.clone()).unwrap_or_else(|| {
         println!("❌ The template '{}' is not found.", name);

package/rust/config/loader.rs

@@ -1,5 +1,4 @@
 use std::{ fs, path::Path };
-
 use crate::config::Config;
 
 pub fn load_config(path: Option<&Path>) -> Option<Config> {

package/rust/core/builder/mod.rs

@@ -1,10 +1,10 @@
-use crate::audio::render::render_audio_with_modules;
-use crate::core::parser::statement::Statement;
+use crate::{ audio::render::render_audio_with_modules, core::parser::statement::Statement };
 use crate::core::store::global::GlobalStore;
-use crate::utils::logger::Logger;
 use std::{ collections::HashMap, fs::create_dir_all };
 use std::io::Write;
 
+use crate::utils::logger::Logger;
+
 pub struct Builder {}
 
 impl Builder {
@@ -12,16 +12,14 @@ impl Builder {
         Builder {}
     }
 
-    pub fn build_ast(&self, modules: &HashMap<String, Vec<Statement>>) {
-        let output_path = "./output";
-
+    pub fn build_ast(&self, modules: &HashMap<String, Vec<Statement>>, out_dir: &str) {
         for (name, statements) in modules {
             let formatted_name = name.split("/").last().unwrap_or(name);
             let formatted_name = formatted_name.replace(".deva", "");
 
-            create_dir_all(format!("{}/ast", output_path)).expect("Failed to create AST directory");
+            create_dir_all(format!("{}/ast", out_dir)).expect("Failed to create AST directory");
 
-            let file_path = format!("{}/ast/{}.json", output_path, formatted_name);
+            let file_path = format!("{}/ast/{}.json", out_dir, formatted_name);
             let mut file = std::fs::File::create(file_path).expect("Failed to create AST file");
 
             let content = serde_json
@@ -46,7 +44,9 @@ impl Builder {
             global_store
         );
 
-        create_dir_all(format!("{}/audio", normalized_output_dir)).expect("Failed to create audio directory");
+        create_dir_all(format!("{}/audio", normalized_output_dir)).expect(
+            "Failed to create audio directory"
+        );
 
         for (module_name, mut audio_engine) in audio_engines {
             let formatted_module_name = module_name

package/rust/core/lexer/handler/mod.rs

@@ -42,7 +42,7 @@ fn advance_char<I: Iterator<Item = char>>(
     Some(c)
 }
 
-pub fn handle_content_lexing(content: String) -> Vec<Token> {
+pub fn handle_content_lexing(content: String) -> Result<Vec<Token>, String> {
     let mut tokens = Vec::new();
 
     let mut line = 1;
@@ -234,5 +234,5 @@ pub fn handle_content_lexing(content: String) -> Vec<Token> {
     //     );
     // }
 
-    tokens
+    Ok(tokens)
 }

package/rust/core/lexer/handler/newline.rs

@@ -14,6 +14,10 @@ pub fn handle_newline_lexer(
         lexeme: ch.to_string(),
         line: *line,
         column: 0,
-        indent: 0,
+        indent: *current_indent,
     });
+
+    *line += 1;
+    *column = 1;
+    *at_line_start = true;
 }

package/rust/core/lexer/mod.rs

@@ -2,7 +2,10 @@ pub mod handler;
 pub mod token;
 
 use std::fs;
-use crate::core::{ lexer::{ handler::handle_content_lexing, token::Token }, utils::path::normalize_path };
+use crate::core::{
+    lexer::{ handler::handle_content_lexing, token::Token },
+    utils::path::normalize_path,
+};
 
 pub struct Lexer {}
 
@@ -11,14 +14,16 @@ impl Lexer {
         Lexer {}
     }
 
+    pub fn lex_from_source(&self, source: &str) -> Result<Vec<Token>, String> {
+        handle_content_lexing(source.to_string())
+    }
+
     pub fn lex_tokens(&self, entrypoint: &str) -> Vec<Token> {
         let path = normalize_path(entrypoint);
 
-        let file_content = fs
-            ::read_to_string(&path)
-            .expect("Failed to read the entrypoint file");
+        let file_content = fs::read_to_string(&path).expect("Failed to read the entrypoint file");
 
-        let tokens = handle_content_lexing(file_content);
+        let tokens = handle_content_lexing(file_content).expect("Failed to lex the content");
 
         tokens
     }

package/rust/core/parser/handler/loop_.rs

@@ -40,6 +40,17 @@ pub fn parse_loop_token(parser: &mut Parser, global_store: &mut GlobalStore) ->
     );
     let loop_body = parser.parse_block(tokens.clone(), global_store);
 
+    // Peek for dedent
+    if let Some(token) = parser.peek() {
+        if token.kind == TokenKind::Dedent {
+            parser.advance();
+        } else {
+            // Unexpected token after loop body
+        }
+    } else {
+        // EOF or unexpected end of input
+    }
+
     let mut value_map = HashMap::new();
 
     value_map.insert("iterator".to_string(), Value::Identifier(iterator_name));

package/rust/core/parser/mod.rs

@@ -225,7 +225,6 @@ impl Parser {
                 break;
             }
             if condition(token) {
-                self.advance(); // Consume the token that matches the condition
                 break;
             }
             collected.push(self.advance().unwrap().clone());

package/rust/core/preprocessor/loader.rs

@@ -1,5 +1,4 @@
 use std::collections::HashMap;
-
 use crate::{
     core::{
         error::ErrorHandler,
@@ -11,8 +10,9 @@ use crate::{
             resolver::{ resolve_all_modules, resolve_and_flatten_all_modules },
         },
         store::global::GlobalStore,
+        utils::path::normalize_path,
     },
-    utils::logger::{ Logger },
+    utils::logger::Logger,
 };
 
 pub struct ModuleLoader {
@@ -28,7 +28,67 @@ impl ModuleLoader {
         }
     }
 
-    pub fn load_all(
+    pub fn from_raw_source(
+        entry_path: &str,
+        output_path: &str,
+        content: &str,
+        global_store: &mut GlobalStore
+    ) -> Self {
+        let normalized_entry_path = normalize_path(entry_path);
+
+        let mut module = Module::new(&entry_path);
+        module.content = content.to_string();
+
+        println!("Loading module from raw source: {}", normalized_entry_path);
+
+        global_store.insert_module(normalized_entry_path.to_string(), module);
+
+        Self {
+            entry: normalized_entry_path.to_string(),
+            output: output_path.to_string(),
+        }
+    }
+
+    pub fn extract_statements_map(
+        &self,
+        global_store: &GlobalStore
+    ) -> HashMap<String, Vec<Statement>> {
+        global_store.modules
+            .iter()
+            .map(|(path, module)| (path.clone(), module.statements.clone()))
+            .collect()
+    }
+
+    pub fn load_single_module(&self, global_store: &mut GlobalStore) -> Result<Module, String> {
+        let mut module = global_store.modules
+            .remove(&self.entry)
+            .ok_or_else(|| format!("Module not found in store for path: {}", self.entry))?;
+
+        // SECTION Lexing the module content
+        let lexer = Lexer::new();
+        let tokens = lexer
+            .lex_from_source(&module.content)
+            .map_err(|e| format!("Lexer failed: {}", e))?;
+
+        module.tokens = tokens.clone();
+
+        // SECTION Parsing tokens into statements
+        let mut parser = Parser::new();
+        parser.set_current_module(self.entry.clone());
+        let statements = parser.parse_tokens(tokens, global_store);
+        module.statements = statements;
+
+        // SECTION Error handling
+        let mut error_handler = ErrorHandler::new();
+        error_handler.detect_from_statements(&mut parser, &module.statements);
+
+        global_store.modules.insert(self.entry.clone(), module.clone());
+
+        Ok(module)
+    }
+
+    #[cfg(feature = "cli")]
+    pub fn load_all_modules(
         &self,
         global_store: &mut GlobalStore
     ) -> (HashMap<String, Vec<Token>>, HashMap<String, Vec<Statement>>) {
@@ -44,6 +104,7 @@ impl ModuleLoader {
         (tokens_by_module, statemnts_by_module)
     }
 
+    #[cfg(feature = "cli")]
     fn load_module_recursively(
         &self,
         path: &str,
@@ -95,6 +156,7 @@ impl ModuleLoader {
         tokens_by_module
     }
 
+    #[cfg(feature = "cli")]
     fn load_module_imports(&self, path: &String, global_store: &mut GlobalStore) {
         let imports = global_store.modules
             .get(path)

package/rust/core/preprocessor/module.rs

@@ -18,6 +18,7 @@ pub struct Module {
     pub variable_table: VariableTable,
     pub export_table: ExportTable,
     pub import_table: ImportTable,
+    pub content: String,
 }
 
 impl Module {
@@ -30,6 +31,7 @@ impl Module {
             export_table: ExportTable::new(),
             import_table: ImportTable::new(),
             resolved: false,
+            content: String::new(),
         }
     }
 

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

@@ -33,13 +33,18 @@ pub fn resolve_loop(
                         Value::Null
                     }
                     None => {
-                        log_type_error(
-                            &logger,
-                            module,
-                            stmt,
-                            format!("Loop iterator '{ident}' not found")
-                        );
-                        Value::Null
+                        // Value is not a variable so we assume it's a number
+                        if let Ok(n) = ident.parse::<f32>() {
+                            Value::Number(n)
+                        } else {
+                            log_type_error(
+                                &logger,
+                                module,
+                                stmt,
+                                format!("Loop iterator '{ident}' is not a valid number")
+                            );
+                            Value::Null
+                        }
                     }
                 }
             }

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

@@ -63,9 +63,9 @@ pub fn resolve_and_flatten_all_modules(
     global_store: &mut GlobalStore
 ) -> HashMap<String, Vec<Statement>> {
     let logger = Logger::new();
-    let snapshot = global_store.clone(); // pour éviter les emprunts mutables
+    let snapshot = global_store.clone();
 
-    // 1. Résolution des imports
+    // 1. Imports resolution
     for (module_path, module) in global_store.modules.iter_mut() {
         for (name, source_path) in &module.import_table.imports {
             if let Value::String(source_path_str) = source_path {
@@ -96,8 +96,8 @@ pub fn resolve_and_flatten_all_modules(
         }
     }
 
-    // 2. Résolution des statements
-    let mut resolved_map = HashMap::new();
+    // 2. Statements resolution
+    let mut resolved_map: HashMap<String, Vec<Statement>> = HashMap::new();
     let store_snapshot = global_store.clone();
 
     for (path, module) in &store_snapshot.modules {
@@ -135,7 +135,6 @@ pub fn resolve_and_flatten_all_modules(
                 }
 
                 StatementKind::Import { .. } | StatementKind::Export { .. } => {
-                    // Rien à faire
                     resolved.push(stmt.clone());
                 }
 

package/rust/lib.rs

@@ -0,0 +1,118 @@
+pub mod core;
+pub mod utils;
+pub mod config;
+pub mod audio;
+
+use serde::{ Deserialize, Serialize };
+use wasm_bindgen::prelude::*;
+use serde_wasm_bindgen::to_value;
+
+use crate::core::{
+    parser::statement::{ Statement, StatementKind },
+    preprocessor::loader::ModuleLoader,
+    shared::value::Value,
+    store::global::GlobalStore,
+    utils::path::normalize_path,
+};
+
+#[derive(Serialize, Deserialize)]
+struct ParseResult {
+    ok: bool,
+    ast: String,
+    errors: Vec<ErrorResult>,
+}
+
+#[derive(Serialize, Deserialize)]
+struct ErrorResult {
+    message: String,
+    line: usize,
+    column: usize,
+}
+
+#[wasm_bindgen]
+pub fn parse(entry_path: &str, source: &str) -> Result<JsValue, JsValue> {
+    let statements = parse_internal_from_string(entry_path, source);
+
+    match statements {
+        Ok(value) => {
+            let ast_string = value;
+            to_value(&ast_string).map_err(|e|
+                JsValue::from_str(&format!("Error converting AST to JS value: {}", e))
+            )
+        }
+        Err(e) => { Err(JsValue::from_str(&format!("Error: {}", e))) }
+    }
+}
+
+fn parse_internal_from_string(virtual_path: &str, source: &str) -> Result<ParseResult, String> {
+    let entry_path = normalize_path(virtual_path);
+    let output_path = normalize_path("./temp");
+
+    let mut global_store = GlobalStore::new();
+    let loader = ModuleLoader::from_raw_source(
+        &entry_path,
+        &output_path,
+        source,
+        &mut global_store
+    );
+
+    let module = loader
+        .load_single_module(&mut global_store)
+        .map_err(|e| format!("Error loading module: {}", e))?;
+
+    let raw_ast = ast_to_string(module.statements.clone());
+
+    let found_errors = collect_errors_recursively(&module.statements);
+
+    let result = ParseResult {
+        ok: true,
+        ast: raw_ast,
+        errors: found_errors,
+    };
+
+    Ok(result)
+}
+
+fn collect_errors_recursively(statements: &[Statement]) -> Vec<ErrorResult> {
+    let mut errors: Vec<ErrorResult> = Vec::new();
+
+    for stmt in statements {
+        match &stmt.kind {
+            StatementKind::Unknown => {
+                errors.push(ErrorResult {
+                    message: format!("Unknown statement at line {}:{}", stmt.line, stmt.column),
+                    line: stmt.line,
+                    column: stmt.column,
+                });
+            }
+            StatementKind::Error { message } => {
+                errors.push(ErrorResult {
+                    message: message.clone(),
+                    line: stmt.line,
+                    column: stmt.column,
+                });
+            }
+            StatementKind::Loop => {
+                if let Some(body_statements) = extract_loop_body_statements(&stmt.value) {
+                    errors.extend(collect_errors_recursively(body_statements));
+                }
+            }
+            _ => {}
+        }
+    }
+
+    errors
+}
+
+fn extract_loop_body_statements(value: &Value) -> Option<&[Statement]> {
+    if let Value::Map(map) = value {
+        if let Some(Value::Block(statements)) = map.get("body") {
+            return Some(statements);
+        }
+    }
+    None
+}
+
+fn ast_to_string(statements: Vec<Statement>) -> String {
+    serde_json::to_string_pretty(&statements).expect("Failed to serialize AST")
+}

package/rust/main.rs

@@ -1,3 +1,5 @@
+#![cfg(feature = "cli")]
+
 pub mod core;
 pub mod cli;
 pub mod utils;

package/rust/utils/logger.rs

@@ -1,5 +1,6 @@
-use crossterm::style::{ Attribute, Color, ResetColor, SetAttribute, SetForegroundColor };
-use std::{ fmt::Write };
+#[cfg(feature = "cli")]
+use crossterm::style::{Attribute, Color, ResetColor, SetAttribute, SetForegroundColor};
+use std::fmt::Write;
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum LogLevel {
@@ -12,24 +13,43 @@ pub enum LogLevel {
 }
 
 #[derive(Debug, Clone)]
-pub struct Logger {}
+pub struct Logger;
 
 impl Logger {
     pub fn new() -> Self {
-        Logger {}
+        Logger
     }
 
+    // --- log_message ---
+
+    #[cfg(feature = "cli")]
     pub fn log_message(&self, level: LogLevel, message: &str) {
         let formatted_status = self.format_status(level);
         println!("🦊 {} {} {}", self.language_signature(), formatted_status, message);
     }
 
+    #[cfg(not(feature = "cli"))]
+    pub fn log_message(&self, _level: LogLevel, _message: &str) {
+        // no-op for WASM
+    }
+
+    // --- log_error_with_stacktrace ---
+
+    #[cfg(feature = "cli")]
     pub fn log_error_with_stacktrace(&self, message: &str, stacktrace: &str) {
         let formatted_status = self.format_status(LogLevel::Error);
         println!("🦊 {} {} {}", self.language_signature(), formatted_status, message);
         println!("     ↳ {}", stacktrace);
     }
 
+    #[cfg(not(feature = "cli"))]
+    pub fn log_error_with_stacktrace(&self, _message: &str, _stacktrace: &str) {
+        // no-op for WASM
+    }
+
+    // --- language_signature ---
+
+    #[cfg(feature = "cli")]
     fn language_signature(&self) -> String {
         let mut s = String::new();
 
@@ -43,12 +63,19 @@ impl Logger {
 
         write!(&mut s, "{}", SetForegroundColor(Color::Grey)).unwrap();
         s.push(']');
-
         write!(&mut s, "{}", ResetColor).unwrap();
 
         s
     }
 
+    #[cfg(not(feature = "cli"))]
+    fn language_signature(&self) -> String {
+        "[Devalang]".to_string()
+    }
+
+    // --- format_status ---
+
+    #[cfg(feature = "cli")]
     fn format_status(&self, level: LogLevel) -> String {
         let mut s = String::new();
 
@@ -76,9 +103,21 @@ impl Logger {
         s.push_str(status);
         write!(&mut s, "{}", SetAttribute(Attribute::Reset)).unwrap();
         s.push(']');
-
         write!(&mut s, "{}", ResetColor).unwrap();
 
         s
     }
+
+    #[cfg(not(feature = "cli"))]
+    fn format_status(&self, level: LogLevel) -> String {
+        match level {
+            LogLevel::Success => "[SUCCESS]",
+            LogLevel::Error => "[ERROR]",
+            LogLevel::Info => "[INFO]",
+            LogLevel::Warning => "[WARNING]",
+            LogLevel::Watcher => "[WATCHER]",
+            LogLevel::Debug => "[DEBUG]",
+        }
+        .to_string()
+    }
 }

package/rust/utils/spinner.rs

@@ -1,6 +1,8 @@
+#[cfg(feature = "cli")]
 use indicatif::{ ProgressBar, ProgressStyle };
 use std::{ time::Duration };
 
+#[cfg(feature = "cli")]
 pub fn with_spinner<T, F>(start_msg: &str, f: F) -> T where F: FnOnce() -> T {
     let spinner = ProgressBar::new_spinner();
     spinner.set_style(

package/templates/minimal/.devalang

@@ -1,4 +1,5 @@
 [defaults]
 entry = "./src"
 output = "./output"
-watch = false
+watch = false
+repeat = false

package/templates/minimal/README.md

@@ -0,0 +1,202 @@
+<div align="center">
+    <img src="https://firebasestorage.googleapis.com/v0/b/devaloop-labs.firebasestorage.app/o/devalang-teal-logo.svg?alt=media&token=d2a5705a-1eba-4b49-88e6-895a761fb7f7" alt="Devalang Logo">
+</div>
+
+![Rust](https://img.shields.io/badge/Made%20with-Rust-orange?logo=rust)
+![TypeScript](https://img.shields.io/badge/Built%20with-TypeScript-blue?logo=typescript)
+![Node.js](https://img.shields.io/badge/Node.js-18%2B-brightgreen?logo=node.js)
+
+![Project Status](https://img.shields.io/badge/status-alpha-red)
+![Version](https://img.shields.io/badge/version-0.0.1-blue)
+![License: MIT](https://img.shields.io/badge/license-MIT-green)
+![Platform](https://img.shields.io/badge/platform-Windows-blue)
+
+![npm](https://img.shields.io/npm/dt/@devaloop/devalang)
+![crates](https://img.shields.io/crates/d/devalang)
+
+## 🎼 Devalang, by **Devaloop Labs**
+
+🎶 Compose music with code — simple, structured, sonic.
+
+Devalang is a tiny domain-specific language (DSL) for music makers, sound designers, and audio hackers.
+Compose loops, control samples, render and play audio — all in clean, readable text.
+
+🦊 Whether you're building a track, shaping textures, or performing live, Devalang helps you think in rhythms. It’s designed to be simple, expressive, and fast — because your ideas shouldn’t wait.
+
+From studio sketches to live sets, Devalang gives you rhythmic control — with the elegance of code.
+
+> 🚧 **v0.0.1-alpha.5 Notice** 🚧
+>
+> Currently, Devalang CLI is only available for **Windows**.  
+> Linux and macOS binaries will be added in future releases via cross-platform builds.
+
+---
+
+## 📚 Quick Access
+
+- [📖 Documentation](./docs/)
+- [💡 Examples](./examples/)
+- [🌐 Project Website](https://devalang.com)
+
+## 🚀 Features
+
+- 🎵 **Audio Engine**: Integrated audio playback and rendering
+- 🧩 **Module system** for importing and exporting variables between files
+- 📜 **Structured AST** generation for debugging and future compilation
+- 🔢 **Basic data types**: strings, numbers, booleans, maps, arrays
+- 👁️ **Watch mode** for `build`, `check` and `play` commands
+- 📂 **Project templates** for quick setup
+
+## 📆 Installation
+
+### For users
+
+> - ⚠️ Requires [Node.js 18+](https://nodejs.org/en/download)
+
+Install the package globally (NPM)
+
+```bash
+npm install -g @devaloop/devalang
+```
+
+Usage without install (NPX)
+
+```bash
+npx @devaloop/devalang <command>
+```
+
+### For contributors
+
+> - ⚠️ Requires [Node.js 18+](https://nodejs.org/en/download)
+> - ⚠️ Requires [Rust 1.70+](https://www.rust-lang.org/learn/get-started#installing-rust)
+
+```bash
+> git clone https://github.com/devaloop-labs/devalang.git
+> cd devalang
+> npm install
+> cargo install --path .
+```
+
+Development usage (you can customize arguments in package.json)
+
+```bash
+# For syntax checking test
+npm run rust:dev:check
+# For building test
+npm run rust:dev:build
+```
+
+## ❔ Usage
+
+NOTE: Commands are available via `devalang` or `npx @devaloop/devalang`.
+
+NOTE: Arguments can be passed to commands using `--<argument>` syntax. You can also use a configuration file to set default values for various settings, making it easier to manage your Devalang project.
+
+NOTE: Some commands require a mandatory `--entry` argument to specify the input folder, and a `--output` argument to specify the output folder. If not specified, they default to `./src` and `./output` respectively.
+
+For more examples, see [docs/COMMANDS.md](./docs/COMMANDS.md)
+
+### Initialize a new project
+
+In the current directory
+
+```bash
+devalang init
+```
+
+Or use optional arguments to specify a directory name and a template
+
+```bash
+devalang init --name <project-name> --template <template-name>
+```
+
+### Checking syntax only
+
+```bash
+devalang check --watch
+```
+
+### Building output files
+
+```bash
+devalang build --watch
+```
+
+### Playing audio files (once by file change)
+
+```bash
+devalang play --watch
+```
+
+### Playing audio files (continuous playback, even without file changes)
+
+```bash
+devalang play --repeat
+```
+
+## ⚙️ Configuration
+
+You can use a configuration file to set default values for various settings, making it easier to manage your Devalang project.
+
+To do this, create a `.devalang` file in the root of your project directory.
+
+See [docs/CONFIG.md](./docs/CONFIG.md) for more information.
+
+## 📄 Syntax example
+
+For more examples, see [docs/SYNTAX.md](./docs/SYNTAX.md)
+
+```deva
+# index.deva
+
+@import { globalBpm, globalBank, kickDuration } from "global.deva"
+
+@load "./examples/samples/kick-808.wav" as customKick
+
+bpm globalBpm
+# Will declare the tempo at the globalBpm variable beats per minute
+
+bank globalBank
+# Will declare a custom instrument bank using the globalBank variable
+
+loop 5:
+    .customKick kickDuration {reverb=50, drive=25}
+    # Will play 5 times a kick for the duration of the kickDuration variable with reverb and drive effects
+```
+
+```deva
+# global.deva
+
+let globalBpm = 120
+let globalBank = 808
+let kickDuration = 500
+
+@export { globalBpm, globalBank, kickDuration }
+```
+
+## 🧯 Known issues
+
+- No support yet for `if`, `else`, `else if` statements
+- No support yet for `@group`, `@pattern`, `@function` statements
+- No support yet for cross-platform builds (Linux, macOS)
+
+## 🧪 Roadmap Highlights
+
+For more info, see [docs/ROADMAP.md](./docs/ROADMAP.md)
+
+- ⏳ Other statements (e.g `if`, `@group`, ...)
+- ⏳ Cross-platform support (Linux, macOS)
+- ⏳ More built-in instruments (e.g. snare, hi-hat, etc.)
+
+## 🛡️ License
+
+MIT — see [LICENSE](./LICENSE)
+
+## 🤝 Contributing
+
+Contributions, bug reports and suggestions are welcome !  
+Feel free to open an issue or submit a pull request.
+
+## 📢 Contact
+
+📧 [contact@devaloop.com](mailto:contact@devaloop.com)

package/templates/welcome/.devalang

@@ -1,4 +1,5 @@
 [defaults]
 entry = "./src"
 output = "./output"
-watch = false
+watch = false
+repeat = false

package/templates/welcome/README.md

@@ -11,44 +11,41 @@
 ![License: MIT](https://img.shields.io/badge/license-MIT-green)
 ![Platform](https://img.shields.io/badge/platform-Windows-blue)
 
-![npm](https://img.shields.io/npm/dm/@devaloop/devalang)
+![npm](https://img.shields.io/npm/dt/@devaloop/devalang)
+![crates](https://img.shields.io/crates/d/devalang)
 
 ## 🎼 Devalang, by **Devaloop Labs**
 
 🎶 Compose music with code — simple, structured, sonic.
 
 Devalang is a tiny domain-specific language (DSL) for music makers, sound designers, and audio hackers.
-Compose loops, control samples, and automate parameters — all in clean, readable text.
+Compose loops, control samples, render and play audio — all in clean, readable text.
 
 🦊 Whether you're building a track, shaping textures, or performing live, Devalang helps you think in rhythms. It’s designed to be simple, expressive, and fast — because your ideas shouldn’t wait.
 
 From studio sketches to live sets, Devalang gives you rhythmic control — with the elegance of code.
 
-> 🚧 **v0.0.1-alpha.1 Notice** 🚧
->
-> Devalang is still in early development. This version does not yet include **sound rendering**.
->
-> You can parse code, generate the AST, and validate syntax — all essential building blocks for the upcoming audio engine.
->
-> Currently, only `.kick` is included as a built-in trigger.
-> Custom instruments can be defined with `@load`, allowing any sound sample to be triggered with the same syntax.
+> 🚧 **v0.0.1-alpha.5 Notice** 🚧
 >
 > Currently, Devalang CLI is only available for **Windows**.  
 > Linux and macOS binaries will be added in future releases via cross-platform builds.
 
+---
+
+## 📚 Quick Access
+
+- [📖 Documentation](./docs/)
+- [💡 Examples](./examples/)
+- [🌐 Project Website](https://devalang.com)
+
 ## 🚀 Features
 
-- 🧩 Module system for importing and exporting variables between files (`@import`, `@export`)
-- 📜 Structured AST generation for debugging and future compilation
-- 🔢 Basic data types: strings, numbers, booleans, maps, arrays
-- 👁️ Watch mode for `build` and `check` commands
-- ⏱️ `bpm` assignment for setting tempo
-- 🧱 `bank` declaration to define the instrument set
-- 🔁 Looping system with fixed repetitions (`loop 4:`)
-- 🧪 Instruction calls with parameters (e.g. `.kick auto {reverb:10, decay:20}`) for testing pattern syntax
-- 📄 `let` assignments for storing reusable values
-- 🔄 `@load` assignment to load a sample (.mp3, .wav) to use it as a value
-- 🛠️ CLI tools for syntax checking (`check`), AST output (`build`)
+- 🎵 **Audio Engine**: Integrated audio playback and rendering
+- 🧩 **Module system** for importing and exporting variables between files
+- 📜 **Structured AST** generation for debugging and future compilation
+- 🔢 **Basic data types**: strings, numbers, booleans, maps, arrays
+- 👁️ **Watch mode** for `build`, `check` and `play` commands
+- 📂 **Project templates** for quick setup
 
 ## 📆 Installation
 
@@ -80,15 +77,23 @@ npx @devaloop/devalang <command>
 > cargo install --path .
 ```
 
-Usage for development (feel free to change arguments in package.json)
+Development usage (you can customize arguments in package.json)
 
 ```bash
 # For syntax checking test
-npm run rust:dev <command>
+npm run rust:dev:check
+# For building test
+npm run rust:dev:build
 ```
 
 ## ❔ Usage
 
+NOTE: Commands are available via `devalang` or `npx @devaloop/devalang`.
+
+NOTE: Arguments can be passed to commands using `--<argument>` syntax. You can also use a configuration file to set default values for various settings, making it easier to manage your Devalang project.
+
+NOTE: Some commands require a mandatory `--entry` argument to specify the input folder, and a `--output` argument to specify the output folder. If not specified, they default to `./src` and `./output` respectively.
+
 For more examples, see [docs/COMMANDS.md](./docs/COMMANDS.md)
 
 ### Initialize a new project
@@ -105,16 +110,28 @@ Or use optional arguments to specify a directory name and a template
 devalang init --name <project-name> --template <template-name>
 ```
 
-### Checking syntax only and output debug files
+### Checking syntax only
 
 ```bash
-devalang check --entry <entry-directory> --output <output-directory> --watch
+devalang check --watch
 ```
 
-### Building output file(s) (AST generation for the moment)
+### Building output files
 
 ```bash
-devalang build --entry <entry-directory> --output <output-directory> --watch
+devalang build --watch
+```
+
+### Playing audio files (once by file change)
+
+```bash
+devalang play --watch
+```
+
+### Playing audio files (continuous playback, even without file changes)
+
+```bash
+devalang play --repeat
 ```
 
 ## ⚙️ Configuration
@@ -134,6 +151,8 @@ For more examples, see [docs/SYNTAX.md](./docs/SYNTAX.md)
 
 @import { globalBpm, globalBank, kickDuration } from "global.deva"
 
+@load "./examples/samples/kick-808.wav" as customKick
+
 bpm globalBpm
 # Will declare the tempo at the globalBpm variable beats per minute
 
@@ -141,7 +160,7 @@ bank globalBank
 # Will declare a custom instrument bank using the globalBank variable
 
 loop 5:
-    .kick kickDuration {reverb=50, drive=25}
+    .customKick kickDuration {reverb=50, drive=25}
     # Will play 5 times a kick for the duration of the kickDuration variable with reverb and drive effects
 ```
 
@@ -157,16 +176,14 @@ let kickDuration = 500
 
 ## 🧯 Known issues
 
-- No support yet for Audio Engine
 - No support yet for `if`, `else`, `else if` statements
 - No support yet for `@group`, `@pattern`, `@function` statements
-- Nested loops and conditions may not be fully tested
+- No support yet for cross-platform builds (Linux, macOS)
 
 ## 🧪 Roadmap Highlights
 
 For more info, see [docs/ROADMAP.md](./docs/ROADMAP.md)
 
-- ⏳ Audio engine integration
 - ⏳ Other statements (e.g `if`, `@group`, ...)
 - ⏳ Cross-platform support (Linux, macOS)
 - ⏳ More built-in instruments (e.g. snare, hi-hat, etc.)