web-audio-recorder-ts 1.0.3 → 1.0.5

package/dist/encoders/Mp3LameEncoder.d.ts

@@ -12,6 +12,8 @@ export declare class Mp3LameEncoderWrapper implements AudioEncoder {
     private sampleRate;
     private numChannels;
     private bitrate;
+    private bufferCount;
+    private totalSamples;
     /**
      * Cria uma instância do encoder MP3 LAME
      *

package/dist/encoders/OggVorbisEncoder.d.ts

@@ -12,6 +12,8 @@ export declare class OggVorbisEncoderWrapper implements AudioEncoder {
     private sampleRate;
     private numChannels;
     private quality;
+    private bufferCount;
+    private totalSamples;
     /**
      * Cria uma instância do encoder OGG Vorbis
      *

package/dist/index.cjs.js

@@ -147,6 +147,9 @@ class WebAudioRecorder {
             if (!this.encoder) {
                 throw new Error('Encoder is not initialized');
             }
+            // Aguardar um pouco para garantir que todos os callbacks de áudio foram processados
+            // Isso evita condições de corrida onde finish() é chamado antes de todos os buffers serem processados
+            await new Promise(resolve => setTimeout(resolve, 50));
             const blob = this.encoder.finish(mimeType);
             const url = URL.createObjectURL(blob);
             const timecode = Date.now() - this.startTime;
@@ -549,33 +552,47 @@ function configureEncoderPaths(baseUrl) {
  * Useful when auto-detection fails
  */
 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
     const possiblePaths = [
-        // Primeiro: tentar node_modules (prioridade máxima)
+        // 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)
         `/${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 (const path of possiblePaths) {
+    for (let i = 0; i < possiblePaths.length; i++) {
+        const path = possiblePaths[i];
         try {
             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) {
@@ -584,21 +601,30 @@ async function findEncoderPath(filename) {
                 const trimmedText = text.trim();
                 // Se começar com '<', é HTML (404, etc) - pular este caminho
                 if (trimmedText.startsWith('<')) {
-                    console.warn(`Path ${path} returned HTML instead of JavaScript, skipping...`);
+                    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(`✅ Found encoder file at: ${path}`);
+                    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}`);
             }
         }
         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);
     return null;
 }
 
@@ -620,15 +646,43 @@ class OggVorbisEncoderWrapper {
      */
     constructor(sampleRate, numChannels, options = {}) {
         this.encoder = null;
+        this.bufferCount = 0;
+        this.totalSamples = 0;
+        // Validar parâmetros
+        if (!Number.isFinite(sampleRate) || sampleRate <= 0) {
+            throw new Error(`Invalid sampleRate: ${sampleRate}. Must be a positive number.`);
+        }
+        if (!Number.isInteger(numChannels) || numChannels < 1 || numChannels > 2) {
+            throw new Error(`Invalid numChannels: ${numChannels}. Must be 1 (mono) or 2 (stereo).`);
+        }
         this.sampleRate = sampleRate;
         this.numChannels = numChannels;
-        this.quality = options.quality ?? 0.5;
+        // 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.');
         }
-        // Criar instância do encoder
-        this.encoder = new OggVorbisEncoder(sampleRate, numChannels, this.quality);
+        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}`);
+        }
     }
     /**
      * Codifica buffers de áudio
@@ -642,7 +696,60 @@ class OggVorbisEncoderWrapper {
         if (buffers.length !== this.numChannels) {
             throw new Error(`Expected ${this.numChannels} channels, got ${buffers.length}`);
         }
-        this.encoder.encode(buffers);
+        // 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;
+            }
+        }
+        else {
+            // Nenhum buffer fornecido
+            return;
+        }
+        // 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;
+            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;
+                }
+                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));
+                }
+            }
+            if (hasInvalidValues) {
+                console.warn(`OGG Encoder: Found invalid values (NaN/Infinity) in channel ${channelIndex}. ` +
+                    `Replaced with 0. Buffer length: ${buffer.length}`);
+            }
+            return safeBuffer;
+        });
+        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}`);
+        }
     }
     /**
      * Finaliza o encoding e retorna o Blob OGG
@@ -654,7 +761,25 @@ class OggVorbisEncoderWrapper {
         if (!this.encoder) {
             throw new Error('Encoder is not initialized');
         }
-        return this.encoder.finish(mimeType);
+        // 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
+        }
+        try {
+            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}`);
+        }
     }
     /**
      * Cancela o encoding
@@ -664,6 +789,9 @@ class OggVorbisEncoderWrapper {
             this.encoder.cancel();
             this.encoder = null;
         }
+        // Reset contadores
+        this.bufferCount = 0;
+        this.totalSamples = 0;
     }
 }
 /**
@@ -680,8 +808,14 @@ async function loadOggVorbisEncoder(scriptUrl) {
         // Tentar encontrar o arquivo automaticamente
         const foundPath = await findEncoderPath('OggVorbisEncoder.min.js');
         if (!foundPath) {
-            throw new Error('Could not find OggVorbisEncoder.min.js. ' +
-                'Please provide the path manually or ensure the package is installed correctly.');
+            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);
         }
         scriptUrl = foundPath;
     }
@@ -812,15 +946,43 @@ class Mp3LameEncoderWrapper {
      */
     constructor(sampleRate, numChannels, options = {}) {
         this.encoder = null;
+        this.bufferCount = 0;
+        this.totalSamples = 0;
+        // Validar parâmetros
+        if (!Number.isFinite(sampleRate) || sampleRate <= 0) {
+            throw new Error(`Invalid sampleRate: ${sampleRate}. Must be a positive number.`);
+        }
+        if (!Number.isInteger(numChannels) || numChannels < 1 || numChannels > 2) {
+            throw new Error(`Invalid numChannels: ${numChannels}. Must be 1 (mono) or 2 (stereo).`);
+        }
         this.sampleRate = sampleRate;
         this.numChannels = numChannels;
-        this.bitrate = options.bitrate ?? 128;
+        // Validar e limitar bitrate (32 a 320 kbps para MP3)
+        const rawBitrate = options.bitrate ?? 128;
+        if (!Number.isFinite(rawBitrate) || !Number.isInteger(rawBitrate)) {
+            console.warn(`Invalid bitrate value: ${rawBitrate}. Using default 128`);
+            this.bitrate = 128;
+        }
+        else {
+            // Clamp bitrate to valid range
+            this.bitrate = Math.max(32, Math.min(320, rawBitrate));
+            if (rawBitrate !== this.bitrate) {
+                console.warn(`Bitrate value ${rawBitrate} clamped to valid range: ${this.bitrate}`);
+            }
+        }
         // Verificar se Mp3LameEncoder está disponível
         if (typeof Mp3LameEncoder === 'undefined') {
             throw new Error('Mp3LameEncoder is not loaded. Make sure to load Mp3LameEncoder.min.js before using this encoder.');
         }
-        // Criar instância do encoder
-        this.encoder = new Mp3LameEncoder(sampleRate, numChannels, this.bitrate);
+        try {
+            // Criar instância do encoder
+            this.encoder = new Mp3LameEncoder(sampleRate, numChannels, this.bitrate);
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to initialize MP3 encoder: ${errorMsg}. ` +
+                `Parameters: sampleRate=${sampleRate}, numChannels=${numChannels}, bitrate=${this.bitrate}`);
+        }
     }
     /**
      * Codifica buffers de áudio
@@ -834,7 +996,60 @@ class Mp3LameEncoderWrapper {
         if (buffers.length !== this.numChannels) {
             throw new Error(`Expected ${this.numChannels} channels, got ${buffers.length}`);
         }
-        this.encoder.encode(buffers);
+        // 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;
+            }
+        }
+        else {
+            // Nenhum buffer fornecido
+            return;
+        }
+        // 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;
+            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;
+                }
+                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));
+                }
+            }
+            if (hasInvalidValues) {
+                console.warn(`MP3 Encoder: Found invalid values (NaN/Infinity) in channel ${channelIndex}. ` +
+                    `Replaced with 0. Buffer length: ${buffer.length}`);
+            }
+            return safeBuffer;
+        });
+        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(`MP3 encoding error: ${errorMsg}. ` +
+                `Buffers: ${buffers.length} channels, lengths: ${buffers.map(b => b.length).join(', ')}, ` +
+                `Total buffers processed: ${this.bufferCount}, Total samples: ${this.totalSamples}`);
+        }
     }
     /**
      * Finaliza o encoding e retorna o Blob MP3
@@ -846,7 +1061,25 @@ class Mp3LameEncoderWrapper {
         if (!this.encoder) {
             throw new Error('Encoder is not initialized');
         }
-        return this.encoder.finish(mimeType);
+        // Verificar se há dados processados
+        if (this.bufferCount === 0) {
+            console.warn('MP3 Encoder: finish() called but no buffers were encoded. This may cause issues with the Emscripten encoder.');
+            // Ainda tentar finalizar, mas avisar
+        }
+        try {
+            const blob = this.encoder.finish(mimeType);
+            // Validar que o blob não está vazio
+            if (blob.size === 0) {
+                console.warn('MP3 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(`MP3 finish() error: ${errorMsg}. ` +
+                `Buffers processed: ${this.bufferCount}, Total samples: ${this.totalSamples}, ` +
+                `Sample rate: ${this.sampleRate}, Channels: ${this.numChannels}, Bitrate: ${this.bitrate}`);
+        }
     }
     /**
      * Cancela o encoding
@@ -856,6 +1089,9 @@ class Mp3LameEncoderWrapper {
             this.encoder.cancel();
             this.encoder = null;
         }
+        // Reset contadores
+        this.bufferCount = 0;
+        this.totalSamples = 0;
     }
 }
 /**
@@ -872,8 +1108,14 @@ async function loadMp3LameEncoder(scriptUrl) {
         // Tentar encontrar o arquivo automaticamente
         const foundPath = await findEncoderPath('Mp3LameEncoder.min.js');
         if (!foundPath) {
-            throw new Error('Could not find Mp3LameEncoder.min.js. ' +
-                'Please provide the path manually or ensure the package is installed correctly.');
+            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);
         }
         scriptUrl = foundPath;
     }

package/dist/index.esm.js

@@ -144,6 +144,9 @@ class WebAudioRecorder {
             if (!this.encoder) {
                 throw new Error('Encoder is not initialized');
             }
+            // Aguardar um pouco para garantir que todos os callbacks de áudio foram processados
+            // Isso evita condições de corrida onde finish() é chamado antes de todos os buffers serem processados
+            await new Promise(resolve => setTimeout(resolve, 50));
             const blob = this.encoder.finish(mimeType);
             const url = URL.createObjectURL(blob);
             const timecode = Date.now() - this.startTime;
@@ -546,33 +549,47 @@ function configureEncoderPaths(baseUrl) {
  * Useful when auto-detection fails
  */
 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
     const possiblePaths = [
-        // Primeiro: tentar node_modules (prioridade máxima)
+        // 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)
         `/${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 (const path of possiblePaths) {
+    for (let i = 0; i < possiblePaths.length; i++) {
+        const path = possiblePaths[i];
         try {
             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) {
@@ -581,21 +598,30 @@ async function findEncoderPath(filename) {
                 const trimmedText = text.trim();
                 // Se começar com '<', é HTML (404, etc) - pular este caminho
                 if (trimmedText.startsWith('<')) {
-                    console.warn(`Path ${path} returned HTML instead of JavaScript, skipping...`);
+                    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(`✅ Found encoder file at: ${path}`);
+                    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}`);
             }
         }
         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);
     return null;
 }
 
@@ -617,15 +643,43 @@ class OggVorbisEncoderWrapper {
      */
     constructor(sampleRate, numChannels, options = {}) {
         this.encoder = null;
+        this.bufferCount = 0;
+        this.totalSamples = 0;
+        // Validar parâmetros
+        if (!Number.isFinite(sampleRate) || sampleRate <= 0) {
+            throw new Error(`Invalid sampleRate: ${sampleRate}. Must be a positive number.`);
+        }
+        if (!Number.isInteger(numChannels) || numChannels < 1 || numChannels > 2) {
+            throw new Error(`Invalid numChannels: ${numChannels}. Must be 1 (mono) or 2 (stereo).`);
+        }
         this.sampleRate = sampleRate;
         this.numChannels = numChannels;
-        this.quality = options.quality ?? 0.5;
+        // 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.');
         }
-        // Criar instância do encoder
-        this.encoder = new OggVorbisEncoder(sampleRate, numChannels, this.quality);
+        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}`);
+        }
     }
     /**
      * Codifica buffers de áudio
@@ -639,7 +693,60 @@ class OggVorbisEncoderWrapper {
         if (buffers.length !== this.numChannels) {
             throw new Error(`Expected ${this.numChannels} channels, got ${buffers.length}`);
         }
-        this.encoder.encode(buffers);
+        // 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;
+            }
+        }
+        else {
+            // Nenhum buffer fornecido
+            return;
+        }
+        // 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;
+            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;
+                }
+                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));
+                }
+            }
+            if (hasInvalidValues) {
+                console.warn(`OGG Encoder: Found invalid values (NaN/Infinity) in channel ${channelIndex}. ` +
+                    `Replaced with 0. Buffer length: ${buffer.length}`);
+            }
+            return safeBuffer;
+        });
+        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}`);
+        }
     }
     /**
      * Finaliza o encoding e retorna o Blob OGG
@@ -651,7 +758,25 @@ class OggVorbisEncoderWrapper {
         if (!this.encoder) {
             throw new Error('Encoder is not initialized');
         }
-        return this.encoder.finish(mimeType);
+        // 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
+        }
+        try {
+            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}`);
+        }
     }
     /**
      * Cancela o encoding
@@ -661,6 +786,9 @@ class OggVorbisEncoderWrapper {
             this.encoder.cancel();
             this.encoder = null;
         }
+        // Reset contadores
+        this.bufferCount = 0;
+        this.totalSamples = 0;
     }
 }
 /**
@@ -677,8 +805,14 @@ async function loadOggVorbisEncoder(scriptUrl) {
         // Tentar encontrar o arquivo automaticamente
         const foundPath = await findEncoderPath('OggVorbisEncoder.min.js');
         if (!foundPath) {
-            throw new Error('Could not find OggVorbisEncoder.min.js. ' +
-                'Please provide the path manually or ensure the package is installed correctly.');
+            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);
         }
         scriptUrl = foundPath;
     }
@@ -809,15 +943,43 @@ class Mp3LameEncoderWrapper {
      */
     constructor(sampleRate, numChannels, options = {}) {
         this.encoder = null;
+        this.bufferCount = 0;
+        this.totalSamples = 0;
+        // Validar parâmetros
+        if (!Number.isFinite(sampleRate) || sampleRate <= 0) {
+            throw new Error(`Invalid sampleRate: ${sampleRate}. Must be a positive number.`);
+        }
+        if (!Number.isInteger(numChannels) || numChannels < 1 || numChannels > 2) {
+            throw new Error(`Invalid numChannels: ${numChannels}. Must be 1 (mono) or 2 (stereo).`);
+        }
         this.sampleRate = sampleRate;
         this.numChannels = numChannels;
-        this.bitrate = options.bitrate ?? 128;
+        // Validar e limitar bitrate (32 a 320 kbps para MP3)
+        const rawBitrate = options.bitrate ?? 128;
+        if (!Number.isFinite(rawBitrate) || !Number.isInteger(rawBitrate)) {
+            console.warn(`Invalid bitrate value: ${rawBitrate}. Using default 128`);
+            this.bitrate = 128;
+        }
+        else {
+            // Clamp bitrate to valid range
+            this.bitrate = Math.max(32, Math.min(320, rawBitrate));
+            if (rawBitrate !== this.bitrate) {
+                console.warn(`Bitrate value ${rawBitrate} clamped to valid range: ${this.bitrate}`);
+            }
+        }
         // Verificar se Mp3LameEncoder está disponível
         if (typeof Mp3LameEncoder === 'undefined') {
             throw new Error('Mp3LameEncoder is not loaded. Make sure to load Mp3LameEncoder.min.js before using this encoder.');
         }
-        // Criar instância do encoder
-        this.encoder = new Mp3LameEncoder(sampleRate, numChannels, this.bitrate);
+        try {
+            // Criar instância do encoder
+            this.encoder = new Mp3LameEncoder(sampleRate, numChannels, this.bitrate);
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to initialize MP3 encoder: ${errorMsg}. ` +
+                `Parameters: sampleRate=${sampleRate}, numChannels=${numChannels}, bitrate=${this.bitrate}`);
+        }
     }
     /**
      * Codifica buffers de áudio
@@ -831,7 +993,60 @@ class Mp3LameEncoderWrapper {
         if (buffers.length !== this.numChannels) {
             throw new Error(`Expected ${this.numChannels} channels, got ${buffers.length}`);
         }
-        this.encoder.encode(buffers);
+        // 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;
+            }
+        }
+        else {
+            // Nenhum buffer fornecido
+            return;
+        }
+        // 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;
+            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;
+                }
+                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));
+                }
+            }
+            if (hasInvalidValues) {
+                console.warn(`MP3 Encoder: Found invalid values (NaN/Infinity) in channel ${channelIndex}. ` +
+                    `Replaced with 0. Buffer length: ${buffer.length}`);
+            }
+            return safeBuffer;
+        });
+        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(`MP3 encoding error: ${errorMsg}. ` +
+                `Buffers: ${buffers.length} channels, lengths: ${buffers.map(b => b.length).join(', ')}, ` +
+                `Total buffers processed: ${this.bufferCount}, Total samples: ${this.totalSamples}`);
+        }
     }
     /**
      * Finaliza o encoding e retorna o Blob MP3
@@ -843,7 +1058,25 @@ class Mp3LameEncoderWrapper {
         if (!this.encoder) {
             throw new Error('Encoder is not initialized');
         }
-        return this.encoder.finish(mimeType);
+        // Verificar se há dados processados
+        if (this.bufferCount === 0) {
+            console.warn('MP3 Encoder: finish() called but no buffers were encoded. This may cause issues with the Emscripten encoder.');
+            // Ainda tentar finalizar, mas avisar
+        }
+        try {
+            const blob = this.encoder.finish(mimeType);
+            // Validar que o blob não está vazio
+            if (blob.size === 0) {
+                console.warn('MP3 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(`MP3 finish() error: ${errorMsg}. ` +
+                `Buffers processed: ${this.bufferCount}, Total samples: ${this.totalSamples}, ` +
+                `Sample rate: ${this.sampleRate}, Channels: ${this.numChannels}, Bitrate: ${this.bitrate}`);
+        }
     }
     /**
      * Cancela o encoding
@@ -853,6 +1086,9 @@ class Mp3LameEncoderWrapper {
             this.encoder.cancel();
             this.encoder = null;
         }
+        // Reset contadores
+        this.bufferCount = 0;
+        this.totalSamples = 0;
     }
 }
 /**
@@ -869,8 +1105,14 @@ async function loadMp3LameEncoder(scriptUrl) {
         // Tentar encontrar o arquivo automaticamente
         const foundPath = await findEncoderPath('Mp3LameEncoder.min.js');
         if (!foundPath) {
-            throw new Error('Could not find Mp3LameEncoder.min.js. ' +
-                'Please provide the path manually or ensure the package is installed correctly.');
+            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);
         }
         scriptUrl = foundPath;
     }

package/dist/index.umd.js

@@ -151,6 +151,9 @@
                 if (!this.encoder) {
                     throw new Error('Encoder is not initialized');
                 }
+                // Aguardar um pouco para garantir que todos os callbacks de áudio foram processados
+                // Isso evita condições de corrida onde finish() é chamado antes de todos os buffers serem processados
+                await new Promise(resolve => setTimeout(resolve, 50));
                 const blob = this.encoder.finish(mimeType);
                 const url = URL.createObjectURL(blob);
                 const timecode = Date.now() - this.startTime;
@@ -553,33 +556,47 @@
      * Useful when auto-detection fails
      */
     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
         const possiblePaths = [
-            // Primeiro: tentar node_modules (prioridade máxima)
+            // 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)
             `/${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 (const path of possiblePaths) {
+        for (let i = 0; i < possiblePaths.length; i++) {
+            const path = possiblePaths[i];
             try {
                 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) {
@@ -588,21 +605,30 @@
                     const trimmedText = text.trim();
                     // Se começar com '<', é HTML (404, etc) - pular este caminho
                     if (trimmedText.startsWith('<')) {
-                        console.warn(`Path ${path} returned HTML instead of JavaScript, skipping...`);
+                        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(`✅ Found encoder file at: ${path}`);
+                        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}`);
                 }
             }
             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);
         return null;
     }
 
@@ -624,15 +650,43 @@
          */
         constructor(sampleRate, numChannels, options = {}) {
             this.encoder = null;
+            this.bufferCount = 0;
+            this.totalSamples = 0;
+            // Validar parâmetros
+            if (!Number.isFinite(sampleRate) || sampleRate <= 0) {
+                throw new Error(`Invalid sampleRate: ${sampleRate}. Must be a positive number.`);
+            }
+            if (!Number.isInteger(numChannels) || numChannels < 1 || numChannels > 2) {
+                throw new Error(`Invalid numChannels: ${numChannels}. Must be 1 (mono) or 2 (stereo).`);
+            }
             this.sampleRate = sampleRate;
             this.numChannels = numChannels;
-            this.quality = options.quality ?? 0.5;
+            // 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.');
             }
-            // Criar instância do encoder
-            this.encoder = new OggVorbisEncoder(sampleRate, numChannels, this.quality);
+            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}`);
+            }
         }
         /**
          * Codifica buffers de áudio
@@ -646,7 +700,60 @@
             if (buffers.length !== this.numChannels) {
                 throw new Error(`Expected ${this.numChannels} channels, got ${buffers.length}`);
             }
-            this.encoder.encode(buffers);
+            // 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;
+                }
+            }
+            else {
+                // Nenhum buffer fornecido
+                return;
+            }
+            // 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;
+                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;
+                    }
+                    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));
+                    }
+                }
+                if (hasInvalidValues) {
+                    console.warn(`OGG Encoder: Found invalid values (NaN/Infinity) in channel ${channelIndex}. ` +
+                        `Replaced with 0. Buffer length: ${buffer.length}`);
+                }
+                return safeBuffer;
+            });
+            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}`);
+            }
         }
         /**
          * Finaliza o encoding e retorna o Blob OGG
@@ -658,7 +765,25 @@
             if (!this.encoder) {
                 throw new Error('Encoder is not initialized');
             }
-            return this.encoder.finish(mimeType);
+            // 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
+            }
+            try {
+                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}`);
+            }
         }
         /**
          * Cancela o encoding
@@ -668,6 +793,9 @@
                 this.encoder.cancel();
                 this.encoder = null;
             }
+            // Reset contadores
+            this.bufferCount = 0;
+            this.totalSamples = 0;
         }
     }
     /**
@@ -684,8 +812,14 @@
             // Tentar encontrar o arquivo automaticamente
             const foundPath = await findEncoderPath('OggVorbisEncoder.min.js');
             if (!foundPath) {
-                throw new Error('Could not find OggVorbisEncoder.min.js. ' +
-                    'Please provide the path manually or ensure the package is installed correctly.');
+                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);
             }
             scriptUrl = foundPath;
         }
@@ -816,15 +950,43 @@
          */
         constructor(sampleRate, numChannels, options = {}) {
             this.encoder = null;
+            this.bufferCount = 0;
+            this.totalSamples = 0;
+            // Validar parâmetros
+            if (!Number.isFinite(sampleRate) || sampleRate <= 0) {
+                throw new Error(`Invalid sampleRate: ${sampleRate}. Must be a positive number.`);
+            }
+            if (!Number.isInteger(numChannels) || numChannels < 1 || numChannels > 2) {
+                throw new Error(`Invalid numChannels: ${numChannels}. Must be 1 (mono) or 2 (stereo).`);
+            }
             this.sampleRate = sampleRate;
             this.numChannels = numChannels;
-            this.bitrate = options.bitrate ?? 128;
+            // Validar e limitar bitrate (32 a 320 kbps para MP3)
+            const rawBitrate = options.bitrate ?? 128;
+            if (!Number.isFinite(rawBitrate) || !Number.isInteger(rawBitrate)) {
+                console.warn(`Invalid bitrate value: ${rawBitrate}. Using default 128`);
+                this.bitrate = 128;
+            }
+            else {
+                // Clamp bitrate to valid range
+                this.bitrate = Math.max(32, Math.min(320, rawBitrate));
+                if (rawBitrate !== this.bitrate) {
+                    console.warn(`Bitrate value ${rawBitrate} clamped to valid range: ${this.bitrate}`);
+                }
+            }
             // Verificar se Mp3LameEncoder está disponível
             if (typeof Mp3LameEncoder === 'undefined') {
                 throw new Error('Mp3LameEncoder is not loaded. Make sure to load Mp3LameEncoder.min.js before using this encoder.');
             }
-            // Criar instância do encoder
-            this.encoder = new Mp3LameEncoder(sampleRate, numChannels, this.bitrate);
+            try {
+                // Criar instância do encoder
+                this.encoder = new Mp3LameEncoder(sampleRate, numChannels, this.bitrate);
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                throw new Error(`Failed to initialize MP3 encoder: ${errorMsg}. ` +
+                    `Parameters: sampleRate=${sampleRate}, numChannels=${numChannels}, bitrate=${this.bitrate}`);
+            }
         }
         /**
          * Codifica buffers de áudio
@@ -838,7 +1000,60 @@
             if (buffers.length !== this.numChannels) {
                 throw new Error(`Expected ${this.numChannels} channels, got ${buffers.length}`);
             }
-            this.encoder.encode(buffers);
+            // 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;
+                }
+            }
+            else {
+                // Nenhum buffer fornecido
+                return;
+            }
+            // 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;
+                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;
+                    }
+                    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));
+                    }
+                }
+                if (hasInvalidValues) {
+                    console.warn(`MP3 Encoder: Found invalid values (NaN/Infinity) in channel ${channelIndex}. ` +
+                        `Replaced with 0. Buffer length: ${buffer.length}`);
+                }
+                return safeBuffer;
+            });
+            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(`MP3 encoding error: ${errorMsg}. ` +
+                    `Buffers: ${buffers.length} channels, lengths: ${buffers.map(b => b.length).join(', ')}, ` +
+                    `Total buffers processed: ${this.bufferCount}, Total samples: ${this.totalSamples}`);
+            }
         }
         /**
          * Finaliza o encoding e retorna o Blob MP3
@@ -850,7 +1065,25 @@
             if (!this.encoder) {
                 throw new Error('Encoder is not initialized');
             }
-            return this.encoder.finish(mimeType);
+            // Verificar se há dados processados
+            if (this.bufferCount === 0) {
+                console.warn('MP3 Encoder: finish() called but no buffers were encoded. This may cause issues with the Emscripten encoder.');
+                // Ainda tentar finalizar, mas avisar
+            }
+            try {
+                const blob = this.encoder.finish(mimeType);
+                // Validar que o blob não está vazio
+                if (blob.size === 0) {
+                    console.warn('MP3 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(`MP3 finish() error: ${errorMsg}. ` +
+                    `Buffers processed: ${this.bufferCount}, Total samples: ${this.totalSamples}, ` +
+                    `Sample rate: ${this.sampleRate}, Channels: ${this.numChannels}, Bitrate: ${this.bitrate}`);
+            }
         }
         /**
          * Cancela o encoding
@@ -860,6 +1093,9 @@
                 this.encoder.cancel();
                 this.encoder = null;
             }
+            // Reset contadores
+            this.bufferCount = 0;
+            this.totalSamples = 0;
         }
     }
     /**
@@ -876,8 +1112,14 @@
             // Tentar encontrar o arquivo automaticamente
             const foundPath = await findEncoderPath('Mp3LameEncoder.min.js');
             if (!foundPath) {
-                throw new Error('Could not find Mp3LameEncoder.min.js. ' +
-                    'Please provide the path manually or ensure the package is installed correctly.');
+                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);
             }
             scriptUrl = foundPath;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "web-audio-recorder-ts",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "type": "module",
   "description": "TypeScript port of web-audio-recorder-js with full type support for WAV, OGG Vorbis, and MP3 audio recording",
   "main": "dist/index.cjs.js",