@devaloop/devalang 0.0.1-beta.1 → 0.0.1-beta.2

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

@@ -0,0 +1,294 @@
+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

@@ -0,0 +1,199 @@
+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

@@ -0,0 +1,40 @@
+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

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