mut fundsp_output: NonSendMut<fundsp_kira::FundspAudioOutput>,
    mut track: ResMut<fundsp_kira::MainTrack>,

    // mut fundsp_output: NonSendMut<fundsp_kira::FundspAudioOutput>,
    // mut track: ResMut<fundsp_kira::MainTrack>,

    {
        use fundsp::hacker32::*;
        fundsp_output.play(
            &fundsp_kira::Machine::new(
                pink() * 0.2 * envelope(|t| exp(-0.1 * t)),
                // pink() * 0.5 * envelope(|t| exp(-10.0 * t)),
                // pink() * 0.2,
            ),
            &mut track,
        );
    }

    // {
    //     use fundsp::hacker32::*;
    //     fundsp_output.play(
    //         &fundsp_kira::Machine::new(
    //             pink() * 0.1 * envelope(|t| exp(-0.1 * t)),
    //             // pink() * 0.5 * envelope(|t| exp(-10.0 * t)),
    //             // pink() * 0.2,
    //         ),
    //         &mut track,
    //     );
    // }

#[allow(clippy::too_many_arguments)]

    /// A fixed number of samples that we should keep in buffer

    sample_pairs.drain(0..(samples_stored.saturating_sub(SAMPLES_TO_KEEP)));

    // Remove old samples
    if samples_stored >= SAMPLES_TO_KEEP {
        // Remove old sampels
        sample_pairs.pop_front();
    }

                    pink() * 0.5 * envelope(|t| exp(-10.0 * t)),

                    pink() * envelope(|t| exp(-5.0 * t)),

            let left_max = sample_pairs
                .iter()
                .map(|(s, _)| s.abs())
                .max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Less))
                .unwrap_or_default();

            let right_max = sample_pairs
                .iter()
                .map(|(_, s)| s.abs())
                .max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Less))
                .unwrap_or_default();

                .include_y(-left_max.max(right_max))
                .include_y(left_max.max(right_max))

                .include_y(-1.0)
                .include_y(1.0)

    time::Duration,

// - (!unimplemented) the channel it is associated with gets a new `Machined` to play.

// - the channel it is associated with gets a new `Machined` to play.

    // TODO Make this called from some systems, and provide a way to
    // *queue* these commands, so that external systems aren't touching
    // the *non-Send* Self (FundspAudioOutput)
    //
    // The non-threadedness of this manifests as a v small delay but it annoying

    ) {

    ) -> Option<()> {

                ))

                )?)

            // TODO Proper API and errors
            Some(())
        } else {
            None

        self.sample.store(sample.to_bits(), Ordering::SeqCst);

        self.sample.store(sample.to_bits(), Ordering::Release);

        self.rms.store(rms.to_bits(), Ordering::SeqCst);

        self.rms.store(rms.to_bits(), Ordering::Release);

        let sample_bits = self.sample.load(Ordering::SeqCst);

        let sample_bits = self.sample.load(Ordering::Acquire);

        let rms_bits = self.rms.load(Ordering::SeqCst);

        let rms_bits = self.rms.load(Ordering::Acquire);

    latency: f64,

            latency: 0.0,

    }
    #[allow(dead_code)]
    pub fn latency(&self) -> f64 {
        self.latency

    sample_rate: f64,

    fn new(mut node: N, settings: MachinedSettings, track: &Track<T>) -> Self {

    fn new(mut node: N, settings: MachinedSettings, track: &mut Track<T>) -> Option<Self> {

        // Update track latency
        // SANITY: If there is no latency, we have no outputs!
        track.latency = node.latency()?;

        Self {

        Some(Self {

            sample_rate: track.sample_rate,

        }

        })

                self.sample_rate,

    sample_time: Duration,
    elapsed: Duration,

    buffer: [kira::dsp::Frame; 4],

    fn new(node: T, settings: MachinedSettings, trackable: Trackable<Track>) -> Self {

    #[inline(always)]
    fn make_frame((left, right): (f32, f32)) -> kira::dsp::Frame {
        kira::dsp::Frame { left, right }
    }
    fn new(
        mut node: T,
        sample_rate: f64,
        settings: MachinedSettings,
        trackable: Trackable<Track>,
    ) -> Self {

            node,

            sample_time: Duration::from_secs_f64(sample_rate.recip()),
            elapsed: Duration::ZERO,

            // Get the first four frames
            buffer: [
                // prev
                kira::dsp::Frame::ZERO,
                // current
                Self::make_frame(node.get_stereo()),
                // next_1
                Self::make_frame(node.get_stereo()),
                // next_2
                Self::make_frame(node.get_stereo()),
            ],
            node,

        _dt: f64,

        dt: f64,

        let (left, right) = self.node.get_stereo();
        // Process samples
        let left = self.monitor_left.filter_mono(left);
        let right = self.monitor_right.filter_mono(right);

        // sample rate check
        let frame = kira::dsp::interpolate_frame(
            self.buffer[0],
            self.buffer[1],
            self.buffer[2],
            self.buffer[3],
            (self.elapsed.as_secs_f32() / self.sample_time.as_secs_f32()).clamp(0.0, 1.0),
        );
        self.elapsed += Duration::from_secs_f64(dt);
        while self.elapsed > self.sample_time {
            self.elapsed -= self.sample_time;
            // push in a new frame, by shifting over everything else
            for i in 0..self.buffer.len() - 1 {
                self.buffer[i] = self.buffer[i + 1];
            }
            self.buffer[self.buffer.len() - 1] = Self::make_frame(self.node.get_stereo());
        }
        // Process samples (from frame)
        // Monitor samples
        self.monitor_left.filter_mono(frame.left);
        self.monitor_right.filter_mono(frame.right);

        self.trackable.left_channel.store_sample(left);
        self.trackable.right_channel.store_sample(right);
        kira::dsp::Frame { left, right }

        self.trackable.left_channel.store_sample(frame.left);
        self.trackable.right_channel.store_sample(frame.right);
        frame

            <iframe src="game/index.html" width="1280" height="720"></iframe>

            <iframe src="./game/index.html" width="1280" height="720"></iframe>

    trunk serve

    cargo watch -w../src -s "trunk serve"

    <base data-trunk-public-url />

    trunk build --public-url ./

    trunk build

    trunk build --public-url ./ --release

    trunk build --release

        <base data-trunk-public-url="./" />

[build]
public_url = "./"

rustflags = [ "--cfg=web_sys_unstable_apis" ]

# Uncomment to use WebGPU
# rustflags = [ "--cfg=web_sys_unstable_apis" ]