feat: complete Phase 8.3 - recording settings (input gain, mono/stereo, sample rate)

Recording Settings (Phase 8.3):
- Added input gain control (0.0-2.0 with dB display)
- Real-time gain adjustment via GainNode during recording
- Mono/Stereo recording mode selection
- Sample rate matching (44.1kHz, 48kHz, 96kHz)
- Mono conversion averages all channels when enabled
- Recording settings panel shown when track is armed

Components Created:
- RecordingSettings.tsx: Settings panel with gain slider, mono/stereo toggle, sample rate buttons

Components Modified:
- useRecording hook: Added settings state and GainNode integration
- AudioEditor: Pass recording settings to TrackList
- TrackList: Forward settings to Track components
- Track: Show RecordingSettings when armed for recording

Technical Details:
- GainNode inserted between source and analyser in recording chain
- Real-time gain updates via gainNode.gain.value
- AudioContext created with target sample rate
- Mono conversion done post-recording by averaging channels
- Settings persist during recording session

Phase 8 Complete:
- ✅ Phase 8.1: Audio Input
- ✅ Phase 8.2: Recording Controls (punch/overdub)
- ✅ Phase 8.3: Recording Settings
- 📋 Phase 9: Automation (NEXT)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

lib/hooks/useRecording.ts

@@ -9,8 +9,15 @@ export interface RecordingState {
   inputLevel: number;
 }
 
+export interface RecordingSettings {
+  inputGain: number; // 0.0 to 2.0 (1.0 = unity)
+  recordMono: boolean; // true = mono, false = stereo
+  sampleRate: number; // target sample rate (44100, 48000, etc.)
+}
+
 export interface UseRecordingReturn {
   state: RecordingState;
+  settings: RecordingSettings;
   startRecording: () => Promise<void>;
   stopRecording: () => Promise<AudioBuffer | null>;
   pauseRecording: () => void;
@@ -18,6 +25,9 @@ export interface UseRecordingReturn {
   getInputDevices: () => Promise<MediaDeviceInfo[]>;
   selectInputDevice: (deviceId: string) => Promise<void>;
   requestPermission: () => Promise<boolean>;
+  setInputGain: (gain: number) => void;
+  setRecordMono: (mono: boolean) => void;
+  setSampleRate: (sampleRate: number) => void;
 }
 
 export function useRecording(): UseRecordingReturn {
@@ -28,9 +38,16 @@ export function useRecording(): UseRecordingReturn {
     inputLevel: 0,
   });
 
+  const [settings, setSettings] = React.useState<RecordingSettings>({
+    inputGain: 1.0,
+    recordMono: false,
+    sampleRate: 48000,
+  });
+
   const mediaRecorderRef = React.useRef<MediaRecorder | null>(null);
   const audioContextRef = React.useRef<AudioContext | null>(null);
   const analyserRef = React.useRef<AnalyserNode | null>(null);
+  const gainNodeRef = React.useRef<GainNode | null>(null);
   const streamRef = React.useRef<MediaStream | null>(null);
   const chunksRef = React.useRef<Blob[]>([]);
   const startTimeRef = React.useRef<number>(0);
@@ -128,16 +145,25 @@ export function useRecording(): UseRecordingReturn {
       const stream = await navigator.mediaDevices.getUserMedia(constraints);
       streamRef.current = stream;
 
-      // Create audio context and analyser for level monitoring
-      const audioContext = new AudioContext();
+      // Create audio context with target sample rate
+      const audioContext = new AudioContext({ sampleRate: settings.sampleRate });
       audioContextRef.current = audioContext;
 
       const source = audioContext.createMediaStreamSource(stream);
+
+      // Create gain node for input gain control
+      const gainNode = audioContext.createGain();
+      gainNode.gain.value = settings.inputGain;
+      gainNodeRef.current = gainNode;
+
+      // Create analyser for level monitoring
       const analyser = audioContext.createAnalyser();
       analyser.fftSize = 256;
       analyser.smoothingTimeConstant = 0.3;
 
-      source.connect(analyser);
+      // Connect: source -> gain -> analyser
+      source.connect(gainNode);
+      gainNode.connect(analyser);
       analyserRef.current = analyser;
 
       // Create MediaRecorder
@@ -169,7 +195,7 @@ export function useRecording(): UseRecordingReturn {
       console.error('Failed to start recording:', error);
       throw error;
     }
-  }, [monitorInputLevel]);
+  }, [monitorInputLevel, settings.sampleRate, settings.inputGain]);
 
   // Stop recording and return AudioBuffer
   const stopRecording = React.useCallback(async (): Promise<AudioBuffer | null> => {
@@ -192,7 +218,28 @@ export function useRecording(): UseRecordingReturn {
         try {
           const arrayBuffer = await blob.arrayBuffer();
           const audioContext = new AudioContext();
-          const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
+          let audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
+
+          // Convert to mono if requested
+          if (settings.recordMono && audioBuffer.numberOfChannels > 1) {
+            const monoBuffer = audioContext.createBuffer(
+              1,
+              audioBuffer.length,
+              audioBuffer.sampleRate
+            );
+            const monoData = monoBuffer.getChannelData(0);
+
+            // Mix all channels to mono by averaging
+            for (let i = 0; i < audioBuffer.length; i++) {
+              let sum = 0;
+              for (let channel = 0; channel < audioBuffer.numberOfChannels; channel++) {
+                sum += audioBuffer.getChannelData(channel)[i];
+              }
+              monoData[i] = sum / audioBuffer.numberOfChannels;
+            }
+
+            audioBuffer = monoBuffer;
+          }
 
           // Clean up
           isMonitoringRef.current = false;
@@ -219,7 +266,7 @@ export function useRecording(): UseRecordingReturn {
 
       mediaRecorder.stop();
     });
-  }, []);
+  }, [settings.recordMono]);
 
   // Pause recording
   const pauseRecording = React.useCallback(() => {
@@ -272,8 +319,26 @@ export function useRecording(): UseRecordingReturn {
     };
   }, []);
 
+  // Settings setters
+  const setInputGain = React.useCallback((gain: number) => {
+    setSettings((prev) => ({ ...prev, inputGain: Math.max(0, Math.min(2, gain)) }));
+    // Update gain node if recording
+    if (gainNodeRef.current) {
+      gainNodeRef.current.gain.value = Math.max(0, Math.min(2, gain));
+    }
+  }, []);
+
+  const setRecordMono = React.useCallback((mono: boolean) => {
+    setSettings((prev) => ({ ...prev, recordMono: mono }));
+  }, []);
+
+  const setSampleRate = React.useCallback((sampleRate: number) => {
+    setSettings((prev) => ({ ...prev, sampleRate }));
+  }, []);
+
   return {
     state,
+    settings,
     startRecording,
     stopRecording,
     pauseRecording,
@@ -281,5 +346,8 @@ export function useRecording(): UseRecordingReturn {
     getInputDevices,
     selectInputDevice,
     requestPermission,
+    setInputGain,
+    setRecordMono,
+    setSampleRate,
   };
 }