fix the code its not working as a form, just go ahead and instead of predefining buttons and stuff add it into the designer script this is visual studio. As for the audio waveform viewport I want it to be sized and positioned based off a panel named WavePanel. Return entire code for the form script and the forms designer script.

'Form script'
using System;
using System.Drawing;
using System.Windows.Forms;
using NAudio.Wave;
using NAudio.Wave.SampleProviders;
using Timer = System.Windows.Forms.Timer;

namespace ByteBreath
{
    // DoubleBufferedPanel to reduce flickering
    public class DoubleBufferedPanel : Panel
    {
        public DoubleBufferedPanel()
        {
            this.DoubleBuffered = true;
            this.SetStyle(ControlStyles.AllPaintingInWmPaint |
                          ControlStyles.UserPaint |
                          ControlStyles.OptimizedDoubleBuffer, true);
            this.UpdateStyles();
        }
    }

    public partial class AudioEditorForm : Form
    {
        private float[] audioSamples;      // normalized samples (-1 to 1)
        private WaveFormat waveFormat;
        private string currentFilePath;

        private bool isSelecting = false;
        private int selectionStart = -1;
        private int selectionEnd = -1;

        private int sampleRate;

        private Button btnLoad;
        private Button btnSave;
        private DoubleBufferedPanel waveformPanel;

        private WaveOutEvent waveOut;
        private AudioFileReader audioFileReader;
        private BufferedWaveProvider bufferedWaveProvider;

        private Timer playbackTimer;
        private long playStartSample = 0;
        private long playEndSample = 0;
        private bool isPlaying = false;

        private int viewStartSample = 0;
        private int viewSamples = 0; // number of samples currently displayed in waveform
        private const int minViewSamples = 1000;  // minimum zoom level (number of samples shown)
        private const int maxViewSamplesFactor = 1; // factor of audioSamples.Length to max zoom out

        public AudioEditorForm()
        {
            TopMost = true;

            InitializeComponent();

            this.Text = "Simple Audio Editor";
            this.Width = 800;
            this.Height = 400;

            btnLoad = new Button()
            {
                Text = "Load WAV",
                Left = 10,
                Top = 10,
                Width = 100
            };
            btnLoad.Click += BtnLoad_Click;
            this.Controls.Add(btnLoad);

            btnSave = new Button()
            {
                Text = "Save",
                Left = 120,
                Top = 10,
                Width = 100,
                Enabled = false
            };
            btnSave.Click += BtnSave_Click;
            this.Controls.Add(btnSave);

            waveformPanel = new DoubleBufferedPanel()
            {
                Left = 10,
                Top = 50,
                Width = this.ClientSize.Width - 20,
                Height = this.ClientSize.Height - 60,
                BorderStyle = BorderStyle.FixedSingle,
                BackColor = Color.Black,
                Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right,
                TabIndex = 0
            };
            waveformPanel.Paint += WaveformPanel_Paint;
            waveformPanel.MouseDown += WaveformPanel_MouseDown;
            waveformPanel.MouseMove += WaveformPanel_MouseMove;
            waveformPanel.MouseUp += WaveformPanel_MouseUp;
            waveformPanel.MouseWheel += WaveformPanel_MouseWheel;
            waveformPanel.MouseEnter += WaveformPanel_MouseEnter;
            waveformPanel.MouseLeave += WaveformPanel_MouseLeave;
            waveformPanel.KeyDown += WaveformPanel_KeyDown;
            this.Controls.Add(waveformPanel);

            playbackTimer = new Timer();
            playbackTimer.Interval = 30;
            playbackTimer.Tick += PlaybackTimer_Tick;

            // Set form's KeyPreview to true to allow key events
            this.KeyPreview = true;
            this.KeyDown += AudioEditorForm_KeyDown;
        }

        private bool isMouseInWaveform = false;

        private void WaveformPanel_MouseEnter(object sender, EventArgs e)
        {
            isMouseInWaveform = true;
            waveformPanel.Focus();
        }

        private void WaveformPanel_MouseLeave(object sender, EventArgs e)
        {
            isMouseInWaveform = false;
        }

        // Zoom is handled in this MouseWheel handler attached on waveformPanel
        private void WaveformPanel_MouseWheel(object sender, MouseEventArgs e)
        {
            if (isMouseInWaveform)
            {
                ZoomWaveform(e);
            }
        }

        private void ZoomWaveform(MouseEventArgs e)
        {
            if (audioSamples == null || audioSamples.Length == 0)
                return;

            int panelWidth = waveformPanel.ClientSize.Width;
            if (panelWidth <= 0)
                return;

            // Initialize viewSamples if 0 (e.g. just loaded)
            if (viewSamples == 0)
            {
                viewSamples = audioSamples.Length;
                viewStartSample = 0;
            }

            // Determine zoom factor base on e.Delta (which is multiples of 120)
            // Positive means zoom in; Negative means zoom out
            // We'll use a scaling approach to zoom +/- 10% per notch.
            float zoomFactor = 1.0f - (e.Delta / 1200.0f); // 1200 chosen for smooth zoom, adjust if needed

            if (zoomFactor <= 0)
                zoomFactor = 0.1f; // clamp to minimum zoom increment factor

            int newViewSamples = (int)(viewSamples * zoomFactor);

            // Clamp viewSamples between min and max
            int minSamples = minViewSamples;
            int maxSamples = audioSamples.Length * maxViewSamplesFactor;
            if (maxSamples < minSamples) maxSamples = minSamples;

            if (newViewSamples < minSamples)
                newViewSamples = minSamples;
            if (newViewSamples > maxSamples)
                newViewSamples = maxSamples;

            // No change? Return.
            if (newViewSamples == viewSamples) return;

            // Calculate the sample corresponding to mouse X position in waveform coordinates BEFORE zoom
            double mouseRatio = (double)e.X / panelWidth;
            if (mouseRatio < 0) mouseRatio = 0;
            if (mouseRatio > 1) mouseRatio = 1;

            long mouseSample = viewStartSample + (long)(mouseRatio * viewSamples);

            // Calculate new viewStartSample so the point under the mouse cursor remains roughly fixed
            long newViewStartSample = mouseSample - (long)(mouseRatio * newViewSamples);

            // Clamp newViewStartSample to valid range
            if (newViewStartSample < 0) newViewStartSample = 0;
            if (newViewStartSample + newViewSamples > audioSamples.Length)
                newViewStartSample = audioSamples.Length - newViewSamples;

            if (newViewStartSample < 0)
                newViewStartSample = 0; // Just in case newViewSamples > audioSamples.Length (shouldn't happen)

            viewStartSample = (int)newViewStartSample;
            viewSamples = newViewSamples;

            waveformPanel.Invalidate();
        }

        private void BtnLoad_Click(object sender, EventArgs e)
        {
            using (var ofd = new OpenFileDialog())
            {
                ofd.Filter = "WAV files (*.wav)|*.wav";
                if (ofd.ShowDialog() == DialogResult.OK)
                {
                    currentFilePath = ofd.FileName;
                    LoadWaveFile(currentFilePath);
                }
            }
        }

        private void LoadWaveFile(string path)
        {
            try
            {
                waveOut?.Stop();
                waveOut?.Dispose();
                waveOut = null;
                audioFileReader?.Dispose();
                audioFileReader = null;
                bufferedWaveProvider = null;
                isPlaying = false;

                audioFileReader = new AudioFileReader(path);
                waveFormat = audioFileReader.WaveFormat;
                sampleRate = waveFormat.SampleRate;

                var wholeFile = new float[audioFileReader.Length / 4];
                audioFileReader.Position = 0;
                int offset = 0;
                int samplesRead;
                var buffer = new float[1024];
                while ((samplesRead = audioFileReader.Read(buffer, 0, buffer.Length)) > 0)
                {
                    Array.Copy(buffer, 0, wholeFile, offset, samplesRead);
                    offset += samplesRead;
                }

                audioSamples = wholeFile;

                audioFileReader.Position = 0;

                selectionStart = -1;
                selectionEnd = -1;

                viewStartSample = 0;
                viewSamples = audioSamples.Length;

                btnSave.Enabled = true;

                playStartSample = 0;
                playEndSample = audioSamples.Length - 1;

                waveOut = new WaveOutEvent();
                waveOut.PlaybackStopped += WaveOut_PlaybackStopped;

                bufferedWaveProvider = new BufferedWaveProvider(waveFormat);
                bufferedWaveProvider.BufferLength = audioSamples.Length * waveFormat.BlockAlign;
                bufferedWaveProvider.ClearBuffer();

                // Fill buffer with whole audio for default playback
                byte[] byteBuffer = new byte[audioSamples.Length * 4];
                Buffer.BlockCopy(audioSamples, 0, byteBuffer, 0, byteBuffer.Length);
                bufferedWaveProvider.AddSamples(byteBuffer, 0, byteBuffer.Length);

                waveOut.Init(bufferedWaveProvider);

                waveformPanel.Invalidate();
            }
            catch (Exception ex)
            {
                MessageBox.Show("Failed to load WAV: " + ex.Message);
            }
        }

        private void WaveformPanel_Paint(object sender, PaintEventArgs e)
        {
            e.Graphics.Clear(Color.Black);
            if (audioSamples == null || audioSamples.Length == 0)
            {
                using (var brush = new SolidBrush(Color.White))
                {
                    e.Graphics.DrawString("No audio loaded", this.Font, brush, new PointF(10, 10));
                }
                return;
            }

            int w = waveformPanel.ClientSize.Width;
            int h = waveformPanel.ClientSize.Height;

            using (var pen = new Pen(Color.White))
            {
                if (viewSamples == 0)
                    viewSamples = audioSamples.Length;
                if (viewStartSample + viewSamples > audioSamples.Length)
                    viewStartSample = audioSamples.Length - viewSamples;

                // Avoid negative or zero values
                if (viewStartSample < 0) viewStartSample = 0;
                if (viewSamples <= 0) viewSamples = audioSamples.Length;

                int samplesPerPixel = Math.Max(1, viewSamples / w);

                for (int x = 0; x < w; x++)
                {
                    int startSample = viewStartSample + x * samplesPerPixel;
                    if (startSample > audioSamples.Length - 1)
                        break;
                    int endSample = Math.Min(audioSamples.Length, startSample + samplesPerPixel);

                    float min = 1f;
                    float max = -1f;
                    for (int s = startSample; s < endSample; s++)
                    {
                        float val = audioSamples[s];
                        if (val < min) min = val;
                        if (val > max) max = val;
                    }

                    int yMax = (int)((1 - (max + 1) / 2) * h);
                    int yMin = (int)((1 - (min + 1) / 2) * h);

                    e.Graphics.DrawLine(pen, x, yMin, x, yMax);
                }
            }

            // Draw selection rectangle if any
            if (selectionStart >= 0 && selectionEnd >= 0 && selectionEnd != selectionStart)
            {
                int wSamples = viewSamples;
                int visibleStart = viewStartSample;
                int x1 = (int)((double)(selectionStart - visibleStart) / wSamples * w);
                int x2 = (int)((double)(selectionEnd - visibleStart) / wSamples * w);

                int rectX = Math.Min(x1, x2);
                int rectW = Math.Abs(x2 - x1);

                if (rectW > 0)
                {
                    using (var selectionBrush = new SolidBrush(Color.FromArgb(100, Color.Green)))
                    {
                        e.Graphics.FillRectangle(selectionBrush, rectX, 0, rectW, h);
                    }

                    using (var pen = new Pen(Color.Red, 2))
                    {
                        e.Graphics.DrawRectangle(pen, rectX, 0, rectW, h - 1);
                    }
                }
            }

            // Draw playback position
            if (isPlaying && audioSamples != null && waveOut != null)
            {
                long bytesPerSample = waveFormat.BitsPerSample / 8 * waveFormat.Channels;

                // Get current sample position relative to full audio
                long currentSample = 0;

                try
                {
                    currentSample = waveOut.GetPosition() / bytesPerSample + playStartSample;
                }
                catch
                {
                    currentSample = 0;
                }

                if (currentSample > audioSamples.Length)
                    currentSample = audioSamples.Length;

                long segmentLength = playEndSample - playStartSample + 1;
                if (segmentLength <= 0) segmentLength = audioSamples.Length;

                if (currentSample > playEndSample)
                    currentSample = playEndSample;

                long relativeSamplePos = currentSample - playStartSample;

                int x = 0;

                if (selectionStart >= 0 && selectionEnd >= 0 && selectionStart != selectionEnd)
                {
                    int wSamples = viewSamples;
                    int visibleStart = viewStartSample;

                    int sx1 = (int)((double)(selectionStart - visibleStart) / wSamples * w);
                    int sx2 = (int)((double)(selectionEnd - visibleStart) / wSamples * w);

                    int rectX = Math.Min(sx1, sx2);
                    int rectW = Math.Abs(sx2 - sx1);

                    int selLength = Math.Max(1, Math.Abs(selectionEnd - selectionStart));

                    // Position within selection rectangle
                    if (segmentLength > 0)
                        x = rectX + (int)((double)relativeSamplePos / segmentLength * rectW);
                    else
                        x = rectX;
                }
                else
                {
                    int wSamples = viewSamples;
                    int visibleStart = viewStartSample;
                    // No selection, position across visible waveform
                    x = (int)((double)(currentSample - visibleStart) / wSamples * w);
                }

                if (x >= 0 && x < w)
                {
                    using (var pen = new Pen(Color.Red, 2))
                    {
                        e.Graphics.DrawLine(pen, x, 0, x, h);
                    }
                }
            }
        }

        private void WaveformPanel_MouseDown(object sender, MouseEventArgs e)
        {
            if (audioSamples == null) return;

            isSelecting = true;
            int w = waveformPanel.ClientSize.Width;

            int sampleIndex = viewStartSample + (int)((double)e.X / w * viewSamples);
            sampleIndex = Math.Max(0, Math.Min(sampleIndex, audioSamples.Length - 1));

            selectionStart = sampleIndex;
            selectionEnd = sampleIndex;
            waveformPanel.Invalidate();
        }

        private void WaveformPanel_MouseMove(object sender, MouseEventArgs e)
        {
            if (audioSamples == null || !isSelecting) return;

            int w = waveformPanel.ClientSize.Width;
            int sampleIndex = viewStartSample + (int)((double)e.X / w * viewSamples);
            sampleIndex = Math.Max(0, Math.Min(sampleIndex, audioSamples.Length - 1));

            selectionEnd = sampleIndex;
            waveformPanel.Invalidate();
        }

        private void WaveformPanel_MouseUp(object sender, MouseEventArgs e)
        {
            if (audioSamples == null) return;

            isSelecting = false;

            if (Math.Abs(selectionEnd - selectionStart) == 0)
            {
                selectionStart = -1;
                selectionEnd = -1;
            }
            waveformPanel.Invalidate();
        }

        private void DeleteSelection()
        {
            if (audioSamples == null) return;
            if (selectionStart < 0 || selectionEnd < 0) return;

            int start = Math.Min(selectionStart, selectionEnd);
            int end = Math.Max(selectionStart, selectionEnd);
            if (end == start) return;

            int deletedCount = end - start;

            // Save current view before deletion
            int oldViewStartSample = viewStartSample;
            int oldViewSamples = viewSamples;

            int newLength = audioSamples.Length - deletedCount;
            float[] newSamples = new float[newLength];

            Array.Copy(audioSamples, 0, newSamples, 0, start);
            Array.Copy(audioSamples, end, newSamples, start, audioSamples.Length - end);

            audioSamples = newSamples;

            selectionStart = -1;
            selectionEnd = -1;

            waveOut?.Stop();

            bufferedWaveProvider = new BufferedWaveProvider(waveFormat);
            bufferedWaveProvider.BufferLength = audioSamples.Length * waveFormat.BlockAlign;
            bufferedWaveProvider.ClearBuffer();

            byte[] byteBuffer = new byte[audioSamples.Length * 4];
            Buffer.BlockCopy(audioSamples, 0, byteBuffer, 0, byteBuffer.Length);
            bufferedWaveProvider.AddSamples(byteBuffer, 0, byteBuffer.Length);

            waveOut?.Init(bufferedWaveProvider);

            playStartSample = 0;
            playEndSample = audioSamples.Length - 1;

            // Adjust viewStartSample and viewSamples to keep zoom if possible

            // Case 1: If view window is entirely after deleted segment, move it backward by deletedCount
            if (oldViewStartSample >= end)
            {
                viewStartSample = Math.Max(0, oldViewStartSample - deletedCount);
                viewSamples = oldViewSamples;
            }
            // Case 2: If view window overlaps deleted segment
            else if (oldViewStartSample < end && (oldViewStartSample + oldViewSamples) > start)
            {
                // Calculate new viewSamples at least minViewSamples, max audio length
                int newViewSamples = oldViewSamples - deletedCount;
                if (newViewSamples < minViewSamples) newViewSamples = Math.Min(minViewSamples, audioSamples.Length);
                if (newViewSamples > audioSamples.Length) newViewSamples = audioSamples.Length;

                // Keep viewStartSample same but clamp max to audio length - viewSamples
                viewStartSample = oldViewStartSample;
                if (viewStartSample > audioSamples.Length - newViewSamples)
                    viewStartSample = audioSamples.Length - newViewSamples;
                if (viewStartSample < 0) viewStartSample = 0;

                viewSamples = newViewSamples;
            }
            // Case 3: view window before deleted segment: no change needed
            else
            {
                viewStartSample = oldViewStartSample;
                viewSamples = oldViewSamples;
            }

            // Edge case: if audio fully deleted or new viewSamples bigger than new audio length
            if (viewSamples > audioSamples.Length)
            {
                viewSamples = audioSamples.Length;
                viewStartSample = 0;
            }

            waveformPanel.Invalidate();
            isPlaying = false;
        }

        private void WaveformPanel_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Delete)
            {
                if (selectionStart >= 0 && selectionEnd >= 0 && selectionEnd != selectionStart)
                {
                    DeleteSelection();
                    e.Handled = true;
                }
            }
        }

        private void BtnSave_Click(object sender, EventArgs e)
        {
            if (audioSamples == null || string.IsNullOrEmpty(currentFilePath)) return;

            try
            {
                using (var writer = new WaveFileWriter(currentFilePath, waveFormat))
                {
                    if (waveFormat.Encoding == WaveFormatEncoding.IeeeFloat)
                    {
                        writer.WriteSamples(audioSamples, 0, audioSamples.Length);
                    }
                    else if (waveFormat.BitsPerSample == 16)
                    {
                        short[] int16Samples = new short[audioSamples.Length];
                        for (int i = 0; i < audioSamples.Length; i++)
                        {
                            float sample = audioSamples[i];
                            sample = Math.Max(-1f, Math.Min(1f, sample));
                            int16Samples[i] = (short)(sample * short.MaxValue);
                        }
                        byte[] bytes = new byte[int16Samples.Length * 2];
                        Buffer.BlockCopy(int16Samples, 0, bytes, 0, bytes.Length);
                        writer.Write(bytes, 0, bytes.Length);
                    }
                    else
                    {
                        MessageBox.Show("Unsupported bit depth: " + waveFormat.BitsPerSample);
                        return;
                    }
                }
                MessageBox.Show("File saved to " + currentFilePath);
            }
            catch (Exception ex)
            {
                MessageBox.Show("Failed to save WAV: " + ex.Message);
            }
        }

        private void TogglePlayPause()
        {
            if (audioSamples == null || waveOut == null) return;

            if (!isPlaying)
            {
                if (selectionStart >= 0 && selectionEnd >= 0 && selectionEnd != selectionStart)
                {
                    playStartSample = Math.Min(selectionStart, selectionEnd);
                    playEndSample = Math.Max(selectionStart, selectionEnd);
                }
                else
                {
                    playStartSample = 0;
                    playEndSample = audioSamples.Length - 1;
                }

                waveOut.Stop();

                long bytesPerSample = (waveFormat.BitsPerSample / 8) * waveFormat.Channels;
                long segmentLengthSamples = (playEndSample - playStartSample + 1);
                long lengthBytes = segmentLengthSamples * bytesPerSample;

                if (playStartSample > audioSamples.Length - 1 || segmentLengthSamples <= 0)
                {
                    MessageBox.Show("Invalid selection for playback.");
                    return;
                }

                if (lengthBytes > int.MaxValue)
                {
                    MessageBox.Show("Selection too large for playback.");
                    return;
                }

                int intLengthBytes = (int)lengthBytes;

                bufferedWaveProvider = new BufferedWaveProvider(waveFormat);
                bufferedWaveProvider.BufferLength = intLengthBytes;
                bufferedWaveProvider.ClearBuffer();

                byte[] byteBuffer = new byte[intLengthBytes];

                Buffer.BlockCopy(audioSamples, (int)(playStartSample * 4), byteBuffer, 0, intLengthBytes);
                bufferedWaveProvider.AddSamples(byteBuffer, 0, intLengthBytes);

                waveOut.Init(bufferedWaveProvider);

                waveOut.Play();
                isPlaying = true;
                playbackTimer.Start();
            }
            else
            {
                waveOut.Pause();
                isPlaying = false;
                playbackTimer.Stop();
            }

            waveformPanel.Invalidate();
        }

        private void PlaybackTimer_Tick(object sender, EventArgs e)
        {
            if (!isPlaying) return;

            long bytesPerSample = waveFormat.BitsPerSample / 8 * waveFormat.Channels;
            long currentSample = 0;

            try
            {
                if (bufferedWaveProvider != null && waveOut != null)
                {
                    currentSample = waveOut.GetPosition() / bytesPerSample + playStartSample;
                }
                else if (audioFileReader != null)
                {
                    currentSample = audioFileReader.Position / bytesPerSample;
                }
            }
            catch
            {
                currentSample = 0;
            }

            if (currentSample > playEndSample)
            {
                waveOut.Stop();
                return;
            }

            waveformPanel.Invalidate();
        }

        private void WaveOut_PlaybackStopped(object sender, StoppedEventArgs e)
        {
            isPlaying = false;
            playbackTimer.Stop();
            waveformPanel.Invalidate();
        }

        private void AudioEditorForm_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Space)
            {
                TogglePlayPause();
                e.Handled = true;
            }
        }
    }
}

'Form Designer Script'
namespace ByteBreath
{
    partial class AudioEditorForm
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            SuspendLayout();
            // 
            // AudioEditorForm
            // 
            AutoScaleDimensions = new SizeF(7F, 15F);
            AutoScaleMode = AutoScaleMode.Font;
            ClientSize = new Size(800, 450);
            Name = "AudioEditorForm";
            Text = "AudioEditorForm";
            ResumeLayout(false);
        }

        #endregion
    }
}