carta1 1.4.0 → 1.6.0

package/README.md

@@ -34,6 +34,11 @@ npm ci
 npm run check
 ```
 
+[Native CLI archives](docs/native.md) for Linux and macOS (x64 and ARM64) are
+built with Porffor and attached to GitHub Releases after exact WAV/AEA parity
+checks against the Node CLI. They run without Node.js. See the native guide
+for local builds, supported input formats, and verification.
+
 ## CLI
 
 Run the installed executable directly, or use `npx carta1` from a project that
@@ -184,8 +189,8 @@ npm test            # Run the test suite once
 npm run test:watch  # Re-run tests while editing
 npm run lint        # Check JavaScript and formatting
 npm run format      # Apply repository formatting
-npm run build       # Build the three browser bundles
-npm run check       # Run lint, tests, and the production build
+npm run build       # Build browser bundles and the WME plugin
+npm run check       # Run lint, tests, builds, and packaged WME checks
 ```
 
 Run `npm run check` before submitting a change. Pull requests and pushes run
@@ -201,3 +206,53 @@ implementation used to understand the ATRAC1 format and codec behavior.
 ## License
 
 ISC
+
+## Experimental Web MiniDisc encoder plugin
+
+`npm run build` also emits `dist/carta1.wme`, alongside the three existing
+browser bundles. GitHub Releases attach the WME, all three JavaScript bundles,
+and their source maps. The npm package includes the same build outputs. Release
+CDN links are pinned to that release's version.
+
+**Carta1 (ATRAC1, experimental)** is an ATRAC1 codec for standard MD SP, not
+ATRAC3 LP2/LP4 or ATRAC3plus Hi-MD. Current Web MiniDisc API v1 does not support
+software ATRAC1 output: its SP modes request PCM for the recorder to encode in
+hardware. Installing this plugin does not enable Carta1 recording in the
+unmodified app. All current API v1 codecs (PCM, MP3, AT3, A3+) are explicitly
+reported as unsupported so there is no silent hardware-encoding fallback.
+
+### Proposed host extension for testing
+
+The archive uses the standard API v1 SAR container and default encoder class,
+with the usual `init`, `deinit`, `getSupportFor`, `transcode`, and progress hooks.
+It adds two **proposed, nonstandard** export codec names, using the host's
+existing recording-mode names:
+
+| `exportParams.format`            | PCM channels | Output           |
+| -------------------------------- | ------------ | ---------------- |
+| `{ codec: 'SPS', bitrate: 292 }` | 2            | ATRAC1 stereo SP |
+| `{ codec: 'SPM', bitrate: 146 }` | 1            | ATRAC1 mono SP   |
+
+Bitrates are nominal kbps; ATRAC1 uses 212-byte sound units per channel per
+512 samples at 44.1 kHz. The host's built-in FFmpeg decodes/resamples sources
+and optionally applies ReplayGain; the existing Carta1 worker encodes them.
+`transcode` returns raw sound units **without the 2048-byte AEA header**.
+Stereo sound units alternate left/right. Canonical priming and drain units
+are retained; gapless is not advertised and AEA timeline metadata is omitted.
+
+A host implementing this proposal must extend its export-codec interface,
+preserve SPS/SPM through capability checks and transcoding instead of mapping
+them to PCM, and route the result to a compatible pre-encoded ATRAC1 transfer
+path (such as a supported device's homebrew SP uploader). It must handle channel
+mode, transfer framing/padding, and device capabilities there. Ordinary SP PCM
+upload must never receive these compressed bytes. Neither the proposed names
+nor device transfer compatibility are part of the current WMD API contract;
+the WMD team can revise them when implementing support. No host changes are
+included here.
+
+`npm run test:wme` exercises the built archive and its bundled worker for both
+proposed formats, comparing the returned raw bytes with `encodeAeaPcm` across
+independent tracks. Lifecycle and failure tests run in the normal test suite.
+
+The repository-only WME packager lives in `build/wme.js`. Build tooling is
+excluded from the npm package; the generated `dist/` assets are included.

package/bin/cli.js

@@ -13,16 +13,18 @@
  */
 
 import { program } from 'commander'
+import { validateModes } from './options.js'
+import { inspectAea } from '../codec/boundary/inspect.js'
 import fs from 'fs'
 import path from 'path'
 import { performance } from 'perf_hooks'
 import cliProgress from 'cli-progress'
 import wav from 'wav'
 
+import { pcmBytesToChannels } from '../codec/boundary/pcm.js'
 import { AudioProcessor } from '../codec/boundary/processor.js'
 import { AeaReader } from '../codec/boundary/reader.js'
-import { AeaFile, validateAeaTitle } from '../codec/boundary/container.js'
-import { deserializeFrame } from '../codec/syntax/frame.js'
+import { validateAeaTitle } from '../codec/boundary/container.js'
 import { EncoderOptions } from '../codec/core/options.js'
 import {
   SAMPLE_RATE,
@@ -67,47 +69,6 @@ function validateTitle(title) {
  * @returns {Array<number>} [returns.modes] - Parsed modes if valid
  * @returns {string} [returns.error] - Error message if invalid
  */
-function validateModes(modes) {
-  if (!modes) {
-    return { valid: true }
-  }
-
-  const parts = modes.split(',')
-  if (parts.length !== 3) {
-    return {
-      valid: false,
-      error: `Modes must have exactly 3 values separated by commas, got ${parts.length}`,
-    }
-  }
-
-  const parsedModes = []
-  const validValues = [
-    [0, 2], // Position 1: 0 or 2
-    [0, 2], // Position 2: 0 or 2
-    [0, 3], // Position 3: 0 or 3
-  ]
-
-  for (let i = 0; i < 3; i++) {
-    const mode = parseInt(parts[i], 10)
-    if (isNaN(mode)) {
-      return {
-        valid: false,
-        error: `Mode at position ${i + 1} is not a number: "${parts[i]}"`,
-      }
-    }
-
-    if (!validValues[i].includes(mode)) {
-      return {
-        valid: false,
-        error: `Mode at position ${i + 1} must be ${validValues[i].join(' or ')}, got ${mode}`,
-      }
-    }
-
-    parsedModes.push(mode)
-  }
-
-  return { valid: true, modes: parsedModes }
-}
 
 /**
  * Progress tracking utility for encoding/decoding operations
@@ -341,42 +302,13 @@ class WavReader {
    * @returns {Float32Array|Array<Float32Array>} Processed frame data
    */
   _processFrameBuffer(frameBuffer, frameSize) {
-    if (this.channels === 1) {
-      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 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)
-        right[i] = this._sampleToFloat(frameBuffer, offset + this.bitDepth / 8)
-      }
-      return [left, right]
-    }
-  }
-
-  /**
-   * Convert PCM sample to normalized float32 value
-   *
-   * @private
-   * @param {Buffer} buffer - PCM data buffer
-   * @param {number} offset - Byte offset to sample
-   * @returns {number} Normalized float value [-1.0, 1.0]
-   */
-  _sampleToFloat(buffer, offset) {
-    if (this.bitDepth === 16) return buffer.readInt16LE(offset) / 32768.0
-    if (this.bitDepth === 24) {
-      let s =
-        buffer[offset] | (buffer[offset + 1] << 8) | (buffer[offset + 2] << 16)
-      if (s > 0x7fffff) s -= 0x1000000
-      return s / 8388608.0
-    }
-    if (this.bitDepth === 32) return buffer.readInt32LE(offset) / 2147483648.0
-    return 0
+    const channels = pcmBytesToChannels(
+      frameBuffer,
+      this.bitDepth,
+      this.channels,
+      frameSize
+    )
+    return this.channels === 1 ? channels[0] : channels
   }
 }
 
@@ -544,115 +476,20 @@ async function decodeFile(inputFile, outputFile, options) {
  * @throws {Error} If input file is invalid or cannot be read
  */
 async function dumpFile(inputFile, outputFile, options) {
-  const stats = fs.statSync(inputFile)
-
-  if (!options.quiet) {
-    console.log(`${inputFile} (AEA) → ${outputFile} (JSON)`)
-  }
-
-  const handle = await fs.promises.open(inputFile, 'r')
-  const headerBuffer = Buffer.alloc(AEA_HEADER_SIZE)
-  await handle.read(headerBuffer, 0, AEA_HEADER_SIZE, 0)
-
-  let metadata
-  try {
-    metadata = AeaFile.parseHeader(headerBuffer)
-  } catch (err) {
-    throw new Error(`Invalid AEA header: ${err.message}`)
-  }
-
+  const bytes = await fs.promises.readFile(inputFile)
+  if (!options.quiet) console.log(`${inputFile} (AEA) → ${outputFile} (JSON)`)
   const frameCount = Math.floor(
-    (stats.size - AEA_HEADER_SIZE) / SOUND_UNIT_SIZE
+    (bytes.length - AEA_HEADER_SIZE) / SOUND_UNIT_SIZE
   )
-
-  const dump = {
-    file: {
-      path: inputFile,
-      size: stats.size,
-      headerSize: AEA_HEADER_SIZE,
-      dataSize: stats.size - AEA_HEADER_SIZE,
-      expectedDataSize: frameCount * SOUND_UNIT_SIZE,
-      sizeDifference:
-        stats.size - AEA_HEADER_SIZE - frameCount * SOUND_UNIT_SIZE,
-    },
-    header: {
-      magic: Array.from(headerBuffer.slice(0, 4))
-        .map((b) => b.toString(16).padStart(2, '0'))
-        .join(' '),
-      title: metadata.title,
-      frameCount: metadata.frameCount,
-      channelCount: metadata.channelCount,
-      framesPerChannel: metadata.frameCount / metadata.channelCount,
-      duration: ((metadata.frameCount / metadata.channelCount) * 512) / 44100,
-    },
-    frames: [],
-  }
-
   const progress = new ProgressTracker(frameCount, 'Analyzing', options.quiet)
-
   try {
-    let offset = AEA_HEADER_SIZE
-    for (let i = 0; i < frameCount; i++) {
-      const frameBuffer = Buffer.alloc(SOUND_UNIT_SIZE)
-      await handle.read(frameBuffer, 0, SOUND_UNIT_SIZE, offset)
-
-      try {
-        const frame = deserializeFrame(frameBuffer)
-        const frameInfo = {
-          index: i,
-          offset: offset,
-          offsetHex: '0x' + offset.toString(16),
-          nBfu: frame.nBfu,
-          blockModes: frame.blockModes,
-          scaleFactorIndices: Array.from(frame.scaleFactorIndices),
-          wordLengthIndices: Array.from(frame.wordLengthIndices),
-          hasNonZeroScaleFactors: frame.scaleFactorIndices.some((sf) => sf > 0),
-          hasNonZeroWordLengths: frame.wordLengthIndices.some((wl) => wl > 0),
-          hasCoefficients: frame.quantizedCoefficients.some(
-            (coeffs) => coeffs && coeffs.some((c) => c !== 0)
-          ),
-        }
-
-        // Include full coefficient data for first few frames only
-        if (i < 3 || i === frameCount - 1) {
-          frameInfo.quantizedCoefficients = frame.quantizedCoefficients.map(
-            (coeffs) => (coeffs ? Array.from(coeffs) : null)
-          )
-        }
-
-        dump.frames.push(frameInfo)
-      } catch (err) {
-        dump.frames.push({
-          index: i,
-          offset: offset,
-          offsetHex: '0x' + offset.toString(16),
-          error: err.message,
-        })
-      }
-
+    const dump = inspectAea(bytes, inputFile, () =>
       progress.update(SAMPLE_RATE)
-      offset += SOUND_UNIT_SIZE
-    }
+    )
+    await fs.promises.writeFile(outputFile, JSON.stringify(dump, null, 2))
   } finally {
     progress.stop()
-    await handle.close()
   }
-
-  // Add summary statistics
-  dump.summary = {
-    totalFrames: frameCount,
-    validFrames: dump.frames.filter((f) => !f.error).length,
-    errorFrames: dump.frames.filter((f) => f.error).length,
-    silentFrames: dump.frames.filter(
-      (f) => !f.error && !f.hasNonZeroScaleFactors && !f.hasNonZeroWordLengths
-    ).length,
-    activeFrames: dump.frames.filter(
-      (f) => !f.error && (f.hasNonZeroScaleFactors || f.hasNonZeroWordLengths)
-    ).length,
-  }
-
-  const jsonOutput = JSON.stringify(dump, null, 2)
-  await fs.promises.writeFile(outputFile, jsonOutput)
 }
 
 /**

package/bin/options.js

@@ -0,0 +1,41 @@
+export function validateModes(modes) {
+  if (!modes) {
+    return { valid: true }
+  }
+
+  const parts = modes.split(',')
+  if (parts.length !== 3) {
+    return {
+      valid: false,
+      error: `Modes must have exactly 3 values separated by commas, got ${parts.length}`,
+    }
+  }
+
+  const parsedModes = []
+  const validValues = [
+    [0, 2], // Position 1: 0 or 2
+    [0, 2], // Position 2: 0 or 2
+    [0, 3], // Position 3: 0 or 3
+  ]
+
+  for (let i = 0; i < 3; i++) {
+    const mode = parseInt(parts[i], 10)
+    if (isNaN(mode)) {
+      return {
+        valid: false,
+        error: `Mode at position ${i + 1} is not a number: "${parts[i]}"`,
+      }
+    }
+
+    if (!validValues[i].includes(mode)) {
+      return {
+        valid: false,
+        error: `Mode at position ${i + 1} must be ${validValues[i].join(' or ')}, got ${mode}`,
+      }
+    }
+
+    parsedModes.push(mode)
+  }
+
+  return { valid: true, modes: parsedModes }
+}

package/codec/boundary/inspect.js

@@ -0,0 +1,96 @@
+/** Shared JSON inspection for the Node and native hosts. */
+import { AeaFile } from './container.js'
+import { deserializeFrame } from '../syntax/frame.js'
+import { AEA_HEADER_SIZE, SOUND_UNIT_SIZE } from '../core/constants.js'
+
+export function inspectAea(bytes, inputFile, onFrame = () => {}) {
+  const stats = { size: bytes.length }
+  const headerBuffer = bytes.subarray(0, AEA_HEADER_SIZE)
+  let metadata
+  try {
+    metadata = AeaFile.parseHeader(headerBuffer)
+  } catch (err) {
+    throw new Error(`Invalid AEA header: ${err.message}`)
+  }
+  const frameCount = Math.floor(
+    (bytes.length - AEA_HEADER_SIZE) / SOUND_UNIT_SIZE
+  )
+  const dump = {
+    file: {
+      path: inputFile,
+      size: stats.size,
+      headerSize: AEA_HEADER_SIZE,
+      dataSize: stats.size - AEA_HEADER_SIZE,
+      expectedDataSize: frameCount * SOUND_UNIT_SIZE,
+      sizeDifference:
+        stats.size - AEA_HEADER_SIZE - frameCount * SOUND_UNIT_SIZE,
+    },
+    header: {
+      magic: Array.from(headerBuffer.slice(0, 4))
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join(' '),
+      title: metadata.title,
+      frameCount: metadata.frameCount,
+      channelCount: metadata.channelCount,
+      framesPerChannel: metadata.frameCount / metadata.channelCount,
+      duration: ((metadata.frameCount / metadata.channelCount) * 512) / 44100,
+    },
+    frames: [],
+  }
+
+  let offset = AEA_HEADER_SIZE
+  for (let i = 0; i < frameCount; i++) {
+    const frameBuffer = bytes.subarray(offset, offset + SOUND_UNIT_SIZE)
+
+    try {
+      const frame = deserializeFrame(frameBuffer)
+      const frameInfo = {
+        index: i,
+        offset: offset,
+        offsetHex: '0x' + offset.toString(16),
+        nBfu: frame.nBfu,
+        blockModes: frame.blockModes,
+        scaleFactorIndices: Array.from(frame.scaleFactorIndices),
+        wordLengthIndices: Array.from(frame.wordLengthIndices),
+        hasNonZeroScaleFactors: frame.scaleFactorIndices.some((sf) => sf > 0),
+        hasNonZeroWordLengths: frame.wordLengthIndices.some((wl) => wl > 0),
+        hasCoefficients: frame.quantizedCoefficients.some(
+          (coeffs) => coeffs && coeffs.some((c) => c !== 0)
+        ),
+      }
+
+      // Include full coefficient data for first few frames only
+      if (i < 3 || i === frameCount - 1) {
+        frameInfo.quantizedCoefficients = frame.quantizedCoefficients.map(
+          (coeffs) => (coeffs ? Array.from(coeffs) : null)
+        )
+      }
+
+      dump.frames.push(frameInfo)
+    } catch (err) {
+      dump.frames.push({
+        index: i,
+        offset: offset,
+        offsetHex: '0x' + offset.toString(16),
+        error: err.message,
+      })
+    }
+
+    onFrame()
+    offset += SOUND_UNIT_SIZE
+  }
+  // Add summary statistics
+  dump.summary = {
+    totalFrames: frameCount,
+    validFrames: dump.frames.filter((f) => !f.error).length,
+    errorFrames: dump.frames.filter((f) => f.error).length,
+    silentFrames: dump.frames.filter(
+      (f) => !f.error && !f.hasNonZeroScaleFactors && !f.hasNonZeroWordLengths
+    ).length,
+    activeFrames: dump.frames.filter(
+      (f) => !f.error && (f.hasNonZeroScaleFactors || f.hasNonZeroWordLengths)
+    ).length,
+  }
+
+  return dump
+}

package/codec/boundary/pcm.js

@@ -26,6 +26,92 @@ function writeFourCc(output, offset, value) {
   }
 }
 
+/** Convert interleaved signed little-endian PCM into normalized channels. */
+export function pcmBytesToChannels(bytes, bitDepth, channelCount, sampleCount) {
+  if (![16, 24, 32].includes(bitDepth)) {
+    throw new RangeError(`Unsupported PCM bit depth: ${bitDepth}`)
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
+  const channels = Array.from(
+    { length: channelCount },
+    () => new Float32Array(sampleCount)
+  )
+  let offset = 0
+  for (let sample = 0; sample < sampleCount; sample++) {
+    for (const channel of channels) {
+      let value
+      if (bitDepth === 16) value = view.getInt16(offset, true) / 32768
+      else if (bitDepth === 32) value = view.getInt32(offset, true) / 2147483648
+      else {
+        let integer =
+          bytes[offset] | (bytes[offset + 1] << 8) | (bytes[offset + 2] << 16)
+        if (integer > 0x7fffff) integer -= 0x1000000
+        value = integer / 8388608
+      }
+      channel[sample] = value
+      offset += bitDepth / 8
+    }
+  }
+  return channels
+}
+
+/** Read a RIFF/WAVE byte image. Native file I/O stays outside this boundary. */
+export function parsePcmWave(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
+  const fourCc = (offset) =>
+    String.fromCharCode(...bytes.subarray(offset, offset + 4))
+  if (bytes.length < 12 || fourCc(0) !== 'RIFF' || fourCc(8) !== 'WAVE') {
+    throw new Error('Invalid RIFF/WAVE file')
+  }
+  const end = view.getUint32(4, true) + 8
+  if (end > bytes.length || end < 12)
+    throw new Error('Truncated RIFF/WAVE file')
+  let format = null
+  let data = null
+  for (let offset = 12; offset + 8 <= end;) {
+    const size = view.getUint32(offset + 4, true)
+    const start = offset + 8
+    if (start + size > end) throw new Error('Truncated WAVE chunk')
+    if (fourCc(offset) === 'fmt ') {
+      if (size < 16) throw new Error('Invalid WAVE format chunk')
+      format = {
+        code: view.getUint16(start, true),
+        channelCount: view.getUint16(start + 2, true),
+        sampleRate: view.getUint32(start + 4, true),
+        blockAlign: view.getUint16(start + 12, true),
+        bitDepth: view.getUint16(start + 14, true),
+      }
+    } else if (fourCc(offset) === 'data' && data === null)
+      data = bytes.subarray(start, start + size)
+    offset = start + size + (size & 1)
+  }
+  if (!format || data === null)
+    throw new Error('WAVE requires fmt and data chunks')
+  const { code, channelCount, sampleRate, blockAlign, bitDepth } = format
+  if (code !== 1 || ![16, 24, 32].includes(bitDepth)) {
+    throw new Error('WAVE input must be signed 16, 24, or 32-bit integer PCM')
+  }
+  if (channelCount !== 1 && channelCount !== 2)
+    throw new Error(`Unsupported channel count: ${channelCount}`)
+  if (
+    sampleRate < 1 ||
+    blockAlign !== (channelCount * bitDepth) / 8 ||
+    data.length % blockAlign !== 0
+  ) {
+    throw new Error('Invalid WAVE sample layout')
+  }
+  return {
+    channels: pcmBytesToChannels(
+      data,
+      bitDepth,
+      channelCount,
+      data.length / blockAlign
+    ),
+    sampleRate,
+    bitDepth,
+  }
+}
+
 /**
  * Join complete PCM frames into one channel.
  *

package/codec/boundary/stream.js

@@ -72,20 +72,6 @@ function createDummyFrame() {
   }
 }
 
-/**
- * Collect an async iterable.
- *
- * @param {AsyncIterable} frames
- * @returns {Promise<Array>}
- */
-async function collect(frames) {
-  const output = []
-  for await (const frame of frames) {
-    output.push(frame)
-  }
-  return output
-}
-
 /**
  * Encode chronological PCM frames.
  */
@@ -115,22 +101,21 @@ export class AeaStreamingEncoder {
     if (this.finalized) {
       throw new Error('ATRAC1 encoder has already been finalized')
     }
-    for await (const frame of frames) {
-      validateChunk(frame, this.channelCount)
-      if (this.channelCount === 1) {
-        yield this.leftEncoder(frame)
-      } else {
-        const [left, right] = frame
-        yield this.leftEncoder(left)
-        yield this.rightEncoder(right)
-      }
-
-      this.sampleCount += SAMPLES_PER_FRAME
+    for await (const frame of frames) yield* this.push(frame)
+  }
 
-      if (this.onProgress) {
-        this.onProgress(this.frameIndex++)
-      }
-    }
+  /** Encode one chronological frame for either an async or synchronous host. */
+  push(frame) {
+    if (this.finalized)
+      throw new Error('ATRAC1 encoder has already been finalized')
+    validateChunk(frame, this.channelCount)
+    const encoded =
+      this.channelCount === 1
+        ? [this.leftEncoder(frame)]
+        : [this.leftEncoder(frame[0]), this.rightEncoder(frame[1])]
+    this.sampleCount += SAMPLES_PER_FRAME
+    if (this.onProgress) this.onProgress(this.frameIndex++)
+    return encoded
   }
 
   /**
@@ -184,22 +169,29 @@ export class AeaStreamingDecoder {
    */
   async *frames(frames) {
     for await (const frame of frames) {
-      if (this.channelCount === 1) {
-        yield this.trim(this.leftDecoder(frame))
-        this.reportProgress()
-      } else if (this.leftFrame === null) {
-        this.leftFrame = frame
-      } else {
-        yield this.trim([
-          this.leftDecoder(this.leftFrame),
-          this.rightDecoder(frame),
-        ])
-        this.leftFrame = null
-        this.reportProgress()
-      }
+      const decoded = this.push(frame)
+      if (decoded !== null) yield decoded
     }
   }
 
+  /** Decode one sound unit, returning null until a stereo pair is complete. */
+  push(frame) {
+    let decoded
+    if (this.channelCount === 1) decoded = this.trim(this.leftDecoder(frame))
+    else if (this.leftFrame === null) {
+      this.leftFrame = frame
+      return null
+    } else {
+      decoded = this.trim([
+        this.leftDecoder(this.leftFrame),
+        this.rightDecoder(frame),
+      ])
+      this.leftFrame = null
+    }
+    this.reportProgress()
+    return decoded
+  }
+
   /**
    * Complete an unmatched stereo pair.
    *
@@ -294,8 +286,9 @@ export async function encodeAeaPcm(channels, options = {}) {
     channelCount: channels.length,
     encoderOptions: new EncoderOptions(encoderValues),
   })
-  const frames = encoder.frames(frameBufferToFrames(channels))
-  const encoded = await collect(frames)
+  const encoded = []
+  for (const frame of frameBufferToFrames(channels))
+    encoded.push(...encoder.push(frame))
   encoded.push(...encoder.finish())
 
   const header = AeaFile.createHeader(
@@ -339,16 +332,17 @@ export async function decodeAeaPcm(input) {
     primingSampleCount: info.primingSampleCount,
     sampleCount: info.sampleCount,
   })
-  const frames = (async function* () {
-    for (
-      let offset = AEA_HEADER_SIZE;
-      offset + SOUND_UNIT_SIZE <= bytes.length;
-      offset += SOUND_UNIT_SIZE
-    ) {
-      yield deserializeFrame(bytes.subarray(offset, offset + SOUND_UNIT_SIZE))
-    }
-  })()
-  const decoded = await collect(decoder.frames(frames))
+  const decoded = []
+  for (
+    let offset = AEA_HEADER_SIZE;
+    offset + SOUND_UNIT_SIZE <= bytes.length;
+    offset += SOUND_UNIT_SIZE
+  ) {
+    const frame = decoder.push(
+      deserializeFrame(bytes.subarray(offset, offset + SOUND_UNIT_SIZE))
+    )
+    if (frame !== null) decoded.push(frame)
+  }
   decoded.push(...decoder.finish())
 
   if (info.channelCount === 1) {