@devaloop/devalang 0.0.1-beta.2 → 0.1.1

package/rust/core/audio/engine/notes/params.rs

@@ -1,294 +0,0 @@
-use devalang_types::Value;
-use std::collections::HashMap;
-
-pub struct FilterSpec {
-    pub kind: String,
-    pub cutoff: f32,
-}
-
-pub struct FilterState {
-    pub prev_l: f32,
-    pub prev_r: f32,
-    pub prev_in_l: f32,
-    pub prev_in_r: f32,
-    pub prev_out_l: f32,
-    pub prev_out_r: f32,
-}
-
-pub struct NoteSetup {
-    pub sample_rate: f32,
-    pub channels: usize,
-    pub total_samples: usize,
-    pub start_sample: usize,
-    pub attack_samples: usize,
-    pub decay_samples: usize,
-    pub release_samples: usize,
-    pub sustain_level: f32,
-    pub pluck_click: f32,
-    pub pluck_click_samples: usize,
-    pub drive: f32,
-    pub filters: Vec<FilterSpec>,
-    pub filter_states: Vec<FilterState>,
-    pub lfo_rate: f32,
-    pub lfo_depth: f32,
-    pub lfo_target: Option<String>,
-    pub voices: usize,
-    pub unison_detune: f32,
-    pub volume_env: HashMap<String, Value>,
-    pub pan_env: HashMap<String, Value>,
-    pub pitch_env: HashMap<String, Value>,
-}
-
-pub fn build_note_setup(
-    engine: &mut crate::core::audio::engine::AudioEngine,
-    _waveform: &str,
-    freq: f32,
-    amp: f32,
-    start_time_ms: f32,
-    mut duration_ms: f32,
-    synth_params: &HashMap<String, Value>,
-    note_params: &HashMap<String, Value>,
-    automation: &Option<HashMap<String, Value>>,
-) -> NoteSetup {
-    use crate::core::audio::engine::helpers;
-
-    // Extract ADSR and normalize units
-    let attack = engine.extract_f32(synth_params, "attack").unwrap_or(0.0);
-    let decay = engine.extract_f32(synth_params, "decay").unwrap_or(0.0);
-    let sustain = engine.extract_f32(synth_params, "sustain").unwrap_or(1.0);
-    let release = engine.extract_f32(synth_params, "release").unwrap_or(0.0);
-    let _sustain_level = if sustain > 1.0 {
-        (sustain / 100.0).clamp(0.0, 1.0)
-    } else {
-        sustain.clamp(0.0, 1.0)
-    };
-
-    if let Some(g) = engine.extract_f32(note_params, "gate") {
-        if g > 0.0 && g <= 1.0 {
-            duration_ms = duration_ms * g;
-        } else if g > 1.0 {
-            duration_ms = duration_ms * (g / 100.0);
-        }
-    } else if let Some(g) = engine.extract_f32(synth_params, "gate") {
-        if g > 0.0 && g <= 1.0 {
-            duration_ms = duration_ms * g;
-        } else if g > 1.0 {
-            duration_ms = duration_ms * (g / 100.0);
-        }
-    }
-
-    let velocity = engine.extract_f32(note_params, "velocity").unwrap_or(1.0);
-
-    let detune_cents = engine
-        .extract_f32(note_params, "detune")
-        .or(engine.extract_f32(synth_params, "detune"))
-        .unwrap_or(0.0);
-
-    let _lowpass_cut = engine
-        .extract_f32(note_params, "lowpass")
-        .or(engine.extract_f32(synth_params, "lowpass"))
-        .unwrap_or(0.0);
-
-    let _amplitude = (i16::MAX as f32) * amp.clamp(0.0, 1.0) * velocity.clamp(0.0, 1.0);
-
-    let _freq_start = freq;
-    let mut _freq_end = freq;
-    let _amp_start = amp * velocity.clamp(0.0, 1.0);
-    let mut _amp_end = _amp_start;
-
-    let glide = engine
-        .extract_boolean(note_params, "glide")
-        .unwrap_or(false);
-    let slide = engine
-        .extract_boolean(note_params, "slide")
-        .unwrap_or(false);
-    if glide {
-        if let Some(Value::Number(target_freq)) = note_params.get("target_freq") {
-            _freq_end = *target_freq;
-        } else {
-            _freq_end = freq * 1.5;
-        }
-    }
-    if slide {
-        if let Some(Value::Number(target_amp)) = note_params.get("target_amp") {
-            _amp_end = *target_amp * velocity.clamp(0.0, 1.0);
-        } else {
-            _amp_end = _amp_start * 0.5;
-        }
-    }
-
-    let sample_rate = engine.sample_rate as f32;
-    let channels = engine.channels as usize;
-
-    let total_samples = ((duration_ms / 1000.0) * sample_rate) as usize;
-    let start_sample = ((start_time_ms / 1000.0) * sample_rate) as usize;
-
-    // MIDI event
-    let midi_note_f = 69.0 + 12.0 * (_freq_start / 440.0).log2();
-    let midi_note = midi_note_f.round().clamp(0.0, 127.0) as u8;
-    let midi_vel = (velocity.clamp(0.0, 1.0) * 127.0).round().clamp(0.0, 127.0) as u8;
-    engine
-        .midi_events
-        .push(crate::core::audio::engine::driver::MidiNoteEvent {
-            key: midi_note,
-            vel: midi_vel,
-            start_ms: start_time_ms as u32,
-            duration_ms: duration_ms as u32,
-            channel: 0,
-        });
-
-    let _detune_factor = (2.0_f32).powf(detune_cents / 1200.0);
-
-    let (_volume_env, _pan_env, _pitch_env) = helpers::env_maps_from_automation(automation);
-
-    let attack_s = if attack > 10.0 {
-        attack / 1000.0
-    } else {
-        attack
-    };
-    let decay_s = if decay > 10.0 { decay / 1000.0 } else { decay };
-    let release_s = if release > 10.0 {
-        release / 1000.0
-    } else {
-        release
-    };
-    let sustain_level = _sustain_level;
-
-    let attack_samples = (attack_s * sample_rate) as usize;
-    let decay_samples = (decay_s * sample_rate) as usize;
-    let release_samples = (release_s * sample_rate) as usize;
-
-    // optional pluck click
-    let pluck_click = engine
-        .extract_f32(note_params, "pluck_click")
-        .or(engine.extract_f32(synth_params, "pluck_click"))
-        .unwrap_or(0.0);
-    let pluck_click_ms = engine
-        .extract_f32(note_params, "pluck_click_ms")
-        .or(engine.extract_f32(synth_params, "pluck_click_ms"))
-        .unwrap_or(10.0);
-    let pluck_click_samples = ((pluck_click_ms / 1000.0) * sample_rate) as usize;
-
-    let drive = engine
-        .extract_f32(note_params, "drive")
-        .or(engine.extract_f32(synth_params, "drive"))
-        .unwrap_or(0.0);
-
-    // parse filter specs
-    let mut raw_filters: Vec<HashMap<String, Value>> = Vec::new();
-    if let Some(Value::Array(arr)) = synth_params.get("filters") {
-        for v in arr {
-            if let Value::Map(m) = v {
-                raw_filters.push(m.clone());
-            }
-        }
-    }
-    if let Some(Value::Array(arr)) = note_params.get("filters") {
-        for v in arr {
-            if let Value::Map(m) = v {
-                raw_filters.push(m.clone());
-            }
-        }
-    }
-
-    let mut filters: Vec<FilterSpec> = Vec::new();
-    let mut filter_states: Vec<FilterState> = Vec::new();
-    for rf in raw_filters.into_iter() {
-        let kind = rf
-            .get("type")
-            .and_then(|v| match v {
-                Value::String(s) => Some(s.clone()),
-                Value::Identifier(s) => Some(s.clone()),
-                _ => None,
-            })
-            .unwrap_or_else(|| "lowpass".to_string());
-        let cutoff = rf
-            .get("cutoff")
-            .and_then(|v| match v {
-                Value::Number(n) => Some(*n),
-                Value::String(s) => s.parse::<f32>().ok(),
-                _ => None,
-            })
-            .unwrap_or(1000.0);
-        filters.push(FilterSpec {
-            kind: kind.to_lowercase(),
-            cutoff,
-        });
-        filter_states.push(FilterState {
-            prev_l: 0.0,
-            prev_r: 0.0,
-            prev_in_l: 0.0,
-            prev_in_r: 0.0,
-            prev_out_l: 0.0,
-            prev_out_r: 0.0,
-        });
-    }
-
-    // LFO parsing (from synth or note) - simplified: prefer note params over synth params
-    let mut lfo_rate = 0.0f32;
-    let mut lfo_depth = 0.0f32;
-    let mut lfo_target: Option<String> = None;
-    if let Some(Value::Map(m)) = synth_params.get("lfo") {
-        if let Some(Value::Number(r)) = m.get("rate") {
-            lfo_rate = *r;
-        }
-        if let Some(Value::Number(d)) = m.get("depth") {
-            lfo_depth = *d;
-        }
-        if let Some(Value::String(t)) = m.get("target") {
-            lfo_target = Some(t.clone());
-        }
-    }
-    if let Some(Value::Map(m)) = note_params.get("lfo") {
-        if let Some(Value::Number(r)) = m.get("rate") {
-            lfo_rate = *r;
-        }
-        if let Some(Value::Number(d)) = m.get("depth") {
-            lfo_depth = *d;
-        }
-        if let Some(Value::String(t)) = m.get("target") {
-            lfo_target = Some(t.clone());
-        }
-    }
-
-    let voices = engine
-        .extract_f32(note_params, "voices")
-        .or(engine.extract_f32(synth_params, "voices"))
-        .unwrap_or(1.0)
-        .max(1.0)
-        .round() as usize;
-    let unison_detune = engine
-        .extract_f32(note_params, "unison_detune")
-        .or(engine.extract_f32(synth_params, "unison_detune"))
-        .unwrap_or(0.0);
-
-    let (volume_env, pan_env, pitch_env) = (
-        helpers::env_map_to_hash(&_volume_env),
-        helpers::env_map_to_hash(&_pan_env),
-        helpers::env_map_to_hash(&_pitch_env),
-    );
-
-    NoteSetup {
-        sample_rate,
-        channels,
-        total_samples,
-        start_sample,
-        attack_samples,
-        decay_samples,
-        release_samples,
-        sustain_level,
-        pluck_click,
-        pluck_click_samples,
-        drive,
-        filters,
-        filter_states,
-        lfo_rate,
-        lfo_depth,
-        lfo_target,
-        voices,
-        unison_detune,
-        volume_env,
-        pan_env,
-        pitch_env,
-    }
-}

package/rust/core/audio/engine/sample/insert.rs

@@ -1,199 +0,0 @@
-use devalang_types::Value;
-use devalang_types::VariableTable;
-use devalang_utils::path::normalize_path;
-use rodio::{Decoder, Source};
-use std::{collections::HashMap, fs::File, io::BufReader, path::Path};
-
-pub fn insert_sample_impl(
-    engine: &mut crate::core::audio::engine::driver::AudioEngine,
-    filepath: &str,
-    time_secs: f32,
-    dur_sec: f32,
-    effects: Option<HashMap<String, Value>>,
-    variable_table: &VariableTable,
-) {
-    if filepath.is_empty() {
-        eprintln!("❌ Empty file path provided for audio sample.");
-        return;
-    }
-
-    let module_root = Path::new(&engine.module_name);
-    let root = match devalang_utils::path::get_project_root() {
-        Ok(p) => p,
-        Err(_) => std::env::current_dir().unwrap_or_else(|_| std::path::PathBuf::from(".")),
-    };
-    let resolved_path: String;
-
-    let mut var_path = filepath.to_string();
-    if let Some(Value::String(variable_path)) = variable_table.variables.get(filepath) {
-        var_path = variable_path.clone();
-    } else if let Some(Value::Sample(sample_path)) = variable_table.variables.get(filepath) {
-        var_path = sample_path.clone();
-    }
-
-    if var_path.starts_with("devalang://") {
-        let path_after_protocol = var_path.replace("devalang://", "");
-        let parts: Vec<&str> = path_after_protocol.split('/').collect();
-
-        if parts.len() < 3 {
-            eprintln!(
-                "❌ Invalid devalang:// path format. Expected devalang://<type>/<author>.<bank>/<entity>"
-            );
-            return;
-        }
-
-        let obj_type = parts[0];
-        let bank_name = parts[1];
-        // Rejoin the remainder as the entity path so bank entries can contain
-        // nested paths like "subdir/sample.wav" or plain names.
-        let entity_name = parts[2..].join("/");
-
-        let deva_dir = match devalang_utils::path::get_deva_dir() {
-            Ok(dir) => dir,
-            Err(e) => {
-                eprintln!("❌ {}", e);
-                return;
-            }
-        };
-        let subdir = match obj_type {
-            "bank" => "banks",
-            "plugin" => "plugins",
-            "preset" => "presets",
-            "template" => "templates",
-            other => other,
-        };
-
-        // Determine the bank audio base directory. Prefer an optional
-        // `audioPath` declared in the bank's bank.toml (supports keys
-        // `audioPath` or `audio_path`). If absent, fall back to `audio/`.
-        let mut audio_dir = deva_dir.join(subdir).join(bank_name).join("audio");
-        // Try to read bank.toml to get audioPath
-        let bank_toml = deva_dir.join(subdir).join(bank_name).join("bank.toml");
-        if bank_toml.exists() {
-            if let Ok(content) = std::fs::read_to_string(&bank_toml) {
-                if let Ok(parsed) = toml::from_str::<toml::Value>(&content) {
-                    if let Some(ap) = parsed
-                        .get("audioPath")
-                        .or_else(|| parsed.get("audio_path"))
-                        .and_then(|v| v.as_str())
-                    {
-                        // normalize separators
-                        let ap_norm = ap.replace("\\", "/");
-                        audio_dir = deva_dir.join(subdir).join(bank_name).join(ap_norm);
-                    }
-                }
-            }
-        }
-        // Force looking into the computed audio_dir. If the entity_name
-        // already contains an extension (e.g. .wav/.mp3) or a nested path,
-        // preserve it as-is. Otherwise, try with a .wav extension.
-        let bank_base = audio_dir;
-        let candidate = bank_base.join(&entity_name);
-
-        if candidate.exists() {
-            resolved_path = candidate.to_string_lossy().to_string();
-        } else {
-            // Detect whether the provided entity already includes an extension.
-            let has_extension = std::path::Path::new(&entity_name).extension().is_some();
-
-            if !has_extension {
-                // Try appending .wav as a fallback for shorthand names without extension
-                let wav_candidate = bank_base.join(format!("{}.wav", entity_name));
-                if wav_candidate.exists() {
-                    resolved_path = wav_candidate.to_string_lossy().to_string();
-                } else {
-                    // Last resort: use the legacy location (no audio/), also with .wav
-                    resolved_path = deva_dir
-                        .join(subdir)
-                        .join(bank_name)
-                        .join(format!("{}.wav", entity_name))
-                        .to_string_lossy()
-                        .to_string();
-                }
-            } else {
-                // If an extension was specified, don't append .wav; try legacy location
-                let legacy_candidate = deva_dir.join(subdir).join(bank_name).join(&entity_name);
-
-                if legacy_candidate.exists() {
-                    resolved_path = legacy_candidate.to_string_lossy().to_string();
-                } else {
-                    // No file found; fall back to the audio candidate path (even if missing)
-                    resolved_path = candidate.to_string_lossy().to_string();
-                }
-            }
-        }
-    } else {
-        let entry_dir = module_root.parent().unwrap_or(&root);
-        let absolute_path = root.join(entry_dir).join(&var_path);
-
-        resolved_path = normalize_path(absolute_path.to_string_lossy().to_string());
-    }
-
-    if !Path::new(&resolved_path).exists() {
-        eprintln!("❌ Unknown trigger or missing audio file: {}", filepath);
-        return;
-    }
-
-    let file = match File::open(&resolved_path) {
-        Ok(f) => BufReader::new(f),
-        Err(e) => {
-            eprintln!("❌ Failed to open audio file {}: {}", resolved_path, e);
-            return;
-        }
-    };
-
-    let decoder = match Decoder::new(file) {
-        Ok(d) => d,
-        Err(e) => {
-            eprintln!("❌ Failed to decode audio file {}: {}", resolved_path, e);
-            return;
-        }
-    };
-
-    // Read frames from decoder and convert to mono if needed.
-    let sample_rate = engine.sample_rate as f32;
-    let channels = engine.channels as usize;
-
-    let max_frames = (dur_sec * sample_rate) as usize;
-    let dec_channels = decoder.channels() as usize;
-    let max_raw_samples = max_frames.saturating_mul(dec_channels.max(1));
-    let raw_samples: Vec<i16> = decoder.convert_samples().take(max_raw_samples).collect();
-
-    // Convert interleaved channels to mono by averaging channels per frame.
-    // Apply a small RMS-preserving scale so mono level is similar to mixed stereo.
-    let actual_frames = if dec_channels > 0 {
-        raw_samples.len() / dec_channels
-    } else {
-        0
-    };
-    let mut samples: Vec<i16> = Vec::with_capacity(actual_frames);
-    let rms_scale = (dec_channels as f32).sqrt();
-    for frame in 0..actual_frames {
-        let mut sum: i32 = 0;
-        for ch in 0..dec_channels {
-            sum += raw_samples[frame * dec_channels + ch] as i32;
-        }
-        if dec_channels > 0 {
-            let avg = (sum / (dec_channels as i32)) as f32;
-            let scaled = (avg * rms_scale).clamp(i16::MIN as f32, i16::MAX as f32) as i16;
-            samples.push(scaled);
-        } else {
-            samples.push(0);
-        }
-    }
-
-    if samples.is_empty() {
-        eprintln!("❌ No samples read from {}", resolved_path);
-        return;
-    }
-
-    let offset = (time_secs * sample_rate * (channels as f32)) as usize;
-    let required_len = offset + samples.len() * (channels as usize);
-    if engine.buffer.len() < required_len {
-        engine.buffer.resize(required_len, 0);
-    }
-
-    crate::core::audio::engine::sample::padding::pad_samples_impl(
-        engine, &samples, time_secs, effects,
-    );
-}

package/rust/core/audio/engine/sample/mod.rs

@@ -1,40 +0,0 @@
-pub mod insert;
-pub mod padding;
-
-use devalang_types::Value;
-use devalang_types::VariableTable;
-use std::collections::HashMap;
-
-impl super::driver::AudioEngine {
-    pub fn insert_sample(
-        &mut self,
-        filepath: &str,
-        time_secs: f32,
-        dur_sec: f32,
-        effects: Option<HashMap<String, Value>>,
-        variable_table: &VariableTable,
-    ) {
-        crate::core::audio::engine::sample::insert::insert_sample_impl(
-            self,
-            filepath,
-            time_secs,
-            dur_sec,
-            effects,
-            variable_table,
-        );
-    }
-
-    pub fn pad_samples(
-        &mut self,
-        samples: &[i16],
-        time_secs: f32,
-        effects_map: Option<HashMap<String, Value>>,
-    ) {
-        crate::core::audio::engine::sample::padding::pad_samples_impl(
-            self,
-            samples,
-            time_secs,
-            effects_map,
-        );
-    }
-}

package/rust/core/audio/engine/sample/padding.rs

@@ -1,170 +0,0 @@
-use devalang_types::Value;
-use std::collections::HashMap;
-
-pub fn pad_samples_impl(
-    engine: &mut crate::core::audio::engine::driver::AudioEngine,
-    samples: &[i16],
-    time_secs: f32,
-    effects_map: Option<HashMap<String, Value>>,
-) {
-    let sample_rate = engine.sample_rate as f32;
-    let channels = engine.channels as usize;
-
-    let offset = (time_secs * (sample_rate) * (channels as f32)) as usize;
-    let total_samples = samples.len();
-
-    let mut gain = 1.0;
-    let mut pan = 0.0;
-    let mut fade_in = 0.0;
-    let mut fade_out = 0.0;
-    let mut pitch = 1.0;
-    let mut drive = 0.0;
-    let mut reverb = 0.0;
-    let mut delay = 0.0; // delay time in seconds
-    let delay_feedback = 0.35; // default feedback
-
-    if let Some(map) = &effects_map {
-        for (key, val) in map {
-            match (key.as_str(), val) {
-                ("gain", Value::Number(v)) => {
-                    gain = *v;
-                }
-                ("pan", Value::Number(v)) => {
-                    pan = *v;
-                }
-                ("fadeIn", Value::Number(v)) => {
-                    fade_in = *v;
-                }
-                ("fadeOut", Value::Number(v)) => {
-                    fade_out = *v;
-                }
-                ("pitch", Value::Number(v)) => {
-                    pitch = *v;
-                }
-                ("drive", Value::Number(v)) => {
-                    drive = *v;
-                }
-                ("reverb", Value::Number(v)) => {
-                    reverb = *v;
-                }
-                ("delay", Value::Number(v)) => {
-                    delay = *v;
-                }
-                _ => eprintln!("⚠️ Unknown or invalid effect '{}'", key),
-            }
-        }
-    }
-
-    let fade_in_samples = (fade_in * (sample_rate)) as usize;
-    let fade_out_samples = (fade_out * (sample_rate)) as usize;
-
-    // If no fade specified, apply a tiny default fade (2 ms) when sample boundaries are non-zero
-    let default_boundary_fade_ms = 1.0_f32; // 1 ms
-    let default_fade_samples = (default_boundary_fade_ms * (sample_rate)) as usize;
-    let mut effective_fade_in = fade_in_samples;
-    let mut effective_fade_out = fade_out_samples;
-    if effective_fade_in == 0 {
-        if let Some(&first) = samples.first() {
-            if first.abs() > 64 {
-                // increased threshold to detect only strong abrupt starts
-                effective_fade_in = default_fade_samples.max(1);
-            }
-        }
-    }
-    if effective_fade_out == 0 {
-        if let Some(&last) = samples.last() {
-            if last.abs() > 64 {
-                // increased threshold to detect only strong abrupt ends
-                effective_fade_out = default_fade_samples.max(1);
-            }
-        }
-    }
-
-    // Ensure fades do not exceed half the sample length to avoid silencing short samples
-    if total_samples > 0 {
-        let cap = total_samples / 2;
-        if effective_fade_in > cap {
-            effective_fade_in = cap.max(1);
-        }
-        if effective_fade_out > cap {
-            effective_fade_out = cap.max(1);
-        }
-    }
-
-    let delay_samples = if delay > 0.0 {
-        (delay * (sample_rate)) as usize
-    } else {
-        0
-    };
-    let mut delay_buffer: Vec<f32> = vec![0.0; total_samples + delay_samples];
-
-    for i in 0..total_samples {
-        let pitch_index = if pitch != 1.0 {
-            ((i as f32) / pitch) as usize
-        } else {
-            i
-        };
-
-        let mut adjusted = if pitch_index < total_samples {
-            samples[pitch_index] as f32
-        } else {
-            0.0
-        };
-
-        adjusted *= gain;
-
-        if effective_fade_in > 0 && i < effective_fade_in {
-            if effective_fade_in == 1 {
-                adjusted *= 0.0;
-            } else {
-                adjusted *= (i as f32) / (effective_fade_in as f32);
-            }
-        }
-        if effective_fade_out > 0 && i >= total_samples.saturating_sub(effective_fade_out) {
-            if effective_fade_out == 1 {
-                adjusted *= 0.0;
-            } else {
-                adjusted *= ((total_samples - 1 - i) as f32) / ((effective_fade_out - 1) as f32);
-            }
-        }
-
-        if drive > 0.0 {
-            let normalized = adjusted / (i16::MAX as f32);
-            let pre_gain = (10f32).powf(drive / 20.0);
-            let driven = (normalized * pre_gain).tanh();
-            adjusted = driven * (i16::MAX as f32);
-        }
-
-        if delay_samples > 0 && i >= delay_samples {
-            let echo = delay_buffer[i - delay_samples] * delay_feedback;
-            adjusted += echo;
-        }
-        if delay_samples > 0 {
-            delay_buffer[i] = adjusted;
-        }
-
-        if reverb > 0.0 {
-            let reverb_delay = (0.03 * (sample_rate)) as usize;
-            if i >= reverb_delay {
-                adjusted += (engine.buffer[offset + i - reverb_delay] as f32) * reverb;
-            }
-        }
-
-        let adjusted_sample = adjusted.round().clamp(i16::MIN as f32, i16::MAX as f32) as i16;
-
-        let (left_gain, right_gain) = crate::core::audio::engine::helpers::pan_gains(pan);
-
-        let left = ((adjusted_sample as f32) * left_gain) as i16;
-        let right = ((adjusted_sample as f32) * right_gain) as i16;
-
-        // For interleaved buffer with `channels` channels, each frame has `channels` samples.
-        // left channel at frame i is at offset + i * channels, right at +1.
-        let left_pos = offset + i * channels;
-        let right_pos = left_pos + 1;
-
-        if right_pos < engine.buffer.len() {
-            engine.buffer[left_pos] = engine.buffer[left_pos].saturating_add(left);
-            engine.buffer[right_pos] = engine.buffer[right_pos].saturating_add(right);
-        }
-    }
-}