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

package/rust/core/audio/interpreter/driver.rs

@@ -1,26 +1,68 @@
+use devalang_types::Value;
+use devalang_utils::logger::{LogLevel, Logger};
 use rayon::prelude::*;
 
-use crate::{
-    core::{
-        audio::{
-            engine::AudioEngine,
-            interpreter::{
-                arrow_call::interprete_call_arrow_statement, call::interprete_call_statement,
-                function::interprete_function_statement, let_::interprete_let_statement,
-                load::interprete_load_statement, loop_::interprete_loop_statement,
-                sleep::interprete_sleep_statement, spawn::interprete_spawn_statement,
-                tempo::interprete_tempo_statement, trigger::interprete_trigger_statement,
-            },
+use crate::core::{
+    audio::{
+        engine::AudioEngine,
+        interpreter::{
+            arrow_call::interprete_call_arrow_statement, call::interprete_call_statement,
+            function::interprete_function_statement, let_::interprete_let_statement,
+            load::interprete_load_statement, loop_::interprete_loop_statement,
+            sleep::interprete_sleep_statement, spawn::interprete_spawn_statement,
+            tempo::interprete_tempo_statement, trigger::interprete_trigger_statement,
         },
-        parser::statement::{Statement, StatementKind},
-        shared::value::Value,
-        store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
     },
-    utils::logger::{LogLevel, Logger},
+    parser::statement::{Statement, StatementKind},
+    store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
 };
 
+// WASM playhead callback support (only compiled for wasm32 target)
+#[cfg(target_arch = "wasm32")]
+use serde::Serialize;
+
+#[cfg(target_arch = "wasm32")]
+use wasm_bindgen::prelude::JsValue;
+
+#[cfg(target_arch = "wasm32")]
+use std::cell::RefCell;
+
+#[cfg(target_arch = "wasm32")]
+thread_local! {
+    static PLAYHEAD_CB: RefCell<Option<js_sys::Function>> = RefCell::new(None);
+}
+
+#[cfg(target_arch = "wasm32")]
+pub fn register_playhead_callback(cb: js_sys::Function) {
+    PLAYHEAD_CB.with(|c| *c.borrow_mut() = Some(cb));
+}
+
+#[cfg(target_arch = "wasm32")]
+pub fn unregister_playhead_callback() {
+    PLAYHEAD_CB.with(|c| *c.borrow_mut() = None);
+}
+
+#[cfg(target_arch = "wasm32")]
+fn emit_playhead(time: f32, line: usize, column: usize) {
+    #[derive(Serialize)]
+    struct PlayheadEvent {
+        time: f32,
+        line: usize,
+        column: usize,
+    }
+
+    let ev = PlayheadEvent { time, line, column };
+    if let Ok(v) = serde_wasm_bindgen::to_value(&ev) {
+        PLAYHEAD_CB.with(|c| {
+            if let Some(f) = c.borrow().as_ref() {
+                let _ = f.call1(&JsValue::NULL, &v);
+            }
+        });
+    }
+}
+
 pub fn run_audio_program(
-    statements: &Vec<Statement>,
+    statements: &[Statement],
     audio_engine: &mut AudioEngine,
     _entry: String,
     _output: String,
@@ -36,7 +78,7 @@ pub fn run_audio_program(
         global_store,
         global_store.variables.clone(),
         global_store.functions.clone(),
-        &statements,
+        statements,
         base_bpm,
         base_duration,
         0.0,
@@ -46,6 +88,13 @@ pub fn run_audio_program(
     (max_end_time, cursor_time)
 }
 
+/// Execute a block of statements and schedule audio into the provided
+/// AudioEngine. This function is the core of offline rendering and
+/// performs the following responsibilities:
+/// - sequential evaluation of statements (load, let, trigger, loop, etc.)
+/// - parallel execution of `spawn` blocks (using rayon) and merging results
+/// - scheduling of periodic events (beat/bar) once at the root depth
+/// - emitting playhead events (when compiled for wasm32) after each sequential statement
 pub fn execute_audio_block(
     audio_engine: &mut AudioEngine,
     global_store: &GlobalStore,
@@ -71,7 +120,7 @@ pub fn execute_audio_block(
     for stmt in others {
         match &stmt.kind {
             StatementKind::Load { .. } => {
-                if let Some(new_table) = interprete_load_statement(&stmt, &mut variable_table) {
+                if let Some(new_table) = interprete_load_statement(stmt, &mut variable_table) {
                     variable_table = new_table;
                 }
             }
@@ -116,26 +165,26 @@ pub fn execute_audio_block(
                 }
             }
             StatementKind::Let { .. } => {
-                if let Some(new_table) = interprete_let_statement(&stmt, &mut variable_table) {
+                if let Some(new_table) = interprete_let_statement(stmt, &mut variable_table) {
                     variable_table = new_table;
                 }
             }
             StatementKind::Function { .. } => {
                 if let Some(new_functions) =
-                    interprete_function_statement(&stmt, &mut functions_table)
+                    interprete_function_statement(stmt, &mut functions_table)
                 {
                     functions_table = new_functions;
                 }
             }
             StatementKind::Tempo => {
-                if let Some((new_bpm, new_duration)) = interprete_tempo_statement(&stmt) {
+                if let Some((new_bpm, new_duration)) = interprete_tempo_statement(stmt) {
                     base_bpm = new_bpm;
                     base_duration = new_duration;
                 }
             }
             StatementKind::Trigger { .. } => {
                 if let Some((new_cursor, new_max, _)) = interprete_trigger_statement(
-                    &stmt,
+                    stmt,
                     audio_engine,
                     &variable_table,
                     base_duration,
@@ -148,13 +197,13 @@ pub fn execute_audio_block(
             }
             StatementKind::Sleep => {
                 let (new_cursor, new_max) =
-                    interprete_sleep_statement(&stmt, cursor_time, max_end_time);
+                    interprete_sleep_statement(stmt, cursor_time, max_end_time);
                 cursor_time = new_cursor;
                 max_end_time = new_max;
             }
             StatementKind::Loop => {
                 let (new_max, new_cursor) = interprete_loop_statement(
-                    &stmt,
+                    stmt,
                     audio_engine,
                     global_store,
                     &variable_table,
@@ -169,7 +218,7 @@ pub fn execute_audio_block(
             }
             StatementKind::Call { .. } => {
                 let (new_max, _) = interprete_call_statement(
-                    &stmt,
+                    stmt,
                     audio_engine,
                     &variable_table,
                     &functions_table,
@@ -184,16 +233,16 @@ pub fn execute_audio_block(
             }
             StatementKind::ArrowCall { .. } => {
                 let (new_max, new_cursor) = interprete_call_arrow_statement(
-                    &stmt,
+                    stmt,
                     audio_engine,
                     &variable_table,
+                    global_store,
                     base_bpm,
                     base_duration,
                     &mut max_end_time,
                     Some(&mut cursor_time),
                     true,
                 );
-
                 cursor_time = new_cursor;
 
                 if new_max > max_end_time {
@@ -203,7 +252,7 @@ pub fn execute_audio_block(
             StatementKind::Automate { .. } => {
                 if let Some(new_table) =
                     crate::core::audio::interpreter::automate::interprete_automate_statement(
-                        &stmt,
+                        stmt,
                         &mut variable_table,
                     )
                 {
@@ -237,7 +286,7 @@ pub fn execute_audio_block(
                                 )
                             {
                                 logger.log_message(LogLevel::Print, &res);
-                            } else if let Some(val) = variable_table.get(&s) {
+                            } else if let Some(val) = variable_table.get(s) {
                                 logger.log_message(LogLevel::Print, &format!("{:?}", val));
                             } else if s.contains("$env")
                                 || s.contains("$math")
@@ -251,12 +300,12 @@ pub fn execute_audio_block(
                                 );
                                 match v {
                                     Value::Number(n) => {
-                                        logger.log_message(LogLevel::Print, &format!("{}", n))
+                                        logger.log_message(LogLevel::Print, &format!("{}", n));
                                     }
                                     _ => logger.log_message(LogLevel::Print, s),
                                 }
                             } else {
-                                logger.log_message(LogLevel::Print, s)
+                                logger.log_message(LogLevel::Print, s);
                             }
                         }
                         Value::Number(n) => {
@@ -266,18 +315,19 @@ pub fn execute_audio_block(
                             if let Some(val) = variable_table.get(name) {
                                 match val {
                                     Value::Number(n) => {
-                                        logger.log_message(LogLevel::Print, &format!("{}", n))
+                                        logger.log_message(LogLevel::Print, &format!("{}", n));
                                     }
                                     Value::String(s) => logger.log_message(LogLevel::Print, s),
                                     Value::Boolean(b) => {
-                                        logger.log_message(LogLevel::Print, &format!("{}", b))
+                                        logger.log_message(LogLevel::Print, &format!("{}", b));
                                     }
                                     other => {
-                                        logger.log_message(LogLevel::Print, &format!("{:?}", other))
+                                        logger
+                                            .log_message(LogLevel::Print, &format!("{:?}", other));
                                     }
                                 }
                             } else {
-                                logger.log_message(LogLevel::Print, name)
+                                logger.log_message(LogLevel::Print, name);
                             }
                         }
                         v => logger.log_message(LogLevel::Print, &format!("{:?}", v)),
@@ -286,6 +336,12 @@ pub fn execute_audio_block(
             }
             _ => {}
         }
+
+        // Emit playhead event for UI bindings when building real-time playback
+        #[cfg(target_arch = "wasm32")]
+        {
+            emit_playhead(cursor_time, stmt.line, stmt.column);
+        }
     }
 
     // Execute parallel spawns (collect results)
@@ -316,31 +372,30 @@ pub fn execute_audio_block(
         }
     }
 
-    // ─────────────────────────────────────────────────────────────
     // Built-in periodic events (e.g., on beat(n), on bar(n))
     // Emit handlers across the timeline up to max_end_time.
     // If no audio was scheduled (max_end_time == 0.0), skip.
     // Don't schedule periodic events if we're already inside an event handler
     let in_event = matches!(variable_table.get("__in_event"), Some(Value::Boolean(true)));
     let depth_is_root = matches!(variable_table.get("__depth"), Some(Value::Number(n)) if (*n - 1.0).abs() < f32::EPSILON);
-    if max_end_time > 0.0 && !in_event && depth_is_root {
-        if !global_store.events.is_empty() {
-            // Beat-based handlers (support "beat" and "$beat")
-            for ev_key in ["beat", "$beat"] {
-                if let Some(handlers) = global_store.get_event_handlers(ev_key) {
-                    let mut seen: std::collections::HashSet<(usize, usize, usize)> =
-                        std::collections::HashSet::new();
-                    // Default every 1 beat if args missing
-                    for h in handlers {
-                        let key = (h.line, h.column, h.indent);
-                        if !seen.insert(key) {
-                            continue;
-                        }
-                        if let StatementKind::On { event, args, body } = &h.kind {
-                            let every: f32 = args
-                                .as_ref()
-                                .and_then(|v| v.get(0))
-                                .and_then(|x| match x {
+    if max_end_time > 0.0 && !in_event && depth_is_root && !global_store.events.is_empty() {
+        // Beat-based handlers (support "beat" and "$beat")
+        for ev_key in ["beat", "$beat"] {
+            if let Some(handlers) = global_store.get_event_handlers(ev_key) {
+                let mut seen: std::collections::HashSet<(usize, usize, usize)> =
+                    std::collections::HashSet::new();
+                // Default every 1 beat if args missing
+                for h in handlers {
+                    let key = (h.line, h.column, h.indent);
+                    if !seen.insert(key) {
+                        continue;
+                    }
+                    if let StatementKind::On { event, args, body } = &h.kind {
+                        let every: f32 = args
+                            .as_ref()
+                            .and_then(|v| v.first())
+                            .and_then(|x| {
+                                match x {
                                     Value::Number(n) => Some(*n),
                                     Value::Identifier(s) => {
                                         // Try to resolve from variables first, fallback to parsing the literal
@@ -350,14 +405,81 @@ pub fn execute_audio_block(
                                         }
                                     }
                                     _ => None,
+                                }
+                            })
+                            .unwrap_or(1.0)
+                            .max(0.0001);
+                        let step = base_duration * every;
+                        // Start from first full bar boundary after t=0
+                        let mut t = step;
+                        while t <= max_end_time {
+                            // Prepare event context
+                            let mut vt = variable_table.clone();
+                            let mut ctx = std::collections::HashMap::new();
+                            ctx.insert("name".to_string(), Value::String(event.clone()));
+                            if let Some(a) = args.clone() {
+                                ctx.insert("args".to_string(), Value::Array(a));
+                            }
+                            vt.set("event".to_string(), Value::Map(ctx));
+                            vt.set("beat".to_string(), Value::Number(t / base_duration));
+                            // Prevent nested scheduling
+                            vt.set("__in_event".to_string(), Value::Boolean(true));
+
+                            let (_m, _c) = execute_audio_block(
+                                audio_engine,
+                                global_store,
+                                vt,
+                                functions_table.clone(),
+                                body,
+                                base_bpm,
+                                base_duration,
+                                max_end_time,
+                                t,
+                            );
+
+                            t += step;
+                        }
+                    }
+                }
+            }
+        }
+
+        // Bar-based handlers (default 4/4 time => 4 beats per bar); support "bar" and "$bar"
+        for ev_key in ["bar", "$bar"] {
+            if let Some(handlers) = global_store.get_event_handlers(ev_key) {
+                let mut seen: std::collections::HashSet<(usize, usize, usize)> =
+                    std::collections::HashSet::new();
+                for h in handlers {
+                    let key = (h.line, h.column, h.indent);
+                    if !seen.insert(key) {
+                        continue;
+                    }
+                    if let StatementKind::On { event, args, body } = &h.kind {
+                        let bar_beats = 4.0f32; // TODO: time signature support
+                        let first_only = args.as_ref().and_then(|v| v.first()).is_none();
+
+                        let every_bar: f32 = if first_only {
+                            1.0
+                        } else {
+                            args.as_ref()
+                                .and_then(|v| v.first())
+                                .and_then(|x| match x {
+                                    Value::Number(n) => Some(*n),
+                                    Value::Identifier(s) => match variable_table.get(s) {
+                                        Some(Value::Number(n)) => Some(*n),
+                                        _ => s.parse::<f32>().ok(),
+                                    },
+                                    _ => None,
                                 })
                                 .unwrap_or(1.0)
-                                .max(0.0001);
-                            let step = base_duration * every;
-                            // Start from first full bar boundary after t=0
-                            let mut t = step;
-                            while t <= max_end_time {
-                                // Prepare event context
+                                .max(0.0001)
+                        };
+
+                        let step = base_duration * bar_beats * every_bar;
+
+                        if first_only {
+                            let t = step; // first full bar after t=0
+                            if t <= max_end_time {
                                 let mut vt = variable_table.clone();
                                 let mut ctx = std::collections::HashMap::new();
                                 ctx.insert("name".to_string(), Value::String(event.clone()));
@@ -380,101 +502,34 @@ pub fn execute_audio_block(
                                     max_end_time,
                                     t,
                                 );
-
-                                t += step;
                             }
-                        }
-                    }
-                }
-            }
-
-            // Bar-based handlers (default 4/4 time => 4 beats per bar); support "bar" and "$bar"
-            for ev_key in ["bar", "$bar"] {
-                if let Some(handlers) = global_store.get_event_handlers(ev_key) {
-                    let mut seen: std::collections::HashSet<(usize, usize, usize)> =
-                        std::collections::HashSet::new();
-                    for h in handlers {
-                        let key = (h.line, h.column, h.indent);
-                        if !seen.insert(key) {
-                            continue;
-                        }
-                        if let StatementKind::On { event, args, body } = &h.kind {
-                            let bar_beats = 4.0f32; // TODO: time signature support
-                            let first_only = args.as_ref().and_then(|v| v.get(0)).is_none();
-
-                            let every_bar: f32 = if first_only {
-                                1.0
-                            } else {
-                                args.as_ref()
-                                    .and_then(|v| v.get(0))
-                                    .and_then(|x| match x {
-                                        Value::Number(n) => Some(*n),
-                                        Value::Identifier(s) => match variable_table.get(s) {
-                                            Some(Value::Number(n)) => Some(*n),
-                                            _ => s.parse::<f32>().ok(),
-                                        },
-                                        _ => None,
-                                    })
-                                    .unwrap_or(1.0)
-                                    .max(0.0001)
-                            };
-
-                            let step = base_duration * bar_beats * every_bar;
-
-                            if first_only {
-                                let t = step; // first full bar after t=0
-                                if t <= max_end_time {
-                                    let mut vt = variable_table.clone();
-                                    let mut ctx = std::collections::HashMap::new();
-                                    ctx.insert("name".to_string(), Value::String(event.clone()));
-                                    if let Some(a) = args.clone() {
-                                        ctx.insert("args".to_string(), Value::Array(a));
-                                    }
-                                    vt.set("event".to_string(), Value::Map(ctx));
-                                    vt.set("beat".to_string(), Value::Number(t / base_duration));
-                                    // Prevent nested scheduling
-                                    vt.set("__in_event".to_string(), Value::Boolean(true));
-
-                                    let (_m, _c) = execute_audio_block(
-                                        audio_engine,
-                                        global_store,
-                                        vt,
-                                        functions_table.clone(),
-                                        body,
-                                        base_bpm,
-                                        base_duration,
-                                        max_end_time,
-                                        t,
-                                    );
+                        } else {
+                            let mut t = step; // start from first full bar after t=0
+                            while t <= max_end_time {
+                                let mut vt = variable_table.clone();
+                                let mut ctx = std::collections::HashMap::new();
+                                ctx.insert("name".to_string(), Value::String(event.clone()));
+                                if let Some(a) = args.clone() {
+                                    ctx.insert("args".to_string(), Value::Array(a));
                                 }
-                            } else {
-                                let mut t = step; // start from first full bar after t=0
-                                while t <= max_end_time {
-                                    let mut vt = variable_table.clone();
-                                    let mut ctx = std::collections::HashMap::new();
-                                    ctx.insert("name".to_string(), Value::String(event.clone()));
-                                    if let Some(a) = args.clone() {
-                                        ctx.insert("args".to_string(), Value::Array(a));
-                                    }
-                                    vt.set("event".to_string(), Value::Map(ctx));
-                                    vt.set("beat".to_string(), Value::Number(t / base_duration));
-                                    // Prevent nested scheduling
-                                    vt.set("__in_event".to_string(), Value::Boolean(true));
+                                vt.set("event".to_string(), Value::Map(ctx));
+                                vt.set("beat".to_string(), Value::Number(t / base_duration));
+                                // Prevent nested scheduling
+                                vt.set("__in_event".to_string(), Value::Boolean(true));
 
-                                    let (_m, _c) = execute_audio_block(
-                                        audio_engine,
-                                        global_store,
-                                        vt,
-                                        functions_table.clone(),
-                                        body,
-                                        base_bpm,
-                                        base_duration,
-                                        max_end_time,
-                                        t,
-                                    );
+                                let (_m, _c) = execute_audio_block(
+                                    audio_engine,
+                                    global_store,
+                                    vt,
+                                    functions_table.clone(),
+                                    body,
+                                    base_bpm,
+                                    base_duration,
+                                    max_end_time,
+                                    t,
+                                );
 
-                                    t += step;
-                                }
+                                t += step;
                             }
                         }
                     }

package/rust/core/audio/interpreter/let_.rs

@@ -1,8 +1,8 @@
 use crate::core::{
     parser::statement::{Statement, StatementKind},
-    shared::value::Value,
     store::variable::VariableTable,
 };
+use devalang_types::Value;
 
 pub fn interprete_let_statement(
     stmt: &Statement,

package/rust/core/audio/interpreter/load.rs

@@ -1,6 +1,7 @@
+use devalang_types::Value;
+
 use crate::core::{
     parser::statement::{Statement, StatementKind},
-    shared::value::Value,
     store::variable::VariableTable,
 };
 

package/rust/core/audio/interpreter/loop_.rs

@@ -1,7 +1,8 @@
+use devalang_types::Value;
+
 use crate::core::{
     audio::{engine::AudioEngine, interpreter::driver::execute_audio_block},
     parser::statement::Statement,
-    shared::value::Value,
     store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
 };
 
@@ -27,7 +28,7 @@ pub fn interprete_loop_statement(
             loop_value.get("array"),
             loop_value.get("body"),
         ) {
-            let mut engine = audio_engine;
+            let engine = audio_engine;
             let mut cur_time = cursor_time;
             let mut max_time = max_end_time;
 
@@ -36,11 +37,11 @@ pub fn interprete_loop_statement(
                 scoped_vars.set(var_name.clone(), item.clone());
 
                 let (block_end_time, new_cursor) = execute_audio_block(
-                    &mut engine,
+                    engine,
                     global_store,
                     scoped_vars,
                     functions_table.clone(),
-                    &loop_body,
+                    loop_body,
                     base_bpm,
                     base_duration,
                     max_time,
@@ -84,13 +85,13 @@ pub fn interprete_loop_statement(
             }
         };
 
-        let mut engine = audio_engine;
+        let engine = audio_engine;
         let mut cur_time = cursor_time;
         let mut max_time = max_end_time;
 
         for _ in 0..loop_count {
             let (block_end_time, new_cursor) = execute_audio_block(
-                &mut engine,
+                engine,
                 global_store,
                 variable_table.clone(),
                 functions_table.clone(),

package/rust/core/audio/interpreter/sleep.rs

@@ -1,4 +1,5 @@
-use crate::core::{parser::statement::Statement, shared::value::Value};
+use crate::core::parser::statement::Statement;
+use devalang_types::Value;
 
 pub fn interprete_sleep_statement(
     stmt: &Statement,