carta1 1.1.2 → 1.1.3

package/bin/cli.js

@@ -156,7 +156,7 @@ class ProgressTracker {
  * Provides async iteration over WAV file frames for memory-efficient
  * processing of large audio files. Automatically handles:
  * - Multi-channel deinterleaving
- * - Bit depth conversion to Float64
+ * - Bit depth conversion to float32
  * - Frame padding for the last partial frame
  *
  * @class
@@ -225,9 +225,9 @@ class WavReader {
    * Async iterator for streaming WAV file frames
    *
    * @param {number} [frameSize=SAMPLES_PER_FRAME] - Samples per frame
-   * @yields {Float64Array|Array<Float64Array>} Audio frame data
-   *   - Mono: Float64Array of samples
-   *   - Stereo: [left, right] Float64Arrays
+   * @yields {Float32Array|Array<Float32Array>} Audio frame data
+   *   - Mono: Float32Array of samples
+   *   - Stereo: [left, right] Float32Arrays
    */
   async *[Symbol.asyncIterator](frameSize = SAMPLES_PER_FRAME) {
     const fileStream = fs.createReadStream(this.filePath)
@@ -305,23 +305,23 @@ class WavReader {
   }
 
   /**
-   * Process raw PCM buffer into float64 frame data
+   * Process raw PCM buffer into float32 frame data
    *
    * @private
    * @param {Buffer} frameBuffer - Raw PCM data
    * @param {number} frameSize - Number of samples per channel
-   * @returns {Float64Array|Array<Float64Array>} Processed frame data
+   * @returns {Float32Array|Array<Float32Array>} Processed frame data
    */
   _processFrameBuffer(frameBuffer, frameSize) {
     if (this.channels === 1) {
-      const frame = new Float64Array(frameSize)
+      const frame = new Float32Array(frameSize)
       for (let i = 0; i < frameSize; i++) {
         frame[i] = this._sampleToFloat(frameBuffer, i * (this.bitDepth / 8))
       }
       return frame
     } else {
-      const left = new Float64Array(frameSize)
-      const right = new Float64Array(frameSize)
+      const left = new Float32Array(frameSize)
+      const right = new Float32Array(frameSize)
       for (let i = 0; i < frameSize; i++) {
         const offset = i * this.channels * (this.bitDepth / 8)
         left[i] = this._sampleToFloat(frameBuffer, offset)
@@ -332,7 +332,7 @@ class WavReader {
   }
 
   /**
-   * Convert PCM sample to normalized Float64 value
+   * Convert PCM sample to normalized float32 value
    *
    * @private
    * @param {Buffer} buffer - PCM data buffer

package/codec/analysis/transient.js

@@ -10,13 +10,13 @@ import { FFT } from '../transforms/fft.js'
 
 /**
  * Perform FFT on time-domain samples and return magnitude spectrum
- * @param {Float64Array} samples - Time-domain samples
+ * @param {Float32Array} samples - Time-domain samples
  * @param {number} fftSize - FFT size (must be power of 2)
- * @returns {Float64Array} Magnitude spectrum (positive frequencies only)
+ * @returns {Float32Array} Magnitude spectrum (positive frequencies only)
  */
 export function performFFT(samples, fftSize) {
-  const real = new Float64Array(fftSize)
-  const imag = new Float64Array(fftSize)
+  const real = new Float32Array(fftSize)
+  const imag = new Float32Array(fftSize)
 
   // Copy samples with zero-padding if necessary
   const copyLen = Math.min(samples.length, fftSize)
@@ -26,7 +26,7 @@ export function performFFT(samples, fftSize) {
   FFT.fft(real, imag)
 
   // Calculate magnitude spectrum for positive frequencies
-  const magnitude = new Float64Array(fftSize / 2)
+  const magnitude = new Float32Array(fftSize / 2)
   for (let i = 0; i < fftSize / 2; i++) {
     magnitude[i] = Math.sqrt(real[i] * real[i] + imag[i] * imag[i])
   }
@@ -36,8 +36,8 @@ export function performFFT(samples, fftSize) {
 
 /**
  * Detect transients by analyzing spectral changes between frames
- * @param {Float64Array} currentCoeffs - Current frame coefficients
- * @param {Float64Array} prevCoeffs - Previous frame coefficients
+ * @param {Float32Array} currentCoeffs - Current frame coefficients
+ * @param {Float32Array} prevCoeffs - Previous frame coefficients
  * @param {number} threshold - Detection threshold
  * @returns {boolean} True if transient detected
  */
@@ -56,8 +56,8 @@ export function detectTransient(currentCoeffs, prevCoeffs, threshold) {
 
 /**
  * Calculate all spectral features for transient detection
- * @param {Float64Array} currentCoeffs - Current frame coefficients
- * @param {Float64Array} prevCoeffs - Previous frame coefficients
+ * @param {Float32Array} currentCoeffs - Current frame coefficients
+ * @param {Float32Array} prevCoeffs - Previous frame coefficients
  * @returns {Object} Computed spectral features
  */
 function calculateSpectralFeatures(currentCoeffs, prevCoeffs) {
@@ -114,7 +114,7 @@ function calculateSpectralFlux(currentCoeffs, prevCoeffs) {
 /**
  * Calculate spectral flatness (geometric mean / arithmetic mean)
  * Measures how noise-like vs tonal the spectrum is
- * @param {Float64Array} coeffs - Spectral coefficients
+ * @param {Float32Array} coeffs - Spectral coefficients
  * @returns {number} Flatness measure (0 = tonal, 1 = noise-like)
  */
 function calculateSpectralFlatness(coeffs) {
@@ -143,7 +143,7 @@ function calculateSpectralFlatness(coeffs) {
 /**
  * Calculate ratio of high-frequency to total energy
  * High values indicate bright/harsh sounds that are perceptually important
- * @param {Float64Array} coeffs - Spectral coefficients
+ * @param {Float32Array} coeffs - Spectral coefficients
  * @returns {number} High-frequency energy ratio (0-1)
  */
 function calculateHighFrequencyRatio(coeffs) {
@@ -165,8 +165,8 @@ function calculateHighFrequencyRatio(coeffs) {
 
 /**
  * Calculate energy change between frames in dB
- * @param {Float64Array} currentCoeffs - Current frame coefficients
- * @param {Float64Array} prevCoeffs - Previous frame coefficients
+ * @param {Float32Array} currentCoeffs - Current frame coefficients
+ * @param {Float32Array} prevCoeffs - Previous frame coefficients
  * @returns {number} Energy change in dB (positive values only)
  */
 function calculateEnergyChange(currentCoeffs, prevCoeffs) {

package/codec/browser/interface.js

@@ -64,9 +64,9 @@ class Carta1Worker {
   /**
    * Encode PCM audio to ATRAC1 format
    *
-   * @param {Float64Array|Array<Float64Array>} pcmData - PCM audio data
-   *   - Mono: Float64Array
-   *   - Stereo: [left, right] Float64Arrays
+   * @param {Float32Array|Array<Float32Array>} pcmData - PCM audio data
+   *   - Mono: Float32Array
+   *   - Stereo: [left, right] Float32Arrays
    * @param {Object} [options={}] - Encoder options
    * @param {number} [options.transientThresholdLow] - Low band transient threshold
    * @param {number} [options.transientThresholdMid] - Mid band transient threshold

package/codec/browser/worker.js

@@ -56,7 +56,7 @@ self.onmessage = async (e) => {
 /**
  * Encode PCM audio data to ATRAC1 format
  *
- * @param {Array<Float64Array>} pcmData - PCM audio data [mono] or [left, right]
+ * @param {Array<Float32Array>} pcmData - PCM audio data [mono] or [left, right]
  * @param {Object} options - Encoder options
  * @returns {Promise<Object>} Encoded AEA blob
  */

package/codec/coding/bitallocation.js

@@ -35,7 +35,7 @@ import {
 
 /**
  * Allocate bits to BFUs using optimized greedy Lp-RDO
- * @param {Array<Float64Array>} bfuData
+ * @param {Array<Float32Array>} bfuData
  * @param {Int32Array} bfuSizes
  * @param {number} maxBfuCount
  * @returns {{bfuCount:number, allocation:Int32Array, scaleFactorIndices:Int32Array}}
@@ -62,7 +62,7 @@ export function allocateBits(bfuData, bfuSizes, maxBfuCount) {
  * bits to the BFUs that provide the greatest distortion reduction per bit spent.
  *
  * @param {number} activeBfuCount
- * @param {Array<Float64Array>} bfuData
+ * @param {Array<Float32Array>} bfuData
  * @param {Int32Array} bfuSizes
  * @param {number} remainingBits
  * @returns {{wordLengths: Int32Array, scaleFactorIndices: Int32Array}}
@@ -150,7 +150,7 @@ function distributeBitsRDO(activeBfuCount, bfuData, bfuSizes, remainingBits) {
 /**
  * Find the optimal scale factor index for a set of coefficients.
  * Same semantics as the original.
- * @param {Float64Array} coefficients
+ * @param {Float32Array} coefficients
  * @returns {number}
  */
 export function findScaleFactor(coefficients) {

package/codec/coding/quantization.js

@@ -26,7 +26,7 @@ import {
 
 /**
  * Quantize coefficients.
- * @param {Float64Array} coefficients
+ * @param {Float32Array} coefficients
  * @param {number} scaleFactorIndex
  * @param {number} bitsPerSample
  * @returns {Int32Array} out
@@ -60,17 +60,17 @@ export function quantize(coefficients, scaleFactorIndex, bitsPerSample) {
  * @param {Int32Array} quantized
  * @param {number} scaleFactorIndex
  * @param {number} bitsPerSample
- * @returns {Float64Array}
+ * @returns {Float32Array}
  */
 export function dequantize(quantized, scaleFactorIndex, bitsPerSample) {
   if (bitsPerSample === 0 || scaleFactorIndex === 0) {
-    return new Float64Array(quantized.length)
+    return new Float32Array(quantized.length)
   }
 
   const scaleFactor = SCALE_FACTORS[scaleFactorIndex]
   const quantRange = (1 << (bitsPerSample - QUANTIZATION_SIGN_BIT_SHIFT)) - 1
 
-  const deq = new Float64Array(quantized.length)
+  const deq = new Float32Array(quantized.length)
   for (let i = 0; i < quantized.length; i++) {
     deq[i] = (quantized[i] * scaleFactor) / quantRange
   }
@@ -99,9 +99,9 @@ export function dequantize(quantized, scaleFactorIndex, bitsPerSample) {
  * - Long blocks (mode 0): Higher frequency resolution, fewer temporal segments
  * - Short blocks (mode 1): Lower frequency resolution, more temporal segments
  *
- * @param {Float64Array} coefficients
+ * @param {Float32Array} coefficients
  * @param {Array<number>} blockModes
- * @returns {{bfuData: Array<Float64Array>, bfuSizes: Array<number>, bfuCount: number}}
+ * @returns {{bfuData: Array<Float32Array>, bfuSizes: Array<number>, bfuCount: number}}
  */
 export function groupIntoBFUs(coefficients, blockModes) {
   const bfuData = []
@@ -121,7 +121,7 @@ export function groupIntoBFUs(coefficients, blockModes) {
       const size = SPECS_PER_BFU[bfuIndex]
       const startPos = startPositions[bfuIndex] - bandStart
       const endPos = startPos + size
-      const bfu = new Float64Array(size)
+      const bfu = new Float32Array(size)
 
       if (startPos >= 0 && endPos <= bandSize) {
         bfu.set(coefficients.subarray(bandStart + startPos, bandStart + endPos))

package/codec/core/buffers.js

@@ -8,74 +8,74 @@ export class BufferPool {
   constructor() {
     // Transform buffers
     this.transformBuffers = {
-      64: new Float64Array(64),
-      128: new Float64Array(128),
-      256: new Float64Array(256),
-      512: new Float64Array(512),
+      64: new Float32Array(64),
+      128: new Float32Array(128),
+      256: new Float32Array(256),
+      512: new Float32Array(512),
     }
 
     // QMF work buffers
     this.qmfWorkBuffers = {
       delay: {
-        128: new Float64Array(QMF_DELAY + 128),
-        256: new Float64Array(QMF_DELAY + 256),
-        512: new Float64Array(QMF_DELAY + 512),
+        128: new Float32Array(QMF_DELAY + 128),
+        256: new Float32Array(QMF_DELAY + 256),
+        512: new Float32Array(QMF_DELAY + 512),
       },
       highBandDelay: {
-        128: new Float64Array(QMF_HIGH_BAND_DELAY + 128),
-        256: new Float64Array(QMF_HIGH_BAND_DELAY + 256),
+        128: new Float32Array(QMF_HIGH_BAND_DELAY + 128),
+        256: new Float32Array(QMF_HIGH_BAND_DELAY + 256),
       },
     }
 
     // QMF delay lines
     this.qmfDelays = {
-      lowBand: new Float64Array(QMF_DELAY),
-      midBand: new Float64Array(QMF_DELAY),
-      highBand: new Float64Array(QMF_HIGH_BAND_DELAY),
+      lowBand: new Float32Array(QMF_DELAY),
+      midBand: new Float32Array(QMF_DELAY),
+      highBand: new Float32Array(QMF_HIGH_BAND_DELAY),
     }
 
     // Transient detector
     this.transientDetection = [
-      new Float64Array(64),
-      new Float64Array(64),
-      new Float64Array(128),
+      new Float32Array(64),
+      new Float32Array(64),
+      new Float32Array(128),
     ]
 
     // MDCT/IMDCT work buffers
     this.mdctBuffers = {
       16: {
-        real: new Float64Array(16),
-        imag: new Float64Array(16),
+        real: new Float32Array(16),
+        imag: new Float32Array(16),
       },
       64: {
-        real: new Float64Array(64),
-        imag: new Float64Array(64),
+        real: new Float32Array(64),
+        imag: new Float32Array(64),
       },
       128: {
-        real: new Float64Array(128),
-        imag: new Float64Array(128),
+        real: new Float32Array(128),
+        imag: new Float32Array(128),
       },
     }
 
-    // MDCT overlap buffers
+    // MDCT overlap buffers (encoder)
     this.mdctOverlap = [
-      new Float64Array(32),
-      new Float64Array(32),
-      new Float64Array(32),
+      new Float32Array(32),
+      new Float32Array(32),
+      new Float32Array(32),
     ]
 
-    // IMDCT overlap buffers
+    // IMDCT overlap buffers (decoder)
     this.imdctOverlap = [
-      new Float64Array(256),
-      new Float64Array(256),
-      new Float64Array(512),
+      new Float32Array(256),
+      new Float32Array(256),
+      new Float32Array(512),
     ]
 
     // Spectrum reversal buffers
     this.reversalBuffers = {
-      32: new Float64Array(32),
-      128: new Float64Array(128),
-      256: new Float64Array(256),
+      32: new Float32Array(32),
+      128: new Float32Array(128),
+      256: new Float32Array(256),
     }
   }
 }

package/codec/core/constants.js

@@ -6,7 +6,6 @@
 export const SAMPLE_RATE = 44100
 export const SAMPLES_PER_FRAME = 512
 export const FRAME_RATE = SAMPLE_RATE / SAMPLES_PER_FRAME
-export const CODEC_DELAY = 266
 
 // AEA file format
 export const AEA_MAGIC = new Uint8Array([0x00, 0x08, 0x00, 0x00])
@@ -37,16 +36,6 @@ export const BFU_AMOUNTS_COUNT = 8
 export const BFU_AMOUNTS = new Int32Array([20, 28, 32, 36, 40, 44, 48, 52])
 export const BFU_BAND_BOUNDARIES = new Int32Array([20, 36, 52])
 
-// BFU center frequencies (Hz)
-export const BFU_FREQUENCIES = new Float64Array([
-  172.3, 516.8, 861.3, 1205.9, 1464.3, 1636.5, 1808.8, 1981.1, 2239.5, 2584.0,
-  2928.5, 3273.0, 3574.5, 3832.9, 4091.3, 4349.7, 4608.1, 4866.5, 5124.9,
-  5383.3, 5641.7, 5900.1, 6158.5, 6416.9, 6696.8, 6998.3, 7299.8, 7601.2,
-  7945.8, 8333.3, 8720.9, 9108.5, 9517.7, 9948.3, 10379.0, 10809.7, 11283.4,
-  11800.2, 12317.0, 12833.8, 13350.6, 13867.4, 14384.2, 14901.0, 15590.0,
-  16451.4, 17312.7, 18174.0, 19035.4, 19896.7, 20758.0, 21619.3,
-])
-
 // BFU start positions
 export const BFU_START_LONG = new Int32Array([
   0, 8, 16, 24, 32, 36, 40, 44, 48, 56, 64, 72, 80, 86, 92, 98, 104, 110, 116,
@@ -82,7 +71,7 @@ export const QMF_DELAY = 46
 export const QMF_HIGH_BAND_DELAY = 39
 
 // QMF prototype filter coefficients
-export const QMF_COEFFS = new Float64Array([
+export const QMF_COEFFS = new Float32Array([
   -0.00001461907, -0.00009205479, -0.000056157569, 0.00030117269, 0.0002422519,
   -0.00085293897, -0.0005205574, 0.0020340169, 0.00078333891, -0.0042153862,
   -0.00075614988, 0.0078402944, -0.000061169922, -0.01344162, 0.0024626821,
@@ -92,7 +81,7 @@ export const QMF_COEFFS = new Float64Array([
 
 // QMF window function
 export const QMF_WINDOW = (() => {
-  const window = new Float64Array(QMF_TAPS)
+  const window = new Float32Array(QMF_TAPS)
   for (let i = 0; i < 24; i++) {
     window[i] = QMF_COEFFS[i] * 2.0
     window[47 - i] = QMF_COEFFS[i] * 2.0
@@ -102,7 +91,7 @@ export const QMF_WINDOW = (() => {
 
 // QMF even/odd taps for optimization
 export const QMF_EVEN = (() => {
-  const even = new Float64Array(24)
+  const even = new Float32Array(24)
   for (let i = 0; i < 24; i++) {
     even[i] = QMF_WINDOW[i * 2]
   }
@@ -110,7 +99,7 @@ export const QMF_EVEN = (() => {
 })()
 
 export const QMF_ODD = (() => {
-  const odd = new Float64Array(24)
+  const odd = new Float32Array(24)
   for (let i = 0; i < 24; i++) {
     odd[i] = QMF_WINDOW[i * 2 + 1]
   }

package/codec/io/processor.js

@@ -30,12 +30,6 @@ import {
   WAV_DATA_OFFSET,
 } from '../core/constants.js'
 import { serializeFrame, deserializeFrame, AeaFile } from './serialization.js'
-import {
-  withFlushSamples,
-  withDelayCompensation,
-  withStereoFlushSamples,
-  withStereoDelayCompensation,
-} from '../utils.js'
 
 /**
  * Audio processing utility class providing high-level encoding and decoding operations
@@ -43,7 +37,7 @@ import {
 export class AudioProcessor {
   /**
    * Encodes a stream of audio frames to ATRAC1 format
-   * @param {AsyncIterable<Float64Array>|AsyncIterable<[Float64Array, Float64Array]>} audioFrames - Audio frame stream
+   * @param {AsyncIterable<Float32Array>|AsyncIterable<[Float32Array, Float32Array]>} audioFrames - Audio frame stream
    * @param {Object} [options={}] - Encoding options
    * @param {number} [options.channelCount=1] - Number of audio channels (1 or 2)
    * @param {Function} [options.onProgress] - Progress callback function
@@ -73,7 +67,7 @@ export class AudioProcessor {
 
   /**
    * Internal method for encoding mono audio streams
-   * @param {AsyncIterable<Float64Array>} audioFrames - Mono audio frame stream
+   * @param {AsyncIterable<Float32Array>} audioFrames - Mono audio frame stream
    * @param {Function} onProgress - Progress callback function
    * @param {EncoderOptions} encoderOptions - Encoder configuration
    * @returns {AsyncGenerator<Object>} Stream of encoded frame data
@@ -83,7 +77,7 @@ export class AudioProcessor {
     const options = encoderOptions || new EncoderOptions()
     const encoder = encode(options)
     let frameIndex = 0
-    for await (const frame of withFlushSamples(audioFrames)) {
+    for await (const frame of audioFrames) {
       const result = encoder(frame)
       yield result
 
@@ -95,7 +89,7 @@ export class AudioProcessor {
 
   /**
    * Internal method for encoding stereo audio streams
-   * @param {AsyncIterable<[Float64Array, Float64Array]>} audioFrames - Stereo audio frame stream
+   * @param {AsyncIterable<[Float32Array, Float32Array]>} audioFrames - Stereo audio frame stream
    * @param {Function} onProgress - Progress callback function
    * @param {EncoderOptions} encoderOptions - Encoder configuration
    * @returns {AsyncGenerator<Object>} Stream of encoded frame data (left then right)
@@ -107,9 +101,7 @@ export class AudioProcessor {
     const rightEncoder = encode(options)
     let frameIndex = 0
 
-    for await (const [leftFrame, rightFrame] of withStereoFlushSamples(
-      audioFrames
-    )) {
+    for await (const [leftFrame, rightFrame] of audioFrames) {
       const leftResult = leftEncoder(leftFrame)
       const rightResult = rightEncoder(rightFrame)
 
@@ -128,7 +120,7 @@ export class AudioProcessor {
    * @param {Object} [options={}] - Decoding options
    * @param {number} [options.channelCount=1] - Number of audio channels (1 or 2)
    * @param {Function} [options.onProgress] - Progress callback function
-   * @returns {AsyncGenerator<Float64Array>|AsyncGenerator<[Float64Array, Float64Array]>} Stream of decoded PCM frames
+   * @returns {AsyncGenerator<Float32Array>|AsyncGenerator<[Float32Array, Float32Array]>} Stream of decoded PCM frames
    * @throws {Error} If unsupported channel count is provided
    */
   static async *decodeStream(encodedFrames, options = {}) {
@@ -147,7 +139,7 @@ export class AudioProcessor {
    * Internal method for decoding mono audio streams
    * @param {AsyncIterable<Object>} encodedFrames - Mono encoded frame stream
    * @param {Function} onProgress - Progress callback function
-   * @returns {AsyncGenerator<Float64Array>} Stream of decoded mono PCM frames
+   * @returns {AsyncGenerator<Float32Array>} Stream of decoded mono PCM frames
    * @private
    */
   static async *_decodeMonoStream(encodedFrames, onProgress) {
@@ -167,14 +159,14 @@ export class AudioProcessor {
     }
 
     // Always apply delay compensation
-    yield* withDelayCompensation(rawPcmFrames())
+    yield* rawPcmFrames()
   }
 
   /**
    * Internal method for decoding stereo audio streams
    * @param {AsyncIterable<Object>} encodedFrames - Stereo encoded frame stream (interleaved left/right)
    * @param {Function} onProgress - Progress callback function
-   * @returns {AsyncGenerator<[Float64Array, Float64Array]>} Stream of decoded stereo PCM frame pairs
+   * @returns {AsyncGenerator<[Float32Array, Float32Array]>} Stream of decoded stereo PCM frame pairs
    * @private
    */
   static async *_decodeStereoStream(encodedFrames, onProgress) {
@@ -220,14 +212,14 @@ export class AudioProcessor {
     }
 
     // Always apply stereo delay compensation
-    yield* withStereoDelayCompensation(rawPcmFrames())
+    yield* rawPcmFrames()
   }
 
   /**
    * Converts channel buffer arrays to frame-based stream format
-   * @param {Float64Array[]} buffers - Array of channel buffers (1 for mono, 2 for stereo)
+   * @param {Float32Array[]} buffers - Array of channel buffers (1 for mono, 2 for stereo)
    * @param {number} [frameSize=SAMPLES_PER_FRAME] - Frame size in samples
-   * @returns {Generator<Float64Array>|Generator<[Float64Array, Float64Array]>} Stream of audio frames
+   * @returns {Generator<Float32Array>|Generator<[Float32Array, Float32Array]>} Stream of audio frames
    * @throws {Error} If unsupported channel count is provided
    */
   static *frameBufferToFrames(buffers, frameSize = SAMPLES_PER_FRAME) {
@@ -236,7 +228,7 @@ export class AudioProcessor {
     if (channelCount === 1) {
       const [left] = buffers
       for (let i = 0; i < left.length; i += frameSize) {
-        const frame = new Float64Array(frameSize)
+        const frame = new Float32Array(frameSize)
         const end = Math.min(i + frameSize, left.length)
         for (let j = 0; j < end - i; j++) {
           frame[j] = left[i + j]
@@ -248,8 +240,8 @@ export class AudioProcessor {
       const maxLength = Math.max(left.length, right.length)
 
       for (let i = 0; i < maxLength; i += frameSize) {
-        const leftFrame = new Float64Array(frameSize)
-        const rightFrame = new Float64Array(frameSize)
+        const leftFrame = new Float32Array(frameSize)
+        const rightFrame = new Float32Array(frameSize)
 
         const end = Math.min(i + frameSize, maxLength)
 
@@ -327,7 +319,7 @@ export class AudioProcessor {
 
   /**
    * Creates a WAV file blob from PCM audio frames
-   * @param {Float64Array[]|Float64Array|[Float64Array, Float64Array][]} pcmFrames - PCM audio frames
+   * @param {Float32Array[]|Float32Array|[Float32Array, Float32Array][]} pcmFrames - PCM audio frames
    * @param {number} [channelCount=1] - Number of audio channels
    * @param {number} [sampleRate=SAMPLE_RATE] - Audio sample rate
    * @returns {Blob} WAV file blob
@@ -347,7 +339,7 @@ export class AudioProcessor {
 
   /**
    * Creates a mono WAV file blob from PCM frames
-   * @param {Float64Array[]} frames - Array of mono PCM frames
+   * @param {Float32Array[]} frames - Array of mono PCM frames
    * @param {number} sampleRate - Audio sample rate
    * @returns {Blob} Mono WAV file blob
    * @private
@@ -383,7 +375,7 @@ export class AudioProcessor {
 
   /**
    * Creates a stereo WAV file blob from PCM frame pairs
-   * @param {[Float64Array, Float64Array][]} framePairs - Array of stereo PCM frame pairs
+   * @param {[Float32Array, Float32Array][]} framePairs - Array of stereo PCM frame pairs
    * @param {number} sampleRate - Audio sample rate
    * @returns {Blob} Stereo WAV file blob
    * @private
@@ -524,9 +516,9 @@ export class AudioProcessor {
 
   /**
    * Assembles PCM frames into a continuous buffer
-   * @param {Float64Array[]|[Float64Array, Float64Array][]} pcmFrames - Array of PCM frames
+   * @param {Float32Array[]|[Float32Array, Float32Array][]} pcmFrames - Array of PCM frames
    * @param {number} channelCount - Number of audio channels
-   * @returns {Float64Array} Continuous PCM buffer (interleaved for stereo)
+   * @returns {Float32Array} Continuous PCM buffer (interleaved for stereo)
    * @throws {Error} If unsupported channel count is provided
    */
   static assemblePcmFrames(pcmFrames, channelCount) {
@@ -535,7 +527,7 @@ export class AudioProcessor {
         (sum, frame) => sum + frame.length,
         0
       )
-      const pcm = new Float64Array(totalSamples)
+      const pcm = new Float32Array(totalSamples)
       let offset = 0
       for (const frame of pcmFrames) {
         pcm.set(frame, offset)
@@ -547,7 +539,7 @@ export class AudioProcessor {
         (sum, [left, right]) => sum + Math.max(left.length, right.length),
         0
       )
-      const pcm = new Float64Array(totalSamples * 2)
+      const pcm = new Float32Array(totalSamples * 2)
 
       let pcmOffset = 0
       for (const [leftFrame, rightFrame] of pcmFrames) {