web-audio-recorder-ts 1.0.6 → 1.0.7

package/dist/index.umd.js

@@ -4,7 +4,6 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.WebAudioRecorder = {}));
 })(this, (function (exports) { 'use strict';
 
-    var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
     /**
      * Tipos e interfaces principais para WebAudioRecorder
      */
@@ -91,6 +90,27 @@
                 }
                 // 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
@@ -110,6 +130,7 @@
                             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) {
@@ -120,17 +141,49 @@
                                 // Estéreo -> Mono: usar apenas o primeiro canal
                                 buffers.splice(1);
                             }
-                            else {
-                                // Outros casos: usar apenas os canais disponíveis até o limite esperado
+                            else if (actualChannels < this.numChannels) {
+                                // Menos canais do que esperado: duplicar o último canal
                                 while (buffers.length < this.numChannels && buffers.length > 0) {
-                                    // Duplicar o último canal se necessário
                                     buffers.push(new Float32Array(buffers[buffers.length - 1]));
                                 }
-                                if (buffers.length > this.numChannels) {
-                                    buffers.splice(this.numChannels);
+                            }
+                            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 && buffers.length > 0) {
                             this.encoder.encode(buffers);
@@ -424,233 +477,107 @@
     }
 
     /**
-     * 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 ({ url: (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.umd.js', document.baseURI).href)) }) !== 'undefined' && (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.umd.js', document.baseURI).href))) {
-                try {
-                    // @ts-ignore
-                    const url = new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.umd.js', document.baseURI).href)));
-                    // 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://')) {
+        // Se baseUrl começa com http/https ou /, retorna como está
+        if (normalizedBase.startsWith('http') || normalizedBase.startsWith('/')) {
             return `${normalizedBase}${filename}`;
         }
-        // If baseUrl starts with /, it's already absolute
-        if (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;
-                    }
-                    // 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`);
+                    if (text.trim().startsWith('<')) {
+                        continue; // É HTML (erro)
                     }
-                }
-                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;
     }
 
@@ -686,136 +613,155 @@
             // 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;
         }
@@ -827,28 +773,28 @@
      * @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);
     }
     /**
@@ -1019,15 +965,45 @@
             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
@@ -1041,7 +1017,7 @@
                 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++) {
@@ -1127,28 +1103,26 @@
      * @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);
     }
     /**