pink() * 0.5 * envelope(|t| exp(-t)),
            fundsp_kira::AudioNodeSettings {
                duration: Some(std::time::Duration::from_secs(50)),
                ..default()

            &fundsp_kira::Machine {
                machine: pink() * 0.2 * envelope(|t| exp(-0.1 * t)),
                // machine: pink() * 0.5 * envelope(|t| exp(-10.0 * t)),
                // machine: pink() * 0.2,

            fundsp_kira::AudioNodeSettings { ..default() },

use std::{convert::Infallible, time::Duration};

use std::{convert::Infallible, sync::OnceLock, time::Duration};

    pub(crate) fn play<T: AudioUnit32 + 'static>(&mut self, node: T, settings: AudioNodeSettings) {

    pub(crate) fn play<T: AudioUnit32 + Clone + 'static>(
        &mut self,
        machine: &Machine<T>,
        settings: AudioNodeSettings,
    ) {

                .play(AudioNodeAdapter::<T>::new(node, settings))

                .play(Machined::<T>::new(machine.machine.clone(), settings))

}
#[derive(Asset)]
pub struct Machine<T: AudioUnit32 + 'static> {
    /// The fundsp audio program
    pub machine: T,

pub struct AudioNodeAdapter<T> {

impl<T: AudioUnit32> TypePath for Machine<T> {
    fn type_path() -> &'static str {
        static TYPE_PATH: OnceLock<String> = OnceLock::new();
        TYPE_PATH
            .get_or_init(|| {
                let machine_type_name = std::any::type_name::<T>();
                format!("{}::Machine<{machine_type_name}>", module_path!())
            })
            .as_str()
    }
    fn short_type_path() -> &'static str {
        static SHORT_TYPE_PATH: OnceLock<String> = OnceLock::new();
        SHORT_TYPE_PATH
            .get_or_init(|| {
                let machine_type_name = std::any::type_name::<T>();
                format!("Machine<{machine_type_name}>")
            })
            .as_str()
    }
}
// TODO node should be from a Machine, which is an Asset
pub struct Machined<T> {

// TODO This should be determined by the track

    pub duration: Option<Duration>,

impl<T> AudioNodeAdapter<T>

impl<T> Machined<T>

impl<T> SoundData for AudioNodeAdapter<T>

impl<T> SoundData for Machined<T>

        Ok((
            Box::new(AudioNodeAdapterSound::new(self.node, self.settings)),
            (),
        ))

        Ok((Box::new(FundspSound::new(self.node, self.settings)), ()))

pub struct AudioNodeAdapterSound<T> {

pub struct FundspSound<T> {

    elapsed: Duration,

impl<T> AudioNodeAdapterSound<T>

impl<T> FundspSound<T>

        AudioNodeAdapterSound {

        FundspSound {

            elapsed: Duration::ZERO,

impl<T> Sound for AudioNodeAdapterSound<T>

impl<T> Sound for FundspSound<T>

        self.elapsed += Duration::from_secs_f64(dt);

        // If we are quieter (on both channels!!) than the noise floor, assume we
        // are finished an want to stop
        let below_noise_floor = left_rms < NOISE_FLOOR_RMS && right_rms < NOISE_FLOOR_RMS;

        self.settings
            .duration
            .is_some_and(|lim| self.elapsed >= lim)
            // If we are quieter (on both channels!!) than the noise floor, assume we
            // are finished an want to stop
            || (left_rms < NOISE_FLOOR_RMS && right_rms < NOISE_FLOOR_RMS)

        if below_noise_floor {
            info!("Stopping {self:p} due to being quieter than the noise floor!");
        }
        below_noise_floor