@devaloop/devalang 0.0.1-alpha.9 → 0.0.1-beta.2

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

@@ -1,216 +1,574 @@
-use crate::core::{
-    audio::{
-        engine::AudioEngine,
-        interpreter::{
-            arrow_call::interprete_call_arrow_statement,
-            call::interprete_call_statement,
-            condition::interprete_condition_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 },
-    store::variable::VariableTable,
-};
-
-pub fn run_audio_program(
-    statements: &Vec<Statement>,
-    audio_engine: AudioEngine,
-    entry: String,
-    output: String
-) -> (AudioEngine, f32, f32) {
-    let mut base_bpm = 120.0;
-    let mut base_duration = 60.0 / base_bpm;
-
-    let variable_table = audio_engine.variables.clone();
-
-    let (updated_audio_engine, base_bpm, max_end_time) = execute_audio_block(
-        audio_engine,
-        variable_table.clone(),
-        statements.clone(),
-        base_bpm.clone(),
-        base_duration.clone(),
-        0.0,
-        0.0
-    );
-
-    (updated_audio_engine, base_bpm, max_end_time)
-}
-
-pub fn execute_audio_block(
-    mut audio_engine: AudioEngine,
-    mut variable_table: VariableTable,
-    mut statements: Vec<Statement>,
-    mut base_bpm: f32,
-    mut base_duration: f32,
-    mut max_end_time: f32,
-    mut cursor_time: f32
-) -> (AudioEngine, f32, f32) {
-    let initial_cursor_time = cursor_time;
-
-    for stmt in statements {
-        match &stmt.kind {
-            StatementKind::Load { .. } => {
-                if
-                    let Some(new_variable_table) = interprete_load_statement(
-                        &stmt,
-                        &mut variable_table
-                    )
-                {
-                    variable_table = new_variable_table;
-                } else {
-                    eprintln!("❌ Failed to interpret load statement: {:?}", stmt);
-                }
-            }
-
-            StatementKind::Let { .. } => {
-                if
-                    let Some(new_variable_table) = interprete_let_statement(
-                        &stmt,
-                        &mut variable_table
-                    )
-                {
-                    variable_table = new_variable_table;
-                } else {
-                    eprintln!("❌ Failed to interpret let statement: {:?}", stmt);
-                }
-            }
-
-            StatementKind::Tempo => {
-                if let Some((new_bpm, new_duration)) = interprete_tempo_statement(&stmt) {
-                    base_bpm = new_bpm;
-                    base_duration = new_duration;
-                } else {
-                    eprintln!("❌ Failed to interpret tempo statement: {:?}", stmt);
-                }
-            }
-
-            StatementKind::Trigger { .. } => {
-                if
-                    let Some((new_cursor_time, new_max_end_time, updated_engine)) =
-                        interprete_trigger_statement(
-                            &stmt,
-                            &mut audio_engine,
-                            &variable_table,
-                            base_duration,
-                            cursor_time,
-                            max_end_time
-                        )
-                {
-                    cursor_time = new_cursor_time;
-                    max_end_time = new_max_end_time;
-                    audio_engine = updated_engine;
-                } else {
-                    eprintln!("❌ Failed to interpret trigger statement: {:?}", stmt);
-                }
-            }
-
-            StatementKind::Spawn => {
-                let mut temp_engine = AudioEngine::new(audio_engine.module_name.clone());
-
-                if
-                    let Some((_cur, _max, updated_engine)) = interprete_spawn_statement(
-                        &stmt,
-                        temp_engine,
-                        &variable_table,
-                        base_bpm,
-                        base_duration,
-                        initial_cursor_time,
-                        max_end_time
-                    )
-                {
-                    audio_engine.merge_with(updated_engine);
-                }
-            }
-
-            StatementKind::Call => {
-                let (call_engine, new_max, new_cursor) = interprete_call_statement(
-                    &stmt,
-                    audio_engine.clone(),
-                    variable_table.clone(),
-                    base_bpm,
-                    base_duration,
-                    max_end_time,
-                    cursor_time
-                );
-
-                audio_engine.merge_with(call_engine);
-            }
-
-            StatementKind::Sleep => {
-                let (new_cursor, new_max) = interprete_sleep_statement(
-                    &stmt,
-                    cursor_time,
-                    max_end_time
-                );
-                cursor_time = new_cursor;
-                max_end_time = new_max;
-            }
-
-            StatementKind::Loop => {
-                let (loop_engine, new_max, new_cursor) = interprete_loop_statement(
-                    &stmt,
-                    audio_engine.clone(),
-                    variable_table.clone(),
-                    base_bpm,
-                    base_duration,
-                    max_end_time,
-                    cursor_time
-                );
-                audio_engine = loop_engine;
-                cursor_time = new_cursor;
-                max_end_time = new_max;
-            }
-
-            StatementKind::If | StatementKind::ElseIf | StatementKind::Else => {
-                let (condition_engine, new_max, new_cursor) = interprete_condition_statement(
-                    &stmt,
-                    audio_engine.clone(),
-                    variable_table.clone(),
-                    base_bpm,
-                    base_duration,
-                    max_end_time,
-                    cursor_time
-                );
-
-                audio_engine = condition_engine;
-                cursor_time = new_cursor;
-                max_end_time = new_max;
-            }
-
-            StatementKind::ArrowCall { .. } => {
-                interprete_call_arrow_statement(
-                    &stmt,
-                    &mut audio_engine,
-                    &variable_table,
-                    base_bpm,
-                    base_duration,
-                    &mut max_end_time,
-                    Some(&mut cursor_time),
-                    true
-                );
-            }
-
-            | StatementKind::Bank
-            | StatementKind::Import { .. }
-            | StatementKind::Export { .. }
-            | StatementKind::Group
-            | StatementKind::Unknown => {
-                // NOTE: Ignoring unsupported statement kinds for now.
-            }
-
-            _ => {
-                eprintln!("Unsupported audio statement kind: {:?}", stmt);
-            }
-        }
-    }
-
-    audio_engine.set_variables(variable_table);
-
-    (audio_engine, base_bpm, max_end_time)
-}
+use devalang_types::Value;
+use devalang_utils::logger::{LogLevel, Logger};
+use rayon::prelude::*;
+
+use crate::core::{
+    audio::{
+        engine::AudioEngine,
+        interpreter::statements::{
+            arrow_call::interprete::interprete_arrow_call_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},
+    store::global::GlobalStore,
+};
+use devalang_types::{FunctionTable, VariableTable};
+
+// WASM playhead callback support (only compiled for wasm32 target)
+#[cfg(target_arch = "wasm32")]
+use serde::Serialize;
+
+#[cfg(target_arch = "wasm32")]
+#[derive(Serialize, Clone)]
+pub struct PlayheadEvent {
+    time: f32,
+    line: usize,
+    column: usize,
+}
+
+#[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);
+    static PLAYHEAD_EVENTS: RefCell<Vec<PlayheadEvent>> = RefCell::new(Vec::new());
+}
+
+#[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")]
+pub fn collect_playhead_events() -> Vec<PlayheadEvent> {
+    PLAYHEAD_EVENTS.with(|c| c.borrow().clone())
+}
+
+#[cfg(target_arch = "wasm32")]
+fn emit_playhead(time: f32, line: usize, column: usize) {
+    let ev = PlayheadEvent { time, line, column };
+    PLAYHEAD_EVENTS.with(|c| c.borrow_mut().push(ev.clone()));
+
+    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: &[Statement],
+    audio_engine: &mut AudioEngine,
+    _entry: String,
+    _output: String,
+    _module_variables: VariableTable,
+    _module_functions: FunctionTable,
+    global_store: &mut GlobalStore,
+) -> (f32, f32) {
+    // Clear any previously collected playhead events for wasm target so each
+    // run starts with an empty events buffer.
+    #[cfg(target_arch = "wasm32")]
+    {
+        PLAYHEAD_EVENTS.with(|c| c.borrow_mut().clear());
+    }
+
+    let base_bpm = 120.0;
+    let base_duration = 60.0 / base_bpm;
+
+    let (max_end_time, cursor_time) = execute_audio_block(
+        audio_engine,
+        global_store,
+        global_store.variables.clone(),
+        global_store.functions.clone(),
+        statements,
+        base_bpm,
+        base_duration,
+        0.0,
+        0.0,
+    );
+
+    (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,
+    mut variable_table: VariableTable,
+    mut functions_table: FunctionTable,
+    statements: &[Statement],
+    mut base_bpm: f32,
+    mut base_duration: f32,
+    mut max_end_time: f32,
+    mut cursor_time: f32,
+) -> (f32, f32) {
+    // Track nested depth of execute_audio_block to avoid scheduling periodic events multiple times
+    let current_depth = match variable_table.get("__depth") {
+        Some(Value::Number(n)) => *n,
+        _ => 0.0,
+    };
+    variable_table.set("__depth".to_string(), Value::Number(current_depth + 1.0));
+    let (spawns, others): (Vec<_>, Vec<_>) = statements
+        .iter()
+        .partition(|stmt| matches!(stmt.kind, StatementKind::Spawn { .. }));
+
+    // Execute sequential statements first
+    for stmt in others {
+        match &stmt.kind {
+            StatementKind::Load { .. } => {
+                if let Some(new_table) = interprete_load_statement(stmt, &mut variable_table) {
+                    variable_table = new_table;
+                }
+            }
+            StatementKind::On { .. } => {
+                // already registered in global store during parsing; nothing to do at runtime
+            }
+            StatementKind::Emit { event, payload: _ } => {
+                if let Some(handlers) = global_store.get_event_handlers(event) {
+                    for h in handlers {
+                        if let StatementKind::On {
+                            event: _,
+                            args,
+                            body,
+                        } = &h.kind
+                        {
+                            // Create a derived variable table with 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(arg_list) = args.clone() {
+                                ctx.insert("args".to_string(), Value::Array(arg_list));
+                            }
+                            // Attach payload if any on the Emit statement value
+                            ctx.insert("payload".to_string(), stmt.value.clone());
+                            vt.set("event".to_string(), Value::Map(ctx));
+                            // Mark we're inside an event handler to avoid re-scheduling periodic events recursively
+                            vt.set("__in_event".to_string(), Value::Boolean(true));
+
+                            let (_max, _cursor) = execute_audio_block(
+                                audio_engine,
+                                global_store,
+                                vt,
+                                functions_table.clone(),
+                                body,
+                                base_bpm,
+                                base_duration,
+                                max_end_time,
+                                cursor_time,
+                            );
+                        }
+                    }
+                }
+            }
+            StatementKind::Let { .. } => {
+                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)
+                {
+                    functions_table = new_functions;
+                }
+            }
+            StatementKind::Tempo => {
+                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,
+                    audio_engine,
+                    &variable_table,
+                    base_duration,
+                    cursor_time,
+                    max_end_time,
+                ) {
+                    cursor_time = new_cursor;
+                    max_end_time = new_max;
+                }
+            }
+            StatementKind::Sleep => {
+                let (new_cursor, new_max) =
+                    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,
+                    audio_engine,
+                    global_store,
+                    &variable_table,
+                    &functions_table,
+                    base_bpm,
+                    base_duration,
+                    max_end_time,
+                    cursor_time,
+                );
+                cursor_time = new_cursor;
+                max_end_time = new_max;
+            }
+            StatementKind::Call { .. } => {
+                let (new_max, _) = interprete_call_statement(
+                    stmt,
+                    audio_engine,
+                    &variable_table,
+                    &functions_table,
+                    global_store,
+                    base_bpm,
+                    base_duration,
+                    max_end_time,
+                    cursor_time,
+                );
+                cursor_time = new_max;
+                max_end_time = new_max;
+            }
+            StatementKind::ArrowCall { .. } => {
+                let (new_max, new_cursor) = interprete_arrow_call_statement(
+                    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 {
+                    max_end_time = new_max;
+                }
+            }
+            StatementKind::Automate { .. } => {
+                if
+                    let Some(new_table) =
+                        crate::core::audio::interpreter::statements::automate::interprete_automate_statement(
+                            stmt,
+                            &mut variable_table
+                        )
+                {
+                    variable_table = new_table;
+                }
+            }
+            StatementKind::Print => {
+                // Only print in real-time mode (during playback), not during offline render.
+                let is_realtime = matches!(variable_table.get("__rt"), Some(Value::Boolean(true)));
+                if is_realtime {
+                    let logger = Logger::new();
+                    match &stmt.value {
+                        Value::String(s) => {
+                            let bpm = if let Some(Value::Number(n)) = variable_table.get("bpm") {
+                                *n
+                            } else {
+                                120.0
+                            };
+                            let beat = if let Some(Value::Number(n)) = variable_table.get("beat") {
+                                *n
+                            } else {
+                                0.0
+                            };
+                            // First try JS-like string concatenation: "str " + var + 1 + $env.*
+                            if let Some(res) =
+                                crate::core::audio::evaluator::evaluate_string_expression(
+                                    s,
+                                    &variable_table,
+                                    bpm,
+                                    beat,
+                                )
+                            {
+                                logger.log_message(LogLevel::Print, &res);
+                            } else if let Some(val) = variable_table.get(s) {
+                                logger.log_message(LogLevel::Print, &format!("{:?}", val));
+                            } else if s.contains("$env")
+                                || s.contains("$math")
+                                || s.parse::<f32>().is_ok()
+                            {
+                                let v = crate::core::audio::evaluator::evaluate_rhs_into_value(
+                                    s,
+                                    &variable_table,
+                                    bpm,
+                                    beat,
+                                );
+                                match v {
+                                    Value::Number(n) => {
+                                        logger.log_message(LogLevel::Print, &format!("{}", n));
+                                    }
+                                    _ => logger.log_message(LogLevel::Print, s),
+                                }
+                            } else {
+                                logger.log_message(LogLevel::Print, s);
+                            }
+                        }
+                        Value::Number(n) => {
+                            logger.log_message(LogLevel::Print, &format!("{}", n));
+                        }
+                        Value::Identifier(name) => {
+                            if let Some(val) = variable_table.get(name) {
+                                match val {
+                                    Value::Number(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));
+                                    }
+                                    other => {
+                                        logger
+                                            .log_message(LogLevel::Print, &format!("{:?}", other));
+                                    }
+                                }
+                            } else {
+                                logger.log_message(LogLevel::Print, name);
+                            }
+                        }
+                        v => logger.log_message(LogLevel::Print, &format!("{:?}", v)),
+                    }
+                }
+            }
+            _ => {}
+        }
+
+        // Emit playhead event for UI bindings when building real-time playback
+        // Only emit for statements that are "playable" (i.e., schedule audio)
+        #[cfg(target_arch = "wasm32")]
+        {
+            if matches!(
+                stmt.kind,
+                StatementKind::Trigger { .. }
+                    | StatementKind::Call { .. }
+                    | StatementKind::Spawn { .. }
+                    | StatementKind::Loop
+            ) {
+                emit_playhead(cursor_time, stmt.line, stmt.column);
+            }
+        }
+    }
+
+    // Execute parallel spawns (collect results)
+    let spawn_results: Vec<(AudioEngine, f32)> = spawns
+        .par_iter()
+        .map(|stmt| {
+            let mut local_engine = AudioEngine::new(audio_engine.module_name.clone());
+            let (spawn_max, _) = interprete_spawn_statement(
+                stmt,
+                &mut local_engine,
+                &variable_table,
+                &functions_table,
+                global_store,
+                base_bpm,
+                base_duration,
+                0.0,
+                0.0,
+            );
+            (local_engine, spawn_max)
+        })
+        .collect();
+
+    // Finally, merge results from all spawns
+    for (local_engine, spawn_max) in spawn_results {
+        audio_engine.merge_with(local_engine);
+        if spawn_max > max_end_time {
+            max_end_time = spawn_max;
+        }
+    }
+
+    // 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 && !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
+                                        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
+                            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 * 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));
+                                }
+                                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;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    (max_end_time.max(cursor_time), cursor_time)
+}