web-audio-recorder-ts 1.0.5 → 1.0.7

package/dist/index.esm.js

@@ -84,6 +84,27 @@ class WebAudioRecorder {
             }
             // Criar source node a partir do stream
             this.sourceNode = this.audioContext.createMediaStreamSource(stream);
+            // Detectar número real de canais do stream
+            let detectedChannels = this.numChannels;
+            const audioTracks = stream.getAudioTracks();
+            if (audioTracks.length > 0) {
+                // Tentar obter do getSettings (navegadores modernos)
+                const settings = audioTracks[0].getSettings();
+                if (settings.channelCount) {
+                    detectedChannels = settings.channelCount;
+                }
+                else {
+                    // Fallback: assumir que a maioria dos microfones é mono (1) ou usar padrão (2)
+                    // Mas como não podemos ter certeza sem processar, vamos confiar na configuração 
+                    // ou no padrão do AudioContext
+                    console.log('Channel count not available in track settings, using default/configured:', this.numChannels);
+                }
+            }
+            // Atualizar numChannels se necessário
+            if (detectedChannels !== this.numChannels) {
+                console.log(`Detected ${detectedChannels} channel(s) in stream, adjusting from ${this.numChannels} to ${detectedChannels}`);
+                this.numChannels = detectedChannels;
+            }
             // Criar script processor para capturar dados de áudio
             this.scriptProcessor = this.audioContext.createScriptProcessor(this.bufferSize, this.numChannels, this.numChannels);
             // Conectar os nós
@@ -96,14 +117,69 @@ class WebAudioRecorder {
                 }
                 try {
                     const inputBuffer = event.inputBuffer;
+                    const actualChannels = inputBuffer.numberOfChannels;
                     const buffers = [];
-                    // Extrair dados de cada canal
-                    for (let channel = 0; channel < this.numChannels; channel++) {
+                    // Extrair dados de cada canal disponível
+                    for (let channel = 0; channel < actualChannels; channel++) {
                         const channelData = inputBuffer.getChannelData(channel);
                         buffers.push(new Float32Array(channelData));
                     }
+                    // Garantir que temos exatamente o número de canais esperado
+                    // Se o número de canais do buffer não corresponde ao esperado, ajustar
+                    if (actualChannels !== this.numChannels) {
+                        if (actualChannels === 1 && this.numChannels === 2) {
+                            // Mono -> Estéreo: duplicar o canal
+                            buffers.push(new Float32Array(buffers[0]));
+                        }
+                        else if (actualChannels === 2 && this.numChannels === 1) {
+                            // Estéreo -> Mono: usar apenas o primeiro canal
+                            buffers.splice(1);
+                        }
+                        else if (actualChannels < this.numChannels) {
+                            // Menos canais do que esperado: duplicar o último canal
+                            while (buffers.length < this.numChannels && buffers.length > 0) {
+                                buffers.push(new Float32Array(buffers[buffers.length - 1]));
+                            }
+                        }
+                        else if (actualChannels > this.numChannels) {
+                            // Mais canais do que esperado: usar apenas os primeiros
+                            buffers.splice(this.numChannels);
+                        }
+                    }
+                    // Validação final CRÍTICA: garantir que temos exatamente o número correto de canais
+                    // O encoder Emscripten é muito sensível e aborta se o número de canais não corresponder
+                    if (buffers.length !== this.numChannels) {
+                        console.warn(`Channel mismatch detected: Expected ${this.numChannels} channels, ` +
+                            `got ${buffers.length} after adjustment. ` +
+                            `Actual input channels: ${actualChannels}. ` +
+                            `Fixing by ${buffers.length < this.numChannels ? 'duplicating' : 'removing'} channels.`);
+                        // Tentar corrigir: duplicar ou remover canais conforme necessário
+                        while (buffers.length < this.numChannels) {
+                            if (buffers.length > 0) {
+                                // Duplicar o primeiro canal (ou último se houver mais de um)
+                                const sourceChannel = buffers[buffers.length - 1];
+                                buffers.push(new Float32Array(sourceChannel));
+                            }
+                            else {
+                                // Se não há buffers, criar um buffer vazio (não deveria acontecer)
+                                console.error('No buffers available! Creating empty buffer.');
+                                buffers.push(new Float32Array(inputBuffer.length));
+                            }
+                        }
+                        // Remover canais extras se houver mais do que o esperado
+                        if (buffers.length > this.numChannels) {
+                            buffers.splice(this.numChannels);
+                        }
+                    }
+                    // Validação final absoluta: se ainda não temos o número correto, não codificar
+                    if (buffers.length !== this.numChannels) {
+                        console.error(`CRITICAL: Failed to fix channel mismatch. ` +
+                            `Expected ${this.numChannels}, got ${buffers.length}. ` +
+                            `Skipping this buffer to prevent encoder abort().`);
+                        return; // Não codificar este buffer para evitar abort()
+                    }
                     // Codificar os dados
-                    if (this.encoder) {
+                    if (this.encoder && buffers.length > 0) {
                         this.encoder.encode(buffers);
                     }
                 }
@@ -395,233 +471,107 @@ class WavAudioEncoder {
 }
 
 /**
- * Utility functions for automatically loading encoder files from the npm package
+ * Utility functions for loading encoder files
+ *
+ * STANDARD: Files should be placed in `public/encoders/`
  */
 /**
- * Get the base URL for encoder files
- * Tries to detect the package location automatically
+ * Get the default base URL for encoder files
+ * Defaults to '/encoders' (relative to domain root)
  */
 function getEncoderBaseUrl() {
-    // Try to detect from import.meta.url (ESM)
-    // Use try-catch to safely check for import.meta
-    try {
-        // @ts-ignore - import.meta may not exist in all environments
-        if (typeof import.meta !== 'undefined' && import.meta.url) {
-            try {
-                // @ts-ignore
-                const url = new URL(import.meta.url);
-                // If running from node_modules, construct path to lib
-                if (url.pathname.includes('node_modules')) {
-                    const packagePath = url.pathname.split('node_modules/')[1];
-                    const packageName = packagePath.split('/')[0];
-                    // Return relative path from package root
-                    return `/node_modules/${packageName}/lib`;
-                }
-                // If running from dist, go up to lib
-                if (url.pathname.includes('/dist/')) {
-                    return url.pathname.replace('/dist/', '/lib/').replace(/\/[^/]+$/, '');
-                }
-            }
-            catch (e) {
-                // Fall through to other methods
-            }
-        }
-    }
-    catch (e) {
-        // import.meta not available, continue to other methods
-    }
-    // Try to detect from __dirname (CJS/Node.js)
-    if (typeof __dirname !== 'undefined') {
-        try {
-            // If in node_modules, construct path
-            if (__dirname.includes('node_modules')) {
-                const parts = __dirname.split('node_modules/');
-                if (parts.length > 1) {
-                    const packageName = parts[1].split('/')[0];
-                    // Retornar caminho absoluto se possível
-                    if (typeof window !== 'undefined') {
-                        return `${window.location.origin}/node_modules/${packageName}/lib`;
-                    }
-                    return `/node_modules/${packageName}/lib`;
-                }
-            }
-            // If in dist, go to lib
-            if (__dirname.includes('dist')) {
-                const libPath = __dirname.replace('dist', 'lib');
-                if (typeof window !== 'undefined') {
-                    return `${window.location.origin}${libPath}`;
-                }
-                return libPath;
-            }
-        }
-        catch (e) {
-            // Fall through
-        }
-    }
-    // Try to detect from document.currentScript or all scripts (browser)
-    if (typeof document !== 'undefined') {
-        // Try currentScript first
-        let script = document.currentScript;
-        // If no currentScript, try to find script with web-audio-recorder in src
-        if (!script || !script.src) {
-            const scripts = document.querySelectorAll('script[src]');
-            for (const s of Array.from(scripts)) {
-                const src = s.src;
-                if (src.includes('web-audio-recorder')) {
-                    script = s;
-                    break;
-                }
-            }
-        }
-        if (script && script.src) {
-            try {
-                const url = new URL(script.src);
-                // If from node_modules
-                if (url.pathname.includes('node_modules')) {
-                    const packagePath = url.pathname.split('node_modules/')[1];
-                    const packageName = packagePath.split('/')[0];
-                    // Retornar caminho absoluto para node_modules
-                    return `${url.origin}/node_modules/${packageName}/lib`;
-                }
-                // If from dist, go to lib
-                if (url.pathname.includes('/dist/')) {
-                    const libPath = url.pathname.replace('/dist/', '/lib/').replace(/\/[^/]+$/, '');
-                    return `${url.origin}${libPath}`;
-                }
-            }
-            catch (e) {
-                // Fall through
-            }
-        }
-    }
-    // Default fallback: try node_modules first, then root
-    if (typeof window !== 'undefined') {
-        // Priorizar node_modules
-        return '/node_modules/web-audio-recorder-ts/lib';
-    }
-    return '/lib';
+    // Simples e direto: padrão é a pasta /encoders na raiz
+    return '/encoders';
 }
 /**
  * Get the full URL for an encoder script file
- * @param filename - Name of the encoder file (e.g., 'OggVorbisEncoder.min.js')
- * @param customBaseUrl - Optional custom base URL (overrides auto-detection)
  */
 function getEncoderScriptUrl(filename, customBaseUrl) {
     const baseUrl = customBaseUrl || getEncoderBaseUrl();
-    // Ensure baseUrl ends with /
+    // Garantir barra no final
     const normalizedBase = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
-    // If baseUrl is absolute (starts with http:// or https://), return as is
-    if (normalizedBase.startsWith('http://') || normalizedBase.startsWith('https://')) {
-        return `${normalizedBase}${filename}`;
-    }
-    // If baseUrl starts with /, it's already absolute
-    if (normalizedBase.startsWith('/')) {
+    // Se baseUrl começa com http/https ou /, retorna como está
+    if (normalizedBase.startsWith('http') || normalizedBase.startsWith('/')) {
         return `${normalizedBase}${filename}`;
     }
-    // Otherwise, make it relative to current location
+    // Caso contrário, relativo à origem atual
     if (typeof window !== 'undefined') {
-        const base = window.location.origin;
-        return `${base}/${normalizedBase}${filename}`;
+        return `${window.location.origin}/${normalizedBase}${filename}`;
     }
-    return `${normalizedBase}${filename}`;
+    return `/${normalizedBase}${filename}`;
 }
 /**
  * Configure encoder memory initializer paths
- * @param baseUrl - Base URL for .mem files (defaults to auto-detected path)
+ * Critical for OGG/MP3 Emscripten modules
  */
 function configureEncoderPaths(baseUrl) {
     if (typeof window === 'undefined') {
         return;
     }
-    const url = baseUrl || getEncoderBaseUrl();
+    // Se nenhuma URL for passada, usar o padrão /encoders
+    let url = baseUrl || getEncoderBaseUrl();
+    // Converter para URL absoluta para evitar problemas com Emscripten
+    try {
+        if (!url.startsWith('http')) {
+            // Usar a URL atual como base
+            // Se url for '/encoders', vira 'http://localhost:3000/encoders'
+            url = new URL(url, window.location.href).href;
+        }
+    }
+    catch (e) {
+        console.warn('Failed to resolve absolute URL for encoder path:', e);
+    }
+    // Garantir barra no final
     const normalizedUrl = url.endsWith('/') ? url : `${url}/`;
-    // Configure OGG encoder
+    console.log(`[web-audio-recorder-ts] Configuring encoder memory path to: ${normalizedUrl}`);
+    // Configurar globais para o Emscripten
+    // OGG
     window.OggVorbisEncoderConfig = {
+        // Importante: Emscripten usa isso para achar o arquivo .mem
         memoryInitializerPrefixURL: normalizedUrl
     };
-    // Configure MP3 encoder
+    // MP3
     window.Mp3LameEncoderConfig = {
         memoryInitializerPrefixURL: normalizedUrl
     };
 }
 /**
- * Try multiple paths to find encoder files
- * Useful when auto-detection fails
+ * Find and load encoder script
+ * Simplified: ONLY looks in standard locations or provided path
  */
 async function findEncoderPath(filename) {
-    // Obter base URL atual para construir caminhos relativos
-    const currentOrigin = typeof window !== 'undefined' ? window.location.origin : '';
-    const currentPath = typeof window !== 'undefined' ? window.location.pathname : '';
-    // Priorizar caminhos do node_modules primeiro
+    // Caminhos padrão para tentar
     const possiblePaths = [
-        // Primeiro: tentar node_modules com caminhos absolutos (prioridade máxima)
-        `/node_modules/web-audio-recorder-ts/lib/${filename}`,
-        `${currentOrigin}/node_modules/web-audio-recorder-ts/lib/${filename}`,
-        // Caminhos relativos do node_modules
-        `./node_modules/web-audio-recorder-ts/lib/${filename}`,
-        `../node_modules/web-audio-recorder-ts/lib/${filename}`,
-        `../../node_modules/web-audio-recorder-ts/lib/${filename}`,
-        `../../../node_modules/web-audio-recorder-ts/lib/${filename}`,
-        // Com base no caminho atual
-        `${currentPath.replace(/\/[^/]*$/, '')}/node_modules/web-audio-recorder-ts/lib/${filename}`,
-        // From dist (se os arquivos foram copiados para dist/lib)
-        `/node_modules/web-audio-recorder-ts/dist/lib/${filename}`,
-        `${currentOrigin}/node_modules/web-audio-recorder-ts/dist/lib/${filename}`,
-        `./node_modules/web-audio-recorder-ts/dist/lib/${filename}`,
-        // Auto-detected path (pode apontar para node_modules)
-        getEncoderScriptUrl(filename),
-        // Para desenvolvimento/demo: try public folder (Vite serves public/ at root)
+        // 1. Caminho padrão: /encoders/ (na raiz do servidor)
+        `/encoders/${filename}`,
+        // 2. Caminho na raiz (fallback)
         `/${filename}`,
-        `${currentOrigin}/${filename}`,
-        // Direct lib paths (for development or custom setups)
-        `/lib/${filename}`,
-        `${currentOrigin}/lib/${filename}`,
-        `./lib/${filename}`,
-        `../lib/${filename}`,
-        // CDN or absolute paths (if configured)
-        filename.startsWith('http') ? filename : null
-    ].filter((path) => path !== null);
-    console.log(`[web-audio-recorder-ts] Searching for ${filename} in ${possiblePaths.length} possible paths...`);
-    // Try each path
-    for (let i = 0; i < possiblePaths.length; i++) {
-        const path = possiblePaths[i];
+        // 3. Fallback relativo simples
+        `./encoders/${filename}`
+    ];
+    console.log(`[web-audio-recorder-ts] Looking for ${filename} mainly in /encoders/...`);
+    for (const path of possiblePaths) {
         try {
+            // Resolver URL absoluta para teste
             const testUrl = path.startsWith('http')
                 ? path
                 : new URL(path, typeof window !== 'undefined' ? window.location.href : 'file://').href;
-            console.log(`[web-audio-recorder-ts] Trying path ${i + 1}/${possiblePaths.length}: ${path} -> ${testUrl}`);
-            // Usar GET para verificar se é JavaScript válido (não HTML)
             const response = await fetch(testUrl, { method: 'GET', cache: 'no-cache' });
             if (response.ok) {
-                // Verificar se o conteúdo é JavaScript (não HTML)
+                // Verificar se é JS e não HTML (404)
                 const text = await response.text();
-                const trimmedText = text.trim();
-                // Se começar com '<', é HTML (404, etc) - pular este caminho
-                if (trimmedText.startsWith('<')) {
-                    console.warn(`[web-audio-recorder-ts] ❌ Path ${path} returned HTML instead of JavaScript (likely 404), skipping...`);
-                    continue;
+                if (text.trim().startsWith('<')) {
+                    continue; // É HTML (erro)
                 }
-                // Se parece JavaScript, retornar este caminho
-                if (trimmedText.includes('function') || trimmedText.includes('var') || trimmedText.includes('const') || trimmedText.includes('let') || trimmedText.length > 100) {
-                    console.log(`[web-audio-recorder-ts] ✅ Found encoder file at: ${path}`);
-                    return path;
-                }
-                else {
-                    console.warn(`[web-audio-recorder-ts] ⚠️ Path ${path} returned content but doesn't look like JavaScript`);
-                }
-            }
-            else {
-                console.warn(`[web-audio-recorder-ts] ❌ Path ${path} returned status ${response.status} ${response.statusText}`);
+                console.log(`[web-audio-recorder-ts] ✅ Found encoder at: ${path}`);
+                return path;
             }
         }
         catch (e) {
-            console.warn(`[web-audio-recorder-ts] ❌ Error testing path ${path}:`, e);
-            // Continue to next path
             continue;
         }
     }
-    console.error(`[web-audio-recorder-ts] ❌ Could not find ${filename} in any of the ${possiblePaths.length} paths tried`);
-    console.error(`[web-audio-recorder-ts] Tried paths:`, possiblePaths);
+    console.error(`[web-audio-recorder-ts] ❌ Could not find ${filename}. Please ensure files are in 'public/encoders/' folder.`);
     return null;
 }
 
@@ -657,136 +607,155 @@ class OggVorbisEncoderWrapper {
         // Validar e limitar qualidade (-0.1 a 1.0 para Vorbis)
         const rawQuality = options.quality ?? 0.5;
         if (!Number.isFinite(rawQuality)) {
-            console.warn(`Invalid quality value: ${rawQuality}. Using default 0.5`);
             this.quality = 0.5;
         }
         else {
-            // Clamp quality to valid range
             this.quality = Math.max(-0.1, Math.min(1.0, rawQuality));
-            if (rawQuality !== this.quality) {
-                console.warn(`Quality value ${rawQuality} clamped to valid range: ${this.quality}`);
-            }
         }
         // Verificar se OggVorbisEncoder está disponível
         if (typeof OggVorbisEncoder === 'undefined') {
-            throw new Error('OggVorbisEncoder is not loaded. Make sure to load OggVorbisEncoder.min.js before using this encoder.');
+            throw new Error('OggVorbisEncoder is not loaded.');
         }
         try {
-            // Criar instância do encoder
             this.encoder = new OggVorbisEncoder(sampleRate, numChannels, this.quality);
         }
         catch (error) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            throw new Error(`Failed to initialize OGG encoder: ${errorMsg}. ` +
-                `Parameters: sampleRate=${sampleRate}, numChannels=${numChannels}, quality=${this.quality}`);
+            throw new Error(`Failed to initialize OGG encoder: ${String(error)}`);
         }
     }
     /**
      * Codifica buffers de áudio
-     *
-     * @param buffers - Array de buffers Float32Array, um por canal
      */
     encode(buffers) {
         if (!this.encoder) {
             throw new Error('Encoder is not initialized');
         }
-        if (buffers.length !== this.numChannels) {
-            throw new Error(`Expected ${this.numChannels} channels, got ${buffers.length}`);
+        // Validação básica de entrada
+        if (!buffers || buffers.length === 0) {
+            return;
         }
-        // Validar que todos os buffers têm o mesmo tamanho
-        if (buffers.length > 0) {
-            const expectedLength = buffers[0].length;
-            for (let i = 1; i < buffers.length; i++) {
-                if (buffers[i].length !== expectedLength) {
-                    throw new Error(`Channel ${i} has length ${buffers[i].length}, expected ${expectedLength}`);
-                }
-            }
-            // Validar que há dados para processar
-            if (expectedLength === 0) {
-                // Buffer vazio, não há nada para codificar
-                return;
+        // Preparar buffers para o encoder
+        // O encoder espera exatamente this.numChannels arrays
+        const finalBuffers = [];
+        // 1. Resolver mismatch de canais
+        if (buffers.length === this.numChannels) {
+            // Caso ideal: número de canais bate
+            for (let i = 0; i < this.numChannels; i++) {
+                finalBuffers.push(buffers[i]);
             }
         }
+        else if (buffers.length === 1 && this.numChannels === 2) {
+            // Mono -> Stereo (Duplicar)
+            finalBuffers.push(buffers[0]);
+            finalBuffers.push(buffers[0]);
+        }
+        else if (buffers.length >= 2 && this.numChannels === 1) {
+            // Stereo -> Mono (Pegar apenas o primeiro canal - downmixing simples)
+            finalBuffers.push(buffers[0]);
+        }
         else {
-            // Nenhum buffer fornecido
-            return;
+            // Fallback genérico: preencher com o que tem ou silêncio
+            for (let i = 0; i < this.numChannels; i++) {
+                if (i < buffers.length) {
+                    finalBuffers.push(buffers[i]);
+                }
+                else {
+                    // Duplicar o último disponível
+                    finalBuffers.push(buffers[buffers.length - 1]);
+                }
+            }
         }
-        // Criar cópias dos buffers e validar valores (NaN, Infinity)
-        const safeBuffers = buffers.map((buffer, channelIndex) => {
-            const safeBuffer = new Float32Array(buffer.length);
-            let hasInvalidValues = false;
+        // 2. Sanitizar dados (Safe Clamping)
+        // Importante: valores exatamente 1.0 ou -1.0 podem causar crash em algumas versões do Vorbis encoder
+        // Usamos um clamping levemente conservador para garantir estabilidade
+        const SAFE_MAX = 0.9999;
+        const SAFE_MIN = -0.9999;
+        const safeBuffers = finalBuffers.map(buffer => {
+            // Criar nova cópia para não alterar o original e garantir propriedade
+            const copy = new Float32Array(buffer.length);
             for (let i = 0; i < buffer.length; i++) {
-                const value = buffer[i];
-                // Verificar NaN e Infinity
-                if (!Number.isFinite(value)) {
-                    hasInvalidValues = true;
-                    // Substituir valores inválidos por 0
-                    safeBuffer[i] = 0;
+                const val = buffer[i];
+                if (!Number.isFinite(val)) {
+                    copy[i] = 0; // Remove NaN/Infinity
                 }
                 else {
-                    // Clamp valores para o range válido de áudio (-1.0 a 1.0)
-                    safeBuffer[i] = Math.max(-1, Math.min(1.0, value));
+                    // Clamp conservador
+                    if (val > SAFE_MAX)
+                        copy[i] = SAFE_MAX;
+                    else if (val < SAFE_MIN)
+                        copy[i] = SAFE_MIN;
+                    else
+                        copy[i] = val;
                 }
             }
-            if (hasInvalidValues) {
-                console.warn(`OGG Encoder: Found invalid values (NaN/Infinity) in channel ${channelIndex}. ` +
-                    `Replaced with 0. Buffer length: ${buffer.length}`);
-            }
-            return safeBuffer;
+            return copy;
         });
         try {
             this.encoder.encode(safeBuffers);
-            // Contar buffers processados para garantir que há dados antes de finalizar
             this.bufferCount++;
             this.totalSamples += safeBuffers[0].length;
         }
         catch (error) {
-            // Melhorar mensagem de erro para incluir informações de debug
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            throw new Error(`OGG encoding error: ${errorMsg}. ` +
-                `Buffers: ${buffers.length} channels, lengths: ${buffers.map(b => b.length).join(', ')}, ` +
-                `Total buffers processed: ${this.bufferCount}, Total samples: ${this.totalSamples}`);
+            throw new Error(`OGG encoding error: ${String(error)}`);
         }
     }
     /**
      * Finaliza o encoding e retorna o Blob OGG
-     *
-     * @param mimeType - Tipo MIME (padrão: 'audio/ogg')
-     * @returns Blob contendo o arquivo OGG
      */
     finish(mimeType = 'audio/ogg') {
         if (!this.encoder) {
             throw new Error('Encoder is not initialized');
         }
-        // Verificar se há dados processados
-        if (this.bufferCount === 0) {
-            console.warn('OGG Encoder: finish() called but no buffers were encoded. This may cause issues with the Emscripten encoder.');
-            // Ainda tentar finalizar, mas avisar
+        // Requisito mínimo de samples (0.5s)
+        const MIN_SAMPLES = this.sampleRate * 0.5;
+        if (this.totalSamples < MIN_SAMPLES) {
+            // Se não atingiu o mínimo, gera silêncio para completar e salvar o arquivo
+            // Isso é melhor que lançar erro ou crashar
+            const missingSamples = Math.ceil(MIN_SAMPLES - this.totalSamples);
+            if (missingSamples > 0 && missingSamples < this.sampleRate * 10) { // Limite de 10s de silêncio
+                console.warn(`OGG Encoder: Padding with ${missingSamples} samples of silence to reach minimum duration.`);
+                const silence = new Float32Array(missingSamples); // Preenchido com zeros por padrão
+                const silenceBuffers = Array(this.numChannels).fill(silence);
+                try {
+                    this.encoder.encode(silenceBuffers);
+                }
+                catch (e) {
+                    console.error("Failed to pad silence:", e);
+                }
+            }
+            else if (this.bufferCount === 0) {
+                throw new Error('No audio data recorded.');
+            }
         }
         try {
+            // Tentar finalizar
             const blob = this.encoder.finish(mimeType);
-            // Validar que o blob não está vazio
-            if (blob.size === 0) {
-                console.warn('OGG Encoder: finish() returned empty blob. This may indicate insufficient audio data was encoded.');
-            }
             return blob;
         }
         catch (error) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            throw new Error(`OGG finish() error: ${errorMsg}. ` +
-                `Buffers processed: ${this.bufferCount}, Total samples: ${this.totalSamples}, ` +
-                `Sample rate: ${this.sampleRate}, Channels: ${this.numChannels}, Quality: ${this.quality}`);
+            const msg = String(error);
+            // Se for abort(3), geralmente é erro fatal de memória ou interno do WASM
+            if (msg.includes('abort')) {
+                throw new Error(`OGG Critical Error: The encoder crashed (${msg}). ` +
+                    `This usually happens due to memory issues or invalid audio data. ` +
+                    `Stats: ${this.totalSamples} samples, ${this.bufferCount} buffers.`);
+            }
+            throw new Error(`OGG finish() error: ${msg}`);
         }
     }
     /**
      * Cancela o encoding
      */
     cancel() {
-        if (this.encoder) {
-            this.encoder.cancel();
-            this.encoder = null;
+        try {
+            if (this.encoder) {
+                this.encoder.cancel();
+            }
         }
-        // Reset contadores
+        catch (e) {
+            // Ignorar erros no cancelamento
+        }
+        this.encoder = null;
         this.bufferCount = 0;
         this.totalSamples = 0;
     }
@@ -798,28 +767,28 @@ class OggVorbisEncoderWrapper {
  * @returns Promise que resolve quando o script é carregado
  */
 async function loadOggVorbisEncoder(scriptUrl) {
-    // Se não fornecido, tentar auto-detectar
+    // Se URL não fornecida, tentar encontrar no padrão /encoders
     if (!scriptUrl) {
-        // Configurar paths dos arquivos .mem
-        configureEncoderPaths();
-        // Tentar encontrar o arquivo automaticamente
         const foundPath = await findEncoderPath('OggVorbisEncoder.min.js');
         if (!foundPath) {
-            const errorMsg = 'Could not find OggVorbisEncoder.min.js automatically.\n\n' +
-                'Please try one of the following:\n' +
-                '1. Provide the path manually: await loadOggVorbisEncoder("/path/to/OggVorbisEncoder.min.js")\n' +
-                '2. Copy files to public/: cp node_modules/web-audio-recorder-ts/lib/*.js public/\n' +
-                '3. Configure server to serve node_modules (see NUXT_USAGE.md)\n' +
-                '4. Check browser console for detailed path information';
-            console.error(errorMsg);
-            throw new Error(errorMsg);
+            throw new Error('Could not find OggVorbisEncoder.min.js in public/encoders/ folder.\n' +
+                'Please copy lib/*.js files to your public/encoders/ directory.');
         }
         scriptUrl = foundPath;
     }
+    // Extrair diretório base da URL para configurar carregamento do .mem
+    let baseUrl = '';
+    const lastSlash = scriptUrl.lastIndexOf('/');
+    if (lastSlash !== -1) {
+        baseUrl = scriptUrl.substring(0, lastSlash);
+    }
     else {
-        // Se fornecido, ainda configurar paths dos .mem
-        configureEncoderPaths();
+        // Se não tem barra, assumimos que está na raiz ou relativo simples
+        // Mas se foi retornado por findEncoderPath como 'OggVorbis...', então deve ser ''
+        baseUrl = 'encoders'; // Melhor chute para fallback
     }
+    // Configurar encoder (isso define OggVorbisEncoderConfig global)
+    configureEncoderPaths(baseUrl);
     return loadOggVorbisEncoderInternal(scriptUrl);
 }
 /**
@@ -990,15 +959,45 @@ class Mp3LameEncoderWrapper {
         if (!this.encoder) {
             throw new Error('Encoder is not initialized');
         }
+        // Converter canais se necessário ANTES de validar
+        // Isso permite que streams mono funcionem com encoders estéreo e vice-versa
+        let processedBuffers = buffers;
         if (buffers.length !== this.numChannels) {
-            throw new Error(`Expected ${this.numChannels} channels, got ${buffers.length}`);
+            // Ajustar número de canais para corresponder ao esperado pelo encoder
+            if (buffers.length === 1 && this.numChannels === 2) {
+                // Mono -> Estéreo: duplicar o canal
+                processedBuffers = [
+                    new Float32Array(buffers[0]),
+                    new Float32Array(buffers[0])
+                ];
+            }
+            else if (buffers.length === 2 && this.numChannels === 1) {
+                // Estéreo -> Mono: usar apenas o primeiro canal
+                processedBuffers = [new Float32Array(buffers[0])];
+            }
+            else if (buffers.length < this.numChannels) {
+                // Menos canais: duplicar o último canal
+                processedBuffers = [...buffers];
+                while (processedBuffers.length < this.numChannels && processedBuffers.length > 0) {
+                    processedBuffers.push(new Float32Array(processedBuffers[processedBuffers.length - 1]));
+                }
+            }
+            else if (buffers.length > this.numChannels) {
+                // Mais canais: usar apenas os primeiros
+                processedBuffers = buffers.slice(0, this.numChannels);
+            }
+        }
+        // Validação final
+        if (processedBuffers.length !== this.numChannels) {
+            throw new Error(`Failed to adjust channels: Expected ${this.numChannels} channels, ` +
+                `got ${processedBuffers.length} after conversion from ${buffers.length} channels`);
         }
         // Validar que todos os buffers têm o mesmo tamanho
-        if (buffers.length > 0) {
-            const expectedLength = buffers[0].length;
-            for (let i = 1; i < buffers.length; i++) {
-                if (buffers[i].length !== expectedLength) {
-                    throw new Error(`Channel ${i} has length ${buffers[i].length}, expected ${expectedLength}`);
+        if (processedBuffers.length > 0) {
+            const expectedLength = processedBuffers[0].length;
+            for (let i = 1; i < processedBuffers.length; i++) {
+                if (processedBuffers[i].length !== expectedLength) {
+                    throw new Error(`Channel ${i} has length ${processedBuffers[i].length}, expected ${expectedLength}`);
                 }
             }
             // Validar que há dados para processar
@@ -1012,7 +1011,7 @@ class Mp3LameEncoderWrapper {
             return;
         }
         // Criar cópias dos buffers e validar valores (NaN, Infinity)
-        const safeBuffers = buffers.map((buffer, channelIndex) => {
+        const safeBuffers = processedBuffers.map((buffer, channelIndex) => {
             const safeBuffer = new Float32Array(buffer.length);
             let hasInvalidValues = false;
             for (let i = 0; i < buffer.length; i++) {
@@ -1098,28 +1097,26 @@ class Mp3LameEncoderWrapper {
  * @returns Promise que resolve quando o script é carregado
  */
 async function loadMp3LameEncoder(scriptUrl) {
-    // Se não fornecido, tentar auto-detectar
+    // Se URL não fornecida, tentar encontrar no padrão /encoders
     if (!scriptUrl) {
-        // Configurar paths dos arquivos .mem
-        configureEncoderPaths();
-        // Tentar encontrar o arquivo automaticamente
         const foundPath = await findEncoderPath('Mp3LameEncoder.min.js');
         if (!foundPath) {
-            const errorMsg = 'Could not find Mp3LameEncoder.min.js automatically.\n\n' +
-                'Please try one of the following:\n' +
-                '1. Provide the path manually: await loadMp3LameEncoder("/path/to/Mp3LameEncoder.min.js")\n' +
-                '2. Copy files to public/: cp node_modules/web-audio-recorder-ts/lib/*.js public/\n' +
-                '3. Configure server to serve node_modules (see NUXT_USAGE.md)\n' +
-                '4. Check browser console for detailed path information';
-            console.error(errorMsg);
-            throw new Error(errorMsg);
+            throw new Error('Could not find Mp3LameEncoder.min.js in public/encoders/ folder.\n' +
+                'Please copy lib/*.js files to your public/encoders/ directory.');
         }
         scriptUrl = foundPath;
     }
+    // Extrair diretório base da URL para configurar carregamento do .mem
+    let baseUrl = '';
+    const lastSlash = scriptUrl.lastIndexOf('/');
+    if (lastSlash !== -1) {
+        baseUrl = scriptUrl.substring(0, lastSlash);
+    }
     else {
-        // Se fornecido, ainda configurar paths dos .mem
-        configureEncoderPaths();
+        baseUrl = 'encoders';
     }
+    // Configurar encoder (isso define Mp3LameEncoderConfig global)
+    configureEncoderPaths(baseUrl);
     return loadMp3LameEncoderInternal(scriptUrl);
 }
 /**