loukai-app 0.3.0

package/src/renderer/dist/assets/webrtcManager-BhCHWceK.js

@@ -0,0 +1,2 @@
+class a{constructor(){this.senderPC=null,this.receiverPC=null,this.canvasStream=null,this.pendingICECandidates=[],this.receiverPendingICE=[]}setupSender(){try{console.log("🎬 Setting up WebRTC sender");const e=document.getElementById("karaokeCanvas");if(!e)return{success:!1,error:"Canvas not found"};if(!this.canvasStream){console.log("📹 Capturing stream from karaokeCanvas at 60fps"),this.canvasStream=e.captureStream(60);const i=this.canvasStream.getVideoTracks()[0].getSettings();console.log("🔍 Capture stream resolution:",i.width,"x",i.height),(i.width!==1920||i.height!==1080)&&console.warn("⚠️ Stream resolution not 1080p! Actual:",i.width,"x",i.height)}const r=this.canvasStream;if(r.getVideoTracks().length===0)return{success:!1,error:"No video track"};const n=new RTCPeerConnection({iceServers:[],iceCandidatePoolSize:10,bundlePolicy:"balanced",rtcpMuxPolicy:"require",sdpSemantics:"unified-plan"});return r.getTracks().forEach(t=>{console.log("➕ Adding track:",t.kind),t.kind==="video"&&t.applyConstraints({width:{exact:1920},height:{exact:1080},frameRate:{exact:60}}).then(()=>{console.log("🎯 Applied 1920x1080 constraints to track")}).catch(o=>{console.error("❌ Failed to apply constraints:",o)});const i=n.addTransceiver(t,{direction:"sendonly",streams:[r]});if(t.kind==="video"){const o=i.sender,c=async()=>{try{const s=o.getParameters();s.degradationPreference="maintain-resolution",s.encodings&&s.encodings.length>0&&(s.encodings[0].maxBitrate=5e7,s.encodings[0].maxFramerate=60,s.encodings[0].scaleResolutionDownBy=1,s.encodings[0].minBitrate=1e7),await o.setParameters(s),console.log("🎯 Set maintain-resolution + no downscaling")}catch(s){console.error("❌ Failed to set encoding parameters:",s)}};c(),setTimeout(c,2e3),setTimeout(c,5e3)}}),n.onicecandidate=t=>{t.candidate&&(console.log("🧊 Sender ICE candidate"),window.kaiAPI.canvas.sendICECandidate("sender",{candidate:t.candidate.candidate,sdpMid:t.candidate.sdpMid,sdpMLineIndex:t.candidate.sdpMLineIndex}))},this.senderPC=n,console.log("✅ Sender setup complete"),{success:!0}}catch(e){return console.error("❌ Sender error:",e),{success:!1,error:e.message}}}async createOffer(){try{console.log("📋 Creating offer..."),this.senderPC.getTransceivers().forEach(n=>{if(n.sender&&n.sender.track&&n.sender.track.kind==="video"){const t=RTCRtpSender.getCapabilities("video");console.log("📺 Available video codecs:",t.codecs.map(o=>o.mimeType));const i=t.codecs.filter(o=>!!(o.mimeType.includes("H264")&&o.sdpFmtpLine?.includes("profile-level-id=42e01f")||o.mimeType.includes("VP8"))).sort((o,c)=>o.mimeType.includes("H264")?-1:c.mimeType.includes("H264")?1:0);i.length>0?(n.setCodecPreferences(i),console.log("🎯 Set preferred codec for 1080p:",i[0].mimeType)):console.warn("⚠️ No preferred codecs found, using default")}});const r=await this.senderPC.createOffer({offerToReceiveVideo:!1,voiceActivityDetection:!1});return console.log("📋 Offer created"),console.log("🔧 Setting local description..."),await this.senderPC.setLocalDescription(r),console.log("✅ Local description set on sender"),console.log("🔧 Using original SDP - relying on encoding parameters for quality"),{type:r.type,sdp:r.sdp}}catch(e){return console.error("❌ Error in sender offer creation:",e),{error:e.message,stack:e.stack}}}async setAnswer(e){try{if(console.log("📥 Setting answer in sender..."),await this.senderPC.setRemoteDescription(new RTCSessionDescription(e)),console.log("✅ Remote description set on sender"),this.pendingICECandidates.length>0){console.log(`🧊 Flushing ${this.pendingICECandidates.length} pending ICE candidates`);for(const r of this.pendingICECandidates)try{await this.senderPC.addIceCandidate(new RTCIceCandidate(r)),console.log("✅ Added queued ICE candidate to sender")}catch(n){console.error("❌ Failed to add queued ICE candidate:",n)}this.pendingICECandidates=[]}return{success:!0}}catch(r){return console.error("❌ Error setting answer:",r),{success:!1,error:r.message}}}getSenderStatus(){return this.senderPC?{connectionState:this.senderPC.connectionState,iceConnectionState:this.senderPC.iceConnectionState,iceGatheringState:this.senderPC.iceGatheringState}:{error:"Sender PC not initialized"}}async addICECandidate(e){if(!this.senderPC){console.warn("⚠️ Sender PC not initialized, ignoring ICE candidate");return}if(!this.senderPC.remoteDescription){console.log("🧊 Queueing ICE candidate (remote description not set yet)"),this.pendingICECandidates.push(e);return}try{await this.senderPC.addIceCandidate(new RTCIceCandidate(e)),console.log("✅ Added ICE candidate to sender")}catch(r){console.error("❌ Failed to add ICE candidate:",r)}}cleanupSender(){if(this.senderPC){try{this.senderPC.close(),console.log("🧹 Sender PC closed")}catch(e){console.error("Error closing sender PC:",e)}this.senderPC=null}this.canvasStream&&(this.canvasStream.getTracks().forEach(e=>e.stop()),this.canvasStream=null),this.pendingICECandidates=[]}setupReceiver(){try{console.log("🎬 Setting up WebRTC receiver");const e=document.getElementById("video");if(!e)return{success:!1,error:"Video element not found"};const r=new RTCPeerConnection({iceServers:[],iceCandidatePoolSize:10,bundlePolicy:"balanced",rtcpMuxPolicy:"require"});return r.onicecandidate=n=>{if(n.candidate){console.log("🧊 Receiver ICE candidate");const{ipcRenderer:t}=require("electron");t.invoke("canvas:sendICECandidate","receiver",{candidate:n.candidate.candidate,sdpMid:n.candidate.sdpMid,sdpMLineIndex:n.candidate.sdpMLineIndex})}},r.ontrack=n=>{console.log("🎥 Received stream"),e.srcObject=n.streams[0],console.log("📺 Connected stream to video")},this.receiverPC=r,console.log("✅ Receiver setup complete"),{success:!0}}catch(e){return console.error("❌ Receiver error:",e),{success:!1,error:e.message}}}async setOfferAndCreateAnswer(e){try{if(!this.receiverPC)throw new Error("receiverPC not available");if(console.log("📥 Received offer in child window:",e.type),console.log("🔧 Setting remote description..."),await this.receiverPC.setRemoteDescription(e),console.log("✅ Remote description set on receiver"),this.receiverPendingICE.length>0){console.log(`🧊 Flushing ${this.receiverPendingICE.length} pending ICE candidates`);for(const n of this.receiverPendingICE)try{await this.receiverPC.addIceCandidate(new RTCIceCandidate(n)),console.log("✅ Added queued ICE candidate to receiver")}catch(t){console.error("❌ Failed to add queued ICE candidate:",t)}this.receiverPendingICE=[]}console.log("📋 Creating answer...");const r=await this.receiverPC.createAnswer();return console.log("📋 Answer created:",r.type,r.sdp.length,"chars"),console.log("🔧 Setting local description on receiver..."),await this.receiverPC.setLocalDescription(r),console.log("✅ Local description set on receiver"),{type:r.type,sdp:r.sdp}}catch(r){return console.error("❌ Error in receiver answer creation:",r),{error:r.message,stack:r.stack}}}async addReceiverICECandidate(e){if(!this.receiverPC){console.warn("⚠️ Receiver PC not initialized, ignoring ICE candidate");return}if(!this.receiverPC.remoteDescription){console.log("🧊 Queueing ICE candidate for receiver (remote description not set yet)"),this.receiverPendingICE.push(e);return}try{await this.receiverPC.addIceCandidate(new RTCIceCandidate(e)),console.log("🧊 Added ICE candidate to receiver")}catch(r){console.error("❌ Failed to add ICE candidate to receiver:",r)}}getReceiverStatus(){return this.receiverPC?{connectionState:this.receiverPC.connectionState,iceConnectionState:this.receiverPC.iceConnectionState,iceGatheringState:this.receiverPC.iceGatheringState}:{error:"Receiver PC not initialized"}}checkReceiverReady(){return{ready:!0,hasReceiverPC:!!this.receiverPC}}cleanupReceiver(){if(this.receiverPC){try{this.receiverPC.close(),console.log("🧹 Receiver PC closed")}catch(e){console.error("Error closing receiver PC:",e)}this.receiverPC=null}this.receiverPendingICE=[]}}const l=new a;export{a as WebRTCManager,l as default};
+//# sourceMappingURL=webrtcManager-BhCHWceK.js.map

package/src/renderer/dist/assets/webrtcManager-BhCHWceK.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webrtcManager-BhCHWceK.js","sources":["../../js/webrtcManager.js"],"sourcesContent":["/**\n * WebRTC Manager - Handles canvas streaming via WebRTC\n *\n * Replaces inline executeJavaScript() code with proper module structure\n * for type safety and error handling.\n */\n\nexport class WebRTCManager {\n  constructor() {\n    this.senderPC = null;\n    this.receiverPC = null;\n    this.canvasStream = null;\n    this.pendingICECandidates = []; // Queue for sender early ICE candidates\n    this.receiverPendingICE = []; // Queue for receiver early ICE candidates\n  }\n\n  /**\n   * Set up WebRTC sender in main window\n   * Captures stream directly from karaokeCanvas and creates RTCPeerConnection for sending\n   * @returns {Promise<{success: boolean, error?: string}>}\n   */\n  setupSender() {\n    try {\n      console.log('🎬 Setting up WebRTC sender');\n\n      const canvas = document.getElementById('karaokeCanvas');\n      if (!canvas) {\n        return { success: false, error: 'Canvas not found' };\n      }\n\n      // Capture stream directly from the main karaokeCanvas (final composited output)\n      if (!this.canvasStream) {\n        console.log('📹 Capturing stream from karaokeCanvas at 60fps');\n        this.canvasStream = canvas.captureStream(60);\n\n        // Check stream resolution\n        const track = this.canvasStream.getVideoTracks()[0];\n        const settings = track.getSettings();\n        console.log('🔍 Capture stream resolution:', settings.width, 'x', settings.height);\n\n        if (settings.width !== 1920 || settings.height !== 1080) {\n          console.warn(\n            '⚠️ Stream resolution not 1080p! Actual:',\n            settings.width,\n            'x',\n            settings.height\n          );\n        }\n      }\n\n      // Use the existing stream\n      const stream = this.canvasStream;\n\n      if (stream.getVideoTracks().length === 0) {\n        return { success: false, error: 'No video track' };\n      }\n\n      // Create RTCPeerConnection with optimized settings for local streaming\n      const pc = new RTCPeerConnection({\n        iceServers: [], // No ICE servers needed for local connection\n        iceCandidatePoolSize: 10,\n        bundlePolicy: 'balanced',\n        rtcpMuxPolicy: 'require',\n        sdpSemantics: 'unified-plan',\n      });\n\n      // Add stream tracks with transceivers for better control\n      stream.getTracks().forEach((track) => {\n        console.log('➕ Adding track:', track.kind);\n\n        if (track.kind === 'video') {\n          // Apply constraints to force 1920x1080\n          track\n            .applyConstraints({\n              width: { exact: 1920 },\n              height: { exact: 1080 },\n              frameRate: { exact: 60 },\n            })\n            .then(() => {\n              console.log('🎯 Applied 1920x1080 constraints to track');\n            })\n            .catch((err) => {\n              console.error('❌ Failed to apply constraints:', err);\n            });\n        }\n\n        const transceiver = pc.addTransceiver(track, {\n          direction: 'sendonly',\n          streams: [stream],\n        });\n\n        // Configure for high quality, low compression\n        if (track.kind === 'video') {\n          const sender = transceiver.sender;\n\n          // Set encoding parameters to maintain resolution\n          const setEncodingParams = async () => {\n            try {\n              const params = sender.getParameters();\n\n              // Critical: Tell WebRTC to maintain resolution over frame rate\n              params.degradationPreference = 'maintain-resolution';\n\n              if (params.encodings && params.encodings.length > 0) {\n                // Force no downscaling and high bitrate\n                params.encodings[0].maxBitrate = 50000000; // 50 Mbps\n                params.encodings[0].maxFramerate = 60;\n                params.encodings[0].scaleResolutionDownBy = 1.0; // No downscaling\n                params.encodings[0].minBitrate = 10000000; // Min 10 Mbps\n              }\n\n              await sender.setParameters(params);\n              console.log('🎯 Set maintain-resolution + no downscaling');\n            } catch (error) {\n              console.error('❌ Failed to set encoding parameters:', error);\n            }\n          };\n\n          // Apply immediately\n          setEncodingParams();\n\n          // Apply again after connection to ensure it sticks\n          setTimeout(setEncodingParams, 2000);\n          setTimeout(setEncodingParams, 5000);\n        }\n      });\n\n      // Handle ICE candidates\n      pc.onicecandidate = (event) => {\n        if (event.candidate) {\n          console.log('🧊 Sender ICE candidate');\n          window.kaiAPI.canvas.sendICECandidate('sender', {\n            candidate: event.candidate.candidate,\n            sdpMid: event.candidate.sdpMid,\n            sdpMLineIndex: event.candidate.sdpMLineIndex,\n          });\n        }\n      };\n\n      // Store references\n      this.senderPC = pc;\n\n      console.log('✅ Sender setup complete');\n      return { success: true };\n    } catch (error) {\n      console.error('❌ Sender error:', error);\n      return { success: false, error: error.message };\n    }\n  }\n\n  /**\n   * Create WebRTC offer in sender\n   * @returns {Promise<{type: string, sdp: string} | {error: string}>}\n   */\n  async createOffer() {\n    try {\n      console.log('📋 Creating offer...');\n\n      // Force CPU-efficient codec for 1080p streaming\n      const transceivers = this.senderPC.getTransceivers();\n      transceivers.forEach((transceiver) => {\n        if (\n          transceiver.sender &&\n          transceiver.sender.track &&\n          transceiver.sender.track.kind === 'video'\n        ) {\n          const capabilities = RTCRtpSender.getCapabilities('video');\n          console.log(\n            '📺 Available video codecs:',\n            capabilities.codecs.map((c) => c.mimeType)\n          );\n\n          // Prioritize codecs for CPU efficiency and quality:\n          // 1. H.264 Baseline (hardware accelerated, low CPU)\n          // 2. VP8 (simple, good for local streaming)\n          const preferredCodecs = capabilities.codecs\n            .filter((codec) => {\n              // H.264 Baseline profile (most CPU efficient)\n              if (\n                codec.mimeType.includes('H264') &&\n                codec.sdpFmtpLine?.includes('profile-level-id=42e01f')\n              ) {\n                return true;\n              }\n              // VP8 (simple and efficient)\n              if (codec.mimeType.includes('VP8')) {\n                return true;\n              }\n              return false;\n            })\n            .sort((a, b) => {\n              // H.264 Baseline first, then VP8\n              if (a.mimeType.includes('H264')) return -1;\n              if (b.mimeType.includes('H264')) return 1;\n              return 0;\n            });\n\n          if (preferredCodecs.length > 0) {\n            transceiver.setCodecPreferences(preferredCodecs);\n            console.log('🎯 Set preferred codec for 1080p:', preferredCodecs[0].mimeType);\n          } else {\n            console.warn('⚠️ No preferred codecs found, using default');\n          }\n        }\n      });\n\n      const offer = await this.senderPC.createOffer({\n        offerToReceiveVideo: false,\n        voiceActivityDetection: false,\n      });\n\n      console.log('📋 Offer created');\n\n      console.log('🔧 Setting local description...');\n      await this.senderPC.setLocalDescription(offer);\n      console.log('✅ Local description set on sender');\n\n      console.log('🔧 Using original SDP - relying on encoding parameters for quality');\n\n      // Return only the serializable parts\n      return {\n        type: offer.type,\n        sdp: offer.sdp,\n      };\n    } catch (error) {\n      console.error('❌ Error in sender offer creation:', error);\n      return { error: error.message, stack: error.stack };\n    }\n  }\n\n  /**\n   * Set answer from receiver in sender PC\n   * @param {Object} answer - WebRTC answer from receiver\n   * @returns {Promise<{success: boolean, error?: string}>}\n   */\n  async setAnswer(answer) {\n    try {\n      console.log('📥 Setting answer in sender...');\n      await this.senderPC.setRemoteDescription(new RTCSessionDescription(answer));\n      console.log('✅ Remote description set on sender');\n\n      // Flush pending ICE candidates now that remote description is set\n      if (this.pendingICECandidates.length > 0) {\n        console.log(`🧊 Flushing ${this.pendingICECandidates.length} pending ICE candidates`);\n        for (const candidate of this.pendingICECandidates) {\n          try {\n            // Sequential ICE candidate addition to ensure proper WebRTC connection establishment\n            // eslint-disable-next-line no-await-in-loop\n            await this.senderPC.addIceCandidate(new RTCIceCandidate(candidate));\n            console.log('✅ Added queued ICE candidate to sender');\n          } catch (error) {\n            console.error('❌ Failed to add queued ICE candidate:', error);\n          }\n        }\n        this.pendingICECandidates = [];\n      }\n\n      return { success: true };\n    } catch (error) {\n      console.error('❌ Error setting answer:', error);\n      return { success: false, error: error.message };\n    }\n  }\n\n  /**\n   * Get sender connection status\n   * @returns {{connectionState: string, iceConnectionState: string, iceGatheringState: string} | {error: string}}\n   */\n  getSenderStatus() {\n    if (!this.senderPC) {\n      return { error: 'Sender PC not initialized' };\n    }\n    return {\n      connectionState: this.senderPC.connectionState,\n      iceConnectionState: this.senderPC.iceConnectionState,\n      iceGatheringState: this.senderPC.iceGatheringState,\n    };\n  }\n\n  /**\n   * Add ICE candidate to sender\n   * @param {Object} candidate - ICE candidate\n   * @returns {Promise<void>}\n   */\n  async addICECandidate(candidate) {\n    if (!this.senderPC) {\n      console.warn('⚠️ Sender PC not initialized, ignoring ICE candidate');\n      return;\n    }\n\n    // If remote description not set yet, queue the candidate\n    if (!this.senderPC.remoteDescription) {\n      console.log('🧊 Queueing ICE candidate (remote description not set yet)');\n      this.pendingICECandidates.push(candidate);\n      return;\n    }\n\n    // Remote description is set, add immediately\n    try {\n      await this.senderPC.addIceCandidate(new RTCIceCandidate(candidate));\n      console.log('✅ Added ICE candidate to sender');\n    } catch (error) {\n      console.error('❌ Failed to add ICE candidate:', error);\n    }\n  }\n\n  /**\n   * Cleanup sender resources\n   * @returns {Promise<void>}\n   */\n  cleanupSender() {\n    if (this.senderPC) {\n      try {\n        this.senderPC.close();\n        console.log('🧹 Sender PC closed');\n      } catch (e) {\n        console.error('Error closing sender PC:', e);\n      }\n      this.senderPC = null;\n    }\n\n    // Stop the canvas stream tracks\n    if (this.canvasStream) {\n      this.canvasStream.getTracks().forEach((track) => track.stop());\n      this.canvasStream = null;\n    }\n\n    this.pendingICECandidates = []; // Clear pending candidates\n  }\n\n  // ===== RECEIVER METHODS (for canvas window) =====\n\n  /**\n   * Set up WebRTC receiver in canvas window\n   * Creates RTCPeerConnection for receiving stream\n   * @returns {Promise<{success: boolean, error?: string}>}\n   */\n  setupReceiver() {\n    try {\n      console.log('🎬 Setting up WebRTC receiver');\n\n      const video = document.getElementById('video');\n      if (!video) {\n        return { success: false, error: 'Video element not found' };\n      }\n\n      // Create RTCPeerConnection optimized for local 1080p streaming\n      const pc = new RTCPeerConnection({\n        iceServers: [], // No ICE servers needed for local connection\n        iceCandidatePoolSize: 10,\n        bundlePolicy: 'balanced',\n        rtcpMuxPolicy: 'require',\n      });\n\n      // Handle ICE candidates\n      pc.onicecandidate = (event) => {\n        if (event.candidate) {\n          console.log('🧊 Receiver ICE candidate');\n          const { ipcRenderer } = require('electron');\n          ipcRenderer.invoke('canvas:sendICECandidate', 'receiver', {\n            candidate: event.candidate.candidate,\n            sdpMid: event.candidate.sdpMid,\n            sdpMLineIndex: event.candidate.sdpMLineIndex,\n          });\n        }\n      };\n\n      // Handle incoming stream\n      pc.ontrack = (event) => {\n        console.log('🎥 Received stream');\n        video.srcObject = event.streams[0];\n        console.log('📺 Connected stream to video');\n      };\n\n      // Store reference\n      this.receiverPC = pc;\n\n      console.log('✅ Receiver setup complete');\n      return { success: true };\n    } catch (error) {\n      console.error('❌ Receiver error:', error);\n      return { success: false, error: error.message };\n    }\n  }\n\n  /**\n   * Set offer from sender and create answer\n   * @param {Object} offer - WebRTC offer from sender\n   * @returns {Promise<{type: string, sdp: string} | {error: string}>}\n   */\n  async setOfferAndCreateAnswer(offer) {\n    try {\n      if (!this.receiverPC) {\n        throw new Error('receiverPC not available');\n      }\n\n      console.log('📥 Received offer in child window:', offer.type);\n      console.log('🔧 Setting remote description...');\n      await this.receiverPC.setRemoteDescription(offer);\n      console.log('✅ Remote description set on receiver');\n\n      // Flush pending ICE candidates now that remote description is set\n      if (this.receiverPendingICE.length > 0) {\n        console.log(`🧊 Flushing ${this.receiverPendingICE.length} pending ICE candidates`);\n        for (const candidate of this.receiverPendingICE) {\n          try {\n            // Sequential ICE candidate addition to ensure proper WebRTC connection establishment\n            // eslint-disable-next-line no-await-in-loop\n            await this.receiverPC.addIceCandidate(new RTCIceCandidate(candidate));\n            console.log('✅ Added queued ICE candidate to receiver');\n          } catch (error) {\n            console.error('❌ Failed to add queued ICE candidate:', error);\n          }\n        }\n        this.receiverPendingICE = [];\n      }\n\n      console.log('📋 Creating answer...');\n      const answer = await this.receiverPC.createAnswer();\n      console.log('📋 Answer created:', answer.type, answer.sdp.length, 'chars');\n\n      console.log('🔧 Setting local description on receiver...');\n      await this.receiverPC.setLocalDescription(answer);\n      console.log('✅ Local description set on receiver');\n\n      // Return only the serializable parts\n      return {\n        type: answer.type,\n        sdp: answer.sdp,\n      };\n    } catch (error) {\n      console.error('❌ Error in receiver answer creation:', error);\n      return { error: error.message, stack: error.stack };\n    }\n  }\n\n  /**\n   * Add ICE candidate to receiver\n   * @param {Object} candidate - ICE candidate\n   * @returns {Promise<void>}\n   */\n  async addReceiverICECandidate(candidate) {\n    if (!this.receiverPC) {\n      console.warn('⚠️ Receiver PC not initialized, ignoring ICE candidate');\n      return;\n    }\n\n    // If remote description not set yet, queue the candidate\n    if (!this.receiverPC.remoteDescription) {\n      console.log('🧊 Queueing ICE candidate for receiver (remote description not set yet)');\n      this.receiverPendingICE.push(candidate);\n      return;\n    }\n\n    // Remote description is set, add immediately\n    try {\n      await this.receiverPC.addIceCandidate(new RTCIceCandidate(candidate));\n      console.log('🧊 Added ICE candidate to receiver');\n    } catch (error) {\n      console.error('❌ Failed to add ICE candidate to receiver:', error);\n    }\n  }\n\n  /**\n   * Get receiver connection status\n   * @returns {{connectionState: string, iceConnectionState: string, iceGatheringState: string} | {error: string}}\n   */\n  getReceiverStatus() {\n    if (!this.receiverPC) {\n      return { error: 'Receiver PC not initialized' };\n    }\n    return {\n      connectionState: this.receiverPC.connectionState,\n      iceConnectionState: this.receiverPC.iceConnectionState,\n      iceGatheringState: this.receiverPC.iceGatheringState,\n    };\n  }\n\n  /**\n   * Check if receiver is ready\n   * @returns {{ready: boolean, hasReceiverPC: boolean}}\n   */\n  checkReceiverReady() {\n    return {\n      ready: true,\n      hasReceiverPC: Boolean(this.receiverPC),\n    };\n  }\n\n  /**\n   * Cleanup receiver resources\n   * @returns {Promise<void>}\n   */\n  cleanupReceiver() {\n    if (this.receiverPC) {\n      try {\n        this.receiverPC.close();\n        console.log('🧹 Receiver PC closed');\n      } catch (e) {\n        console.error('Error closing receiver PC:', e);\n      }\n      this.receiverPC = null;\n    }\n    this.receiverPendingICE = []; // Clear pending candidates\n  }\n}\n\n// Create singleton instance\nconst webrtcManager = new WebRTCManager();\n\nexport default webrtcManager;\n"],"names":["WebRTCManager","canvas","settings","stream","pc","track","err","transceiver","sender","setEncodingParams","params","error","event","capabilities","c","preferredCodecs","codec","a","b","offer","answer","candidate","video","ipcRenderer","webrtcManager"],"mappings":"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"}

package/src/renderer/dist/js/autoTuneWorklet.js

@@ -0,0 +1,224 @@
+class AutoTuneProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+
+    // Auto-tune parameters
+    this.enabled = false;
+    this.strength = 0.5; // 0-1 range
+    this.speed = 0.05; // How quickly to correct pitch
+    this.targetPitch = null;
+    this.currentKey = 'C';
+
+    // Pitch detection
+    this.sampleRate = 44100;
+    this.bufferSize = 2048;
+    this.buffer = new Float32Array(this.bufferSize);
+    this.bufferIndex = 0;
+
+    // Musical notes in Hz (A4 = 440Hz)
+    this.noteFrequencies = {
+      C: [65.41, 130.81, 261.63, 523.25, 1046.5],
+      'C#': [69.3, 138.59, 277.18, 554.37, 1108.73],
+      D: [73.42, 146.83, 293.66, 587.33, 1174.66],
+      'D#': [77.78, 155.56, 311.13, 622.25, 1244.51],
+      E: [82.41, 164.81, 329.63, 659.25, 1318.51],
+      F: [87.31, 174.61, 349.23, 698.46, 1396.91],
+      'F#': [92.5, 185.0, 369.99, 739.99, 1479.98],
+      G: [98.0, 196.0, 392.0, 783.99, 1567.98],
+      'G#': [103.83, 207.65, 415.3, 830.61, 1661.22],
+      A: [110.0, 220.0, 440.0, 880.0, 1760.0],
+      'A#': [116.54, 233.08, 466.16, 932.33, 1864.66],
+      B: [123.47, 246.94, 493.88, 987.77, 1975.53],
+    };
+
+    // Scales for key detection
+    this.scales = {
+      C: ['C', 'D', 'E', 'F', 'G', 'A', 'B'],
+      G: ['G', 'A', 'B', 'C', 'D', 'E', 'F#'],
+      D: ['D', 'E', 'F#', 'G', 'A', 'B', 'C#'],
+      A: ['A', 'B', 'C#', 'D', 'E', 'F#', 'G#'],
+      E: ['E', 'F#', 'G#', 'A', 'B', 'C#', 'D#'],
+      B: ['B', 'C#', 'D#', 'E', 'F#', 'G#', 'A#'],
+      F: ['F', 'G', 'A', 'A#', 'C', 'D', 'E'],
+      'A#': ['A#', 'C', 'D', 'D#', 'F', 'G', 'A'],
+      'D#': ['D#', 'F', 'G', 'G#', 'A#', 'C', 'D'],
+      'G#': ['G#', 'A#', 'C', 'C#', 'D#', 'F', 'G'],
+      'C#': ['C#', 'D#', 'F', 'F#', 'G#', 'A#', 'B'],
+      'F#': ['F#', 'G#', 'A#', 'B', 'C#', 'D#', 'F'],
+    };
+
+    // Phase vocoder for pitch shifting
+    this.fftSize = 2048;
+    this.hopSize = this.fftSize / 4;
+    this.analysisWindow = this.createWindow(this.fftSize);
+    this.synthesisWindow = this.createWindow(this.fftSize);
+
+    // Overlap-add buffers
+    this.inputBuffer = new Float32Array(this.fftSize);
+    this.outputBuffer = new Float32Array(this.fftSize);
+    this.overlapBuffer = new Float32Array(this.fftSize);
+
+    // Debug logging
+    this.frameCount = 0;
+    this.lastLogTime = 0;
+
+    // Handle parameter changes from main thread
+    this.port.onmessage = (event) => {
+      if (event.data.type === 'setEnabled') {
+        this.enabled = event.data.value;
+      } else if (event.data.type === 'setStrength') {
+        this.strength = event.data.value / 100; // Convert from 0-100 to 0-1
+      } else if (event.data.type === 'setSpeed') {
+        this.speed = event.data.value / 100; // Convert from 1-100 to 0.01-1
+      } else if (event.data.type === 'setKey') {
+        this.currentKey = event.data.value;
+      }
+    };
+  }
+
+  createWindow(size) {
+    const window = new Float32Array(size);
+    for (let i = 0; i < size; i++) {
+      // Hann window
+      window[i] = 0.5 * (1 - Math.cos((2 * Math.PI * i) / (size - 1)));
+    }
+    return window;
+  }
+
+  detectPitch(buffer) {
+    // Simple autocorrelation-based pitch detection
+    const minPeriod = Math.floor(this.sampleRate / 800); // 800 Hz max
+    const maxPeriod = Math.floor(this.sampleRate / 80); // 80 Hz min
+
+    let maxCorrelation = 0;
+    let bestPeriod = 0;
+
+    for (let period = minPeriod; period < maxPeriod; period++) {
+      let correlation = 0;
+      for (let i = 0; i < buffer.length - period; i++) {
+        correlation += buffer[i] * buffer[i + period];
+      }
+
+      if (correlation > maxCorrelation) {
+        maxCorrelation = correlation;
+        bestPeriod = period;
+      }
+    }
+
+    if (bestPeriod > 0 && maxCorrelation > 0.01) {
+      return this.sampleRate / bestPeriod;
+    }
+
+    return null;
+  }
+
+  findNearestNote(frequency) {
+    if (!frequency) return null;
+
+    const scaleNotes = this.scales[this.currentKey] || this.scales['C'];
+    let minDiff = Infinity;
+    let nearestNote = null;
+    let nearestFreq = null;
+
+    for (const note of scaleNotes) {
+      const frequencies = this.noteFrequencies[note];
+      for (const freq of frequencies) {
+        const diff = Math.abs(frequency - freq);
+        if (diff < minDiff) {
+          minDiff = diff;
+          nearestNote = note;
+          nearestFreq = freq;
+        }
+      }
+    }
+
+    return { note: nearestNote, frequency: nearestFreq };
+  }
+
+  processWithRobotEffect(inputSample) {
+    // Create a robotic auto-tune effect using wave shaping
+    // This is more audible than true pitch shifting but gives the characteristic sound
+
+    // Hard clip the signal for a more digital sound
+    let processed = Math.max(-1, Math.min(1, inputSample * 2));
+
+    // Add harmonic distortion for the "robotic" quality
+    processed = Math.sin(processed * Math.PI);
+
+    // Quantize to create stepped pitch effect
+    const steps = 16; // Number of quantization levels
+    processed = Math.round(processed * steps) / steps;
+
+    // Mix with original based on strength
+    return inputSample * (1 - this.strength) + processed * this.strength;
+  }
+
+  process(inputs, outputs, _parameters) {
+    const input = inputs[0];
+    const output = outputs[0];
+
+    if (!input || !input[0]) {
+      return true;
+    }
+
+    const inputChannel = input[0];
+    const outputChannel = output[0];
+
+    if (!this.enabled) {
+      // Pass through unprocessed
+      outputChannel.set(inputChannel);
+      return true;
+    }
+
+    // Fill detection buffer
+    for (let i = 0; i < inputChannel.length; i++) {
+      this.buffer[this.bufferIndex++] = inputChannel[i];
+
+      if (this.bufferIndex >= this.bufferSize) {
+        // Detect pitch
+        const detectedPitch = this.detectPitch(this.buffer);
+
+        if (detectedPitch) {
+          const nearest = this.findNearestNote(detectedPitch);
+          if (nearest) {
+            // Calculate pitch shift factor
+            const shiftFactor = nearest.frequency / detectedPitch;
+
+            // Log pitch detection every second
+            this.frameCount++;
+            const now = Date.now();
+            if (now - this.lastLogTime > 1000) {
+              this.lastLogTime = now;
+            }
+
+            // Smooth the pitch correction based on speed parameter
+            if (this.targetPitch) {
+              this.targetPitch = this.targetPitch * (1 - this.speed) + shiftFactor * this.speed;
+            } else {
+              this.targetPitch = shiftFactor;
+            }
+          }
+        }
+
+        // Reset buffer
+        this.bufferIndex = 0;
+        this.buffer.fill(0);
+      }
+    }
+
+    // Apply auto-tune effect
+    // For now, use the robotic effect which is more immediately audible
+    for (let i = 0; i < outputChannel.length; i++) {
+      outputChannel[i] = this.processWithRobotEffect(inputChannel[i]);
+    }
+
+    // Log that we're processing
+    if (this.frameCount % 1000 === 0) {
+      // Debug logging disabled for performance
+    }
+
+    return true;
+  }
+}
+
+registerProcessor('auto-tune-processor', AutoTuneProcessor);

package/src/renderer/dist/js/micPitchDetectorWorklet.js

@@ -0,0 +1,137 @@
+/**
+ * Microphone Pitch Detector AudioWorklet
+ * Detects fundamental frequency from microphone input
+ * Sends pitch data to main thread for auto-tune and coaching display
+ */
+
+class MicPitchDetectorProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+
+    // Pitch detection parameters
+    this.sampleRate = 48000; // Will be updated from options
+    this.bufferSize = 2048;
+    this.buffer = new Float32Array(this.bufferSize);
+    this.bufferIndex = 0;
+
+    // Detection rate throttling
+    this.detectionCount = 0;
+    this.detectionInterval = 4; // Detect every 4 buffers (~46ms at 48kHz)
+
+    // Last detected pitch for smoothing
+    this.lastPitch = null;
+    this.smoothingFactor = 0.7; // Exponential smoothing
+
+    // Minimum signal threshold to avoid detecting noise
+    this.minSignalThreshold = 0.01;
+
+    // Handle messages from main thread
+    this.port.onmessage = (event) => {
+      if (event.data.type === 'setSampleRate') {
+        this.sampleRate = event.data.value;
+      } else if (event.data.type === 'setDetectionInterval') {
+        this.detectionInterval = event.data.value;
+      }
+    };
+  }
+
+  /**
+   * Detect pitch using autocorrelation
+   * Returns frequency in Hz or null if no pitch detected
+   */
+  detectPitch(buffer) {
+    // Check signal strength first
+    let sumSquares = 0;
+    for (let i = 0; i < buffer.length; i++) {
+      sumSquares += buffer[i] * buffer[i];
+    }
+    const rms = Math.sqrt(sumSquares / buffer.length);
+
+    if (rms < this.minSignalThreshold) {
+      return null; // Signal too weak
+    }
+
+    // Autocorrelation-based pitch detection
+    // Vocal range: ~80 Hz (E2) to ~800 Hz (G5)
+    const minPeriod = Math.floor(this.sampleRate / 800); // 800 Hz max
+    const maxPeriod = Math.floor(this.sampleRate / 80); // 80 Hz min
+
+    let maxCorrelation = 0;
+    let bestPeriod = 0;
+
+    // Calculate autocorrelation for each possible period
+    for (let period = minPeriod; period < maxPeriod; period++) {
+      let correlation = 0;
+      for (let i = 0; i < buffer.length - period; i++) {
+        correlation += buffer[i] * buffer[i + period];
+      }
+
+      if (correlation > maxCorrelation) {
+        maxCorrelation = correlation;
+        bestPeriod = period;
+      }
+    }
+
+    // Require minimum correlation strength
+    const correlationThreshold = sumSquares * 0.3;
+    if (bestPeriod > 0 && maxCorrelation > correlationThreshold) {
+      const frequency = this.sampleRate / bestPeriod;
+
+      // Apply exponential smoothing
+      if (this.lastPitch !== null) {
+        return this.lastPitch * this.smoothingFactor + frequency * (1 - this.smoothingFactor);
+      }
+      return frequency;
+    }
+
+    return null;
+  }
+
+  process(inputs, outputs) {
+    const input = inputs[0];
+    const output = outputs[0];
+
+    if (!input || !input[0]) {
+      return true;
+    }
+
+    const inputChannel = input[0];
+
+    // Pass through audio unchanged
+    if (output && output[0]) {
+      output[0].set(inputChannel);
+    }
+
+    // Fill detection buffer
+    for (let i = 0; i < inputChannel.length; i++) {
+      this.buffer[this.bufferIndex++] = inputChannel[i];
+
+      if (this.bufferIndex >= this.bufferSize) {
+        // Buffer full - perform detection (throttled)
+        this.detectionCount++;
+        if (this.detectionCount >= this.detectionInterval) {
+          this.detectionCount = 0;
+
+          const detectedPitch = this.detectPitch(this.buffer);
+
+          // Update last pitch for smoothing
+          this.lastPitch = detectedPitch;
+
+          // Send pitch data to main thread
+          this.port.postMessage({
+            type: 'pitch',
+            frequency: detectedPitch,
+            timestamp: Date.now(),
+          });
+        }
+
+        // Reset buffer
+        this.bufferIndex = 0;
+      }
+    }
+
+    return true;
+  }
+}
+
+registerProcessor('mic-pitch-detector', MicPitchDetectorProcessor);

package/src/renderer/dist/js/musicAnalysisWorklet.js

@@ -0,0 +1,216 @@
+// AudioWorklet processor for real-time music analysis
+class MusicAnalysisProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+
+    // Analysis parameters
+    this.fftSize = 512;
+    this.bufferSize = this.fftSize * 2; // Need double for FFT
+    this.buffer = new Float32Array(this.bufferSize);
+    this.bufferIndex = 0;
+
+    // Analysis results
+    this.analysisFrameCount = 0;
+    this.analysisRate = 4; // Send analysis every 4 frames (~15Hz at 60fps)
+
+    // Pre-allocate arrays for efficiency
+    this.frequencyData = new Float32Array(this.fftSize / 2);
+    this.tempBuffer = new Float32Array(this.fftSize);
+
+    // Pitch detection parameters
+    this.sampleRate = 48000; // Will be updated from options
+    this.pitchDetectionEnabled = false;
+    this.lastPitch = null;
+    this.smoothingFactor = 0.7;
+    this.minSignalThreshold = 0.01;
+
+    // Handle messages from main thread
+    this.port.onmessage = (event) => {
+      if (event.data.type === 'setSampleRate') {
+        this.sampleRate = event.data.value;
+      } else if (event.data.type === 'enablePitchDetection') {
+        this.pitchDetectionEnabled = event.data.value;
+      }
+    };
+  }
+
+  process(inputs, _outputs, _parameters) {
+    const input = inputs[0];
+
+    if (!input || !input[0]) {
+      return true;
+    }
+
+    const inputChannel = input[0];
+
+    // Fill circular buffer
+    for (let i = 0; i < inputChannel.length; i++) {
+      this.buffer[this.bufferIndex] = inputChannel[i];
+      this.bufferIndex = (this.bufferIndex + 1) % this.bufferSize;
+    }
+
+    // Perform analysis at reduced rate to avoid overwhelming main thread
+    this.analysisFrameCount++;
+    if (this.analysisFrameCount >= this.analysisRate) {
+      this.analysisFrameCount = 0;
+      this.performAnalysis();
+    }
+
+    return true;
+  }
+
+  detectPitch(buffer) {
+    // Check signal strength first
+    let sumSquares = 0;
+    for (let i = 0; i < buffer.length; i++) {
+      sumSquares += buffer[i] * buffer[i];
+    }
+    const rms = Math.sqrt(sumSquares / buffer.length);
+
+    if (rms < this.minSignalThreshold) {
+      return null; // Signal too weak
+    }
+
+    // Autocorrelation-based pitch detection
+    // Music range: ~80 Hz (bass) to ~2000 Hz (upper harmonics)
+    const minPeriod = Math.floor(this.sampleRate / 2000); // 2000 Hz max
+    const maxPeriod = Math.floor(this.sampleRate / 80); // 80 Hz min
+
+    let maxCorrelation = 0;
+    let bestPeriod = 0;
+
+    // Calculate autocorrelation for each possible period
+    for (let period = minPeriod; period < maxPeriod; period++) {
+      let correlation = 0;
+      for (let i = 0; i < buffer.length - period; i++) {
+        correlation += buffer[i] * buffer[i + period];
+      }
+
+      if (correlation > maxCorrelation) {
+        maxCorrelation = correlation;
+        bestPeriod = period;
+      }
+    }
+
+    // Require minimum correlation strength
+    const correlationThreshold = sumSquares * 0.3;
+    if (bestPeriod > 0 && maxCorrelation > correlationThreshold) {
+      const frequency = this.sampleRate / bestPeriod;
+
+      // Apply exponential smoothing
+      if (this.lastPitch !== null) {
+        return this.lastPitch * this.smoothingFactor + frequency * (1 - this.smoothingFactor);
+      }
+      return frequency;
+    }
+
+    return null;
+  }
+
+  performAnalysis() {
+    // Copy buffer data in correct order for FFT
+    const startIndex = this.bufferIndex;
+    for (let i = 0; i < this.fftSize; i++) {
+      const bufferIdx = (startIndex + i) % this.bufferSize;
+      this.tempBuffer[i] = this.buffer[bufferIdx];
+    }
+
+    // Apply window function (Hann window)
+    for (let i = 0; i < this.fftSize; i++) {
+      const windowValue = 0.5 * (1 - Math.cos((2 * Math.PI * i) / (this.fftSize - 1)));
+      this.tempBuffer[i] *= windowValue;
+    }
+
+    // Detect pitch if enabled
+    let detectedPitch = null;
+    if (this.pitchDetectionEnabled) {
+      detectedPitch = this.detectPitch(this.tempBuffer);
+      this.lastPitch = detectedPitch;
+    }
+
+    // Perform FFT (simplified real-to-complex)
+    this.simpleFFT(this.tempBuffer, this.frequencyData);
+
+    // Analyze frequency bands
+    const analysis = this.analyzeFrequencyBands(this.frequencyData);
+
+    // Add pitch to analysis if detected
+    if (detectedPitch) {
+      analysis.pitch = detectedPitch;
+    }
+
+    // Send results to main thread
+    this.port.postMessage({
+      type: 'analysis',
+      data: analysis,
+    });
+  }
+
+  // Simplified FFT implementation for AudioWorklet
+  simpleFFT(timeData, freqData) {
+    const N = timeData.length;
+    const halfN = N / 2;
+
+    // Convert to magnitude spectrum (simplified)
+    for (let i = 0; i < halfN; i++) {
+      let real = 0;
+      let imag = 0;
+
+      for (let j = 0; j < N; j++) {
+        const angle = (-2 * Math.PI * i * j) / N;
+        real += timeData[j] * Math.cos(angle);
+        imag += timeData[j] * Math.sin(angle);
+      }
+
+      // Magnitude
+      freqData[i] = Math.sqrt(real * real + imag * imag) / N;
+    }
+  }
+
+  analyzeFrequencyBands(frequencyData) {
+    const binCount = frequencyData.length;
+    const bassEnd = Math.floor(binCount * 0.1); // 0-10% (bass)
+    const midEnd = Math.floor(binCount * 0.4); // 10-40% (mids)
+    // 40-100% is treble
+
+    let bassSum = 0,
+      midSum = 0,
+      trebleSum = 0,
+      totalEnergy = 0;
+    let weightedSum = 0; // for spectral centroid
+
+    for (let i = 0; i < binCount; i++) {
+      const value = frequencyData[i];
+      totalEnergy += value;
+      weightedSum += value * i;
+
+      if (i < bassEnd) {
+        bassSum += value;
+      } else if (i < midEnd) {
+        midSum += value;
+      } else {
+        trebleSum += value;
+      }
+    }
+
+    // Calculate averages and normalize
+    const bassAvg = bassEnd > 0 ? bassSum / bassEnd : 0;
+    const midAvg = midEnd - bassEnd > 0 ? midSum / (midEnd - bassEnd) : 0;
+    const trebleAvg = binCount - midEnd > 0 ? trebleSum / (binCount - midEnd) : 0;
+    const energyAvg = binCount > 0 ? totalEnergy / binCount : 0;
+
+    // Calculate spectral centroid (normalized)
+    const centroid = totalEnergy > 0 ? weightedSum / totalEnergy / binCount : 0;
+
+    // Apply smoothing and scaling for visual effects
+    return {
+      energy: Math.min(energyAvg * 50, 1.0), // Scale and clamp
+      bass: Math.min(bassAvg * 100, 1.0),
+      mid: Math.min(midAvg * 80, 1.0),
+      treble: Math.min(trebleAvg * 60, 1.0),
+      centroid: centroid,
+    };
+  }
+}
+
+registerProcessor('music-analysis-processor', MusicAnalysisProcessor);