Arc, OnceLock,

        Arc,

/// Labels for audio systems
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SystemSet)]
pub enum FundspAudioSystemSet {
    /// Label for systems in [`CoreStage::PreUpdate`] that clean up tracked audio instances
    // InstanceCleanup,
    /// Label for system in [`CoreStage::PostUpdate`] that processes audio commands for dynamic channels
    // PlayDynamicChannels,
    /// Label for systems in [`CoreStage::PostUpdate`] that process audio commands for typed channels
    PlayTypedChannels,
}

        .add_systems(
            PostUpdate,
            load_next_machine::<T>.in_set(FundspAudioSystemSet::PlayTypedChannels),
        )
    }
}
fn load_next_machine<T: Resource>(
    mut output: NonSendMut<FundspAudioOutput>,
    mut track: ResMut<Track<T>>,
) {
    if let Some(machine) = track.next_machine.take() {
        output.play(machine, &mut *track);

    pub fn play<N: AudioUnit32 + Clone + 'static, T: Resource>(
        &mut self,
        machine: &Machine<N>,
        track: &mut Track<T>,
    ) {

    fn play<T: Resource>(&mut self, machine: Machine, track: &mut Track<T>) {

            if let Some(machined) = Machined::<T>::new(
                machine.machine.clone(),

            let machined = Machined::<T>::new(
                machine.machine,

            ) {
                track.active_handle = manager
                    .play(machined)
                    .inspect_err(|err| error!("{err}"))
                    .ok();
            }

            );
            track.active_handle = manager
                .play(machined)
                .inspect_err(|err| error!("{err}"))
                .ok();

    next_machine: Option<Machine>,

            next_machine: None,

    // TODO Procide external API endpoints here

    pub fn play(&mut self, machine: &Machine) {
        self.next_machine = Some(machine.clone());
    }

#[derive(Asset)]
pub struct Machine<T: AudioUnit32 + 'static> {

#[derive(Asset, Clone, TypePath)]
pub struct Machine {

    pub machine: T,

    pub machine: Box<dyn AudioUnit32>,

impl<T: AudioUnit32 + 'static> Machine<T> {

impl Machine {

    pub fn new(machine: T) -> Self {

    pub fn new<T: AudioUnit32 + 'static>(machine: T) -> Self {

    pub fn with_noise_floor(machine: T, noise_floor: f32) -> Self {

    pub fn with_noise_floor<T: AudioUnit32 + 'static>(machine: T, noise_floor: f32) -> Self {

            machine,

            machine: Box::new(machine),

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()
    }
}

    fn new<N: AudioUnit32 + 'static>(
        mut node: N,

    fn new(
        mut node: Box<dyn AudioUnit32>,

    ) -> Option<Self> {

    ) -> Self {

        Some(Self {
            node: Box::new(node),

        Self {
            node,

        })

        }

    mut fundsp_output: NonSendMut<fundsp_kira::FundspAudioOutput>,

            fundsp_output.play(
                &fundsp_kira::Machine::new(
                    pink() * envelope(|t| exp(-5.0 * t)),
                    // pink() * 0.2,
                ),
                &mut track,
            );

            track.play(&fundsp_kira::Machine::new(
                pink() * envelope(|t| exp(-5.0 * t)),
                // pink() * 0.2,
            ));