@devaloop/devalang 0.0.1-beta.2 → 0.1.1

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

@@ -1,574 +0,0 @@
-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)
-}

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

@@ -1,2 +0,0 @@
-pub mod driver;
-pub mod statements;