diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..11a5620
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,2 @@
+# Unified patch context uses a required leading space before upstream tabs.
+native/*.patch whitespace=-space-before-tab
diff --git a/.github/ISSUE_SPECS/001-bounded-flac-wasm-codec.md b/.github/ISSUE_SPECS/001-bounded-flac-wasm-codec.md
new file mode 100644
index 0000000..d861983
--- /dev/null
+++ b/.github/ISSUE_SPECS/001-bounded-flac-wasm-codec.md
@@ -0,0 +1,264 @@
+# Build bounded native-FLAC encoding and decoding with pinned libFLAC Wasm
+
+GitHub: https://github.com/misofm/codec/issues/1
+
+Base: public `misofm/codec` main `23841d1`.
+
+## Objective
+
+Deliver `@misofm/codec` 0.1 as a reusable, storage-neutral native-FLAC codec:
+bounded incremental integer PCM encoding and asynchronous streaming decoding,
+using Bun, Effect v4, and package-owned libFLAC 1.5.0 WebAssembly. It must run
+from a packed install on Bun 1.4.2 and Node 22.23.2, and its portable decoder
+contract must be usable by `engine-web-adapter` without importing adapter policy.
+
+Callers own input/output I/O, staging cleanup, concurrency, retries, manifests,
+delivery chunking, URLs/auth, uploads, and publication. Consumers own the Effect
+runtime. Do not inspect or copy Engine/app source or change adapter/CLI/transcoder.
+
+## Public contract
+
+Export Schema-validated `PcmFormat` for one/two channels, integer PCM16/24, and
+integer 8,000–192,000 Hz rates. PCM blocks are non-empty `Int32Array` values of
+signed, right-justified, interleaved samples, aligned to channels and bounded by
+a documented fixed frame maximum. Stereo 44.1 kHz PCM16/24 is mandatory.
+
+`encodeFlac(source, sink, options)` accepts
+`Stream.Stream<Int32Array, EI, RI>` and a generic caller sink:
+
+```ts
+interface RandomAccessByteSink<E, R> {
+  writeAt(offset: bigint, bytes: Uint8Array): Effect.Effect<void, E, R>;
+  resize(length: bigint): Effect.Effect<void, E, R>;
+}
+```
+
+Options contain `format` and optional checked `expectedFrames`. The result
+reports format, encoded byte/frame counts, and finalized STREAMINFO block/frame
+sizes, total frames, and MD5. Preserve source/sink `E` and `R`; add only narrow
+Schema-backed `PcmInputError | FlacEncodeError`. Success follows all writes,
+backward STREAMINFO rewrites, validation, and exactly one final resize. On error
+or interruption the sink may contain partial bytes; the caller owns rollback.
+
+`decodeFlac(source, options?)` accepts a bounded
+`Stream.Stream<Uint8Array, EI, RI>` and returns a lazy
+`Stream.Stream<FlacDecodeEvent, EI | FlacDecodeError, RI | FlacDecoder>`.
+Events distinguish `Metadata`, `Pcm`, and final `Complete`. Each PCM event
+contains the established `PcmFormat`, starting frame, frame
+count, and bounded packed signed little-endian PCM bytes. Metadata becomes available before
+the first PCM block through a documented event/result shape; no PCM may precede
+validated STREAMINFO. Completion validates exact total frames when declared or
+caller-supplied and libFLAC MD5 when present. A standards-defined zero MD5 is
+reported as absent, never as verified. Caller-owned canonical SHA-256
+verification remains separate.
+Truncation, CRC/lost-sync, malformed metadata/frame bounds, trailing policy,
+shape/count/position/MD5 mismatch, callback stall, and ABI/trap failures are
+typed `FlacDecodeError`s with bounded phase/state fields.
+
+Ship external Wasm asset(s), export package-relative URL(s), and provide
+`FlacEncoder`/`FlacDecoder` Context services plus Layers from trusted Wasm bytes.
+Compile/validate a module once per Layer; acquire and release one independent
+codec instance per stream invocation. Core imports are inert and touch no I/O.
+
+## Bounded codec design
+
+- Pin native FLAC compression level 8, single-threaded, without exhaustive
+  model search (`-e`). Build encoder/decoder stream APIs only: no Ogg, CLI,
+  metadata editor, stdio/filesystem, network, WASI, pthreads, or policy formats.
+- Use ordinary fixed, non-growing Wasm memory at most 16 MiB and fixed input,
+  output, callback-operation, and metadata-prefix bounds. Reject unexpected
+  imports/exports, shared/growing memory, bad ABI, offset/count overflow, or stall.
+- Encoder callbacks stage a fixed ordered batch using virtual write/seek/tell;
+  drain every `writeAt` effect before pulling more PCM or making another bounded
+  Wasm process call. Final seek rewrites must produce canonical STREAMINFO/MD5.
+- Decoder bridges libFLAC's synchronous pull/write callbacks to the asynchronous
+  Effect source with a bounded mechanism proven on Bun, Node, and the intended
+  browser host. At most one fixed compressed slot and a fixed small number of PCM
+  blocks may be live. Await downstream demand/credit before processing more;
+  never collect a FLAC file/frame or decoded asset solely to bridge callbacks.
+- Preserve arbitrary source chunk boundaries, including splits across metadata,
+  frame headers/subframes/CRCs and frames larger than the input slot. EOF is
+  signalled only after upstream ends; early EOF must fail without hanging.
+- Scope every instance through its stream's last consumer. Early take, source or
+  consumer failure, and interruption stop input, unblock the bridge, suppress
+  late output, and finalize exactly once. Synchronous Wasm calls are bounded but
+  non-interruptible mid-call; document this cancellation limit.
+
+## Provenance and package
+
+Use official libFLAC 1.5.0 archive SHA-256
+`f2c1c76592a82ffff8413ba3c4a1299b6c7ab06c734dee03fd88630485c2b920`.
+Use Emscripten 6.0.9: emsdk `5eb0bde7585670252e8ba05e9d361627bffd08b5`,
+compiler `4e4223852a0835923411059a3929907d7df1232e`, SDK releases
+`f04ea239d533260dd1db760dd2d668d5f9a88d6b`. Record flags, patches, imports/
+exports, memory, tool/source/artifact hashes, and reproduce checked-in Wasm
+byte-for-byte offline. Ordinary package work uses it without compiler/download.
+Include libFLAC/Emscripten/musl notices; never distribute the GPL `flac` CLI.
+
+Use strict Node-compatible ESM/declarations/exports. Develop with exact
+`effect@4.0.0-rc.115`; advertise peer `4.0.0-rc.112 || 4.0.0-rc.115` only if
+packed Bun and Node consumers typecheck/run both, otherwise use the exact tested
+peer. Record the exact requested Effect-skill revision in evidence.
+
+## Objective gates
+
+1. Deterministic silence/impulse/extrema/random/partial/empty vectors cover both
+   channels/depths, 44.1 kHz and rate boundaries. Native libFLAC independently
+   verifies encoded FLAC and decoded PCM byte-for-byte, including channel order,
+   total frames, SHA-256, finalized STREAMINFO, and canonical-PCM MD5.
+2. Partition properties vary every legal PCM/FLAC source boundary without
+   changing decoded PCM or metadata. Corruption, truncation, trailing bytes,
+   wrong format/sample/range/count, oversized chunks/frames, bad callback data,
+   false codec status, trap, and malformed ABI all reach the documented typed
+   channel, never false success, defect, or hang.
+3. Trace sources/sinks prove pull backpressure and ordered seek writes. Slow
+   consumers prove fixed compressed/PCM credits; long streams prove
+   duration-independent JS/Wasm memory. No mutation retry occurs.
+4. Success, typed failure, defect injection, interruption at every wait/call
+   boundary, early decoded-stream cancellation, and concurrent streams prove one
+   acquire/release, no late work, no cross-stream state, and truthful Exit/Cause.
+5. Static policy proves Wasm is at most 256 KiB per asset, fixed non-shared memory
+   at most 16 MiB, exact audited imports/exports, and no forbidden surface. A
+   clean pinned rebuild reproduces every asset hash.
+6. Public type/Schema tests establish exact values/errors/requirements and
+   rejected misuse. `bun test`, strict typecheck, formatting, policy/license/
+   rebuild checks, `git diff --check`, and packed fresh consumers all pass.
+7. Packed Bun 1.4.2 and Node 22.23.2 consumers resolve installed Wasm assets and
+   run real incremental encode/decode/round-trip plus cancellation for every
+   advertised Effect peer. Add a packed browser consumer before claiming the
+   decoder ready for adapter replacement.
+8. On `/data/issue-77-lossless/run-02`, all 137 `flac8-30s` chunks across 30
+   stereo 44.1 kHz PCM24 stems encode and decode with exact manifest PCM hashes.
+   Run three serial warm Wasm/native-libFLAC level-8 rounds plus separate cold
+   compile/instantiate timing; verification is outside timing. Record per-chunk
+   and aggregate bytes/times/provenance. Compare FLAC payload to 425,690,361
+   bytes; 425,769,056 additionally includes 78,215 manifest and 480 container
+   bytes. Commit no media or encoded corpus.
+
+## Non-goals and workflow
+
+No whole-file convenience API, Promise facade, transcoding/HLS/AAC, sparse
+policy/manifests, storage implementation, upload/publication, CLI, engine/app
+changes, codec selection, Ogg, threads/SIMD, custom codec, npm publish, merge, or
+release. Adapter integration is a later issue after this package gate passes.
+
+Sol scopes, Sol implements, and a fresh Sol adversarially reviews an immutable
+checkpoint. Record implementation/rebuild/packed-consumer/corpus evidence and
+publish-readiness blockers here; do not weaken a gate to declare completion.
+
+## Implementation evidence
+
+The implementation uses the requested Effect guidance at
+`unconfirmedlabs/skills@f415b790865c7d391191a8daf67e4f94a7f0a028`, including
+its reusable-library, Schema, stream, service, and consumer-testing guidance.
+Sol scoped and implemented this slice; independent Sol review found and drove
+fixes for runtime option validation, metadata structure/order, strict linking,
+ABI ranges/stalls, encoder metadata completeness, and successful cleanup errors.
+The final immutable-checkpoint review signed off with no remaining blocker.
+
+The encoder accepts at most 4,096 frames per input element and stages at most
+256 KiB / 64 writes per native call in fixed 16 MiB Wasm memory. The decoder
+accepts at most 256 KiB per input element, emits one packed PCM block of at most
+384 KiB, and uses fixed 2 MiB Wasm memory. Its metadata setting is a read cap;
+retained metadata that cannot fit fails with a typed allocation error rather
+than growing memory. Both APIs await caller work and preserve primary failures
+and interruption. Checked cleanup precedes successful return or `Complete`.
+
+Final asset provenance is recorded in the checked manifests:
+
+| Asset   |   Bytes | SHA-256                                                            |
+| ------- | ------: | ------------------------------------------------------------------ |
+| Encoder | 133,885 | `90da75c73784e7184ea6c27d3ea9509f74df2eda405d8ddc8f964d78a16a273e` |
+| Decoder |  74,338 | `5e282f9874ecb3f49b8ee8437efc318ec14ef5cff5b7580da9d875f94e5c5925` |
+
+Both pinned build scripts reproduced their asset and provenance manifest exactly.
+The encoder permits only `codec.seek` and `codec.write`; the decoder permits
+only `codec.read`. All other unresolved symbols fail the link, including data
+symbols. Both build scripts enforce the 256 KiB asset ceiling. Manifests record
+source/archive hashes, compiler pins/flags, source units, exact imports/exports,
+fixed memory, and the strict linker policy.
+
+The native integration command requires an explicit `CODEC_NATIVE_FLAC`.
+`scripts/build-native-flac.sh` builds the pinned source in a temporary directory
+outside the repository; CI uses this independent oracle. The maximum-block test
+generates 65,535 stereo PCM24 frames and a compressed frame exceeding 256 KiB,
+then decodes through 997-byte fragments to 393,210 exact bytes with SHA-256
+`dfe5d44b7eab5437879b3f91a9c4d5443c263ed0e33dab15399dccc38bfe9443`.
+Small fixtures exercise every two-part PCM/FLAC split and every strict truncated
+prefix of a native 8 kHz stream. Deterministic vectors cover silence, impulses,
+extrema, random partial tails, empty streams, and all four channel/depth shapes.
+
+The actual decoder allocator is sampled across 96 × 4,096-frame blocks while PCM
+is hashed and discarded. Allocation reaches a steady plateau after warm-up;
+Wasm memory remains 2 MiB, and live allocations return to zero after success,
+truncation, and interruption. Public source finalizers run once. Readable WAT
+fixtures and corresponding embedded test bytes audit failure paths without
+requiring a compiler for ordinary tests; these fixtures are excluded from the
+package.
+
+`docs/evidence/packed-consumers.json` records a fresh isolated tarball test:
+139,215 packed bytes, 418,391 unpacked bytes, SHA-256
+`19045d0bd1524d07b2d31e07d64fb06832a50dc968904faa5ba328601a52e7a5`.
+Both advertised Effect peers passed typechecks and real four-format round trips,
+truncation, and cancellation on Bun 1.4.2, Node 22.23.2, Chromium 151.0.7922.34,
+Firefox 153.0, and WebKit 26.5 workers. Every runtime verifies 32,772 frames /
+122,895 canonical PCM bytes. The package owns both deployed assets and resolves
+them from the installed tarball without source-tree aliases.
+
+The canonical server receipt is `benchmark/evidence/corpus-benchmark.json`,
+SHA-256 `c3670d75efb6273a132d232964e14aa1859cb6ca3d2c1bfe85479f3e6a21ae25`.
+It covers all 30 stems / 137 chunks, three serial warm rounds, and separate cold
+compilation. All 137 decoder qualifications verify 971,988,594 canonical PCM
+bytes against manifest SHA-256 and STREAMINFO MD5; all 822 generated-file checks
+also verify exact native-decoded PCM.
+
+| Measurement                 |        Wasm | Native libFLAC 1.5.0 |
+| --------------------------- | ----------: | -------------------: |
+| FLAC payload bytes          | 425,689,892 |          425,690,361 |
+| Median corpus encoding time |    60.580 s |             15.554 s |
+
+Wasm saved 469 bytes (0.000110%) against the native payload and took 3.895 times
+as long on the recorded AMD EPYC 7313P server. Cold compile plus the first
+30-second encode took 485.601 ms, including 2.321 ms compilation. Verification
+is outside timed intervals. A packed consumer check briefly overlapped round 1;
+the receipt explicitly records this caveat and retains all rounds. Round 1 was
+faster than the median for both implementations.
+
+Final local checks passed on the frozen implementation:
+
+- `bun run check`: 40 passed, 5 intentional native-only skips, 832 assertions;
+  formatting and both strict TypeScript checks passed.
+- `CODEC_NATIVE_FLAC=<fresh pinned native build> bun run test:integration`:
+  5 passed, 657 assertions, no skips.
+- `bun run build`, both pinned `--verify` Wasm rebuilds, and
+  `bun run pack:check` passed.
+- `git diff --check` passed. No media, generated dependencies/caches, or packed
+  tarballs are committed.
+
+### Final review and CI
+
+Independent Sol review signed off with no remaining blocker at
+`07189c3c709f77fb5218420896b76b152ae2b01a`. The complete final report is
+`docs/evidence/final-review.md`, SHA-256
+`272505166d9f076b800c6f84de85af518ee0810c5a45f5b7bf6978ab57cfffec`.
+The reviewer independently repeated ordinary/native checks, build, both offline
+Wasm rebuilds, and the full packed matrix, reproducing the same tarball hash.
+
+[GitHub CI run 34737906581](https://github.com/misofm/codec/actions/runs/34737906581)
+passed both jobs on that checkpoint: fresh native and browser/package verification,
+and clean pinned Wasm rebuilds. The follow-up commit records this evidence and
+removes one unused test-only binary literal; it changes no package source, asset,
+manifest, or packed file. The retained ABI regressions pass after that removal.
+
+Reviewable delivery: [draft PR #2](https://github.com/misofm/codec/pull/2).
+There are no remaining implementation blockers for this package slice.
+
+### Release and integration status
+
+No adapter, CLI, or transcoder integration was performed. The adapter can map its
+existing synthesized STREAMINFO prefix and bounded input transport into the new
+stream API; its HTTP/auth, worker credits, OPFS, canonical SHA-256, and readiness
+rules remain caller-owned. Its full packed browser suite and integration memory /
+cancellation checks remain gates for that later migration.
+
+No mobile measurement, npm publication, merge, or release is part of this slice.
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..0e60489
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,49 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  package:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        with:
+          node-version: 22.23.2
+      - uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2
+        with:
+          bun-version: 1.4.2
+      - run: bun install --frozen-lockfile
+      - run: bunx playwright install --with-deps chromium firefox webkit
+      - run: bun run check
+      - name: Build independent native libFLAC oracle
+        run: |
+          codec_native_flac=$(scripts/build-native-flac.sh)
+          echo "CODEC_NATIVE_FLAC=$codec_native_flac" >> "$GITHUB_ENV"
+      - run: bun run test:integration
+      - run: bun run pack:check
+      - run: git diff --check
+
+  wasm:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
+      - uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2
+        with:
+          bun-version: 1.4.2
+      - name: Install pinned Emscripten
+        run: |
+          git clone --depth 1 --branch 6.0.9 https://github.com/emscripten-core/emsdk.git "$RUNNER_TEMP/codec-emsdk"
+          test "$(git -C "$RUNNER_TEMP/codec-emsdk" rev-parse HEAD)" = 5eb0bde7585670252e8ba05e9d361627bffd08b5
+          "$RUNNER_TEMP/codec-emsdk/emsdk" install 6.0.9
+          "$RUNNER_TEMP/codec-emsdk/emsdk" activate 6.0.9
+          echo "CODEC_EMSCRIPTEN_ROOT=$RUNNER_TEMP/codec-emsdk/upstream/emscripten" >> "$GITHUB_ENV"
+      - run: bun run scripts/build-wasm.ts --verify
+      - run: bun run scripts/build-decoder-wasm.ts --verify
+      - run: git diff --exit-code
diff --git a/README.md b/README.md
index 41d02e5..bb3bb78 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1,162 @@
 # @misofm/codec
 
-Effect-based audio codec primitives backed by pinned libFLAC WebAssembly.
+Bounded FLAC encoding and asynchronous streaming decoding, backed by pinned
+libFLAC 1.5.0 WebAssembly and composed with Effect v4. Development uses Bun.
 
-This package owns codec implementation and bounded PCM processing. Callers own
+The package owns codec primitives and Wasm assets. Callers own input/output,
 files, media pipelines, delivery chunks, manifests, storage, and publication.
+See [package boundaries](docs/architecture.md) and the
+[engine web adapter integration contract](docs/adapter-integration.md).
 
-Development uses Bun. The first implementation is tracked in the repository's
-numbered issue specifications under `.github/ISSUE_SPECS/`.
+## Encoding
+
+`encodeFlac(source, sink, options)` accepts an Effect stream of signed,
+right-justified, interleaved `Int32Array` PCM blocks. It supports mono/stereo,
+16/24-bit samples, and integer sample rates from 8,000 through 192,000 Hz.
+Each block contains 1–4,096 frames. An empty source encodes zero frames.
+
+```ts
+import * as Effect from "effect/Effect";
+import { encodeFlac, PcmFormat } from "@misofm/codec";
+import { FlacEncoderLive } from "@misofm/codec/node";
+
+// pcmBlocks and output are caller-owned capabilities.
+const encoded = encodeFlac(pcmBlocks, output, {
+  format: new PcmFormat({ sampleRate: 44100, channels: 2, bitsPerSample: 24 }),
+  expectedFrames: 1323000n,
+}).pipe(Effect.provide(FlacEncoderLive));
+```
+
+The sink supplies `writeAt(offset: bigint, bytes: Uint8Array)` and
+`resize(length: bigint)`, both returning Effects. Writes are ordered and awaited.
+The sink must implement arbitrary byte offsets: libFLAC rewrites STREAMINFO
+when it finishes. Success follows every write, final metadata validation, and
+one final resize. The result includes the format, frame count, encoded length,
+and finalized STREAMINFO/PCM MD5.
+
+Encoding uses compression level 8, a 4,096-frame FLAC block size, one thread, and
+no exhaustive model search, padding, or SEEKTABLE. It does not resample, normalize,
+quantize, or change channel order. Out-of-range samples fail explicitly.
+
+## Asynchronous streaming decoding
+
+`decodeFlac(source, options?)` consumes an Effect stream of FLAC `Uint8Array`
+fragments. Input boundaries may split metadata, frame headers, samples, or CRCs.
+The decoder can suspend for input in the middle of a frame.
+Each source element must be at most 256 KiB; use bounded file/network reads or
+split larger upstream chunks before passing them to the decoder. For example,
+Node/Bun's `createReadStream(path, { highWaterMark: 65536 })` can be adapted with
+`Stream.fromAsyncIterable`. Bun's default `Bun.file(path).stream()` may emit
+larger elements.
+
+```ts
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import { decodeFlac } from "@misofm/codec";
+import { FlacDecoderLive } from "@misofm/codec/node";
+
+const decoded = decodeFlac(flacFragments).pipe(
+  Stream.runForEach((event) => {
+    switch (event._tag) {
+      case "Metadata":
+        return onMetadata(event);
+      case "Pcm":
+        return consumePcm(event.bytes);
+      case "Complete":
+        return onComplete(event);
+    }
+  }),
+  Effect.provide(FlacDecoderLive),
+);
+```
+
+Events establish the format before PCM, emit bounded packed signed little-endian
+PCM blocks, then report completion after stream validation. PCM received before
+completion is provisional. A zero embedded MD5 is reported as absent rather than
+verified. Applications may additionally check their own canonical SHA-256.
+If STREAMINFO omits both the sample count and MD5, detecting a cut at a valid
+frame boundary requires a caller-supplied `expectedFrames` or external digest.
+
+The decoder accepts a single FLAC stream and rejects trailing bytes or a second
+concatenated stream. Optional `expectedFormat` and `expectedFrames` constrain the
+decoded result. Metadata reading defaults to a 1 MiB cap, configurable from 42
+bytes through 16 MiB. This is a read limit: increasing it does not enlarge the
+decoder's fixed memory, and retained metadata that cannot fit fails explicitly.
+
+| Per-operation resource | Encoder                | Decoder                        |
+| ---------------------- | ---------------------- | ------------------------------ |
+| Fixed Wasm memory      | 16 MiB                 | 2 MiB                          |
+| Input element          | 4,096 PCM frames       | 256 KiB compressed bytes       |
+| Staged output          | 256 KiB callback bytes | One PCM block, at most 384 KiB |
+
+Decoded blocks may contain up to 65,535 frames. The library waits for downstream
+demand before decoding the next block. Callers must also bound upstream stream
+batches and any output queues they introduce.
+
+The decoder needs no shared memory, cross-origin isolation, network client, or
+filesystem. The portable entrypoint accepts a compiled-module Layer created from
+Wasm bytes. The `/node` entrypoint loads the installed package assets on Node or
+Bun. Browser consumers can load the exported `FLAC_*_WASM_URL` values and use
+`makeFlacEncoderLayer` / `makeFlacDecoderLayer`; bundlers must deploy those assets
+with their corresponding URLs.
+
+## Effect and resource ownership
+
+The APIs preserve source/sink error and service types. Codec and PCM failures
+use Schema-backed tagged errors. Core imports are inert; each Layer shares a
+compiled module, and each operation owns an independent Wasm instance.
+
+Source consumption and output writes obey backpressure. Failure, interruption,
+and early stream cancellation release the codec. Calls into Wasm are synchronous
+and cannot be interrupted in the middle of a call; cancellation is observed
+between bounded calls and during Effect input/output waits. Run heavy jobs in
+application-owned workers when event-loop responsiveness matters.
+
+Partial output may remain after failure or interruption. Callers own staging,
+rollback, cleanup, durable commits, and retry policy. The package does not retry
+mutations or publish output. Applications also bound concurrent codec operations
+and any buffering added before or after these APIs.
+
+## Development and verification
+
+```sh
+bun install --frozen-lockfile
+bun run check
+bun run pack:check
+```
+
+Independent native verification builds the pinned libFLAC source outside the
+repository and uses the resulting CLI only as a test oracle:
+
+```sh
+CODEC_NATIVE_FLAC=$(scripts/build-native-flac.sh) bun run test:integration
+```
+
+The supported peer matrix is `effect@4.0.0-rc.112` and `4.0.0-rc.115`; development
+pins rc.115. Packed consumer checks execute real incremental encoding, decoding,
+round trips, cancellation, and typed truncation failures on Bun 1.4.2, Node
+22.23.2, and Chromium, Firefox, and WebKit workers. Consumer examples are compiled from an isolated
+installed tarball, without workspace aliases.
+
+Rebuilding Wasm requires the pinned Emscripten 6.0.9 toolchain. Set
+`CODEC_EMSCRIPTEN_ROOT` to its `upstream/emscripten` directory, then run:
+
+```sh
+bun run scripts/build-wasm.ts --verify
+bun run scripts/build-decoder-wasm.ts --verify
+```
+
+Build verification compares fresh output with checked-in asset and provenance
+manifests. Intentional changes use the scripts' explicit `--update` mode first.
+Normal installation and TypeScript builds use the packaged assets without a
+compiler or codec download. See [third-party notices](THIRD_PARTY_NOTICES.md).
+
+The implementation follows the requested
+[Effect skill at revision f415b79](https://github.com/unconfirmedlabs/skills/tree/f415b790865c7d391191a8daf67e4f94a7f0a028/effect-ts).
+Foreign Wasm callbacks are a narrow synchronous boundary; Effect owns their
+asynchronous input/output and resource lifetime. Build and consumer scripts own
+their process/host boundaries.
+
+The [server corpus benchmark](https://github.com/misofm/codec/tree/main/benchmark) records Wasm measurements
+separately from native libFLAC and validates every result against canonical PCM.
+No mobile benchmark is included. The package has not been published to npm.
diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md
new file mode 100644
index 0000000..b778237
--- /dev/null
+++ b/THIRD_PARTY_NOTICES.md
@@ -0,0 +1,27 @@
+# Third-party software
+
+`@misofm/codec` source is licensed under Apache-2.0. Its bundled WebAssembly
+assets incorporate separately licensed software. Complete notices in
+`vendor/licenses/` are included in the npm package.
+
+| Component          | Version                      | Notice                                                              |
+| ------------------ | ---------------------------- | ------------------------------------------------------------------- |
+| libFLAC            | 1.5.0                        | [Xiph BSD license](vendor/licenses/libFLAC.txt)                     |
+| Emscripten runtime | 6.0.9                        | [MIT / University of Illinois-NCSA](vendor/licenses/emscripten.txt) |
+| musl libc          | supplied by Emscripten 6.0.9 | [musl notices](vendor/licenses/musl.txt)                            |
+| LLVM compiler-rt   | supplied by Emscripten 6.0.9 | [LLVM notices](vendor/licenses/compiler-rt.txt)                     |
+
+The decoder's freestanding allocator/runtime is derived from
+`misofm/engine-web-adapter`, `decoder/freestanding.c`, revision
+`73e891df62375d1ee45d8228029796ef9597cb43`, Copyright 2026 Miso, under Apache-2.0.
+The package-local adaptation is identified in `native/decoder-runtime.c`.
+
+Only the libFLAC library is linked into the assets. The upstream `flac` command
+line program is a development and verification tool and is not distributed in
+the npm package.
+
+The source archive is retained in the Git repository for reproducible builds.
+Its upstream distribution includes files under other licenses; those files are
+not all linked into the distributed assets. Consult the archive's individual
+notices when using it independently. Wasm build manifests record exact source,
+toolchain, patch, and asset provenance.
diff --git a/benchmark/README.md b/benchmark/README.md
new file mode 100644
index 0000000..c4468a2
--- /dev/null
+++ b/benchmark/README.md
@@ -0,0 +1,56 @@
+# Lossless corpus benchmark
+
+`corpus.ts` compares the package's pinned libFLAC Wasm encoder with the pinned
+native libFLAC 1.5.0 CLI on the 30-stem, 137-chunk issue-77 corpus. It also
+qualifies the package decoder with deliberately fragmented FLAC input. Corpus
+audio and generated files remain outside this repository.
+
+The benchmark measures encoding only. Input integrity checks, STREAMINFO checks,
+native decode, package decode, PCM hashing, and receipt serialization run outside
+the timed interval. A cold Wasm compile is reported separately from the three
+serial warm rounds.
+
+The receipt reports the installed Node runtime separately from the Node
+compatibility version exposed by Bun's `process.version`.
+
+```sh
+bun run benchmark/corpus.ts \
+  --corpus /data/issue-77-lossless/run-02 \
+  --sources /home/bl/misofm/engine-web-adapter/research/077-lossless-delivery/sources.json \
+  --native-flac /data/issue-77-lossless/tooling/flac-build/src/flac/flac \
+  --rounds 3 \
+  --receipt benchmark/evidence/corpus-benchmark.json
+```
+
+## Recorded qualification
+
+The canonical 2026-09-13 receipt has SHA-256
+`c3670d75efb6273a132d232964e14aa1859cb6ca3d2c1bfe85479f3e6a21ae25`.
+It pins encoder `90da75c73784e7184ea6c27d3ea9509f74df2eda405d8ddc8f964d78a16a273e`
+and decoder `5e282f9874ecb3f49b8ee8437efc318ec14ef5cff5b7580da9d875f94e5c5925`.
+All 137 chunks decoded to the expected 971,988,594 PCM bytes and verified their
+manifest SHA-256 and STREAMINFO MD5. All 822 generated-file checks also decoded
+to the expected PCM.
+
+Wasm produced 425,689,892 FLAC payload bytes, 469 bytes (0.000110%) less than
+native libFLAC's 425,690,361 bytes. Median serial encoding time was 60.580 s for
+Wasm and 15.554 s for native, a 3.895x ratio. Cold compile plus first encode was
+485.601 ms, of which compilation was 2.321 ms. A packed fresh-consumer check
+briefly overlapped warm round 1 and completed before rounds 2 and 3. The receipt
+retains all values and records the caveat; round 1 was faster than the median for
+both implementations.
+
+Use `--limit 1 --rounds 1` for a development smoke run. A limited run is marked
+as such and cannot satisfy the issue gate. The native command uses level 8 with
+no exhaustive model search, padding, or SEEKTABLE. Receipt totals distinguish
+FLAC payload bytes from the retained 425,769,056-byte delivery total, which also
+contains 78,215 manifest bytes and 480 container bytes.
+
+The predictive fixture in `test/encode-native-integration.test.ts` was also
+replayed against the superseded encoder asset
+`ddd796cd287f6fd3f95a4643644cfb9bdf83c9a138d59fd763467651ed688240`.
+That asset produced 102,778 bytes versus native's 96,283 bytes (+6.745739%) and
+no LPC subframe above order 1. The fixed encoder produced 97,621 bytes
+(+1.389653%) and 64 higher-order LPC subframes on the same fixture, proving that
+both regression assertions reject the original missing-math-table build. The
+superseded asset is not retained in this repository.
diff --git a/benchmark/corpus.ts b/benchmark/corpus.ts
new file mode 100644
index 0000000..c47a00e
--- /dev/null
+++ b/benchmark/corpus.ts
@@ -0,0 +1,1409 @@
+import { createHash } from "node:crypto";
+import {
+  mkdir,
+  mkdtemp,
+  open,
+  copyFile,
+  readFile,
+  readdir,
+  rm,
+  stat,
+  writeFile,
+  type FileHandle,
+} from "node:fs/promises";
+import { cpus, platform, release, tmpdir } from "node:os";
+import { basename, dirname, join } from "node:path";
+
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+
+import {
+  FLAC_ENCODER_WASM_SHA256,
+  FLAC_ENCODER_WASM_URL,
+  FlacEncoder,
+  PcmFormat,
+  encodeFlac,
+  type RandomAccessByteSink,
+} from "../src/index.js";
+import {
+  decodeFlac,
+  type FlacDecodeComplete,
+  type FlacMetadata,
+} from "../src/decode.js";
+import {
+  FLAC_DECODER_WASM_SHA256,
+  FLAC_DECODER_WASM_URL,
+  FlacDecoder,
+  loadFlacDecoderFromBytes,
+} from "../src/decoder-wasm.js";
+import { loadFlacEncoderFromBytes } from "../src/wasm.js";
+
+const EXPECTED_STEMS = 30;
+const EXPECTED_CHUNKS = 137;
+const EXPECTED_BASELINE_PAYLOAD_BYTES = 425_690_361;
+const EXPECTED_BASELINE_MANIFEST_BYTES = 78_215;
+const EXPECTED_BASELINE_CONTAINER_BYTES = 480;
+const EXPECTED_RELEASE_REVISION = "aab52d13309a191494bcb02dc706519c31bc1a97";
+const PCM_FRAMES_PER_READ = 4_096;
+const FLAC_FRAGMENT_PATTERN = [
+  1, 2, 3, 5, 7, 31, 257, 4_093, 65_521, 262_139,
+] as const;
+
+const median = (values: ReadonlyArray<number>): number => {
+  if (values.length === 0)
+    throw new Error("cannot calculate a median without values");
+  const sorted = [...values].sort((left, right) => left - right);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0
+    ? ((sorted[middle - 1] ?? 0) + (sorted[middle] ?? 0)) / 2
+    : sorted[middle]!;
+};
+
+const Sha256 = Schema.String.pipe(
+  Schema.check(Schema.isPattern(/^[0-9a-f]{64}$/)),
+);
+
+const ChunkManifest = Schema.Struct({
+  bytes: Schema.Natural,
+  flacSha256: Sha256,
+  frames: Schema.Natural,
+  offset: Schema.Natural,
+  packedStartFrame: Schema.Natural,
+  pcmSha256: Sha256,
+});
+
+const StemManifest = Schema.Struct({
+  bitDepth: Schema.Literal(24),
+  channels: Schema.Literal(2),
+  chunks: Schema.Array(ChunkManifest),
+  format: Schema.Literal("miso_sparse_stem_v1"),
+  frames: Schema.Natural,
+  identity: Schema.String,
+  sampleRateHz: Schema.Literal(44_100),
+});
+
+const SourcesCatalog = Schema.Struct({
+  format: Schema.Literal("issue77-source-catalog-v1"),
+  release: Schema.Struct({
+    repository: Schema.String,
+    revision: Schema.String,
+    path: Schema.String,
+    sha256: Sha256,
+  }),
+  stems: Schema.Array(
+    Schema.Struct({
+      identity: Schema.String,
+      shape: Schema.Struct({
+        sampleRateHz: Schema.Literal(44_100),
+        channels: Schema.Literal(2),
+        bitDepth: Schema.Literal(24),
+        frames: Schema.Natural,
+      }),
+      chunkCount: Schema.Natural,
+    }),
+  ),
+});
+
+class BenchmarkError extends Schema.TaggedError<BenchmarkError>()(
+  "BenchmarkError",
+  {
+    phase: Schema.Literals([
+      "arguments",
+      "corpus",
+      "input",
+      "wasm",
+      "native-encode",
+      "native-decode",
+      "verify",
+      "receipt",
+    ]),
+    detail: Schema.String,
+    path: Schema.optionalKey(Schema.String),
+    cause: Schema.optionalKey(Schema.Defect()),
+  },
+) {}
+
+interface Arguments {
+  readonly corpus: string;
+  readonly sources: string;
+  readonly nativeFlac: string;
+  readonly receipt: string;
+  readonly rounds: number;
+  readonly limit: number | undefined;
+  readonly keepWasm: string | undefined;
+}
+
+interface CorpusChunk {
+  readonly stemIdentity: string;
+  readonly chunkIndex: number;
+  readonly activeRawPath: string;
+  readonly sourceManifestPath: string;
+  readonly retainedFlacPath: string;
+  readonly expectedFlacSha256: string;
+  readonly packedStartFrame: number;
+  readonly frames: number;
+  readonly expectedPcmSha256: string;
+  readonly retainedFlacBytes: number;
+}
+
+interface InputDigest {
+  readonly bytes: number;
+  readonly sha256: string;
+  readonly md5: string;
+}
+
+interface StreamInfo {
+  readonly minimumBlockSize: number;
+  readonly maximumBlockSize: number;
+  readonly minimumFrameSize: number;
+  readonly maximumFrameSize: number;
+  readonly sampleRate: number;
+  readonly channels: number;
+  readonly bitsPerSample: number;
+  readonly totalFrames: string;
+  readonly md5Hex: string;
+}
+
+interface MeasurementRow {
+  readonly implementation: "wasm" | "native";
+  readonly round: number;
+  readonly stemIdentity: string;
+  readonly chunkIndex: number;
+  readonly frames: number;
+  readonly expectedPcmSha256: string;
+  readonly encodedBytes: number;
+  readonly elapsedMilliseconds: number;
+  readonly streamInfo: StreamInfo;
+  readonly nativeDecodedPcmSha256: string;
+}
+
+interface DecodeQualificationRow {
+  readonly stemIdentity: string;
+  readonly chunkIndex: number;
+  readonly encodedBytes: number;
+  readonly frames: number;
+  readonly pcmBytes: number;
+  readonly pcmBlocks: number;
+  readonly maximumPcmBlockBytes: number;
+  readonly pcmSha256: string;
+  readonly metadataMd5Present: boolean;
+  readonly completeMd5Checked: boolean;
+  readonly completeMd5Verified: boolean;
+}
+
+const fail = (
+  phase: BenchmarkError["phase"],
+  detail: string,
+  fields: { readonly path?: string; readonly cause?: unknown } = {},
+): BenchmarkError => new BenchmarkError({ phase, detail, ...fields });
+
+const parseArguments = (argv: ReadonlyArray<string>): Arguments => {
+  const values = new Map<string, string>();
+  for (let index = 0; index < argv.length; index += 2) {
+    const name = argv[index];
+    const value = argv[index + 1];
+    if (name === undefined || value === undefined || !name.startsWith("--")) {
+      throw fail(
+        "arguments",
+        `expected --name value pairs, received ${argv.join(" ")}`,
+      );
+    }
+    values.set(name.slice(2), value);
+  }
+
+  const required = (name: string): string => {
+    const value = values.get(name);
+    if (value === undefined || value.length === 0) {
+      throw fail("arguments", `missing --${name}`);
+    }
+    return value;
+  };
+  const positiveInteger = (name: string, fallback?: number): number => {
+    const text = values.get(name);
+    if (text === undefined && fallback !== undefined) return fallback;
+    const value = Number(text);
+    if (!Number.isSafeInteger(value) || value <= 0) {
+      throw fail("arguments", `--${name} must be a positive safe integer`);
+    }
+    return value;
+  };
+
+  return {
+    corpus: required("corpus"),
+    sources: required("sources"),
+    nativeFlac: required("native-flac"),
+    receipt: required("receipt"),
+    rounds: positiveInteger("rounds", 3),
+    limit: values.has("limit") ? positiveInteger("limit") : undefined,
+    keepWasm: values.get("keep-wasm"),
+  };
+};
+
+const readUnknownJson = (
+  path: string,
+): Effect.Effect<unknown, BenchmarkError> =>
+  Effect.tryPromise({
+    try: async () => JSON.parse(await readFile(path, "utf8")) as unknown,
+    catch: (cause) =>
+      fail("corpus", "could not read or parse JSON", { path, cause }),
+  });
+
+const decodeJson = <A, I, R>(
+  schema: Schema.Codec<A, I, R, never>,
+  path: string,
+): Effect.Effect<A, BenchmarkError, R> =>
+  readUnknownJson(path).pipe(
+    Effect.flatMap(Schema.decodeUnknownEffect(schema)),
+    Effect.mapError((cause) =>
+      cause instanceof BenchmarkError
+        ? cause
+        : fail("corpus", `JSON failed schema validation: ${String(cause)}`, {
+            path,
+            cause,
+          }),
+    ),
+  );
+
+const discoverCorpus = Effect.fn("benchmark.discoverCorpus")(function* (
+  args: Arguments,
+): Effect.fn.Return<ReadonlyArray<CorpusChunk>, BenchmarkError> {
+  const catalog = yield* decodeJson(SourcesCatalog, args.sources);
+  if (catalog.release.revision !== EXPECTED_RELEASE_REVISION) {
+    return yield* fail(
+      "corpus",
+      `source catalog release is ${catalog.release.revision}; expected ${EXPECTED_RELEASE_REVISION}`,
+      { path: args.sources },
+    );
+  }
+  const entries = yield* Effect.tryPromise({
+    try: () => readdir(args.corpus, { withFileTypes: true }),
+    catch: (cause) =>
+      fail("corpus", "could not enumerate corpus", {
+        path: args.corpus,
+        cause,
+      }),
+  });
+  const stemIds = entries
+    .filter((entry) => entry.isDirectory() && /^[0-9a-f]{64}$/.test(entry.name))
+    .map((entry) => entry.name)
+    .sort();
+
+  const catalogIds = new Set(
+    catalog.stems.map((stem) => stem.identity.replace(/^sha256:/, "")),
+  );
+  const chunks: Array<CorpusChunk> = [];
+  for (const stemId of stemIds) {
+    if (!catalogIds.has(stemId)) continue;
+    const manifestPath = join(
+      args.corpus,
+      stemId,
+      "flac8-30s",
+      "manifest.json",
+    );
+    const activeRawPath = join(args.corpus, stemId, "active.raw");
+    const manifest = yield* decodeJson(StemManifest, manifestPath);
+    if (manifest.identity !== `sha256:${stemId}`) {
+      return yield* fail(
+        "corpus",
+        "manifest identity does not match its directory",
+        {
+          path: manifestPath,
+        },
+      );
+    }
+    const catalogStem = catalog.stems.find(
+      (stem) => stem.identity === manifest.identity,
+    );
+    if (
+      catalogStem === undefined ||
+      catalogStem.chunkCount !== manifest.chunks.length
+    ) {
+      return yield* fail(
+        "corpus",
+        "source catalog and candidate chunk count differ",
+        {
+          path: manifestPath,
+        },
+      );
+    }
+    let packedFrameCursor = 0;
+    for (const chunk of manifest.chunks) {
+      if (
+        !Number.isSafeInteger(chunk.frames) ||
+        !Number.isSafeInteger(chunk.packedStartFrame) ||
+        chunk.packedStartFrame !== packedFrameCursor
+      ) {
+        return yield* fail(
+          "corpus",
+          "candidate chunks are not contiguous safe PCM ranges",
+          {
+            path: manifestPath,
+          },
+        );
+      }
+      packedFrameCursor += chunk.frames;
+    }
+    const activeRaw = yield* Effect.tryPromise({
+      try: () => stat(activeRawPath),
+      catch: (cause) =>
+        fail("corpus", "could not stat active PCM", {
+          path: activeRawPath,
+          cause,
+        }),
+    });
+    if (activeRaw.size !== packedFrameCursor * 6) {
+      return yield* fail(
+        "corpus",
+        `active PCM has ${activeRaw.size} bytes; chunks require ${packedFrameCursor * 6}`,
+        { path: activeRawPath },
+      );
+    }
+    manifest.chunks.forEach((chunk, chunkIndex) => {
+      chunks.push({
+        stemIdentity: manifest.identity,
+        chunkIndex,
+        activeRawPath,
+        sourceManifestPath: manifestPath,
+        retainedFlacPath: join(
+          args.corpus,
+          stemId,
+          "flac8-30s",
+          `${chunkIndex}.flac`,
+        ),
+        expectedFlacSha256: chunk.flacSha256,
+        packedStartFrame: chunk.packedStartFrame,
+        frames: chunk.frames,
+        expectedPcmSha256: chunk.pcmSha256,
+        retainedFlacBytes: chunk.bytes,
+      });
+    });
+  }
+
+  if (stemIds.length !== EXPECTED_STEMS || chunks.length !== EXPECTED_CHUNKS) {
+    return yield* fail(
+      "corpus",
+      `expected ${EXPECTED_STEMS} stems/${EXPECTED_CHUNKS} chunks, found ${stemIds.length}/${chunks.length}`,
+      { path: args.corpus },
+    );
+  }
+  const retainedPayload = chunks.reduce(
+    (total, chunk) => total + chunk.retainedFlacBytes,
+    0,
+  );
+  if (retainedPayload !== EXPECTED_BASELINE_PAYLOAD_BYTES) {
+    return yield* fail(
+      "corpus",
+      `retained payload is ${retainedPayload}, expected ${EXPECTED_BASELINE_PAYLOAD_BYTES}`,
+      { path: args.corpus },
+    );
+  }
+  return args.limit === undefined ? chunks : chunks.slice(0, args.limit);
+});
+
+const readExact = async (
+  handle: FileHandle,
+  position: number,
+  length: number,
+): Promise<Uint8Array> => {
+  const bytes = new Uint8Array(length);
+  let filled = 0;
+  while (filled < length) {
+    const read = await handle.read(
+      bytes,
+      filled,
+      length - filled,
+      position + filled,
+    );
+    if (read.bytesRead === 0) {
+      throw new Error(
+        `unexpected EOF at ${position + filled}; needed ${length - filled} bytes`,
+      );
+    }
+    filled += read.bytesRead;
+  }
+  return bytes;
+};
+
+const hashPcmRange = (
+  chunk: CorpusChunk,
+): Effect.Effect<InputDigest, BenchmarkError> =>
+  Effect.tryPromise({
+    try: async () => {
+      const handle = await open(chunk.activeRawPath, "r");
+      const sha256 = createHash("sha256");
+      const md5 = createHash("md5");
+      const bytesPerFrame = 6;
+      let position = chunk.packedStartFrame * bytesPerFrame;
+      let remaining = chunk.frames * bytesPerFrame;
+      try {
+        while (remaining > 0) {
+          const length = Math.min(
+            remaining,
+            PCM_FRAMES_PER_READ * bytesPerFrame,
+          );
+          const bytes = await readExact(handle, position, length);
+          sha256.update(bytes);
+          md5.update(bytes);
+          position += length;
+          remaining -= length;
+        }
+      } finally {
+        await handle.close();
+      }
+      return {
+        bytes: chunk.frames * bytesPerFrame,
+        sha256: sha256.digest("hex"),
+        md5: md5.digest("hex"),
+      };
+    },
+    catch: (cause) =>
+      fail("input", "could not hash PCM source range", {
+        path: chunk.activeRawPath,
+        cause,
+      }),
+  });
+
+const pcmSource = (
+  chunk: CorpusChunk,
+): Stream.Stream<Int32Array, BenchmarkError> => {
+  const iterable: AsyncIterable<Int32Array> = {
+    async *[Symbol.asyncIterator]() {
+      const handle = await open(chunk.activeRawPath, "r");
+      let frameOffset = chunk.packedStartFrame;
+      let remainingFrames = chunk.frames;
+      try {
+        while (remainingFrames > 0) {
+          const frames = Math.min(remainingFrames, PCM_FRAMES_PER_READ);
+          const packed = await readExact(handle, frameOffset * 6, frames * 6);
+          const samples = new Int32Array(frames * 2);
+          for (let index = 0; index < samples.length; index += 1) {
+            const byteOffset = index * 3;
+            const low = packed[byteOffset];
+            const middle = packed[byteOffset + 1];
+            const high = packed[byteOffset + 2];
+            if (
+              low === undefined ||
+              middle === undefined ||
+              high === undefined
+            ) {
+              throw new Error(`misaligned PCM at sample ${index}`);
+            }
+            const unsigned = low | (middle << 8) | (high << 16);
+            samples[index] =
+              (unsigned & 0x80_0000) === 0 ? unsigned : unsigned | 0xff00_0000;
+          }
+          yield samples;
+          frameOffset += frames;
+          remainingFrames -= frames;
+        }
+      } finally {
+        await handle.close();
+      }
+    },
+  };
+  return Stream.fromAsyncIterable(iterable, (cause) =>
+    cause instanceof BenchmarkError
+      ? cause
+      : fail("input", "PCM source stream failed", {
+          path: chunk.activeRawPath,
+          cause,
+        }),
+  );
+};
+
+const fragmentedFlacSource = (
+  path: string,
+): Stream.Stream<Uint8Array, BenchmarkError> => {
+  const iterable: AsyncIterable<Uint8Array> = {
+    async *[Symbol.asyncIterator]() {
+      const handle = await open(path, "r");
+      let position = 0;
+      let fragmentIndex = 0;
+      try {
+        const file = await handle.stat();
+        while (position < file.size) {
+          const requested =
+            FLAC_FRAGMENT_PATTERN[
+              fragmentIndex % FLAC_FRAGMENT_PATTERN.length
+            ]!;
+          const length = Math.min(requested, file.size - position);
+          yield await readExact(handle, position, length);
+          position += length;
+          fragmentIndex += 1;
+        }
+      } finally {
+        await handle.close();
+      }
+    },
+  };
+  return Stream.fromAsyncIterable(iterable, (cause) =>
+    cause instanceof BenchmarkError
+      ? cause
+      : fail("input", "fragmented FLAC source failed", { path, cause }),
+  );
+};
+
+const verifyPackageDecode = Effect.fn("benchmark.verifyPackageDecode")(
+  function* (
+    format: PcmFormat,
+    chunk: CorpusChunk,
+  ): Effect.fn.Return<
+    DecodeQualificationRow,
+    BenchmarkError | import("../src/decoder-errors.js").FlacDecodeError,
+    FlacDecoder
+  > {
+    const flacSha256 = yield* sha256File(chunk.retainedFlacPath);
+    if (flacSha256 !== chunk.expectedFlacSha256) {
+      return yield* fail(
+        "input",
+        "retained FLAC hash does not match manifest",
+        {
+          path: chunk.retainedFlacPath,
+        },
+      );
+    }
+    const digest = createHash("sha256");
+    let metadata: FlacMetadata | undefined;
+    let complete: FlacDecodeComplete | undefined;
+    let expectedFrameOffset = 0n;
+    let pcmBytes = 0;
+    let pcmBlocks = 0;
+    let maximumPcmBlockBytes = 0;
+    yield* Stream.runForEach(
+      decodeFlac(fragmentedFlacSource(chunk.retainedFlacPath), {
+        expectedFormat: format,
+        expectedFrames: BigInt(chunk.frames),
+      }),
+      (event) => {
+        if (event._tag === "Metadata") {
+          if (
+            metadata !== undefined ||
+            pcmBlocks !== 0 ||
+            complete !== undefined ||
+            event.format.sampleRate !== format.sampleRate ||
+            event.format.channels !== format.channels ||
+            event.format.bitsPerSample !== format.bitsPerSample ||
+            event.totalFrames !== BigInt(chunk.frames)
+          ) {
+            return Effect.fail(
+              fail("verify", "decoder emitted invalid or misplaced metadata", {
+                path: chunk.retainedFlacPath,
+              }),
+            );
+          }
+          metadata = event;
+          return Effect.void;
+        }
+        if (event._tag === "Pcm") {
+          if (
+            metadata === undefined ||
+            complete !== undefined ||
+            event.frameOffset !== expectedFrameOffset ||
+            event.bytes.byteLength !== event.frames * 6
+          ) {
+            return Effect.fail(
+              fail(
+                "verify",
+                "decoder emitted invalid PCM event ordering or shape",
+                {
+                  path: chunk.retainedFlacPath,
+                },
+              ),
+            );
+          }
+          digest.update(event.bytes);
+          expectedFrameOffset += BigInt(event.frames);
+          pcmBytes += event.bytes.byteLength;
+          pcmBlocks += 1;
+          maximumPcmBlockBytes = Math.max(
+            maximumPcmBlockBytes,
+            event.bytes.byteLength,
+          );
+          return Effect.void;
+        }
+        if (
+          metadata === undefined ||
+          complete !== undefined ||
+          event.frames !== BigInt(chunk.frames) ||
+          event.bytes !== BigInt(chunk.frames * 6)
+        ) {
+          return Effect.fail(
+            fail("verify", "decoder emitted invalid completion", {
+              path: chunk.retainedFlacPath,
+            }),
+          );
+        }
+        complete = event;
+        return Effect.void;
+      },
+    );
+    const pcmSha256 = digest.digest("hex");
+    if (
+      metadata === undefined ||
+      complete === undefined ||
+      expectedFrameOffset !== BigInt(chunk.frames) ||
+      pcmBytes !== chunk.frames * 6 ||
+      pcmSha256 !== chunk.expectedPcmSha256 ||
+      !metadata.md5Present ||
+      !complete.md5Checked ||
+      !complete.md5Verified
+    ) {
+      return yield* fail(
+        "verify",
+        "package decoder did not produce one fully verified PCM stream",
+        {
+          path: chunk.retainedFlacPath,
+        },
+      );
+    }
+    return {
+      stemIdentity: chunk.stemIdentity,
+      chunkIndex: chunk.chunkIndex,
+      encodedBytes: chunk.retainedFlacBytes,
+      frames: chunk.frames,
+      pcmBytes,
+      pcmBlocks,
+      maximumPcmBlockBytes,
+      pcmSha256,
+      metadataMd5Present: metadata.md5Present,
+      completeMd5Checked: complete.md5Checked,
+      completeMd5Verified: complete.md5Verified,
+    };
+  },
+);
+
+const safePosition = (offset: bigint): number => {
+  const position = Number(offset);
+  if (!Number.isSafeInteger(position) || position < 0) {
+    throw new Error(`unsafe output offset ${offset}`);
+  }
+  return position;
+};
+
+const makeFileSink = (
+  handle: FileHandle,
+  path: string,
+): RandomAccessByteSink<BenchmarkError, never> => ({
+  writeAt: (offset, bytes) =>
+    Effect.tryPromise({
+      try: async () => {
+        const position = safePosition(offset);
+        let written = 0;
+        while (written < bytes.byteLength) {
+          const result = await handle.write(
+            bytes,
+            written,
+            bytes.byteLength - written,
+            position + written,
+          );
+          if (result.bytesWritten === 0)
+            throw new Error("zero-byte positional write");
+          written += result.bytesWritten;
+        }
+      },
+      catch: (cause) =>
+        fail("wasm", "seekable output write failed", { path, cause }),
+    }),
+  resize: (length) =>
+    Effect.tryPromise({
+      try: () => handle.truncate(safePosition(length)),
+      catch: (cause) =>
+        fail("wasm", "seekable output resize failed", { path, cause }),
+    }),
+});
+
+const withFileSink = <A, E, R>(
+  path: string,
+  use: (
+    sink: RandomAccessByteSink<BenchmarkError, never>,
+  ) => Effect.Effect<A, E, R>,
+): Effect.Effect<A, BenchmarkError | E, R> =>
+  Effect.acquireUseRelease(
+    Effect.tryPromise({
+      try: () => open(path, "w+"),
+      catch: (cause) =>
+        fail("wasm", "could not open seekable output", { path, cause }),
+    }),
+    (handle) => use(makeFileSink(handle, path)),
+    (handle) => Effect.promise(() => handle.close()),
+  );
+
+const parseStreamInfo = (
+  path: string,
+): Effect.Effect<StreamInfo, BenchmarkError> =>
+  Effect.tryPromise({
+    try: async () => {
+      const handle = await open(path, "r");
+      let bytes: Uint8Array;
+      try {
+        bytes = await readExact(handle, 0, 42);
+      } finally {
+        await handle.close();
+      }
+      if (String.fromCharCode(...bytes.subarray(0, 4)) !== "fLaC") {
+        throw new Error("missing native FLAC marker");
+      }
+      const metadataHeader = bytes[4];
+      const metadataLength =
+        ((bytes[5] ?? 0) << 16) | ((bytes[6] ?? 0) << 8) | (bytes[7] ?? 0);
+      if (
+        metadataHeader === undefined ||
+        (metadataHeader & 0x7f) !== 0 ||
+        metadataLength !== 34
+      ) {
+        throw new Error("first metadata block is not 34-byte STREAMINFO");
+      }
+      const packed = bytes.subarray(18, 26);
+      let shape = 0n;
+      for (const byte of packed) shape = (shape << 8n) | BigInt(byte);
+      return {
+        minimumBlockSize: ((bytes[8] ?? 0) << 8) | (bytes[9] ?? 0),
+        maximumBlockSize: ((bytes[10] ?? 0) << 8) | (bytes[11] ?? 0),
+        minimumFrameSize:
+          ((bytes[12] ?? 0) << 16) | ((bytes[13] ?? 0) << 8) | (bytes[14] ?? 0),
+        maximumFrameSize:
+          ((bytes[15] ?? 0) << 16) | ((bytes[16] ?? 0) << 8) | (bytes[17] ?? 0),
+        sampleRate: Number((shape >> 44n) & 0xf_ffffn),
+        channels: Number((shape >> 41n) & 0x7n) + 1,
+        bitsPerSample: Number((shape >> 36n) & 0x1fn) + 1,
+        totalFrames: String(shape & 0xf_ffff_ffffn),
+        md5Hex: Buffer.from(bytes.subarray(26, 42)).toString("hex"),
+      };
+    },
+    catch: (cause) =>
+      fail("verify", "could not parse STREAMINFO", { path, cause }),
+  });
+
+const sha256File = (path: string): Effect.Effect<string, BenchmarkError> =>
+  Effect.tryPromise({
+    try: async () => {
+      const handle = await open(path, "r");
+      const digest = createHash("sha256");
+      let position = 0;
+      try {
+        const file = await handle.stat();
+        while (position < file.size) {
+          const length = Math.min(256 * 1_024, file.size - position);
+          digest.update(await readExact(handle, position, length));
+          position += length;
+        }
+      } finally {
+        await handle.close();
+      }
+      return digest.digest("hex");
+    },
+    catch: (cause) => fail("verify", "could not hash file", { path, cause }),
+  });
+
+const runNative = (
+  command: ReadonlyArray<string>,
+  phase: "native-encode" | "native-decode",
+): Effect.Effect<
+  { readonly stdout: Uint8Array; readonly stderr: string },
+  BenchmarkError
+> =>
+  Effect.tryPromise({
+    try: async (signal) => {
+      const child = Bun.spawn([...command], { stdout: "pipe", stderr: "pipe" });
+      const abort = () => child.kill();
+      signal.addEventListener("abort", abort, { once: true });
+      try {
+        const [stdout, stderr, exitCode] = await Promise.all([
+          new Response(child.stdout).bytes(),
+          new Response(child.stderr).text(),
+          child.exited,
+        ]);
+        if (exitCode !== 0) {
+          throw new Error(
+            `${basename(command[0] ?? "command")} exited ${exitCode}: ${stderr.slice(0, 4_096)}`,
+          );
+        }
+        return { stdout, stderr };
+      } finally {
+        signal.removeEventListener("abort", abort);
+      }
+    },
+    catch: (cause) =>
+      fail(phase, "native libFLAC command failed", {
+        ...(command[0] === undefined ? {} : { path: command[0] }),
+        cause,
+      }),
+  });
+
+const nativeEncode = (
+  nativeFlac: string,
+  chunk: CorpusChunk,
+  outputPath: string,
+): Effect.Effect<void, BenchmarkError> =>
+  runNative(
+    [
+      nativeFlac,
+      "--totally-silent",
+      "--force",
+      "-8",
+      "--no-exhaustive-model-search",
+      "--threads=1",
+      "--no-padding",
+      "--no-seektable",
+      "--force-raw-format",
+      "--endian=little",
+      "--sign=signed",
+      "--channels=2",
+      "--bps=24",
+      "--sample-rate=44100",
+      `--skip=${chunk.packedStartFrame}`,
+      `--until=+${chunk.frames}`,
+      `--output-name=${outputPath}`,
+      chunk.activeRawPath,
+    ],
+    "native-encode",
+  ).pipe(Effect.asVoid);
+
+const nativeDecodeDigest = (
+  nativeFlac: string,
+  inputPath: string,
+): Effect.Effect<
+  { readonly bytes: number; readonly sha256: string },
+  BenchmarkError
+> =>
+  Effect.tryPromise({
+    try: async (signal) => {
+      const child = Bun.spawn(
+        [
+          nativeFlac,
+          "--totally-silent",
+          "--decode",
+          "--stdout",
+          "--force-raw-format",
+          "--endian=little",
+          "--sign=signed",
+          inputPath,
+        ],
+        { stdout: "pipe", stderr: "pipe" },
+      );
+      const abort = () => child.kill();
+      signal.addEventListener("abort", abort, { once: true });
+      const digest = createHash("sha256");
+      let bytes = 0;
+      try {
+        const stderrPromise = new Response(child.stderr).text();
+        const reader = child.stdout.getReader();
+        try {
+          while (true) {
+            const next = await reader.read();
+            if (next.done) break;
+            bytes += next.value.byteLength;
+            digest.update(next.value);
+          }
+        } finally {
+          reader.releaseLock();
+        }
+        const [exitCode, stderr] = await Promise.all([
+          child.exited,
+          stderrPromise,
+        ]);
+        if (exitCode !== 0) {
+          throw new Error(
+            `flac decode exited ${exitCode}: ${stderr.slice(0, 4_096)}`,
+          );
+        }
+        return { bytes, sha256: digest.digest("hex") };
+      } finally {
+        signal.removeEventListener("abort", abort);
+      }
+    },
+    catch: (cause) =>
+      fail("native-decode", "native libFLAC decode failed", {
+        path: inputPath,
+        cause,
+      }),
+  });
+
+const validateOutput = Effect.fn("benchmark.validateOutput")(function* (
+  nativeFlac: string,
+  chunk: CorpusChunk,
+  input: InputDigest,
+  outputPath: string,
+): Effect.fn.Return<
+  {
+    readonly bytes: number;
+    readonly streamInfo: StreamInfo;
+    readonly nativeDecodedPcmSha256: string;
+  },
+  BenchmarkError
+> {
+  const [file, streamInfo, decoded] = yield* Effect.all(
+    [
+      Effect.tryPromise({
+        try: () => stat(outputPath),
+        catch: (cause) =>
+          fail("verify", "could not stat encoded FLAC", {
+            path: outputPath,
+            cause,
+          }),
+      }),
+      parseStreamInfo(outputPath),
+      nativeDecodeDigest(nativeFlac, outputPath),
+    ],
+    { concurrency: 2 },
+  );
+  if (
+    streamInfo.sampleRate !== 44_100 ||
+    streamInfo.channels !== 2 ||
+    streamInfo.bitsPerSample !== 24
+  ) {
+    return yield* fail(
+      "verify",
+      "STREAMINFO format does not match corpus PCM",
+      { path: outputPath },
+    );
+  }
+  if (streamInfo.totalFrames !== String(chunk.frames)) {
+    return yield* fail("verify", "STREAMINFO total frames do not match chunk", {
+      path: outputPath,
+    });
+  }
+  if (streamInfo.md5Hex !== input.md5) {
+    return yield* fail("verify", "STREAMINFO MD5 does not match source PCM", {
+      path: outputPath,
+    });
+  }
+  if (
+    decoded.bytes !== input.bytes ||
+    decoded.sha256 !== chunk.expectedPcmSha256
+  ) {
+    return yield* fail("verify", "native decode does not match source PCM", {
+      path: outputPath,
+    });
+  }
+  return {
+    bytes: file.size,
+    streamInfo,
+    nativeDecodedPcmSha256: decoded.sha256,
+  };
+});
+
+const measureWasm = Effect.fn("benchmark.measureWasm")(function* (
+  nativeFlac: string,
+  format: PcmFormat,
+  chunk: CorpusChunk,
+  input: InputDigest,
+  outputPath: string,
+  round: number,
+): Effect.fn.Return<
+  MeasurementRow,
+  | BenchmarkError
+  | import("../src/index.js").PcmInputError
+  | import("../src/index.js").FlacEncodeError,
+  FlacEncoder
+> {
+  const started = performance.now();
+  yield* withFileSink(outputPath, (sink) =>
+    encodeFlac(pcmSource(chunk), sink, {
+      format,
+      expectedFrames: BigInt(chunk.frames),
+    }),
+  );
+  const elapsedMilliseconds = performance.now() - started;
+  const verified = yield* validateOutput(nativeFlac, chunk, input, outputPath);
+  return {
+    implementation: "wasm",
+    round,
+    stemIdentity: chunk.stemIdentity,
+    chunkIndex: chunk.chunkIndex,
+    frames: chunk.frames,
+    expectedPcmSha256: chunk.expectedPcmSha256,
+    encodedBytes: verified.bytes,
+    elapsedMilliseconds,
+    streamInfo: verified.streamInfo,
+    nativeDecodedPcmSha256: verified.nativeDecodedPcmSha256,
+  };
+});
+
+const measureNative = Effect.fn("benchmark.measureNative")(function* (
+  nativeFlac: string,
+  chunk: CorpusChunk,
+  input: InputDigest,
+  outputPath: string,
+  round: number,
+): Effect.fn.Return<MeasurementRow, BenchmarkError> {
+  const started = performance.now();
+  yield* nativeEncode(nativeFlac, chunk, outputPath);
+  const elapsedMilliseconds = performance.now() - started;
+  const verified = yield* validateOutput(nativeFlac, chunk, input, outputPath);
+  return {
+    implementation: "native",
+    round,
+    stemIdentity: chunk.stemIdentity,
+    chunkIndex: chunk.chunkIndex,
+    frames: chunk.frames,
+    expectedPcmSha256: chunk.expectedPcmSha256,
+    encodedBytes: verified.bytes,
+    elapsedMilliseconds,
+    streamInfo: verified.streamInfo,
+    nativeDecodedPcmSha256: verified.nativeDecodedPcmSha256,
+  };
+});
+
+const program = Effect.gen(function* () {
+  const args = yield* Effect.try({
+    try: () => parseArguments(Bun.argv.slice(2)),
+    catch: (cause) =>
+      cause instanceof BenchmarkError
+        ? cause
+        : fail("arguments", "could not parse command line", { cause }),
+  });
+  const chunks = yield* discoverCorpus(args);
+  const format = yield* PcmFormat.makeEffect({
+    sampleRate: 44_100,
+    channels: 2,
+    bitsPerSample: 24,
+  }).pipe(
+    Effect.mapError((cause) =>
+      fail("corpus", "could not construct corpus PCM format", { cause }),
+    ),
+  );
+
+  const wasmPath = FLAC_ENCODER_WASM_URL.pathname;
+  const wasmBytes = yield* Effect.tryPromise({
+    try: async () => new Uint8Array(await readFile(FLAC_ENCODER_WASM_URL)),
+    catch: (cause) =>
+      fail("wasm", "could not read encoder Wasm", { path: wasmPath, cause }),
+  });
+  const wasmSha256 = createHash("sha256").update(wasmBytes).digest("hex");
+  const expectedEncoderWasmSha256: string = FLAC_ENCODER_WASM_SHA256;
+  if (
+    expectedEncoderWasmSha256 !== "pending" &&
+    wasmSha256 !== expectedEncoderWasmSha256
+  ) {
+    return yield* fail("wasm", "encoder Wasm hash differs from exported pin", {
+      path: wasmPath,
+    });
+  }
+  const decoderWasmPath = FLAC_DECODER_WASM_URL.pathname;
+  const decoderWasmBytes = yield* Effect.tryPromise({
+    try: async () => new Uint8Array(await readFile(FLAC_DECODER_WASM_URL)),
+    catch: (cause) =>
+      fail("wasm", "could not read decoder Wasm", {
+        path: decoderWasmPath,
+        cause,
+      }),
+  });
+  const decoderWasmSha256 = createHash("sha256")
+    .update(decoderWasmBytes)
+    .digest("hex");
+  const expectedDecoderWasmSha256: string = FLAC_DECODER_WASM_SHA256;
+  if (
+    expectedDecoderWasmSha256 !== "pending" &&
+    decoderWasmSha256 !== expectedDecoderWasmSha256
+  ) {
+    return yield* fail("wasm", "decoder Wasm hash differs from exported pin", {
+      path: decoderWasmPath,
+    });
+  }
+  const decoderCompileStarted = performance.now();
+  const decoder = yield* loadFlacDecoderFromBytes(decoderWasmBytes);
+  const decoderCompileMilliseconds = performance.now() - decoderCompileStarted;
+  const nativeVersionResult = yield* runNative(
+    [args.nativeFlac, "--version"],
+    "native-encode",
+  );
+  const nodeVersionResult = yield* runNative(
+    ["node", "--version"],
+    "native-encode",
+  );
+  const nativeSha256 = yield* sha256File(args.nativeFlac);
+  const sourceCatalogSha256 = yield* sha256File(args.sources);
+  const inputDigests = new Map<string, InputDigest>();
+  for (const chunk of chunks) {
+    const input = yield* hashPcmRange(chunk);
+    if (input.sha256 !== chunk.expectedPcmSha256) {
+      return yield* fail("input", "source PCM hash does not match manifest", {
+        path: chunk.activeRawPath,
+      });
+    }
+    inputDigests.set(`${chunk.stemIdentity}:${chunk.chunkIndex}`, input);
+  }
+  const decodeQualification: Array<DecodeQualificationRow> = [];
+  for (const chunk of chunks) {
+    decodeQualification.push(
+      yield* verifyPackageDecode(format, chunk).pipe(
+        Effect.provideService(FlacDecoder, decoder),
+      ),
+    );
+  }
+
+  const receipt = yield* Effect.acquireUseRelease(
+    Effect.tryPromise({
+      try: () => mkdtemp(join(tmpdir(), "misofm-codec-benchmark-")),
+      catch: (cause) =>
+        fail("receipt", "could not create benchmark workspace", { cause }),
+    }),
+    (workspace) =>
+      Effect.gen(function* () {
+        const firstChunk = chunks[0];
+        if (firstChunk === undefined)
+          return yield* fail("corpus", "corpus selection is empty");
+        const firstKey = `${firstChunk.stemIdentity}:${firstChunk.chunkIndex}`;
+        const firstInput = inputDigests.get(firstKey);
+        if (firstInput === undefined)
+          return yield* fail("input", `missing digest for ${firstKey}`);
+        const coldOutput = join(workspace, "cold-compile-first-chunk.flac");
+        const coldStarted = performance.now();
+        const encoder = yield* loadFlacEncoderFromBytes(wasmBytes);
+        const compiledAt = performance.now();
+        yield* withFileSink(coldOutput, (sink) =>
+          encodeFlac(pcmSource(firstChunk), sink, {
+            format,
+            expectedFrames: BigInt(firstChunk.frames),
+          }),
+        ).pipe(Effect.provideService(FlacEncoder, encoder));
+        const coldFinished = performance.now();
+        const coldVerified = yield* validateOutput(
+          args.nativeFlac,
+          firstChunk,
+          firstInput,
+          coldOutput,
+        );
+
+        const rows: Array<MeasurementRow> = [];
+        for (let round = 1; round <= args.rounds; round += 1) {
+          for (const chunk of chunks) {
+            const key = `${chunk.stemIdentity}:${chunk.chunkIndex}`;
+            const input = inputDigests.get(key);
+            if (input === undefined)
+              return yield* fail("input", `missing digest for ${key}`);
+            const stemId = chunk.stemIdentity.replace(/^sha256:/, "");
+            const wasmOutput = join(
+              workspace,
+              `${stemId}-${chunk.chunkIndex}-wasm.flac`,
+            );
+            const nativeOutput = join(
+              workspace,
+              `${stemId}-${chunk.chunkIndex}-native.flac`,
+            );
+            const wasmRow = yield* measureWasm(
+              args.nativeFlac,
+              format,
+              chunk,
+              input,
+              wasmOutput,
+              round,
+            ).pipe(Effect.provideService(FlacEncoder, encoder));
+            rows.push(wasmRow);
+            if (
+              args.keepWasm !== undefined &&
+              round === 1 &&
+              chunk === firstChunk
+            ) {
+              const keepWasm = args.keepWasm;
+              yield* Effect.tryPromise({
+                try: async () => {
+                  await mkdir(dirname(keepWasm), { recursive: true });
+                  await copyFile(wasmOutput, keepWasm);
+                },
+                catch: (cause) =>
+                  fail("receipt", "could not retain first Wasm FLAC", {
+                    path: keepWasm,
+                    cause,
+                  }),
+              });
+            }
+            rows.push(
+              yield* measureNative(
+                args.nativeFlac,
+                chunk,
+                input,
+                nativeOutput,
+                round,
+              ),
+            );
+          }
+        }
+
+        const totals = Array.from(
+          { length: args.rounds },
+          (_, index) => index + 1,
+        ).flatMap((round) =>
+          (["wasm", "native"] as const).map((implementation) => {
+            const selected = rows.filter(
+              (row) =>
+                row.round === round && row.implementation === implementation,
+            );
+            return {
+              round,
+              implementation,
+              chunks: selected.length,
+              encodedBytes: selected.reduce(
+                (total, row) => total + row.encodedBytes,
+                0,
+              ),
+              elapsedMilliseconds: selected.reduce(
+                (total, row) => total + row.elapsedMilliseconds,
+                0,
+              ),
+            };
+          }),
+        );
+        const wasmTotals = totals.filter(
+          (total) => total.implementation === "wasm",
+        );
+        const nativeTotals = totals.filter(
+          (total) => total.implementation === "native",
+        );
+        const wasmPayloadBytes = wasmTotals[0]?.encodedBytes;
+        const nativePayloadBytes = nativeTotals[0]?.encodedBytes;
+        if (
+          wasmPayloadBytes === undefined ||
+          nativePayloadBytes === undefined ||
+          wasmTotals.some((total) => total.encodedBytes !== wasmPayloadBytes) ||
+          nativeTotals.some(
+            (total) => total.encodedBytes !== nativePayloadBytes,
+          )
+        ) {
+          return yield* fail(
+            "verify",
+            "encoded payload totals changed between serial rounds",
+          );
+        }
+        const wasmMedianMilliseconds = median(
+          wasmTotals.map((total) => total.elapsedMilliseconds),
+        );
+        const nativeMedianMilliseconds = median(
+          nativeTotals.map((total) => total.elapsedMilliseconds),
+        );
+        const payloadDeltaBytes = wasmPayloadBytes - nativePayloadBytes;
+
+        return {
+          format: "misofm-codec-corpus-benchmark-v1",
+          complete: args.limit === undefined && args.rounds === 3,
+          createdAt: new Date().toISOString(),
+          configuration: {
+            rounds: args.rounds,
+            limit: args.limit ?? null,
+            retainedFirstWasmOutput: args.keepWasm ?? null,
+            level: 8,
+            exhaustiveModelSearch: false,
+            padding: false,
+            seekTable: false,
+            verificationInsideTimedIntervals: false,
+            pcm24ToInt32ConversionInsideWasmIntervals: true,
+            outputWritesInsideTimedIntervals: true,
+            nativeProcessStartupInsideTimedIntervals: true,
+            wasmPcmFramesPerRead: PCM_FRAMES_PER_READ,
+            corpusStemCount: EXPECTED_STEMS,
+            corpusChunkCount: EXPECTED_CHUNKS,
+          },
+          baseline: {
+            flacPayloadBytes: EXPECTED_BASELINE_PAYLOAD_BYTES,
+            manifestBytes: EXPECTED_BASELINE_MANIFEST_BYTES,
+            containerBytes: EXPECTED_BASELINE_CONTAINER_BYTES,
+            deliveryBytes:
+              EXPECTED_BASELINE_PAYLOAD_BYTES +
+              EXPECTED_BASELINE_MANIFEST_BYTES +
+              EXPECTED_BASELINE_CONTAINER_BYTES,
+          },
+          host: {
+            bunRuntimeVersion: Bun.version,
+            nodeRuntimeVersion: new TextDecoder()
+              .decode(nodeVersionResult.stdout)
+              .trim(),
+            bunNodeCompatibilityVersion: process.version,
+            os: `${platform()} ${release()}`,
+            cpu: cpus()[0]?.model ?? "unknown",
+          },
+          provenance: {
+            corpusRoot: args.corpus,
+            sourcesCatalog: args.sources,
+            sourcesCatalogSha256: sourceCatalogSha256,
+            nativeFlac: args.nativeFlac,
+            nativeFlacSha256: nativeSha256,
+            nativeFlacVersion: new TextDecoder()
+              .decode(nativeVersionResult.stdout)
+              .trim(),
+            encoderWasmUrl: FLAC_ENCODER_WASM_URL.href,
+            encoderWasmSha256: wasmSha256,
+            decoderWasmUrl: FLAC_DECODER_WASM_URL.href,
+            decoderWasmSha256,
+          },
+          decoderCompileMilliseconds,
+          decodeQualification,
+          cold: {
+            stemIdentity: firstChunk.stemIdentity,
+            chunkIndex: firstChunk.chunkIndex,
+            frames: firstChunk.frames,
+            compileMilliseconds: compiledAt - coldStarted,
+            compileInstantiateEncodeMilliseconds: coldFinished - coldStarted,
+            encodedBytes: coldVerified.bytes,
+            nativeDecodedPcmSha256: coldVerified.nativeDecodedPcmSha256,
+          },
+          summary: {
+            selectedChunks: chunks.length,
+            selectedFrames: chunks.reduce(
+              (total, chunk) => total + chunk.frames,
+              0,
+            ),
+            decoderQualifiedChunks: decodeQualification.length,
+            decoderPcmBytes: decodeQualification.reduce(
+              (total, row) => total + row.pcmBytes,
+              0,
+            ),
+            decoderPcmBlocks: decodeQualification.reduce(
+              (total, row) => total + row.pcmBlocks,
+              0,
+            ),
+            decoderMaximumPcmBlockBytes: decodeQualification.reduce(
+              (maximum, row) => Math.max(maximum, row.maximumPcmBlockBytes),
+              0,
+            ),
+            wasmPayloadBytes,
+            nativePayloadBytes,
+            payloadDeltaBytes,
+            payloadDeltaPercent:
+              nativePayloadBytes === 0
+                ? 0
+                : (payloadDeltaBytes / nativePayloadBytes) * 100,
+            wasmMedianMilliseconds,
+            nativeMedianMilliseconds,
+            wasmToNativeMedianTimeRatio:
+              nativeMedianMilliseconds === 0
+                ? null
+                : wasmMedianMilliseconds / nativeMedianMilliseconds,
+          },
+          totals,
+          rows,
+        };
+      }),
+    (workspace) =>
+      Effect.tryPromise({
+        try: () => rm(workspace, { recursive: true, force: true }),
+        catch: (cause) =>
+          fail("receipt", "could not remove benchmark workspace", {
+            path: workspace,
+            cause,
+          }),
+      }),
+  );
+
+  yield* Effect.tryPromise({
+    try: async () => {
+      await mkdir(dirname(args.receipt), { recursive: true });
+      await writeFile(args.receipt, `${JSON.stringify(receipt, null, 2)}\n`, {
+        flag: "wx",
+      });
+    },
+    catch: (cause) =>
+      fail("receipt", "could not write new receipt", {
+        path: args.receipt,
+        cause,
+      }),
+  });
+  yield* Effect.logInfo("codec corpus benchmark complete", {
+    receipt: args.receipt,
+    chunks: chunks.length,
+    rounds: args.rounds,
+  });
+});
+
+await Effect.runPromise(program);
diff --git a/benchmark/evidence/corpus-benchmark.json b/benchmark/evidence/corpus-benchmark.json
new file mode 100644
index 0000000..5f7088c
--- /dev/null
+++ b/benchmark/evidence/corpus-benchmark.json
@@ -0,0 +1,19991 @@
+{
+  "format": "misofm-codec-corpus-benchmark-v1",
+  "complete": true,
+  "createdAt": "2026-09-13T04:19:33.907Z",
+  "configuration": {
+    "rounds": 3,
+    "limit": null,
+    "retainedFirstWasmOutput": null,
+    "level": 8,
+    "exhaustiveModelSearch": false,
+    "padding": false,
+    "seekTable": false,
+    "verificationInsideTimedIntervals": false,
+    "pcm24ToInt32ConversionInsideWasmIntervals": true,
+    "outputWritesInsideTimedIntervals": true,
+    "nativeProcessStartupInsideTimedIntervals": true,
+    "wasmPcmFramesPerRead": 4096,
+    "corpusStemCount": 30,
+    "corpusChunkCount": 137
+  },
+  "baseline": {
+    "flacPayloadBytes": 425690361,
+    "manifestBytes": 78215,
+    "containerBytes": 480,
+    "deliveryBytes": 425769056
+  },
+  "host": {
+    "bunRuntimeVersion": "1.4.2",
+    "nodeRuntimeVersion": "v22.23.2",
+    "bunNodeCompatibilityVersion": "v26.3.0",
+    "os": "linux 6.8.0-139-generic",
+    "cpu": "AMD EPYC 7313P 16-Core Processor"
+  },
+  "provenance": {
+    "corpusRoot": "/data/issue-77-lossless/run-02",
+    "sourcesCatalog": "/home/bl/misofm/engine-web-adapter/research/077-lossless-delivery/sources.json",
+    "sourcesCatalogSha256": "2ab3f51138c6d537f3ba312cbac5001556e0d930c649a7ddee95fb223d472085",
+    "nativeFlac": "/data/issue-77-lossless/tooling/flac-build/src/flac/flac",
+    "nativeFlacSha256": "0dc864415c16c4ea729f6c3ce6487f89d85b231cf3f4a8dd66813c10fa2f6b74",
+    "nativeFlacVersion": "flac 1.5.0",
+    "encoderWasmUrl": "file:///home/bl/misofm/codec/wasm/flac-encoder.wasm",
+    "encoderWasmSha256": "90da75c73784e7184ea6c27d3ea9509f74df2eda405d8ddc8f964d78a16a273e",
+    "decoderWasmUrl": "file:///home/bl/misofm/codec/wasm/flac-decoder.wasm",
+    "decoderWasmSha256": "5e282f9874ecb3f49b8ee8437efc318ec14ef5cff5b7580da9d875f94e5c5925"
+  },
+  "decoderCompileMilliseconds": 4.027464999999992,
+  "decodeQualification": [
+    {
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 0,
+      "encodedBytes": 4150349,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "0ad333131602d2eed204c673014271b346328956a17a459cda005d12aff26324",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 1,
+      "encodedBytes": 4371137,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "498bd8b6bfeb1e240e24b0c0f948f26e59259d319adf0e61f5cd7e5ec79d10e8",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 2,
+      "encodedBytes": 2982490,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "a9b0a5e36c48ce2ecd758f22ba512342b8d6378c86d8a0c95c8b5fb01d86ae7f",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 3,
+      "encodedBytes": 4539490,
+      "frames": 1162869,
+      "pcmBytes": 6977214,
+      "pcmBlocks": 284,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "ad88aea64fa81f9247059b6e75ccbeadd4b350cae9a83d7940f4594e87dd7936",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 0,
+      "encodedBytes": 3396577,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "b4d086eb6ea6fb003acaa30cbf00317bb1567dee9c03521701ad60f404f7a2c7",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 1,
+      "encodedBytes": 5287163,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "72e151c5c4f167900d89a7096ea63dcabeb846c160caaeaec4d0711ddbb9ae76",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 2,
+      "encodedBytes": 3847607,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "4b8d2779ff5af472ae8159a9429aba0befe0eca99cd4b4f29432f8dd33af6c1f",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 3,
+      "encodedBytes": 3190350,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "874cb197ccd1ef18c42c4de586b947796463dfaa211978c5ecf747683f20b367",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 4,
+      "encodedBytes": 5481625,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "f6ccbd0a0a535ebc8f2b53ae0adeb7fc4796648646edb2caae934f889f6e1bb4",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 5,
+      "encodedBytes": 2580489,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "ef9d092ac5241f9d7479dd6098355cf95724cc229b90286b20b48318cd2266f6",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 6,
+      "encodedBytes": 1094519,
+      "frames": 561092,
+      "pcmBytes": 3366552,
+      "pcmBlocks": 137,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "68599d04661ee4e25c2f965d2c5197f84eae66e6b5cd3e52a915d70c44567cbc",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:1d0544c63bf19bcc8d8b663d73fb9b206f9d107d52f7729ead8fce52aaa9be71",
+      "chunkIndex": 0,
+      "encodedBytes": 4802021,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "3e07a582bb431c6106a0eeea238aeddfd33ab51272f2f4ec19f24461230d6879",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:1d0544c63bf19bcc8d8b663d73fb9b206f9d107d52f7729ead8fce52aaa9be71",
+      "chunkIndex": 1,
+      "encodedBytes": 3270968,
+      "frames": 1179460,
+      "pcmBytes": 7076760,
+      "pcmBlocks": 288,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "b1fed292edbe942de39423402a36ee74165dc92c74d4630e85d8aec07e26f6e2",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 0,
+      "encodedBytes": 4187419,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "a19561147112095642424463ea315305b085a03c9c82becb7ac38c3e923c2407",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 1,
+      "encodedBytes": 3050969,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "55a9246cc0cfbf1ea647cad6f98d37f9d9351d2743ea6d09e87afeeeaafd94e3",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 2,
+      "encodedBytes": 4662993,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "52e84d5ab6f4d8e41262b82fae7a1fc2e774f9d29b10e5e9e7b64592799e27dd",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 3,
+      "encodedBytes": 2161240,
+      "frames": 630874,
+      "pcmBytes": 3785244,
+      "pcmBlocks": 155,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "d2903e6abfcf42e70792f30af34c900d64ad340d77ef31a775287c68d17596b9",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 0,
+      "encodedBytes": 2867123,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "9cd318a12c7c8fa38f058ab7c8e032b363c431af852557febfc61a2a18c34970",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 1,
+      "encodedBytes": 4455811,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "0016abd2094e03efc2cb2bf4301934db1c55b68a034ca7a977e1eb4b6bf71799",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 2,
+      "encodedBytes": 4664160,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "fb92413909c791e44c9aaffed2aa7dd0025bb3af28e6bc54da191243aa2c31da",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 3,
+      "encodedBytes": 4600172,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "0c53b70e20dad8a58b0ccd63fae413169addf85c2ff23899acb8cfcf9d112f7b",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 4,
+      "encodedBytes": 2886170,
+      "frames": 915923,
+      "pcmBytes": 5495538,
+      "pcmBlocks": 224,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "ee9d65603f1b22585957d02a4c56be87be47cf6354808438964a3a1c031cfd9f",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 0,
+      "encodedBytes": 2556311,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "74c0df9dcd402798188e653381e0166de4eb0e9e0e5e7d28de95dc2d7921efc9",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 1,
+      "encodedBytes": 1499027,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "8f9568ecd4f1890cdd81cb5173c40112d98c1a4d61fd36314e4bb2030124cb2a",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 2,
+      "encodedBytes": 2203168,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "0d76eb91be0008835d5774ac3b2738db6e392d32e4fc767d77a25394f82ba7e4",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 3,
+      "encodedBytes": 4652717,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "95c4368b4a153a4b38ea1d8f4b4fe10db945dad45351d3a74e5fe38fdc4273fa",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 4,
+      "encodedBytes": 465680,
+      "frames": 207800,
+      "pcmBytes": 1246800,
+      "pcmBlocks": 51,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "7e432c880c57ed605b55cf95c74625b569353b7df4dc398f731e0b81c40e71ef",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:2dd061241fa7fe3128289427e108ee63501f4ed77c7208f1b37ff49fa6ccff0b",
+      "chunkIndex": 0,
+      "encodedBytes": 2892311,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "ed128680f0adb80432e3cce5156094cb93edefa0d6339dcfa20ee11a3610a693",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:2dd061241fa7fe3128289427e108ee63501f4ed77c7208f1b37ff49fa6ccff0b",
+      "chunkIndex": 1,
+      "encodedBytes": 2726860,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "ea144cffa39519276d7320c735e04874b41c1a26d160703000ab7b0cec8400a8",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:2dd061241fa7fe3128289427e108ee63501f4ed77c7208f1b37ff49fa6ccff0b",
+      "chunkIndex": 2,
+      "encodedBytes": 2587993,
+      "frames": 932160,
+      "pcmBytes": 5592960,
+      "pcmBlocks": 228,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "2fe58c8e997921bfcf38f90cc60e75cdd4693167a6879bb9ce3cd82222f04484",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 0,
+      "encodedBytes": 1374937,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "624eb9b34a886ec6358d888dd40dedbc626eaf8120f5857a4a4a66564d718228",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 1,
+      "encodedBytes": 813885,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "3cc0f29b0fc5ae8aa860430556697b4b2301a5537ab6f417baf667f498c21399",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 2,
+      "encodedBytes": 701130,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "77a7ec33fa71caea53ad8f039c991b547b56dca2f267013b9a91fa1093c6b5f6",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 3,
+      "encodedBytes": 876850,
+      "frames": 1057881,
+      "pcmBytes": 6347286,
+      "pcmBlocks": 259,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "e1c58aca6a4e6b13d373151f083a94be66336f1ea664eb691eb1aaeb3cf234db",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 0,
+      "encodedBytes": 1943384,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "d65ddf96ef3551fdd5c08ca4a51b90f1c46ecb35544714d470119b2ba0c5cd63",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 1,
+      "encodedBytes": 2803492,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "ef94fcfe71b9f59da74d552ee67fd658841d8f4547eca40ef2a928d3431ecbbc",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 2,
+      "encodedBytes": 3690485,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "836755243b06af4a9fa6dd26a38b6ecb486feddb013575b58f4ed55858794bbf",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 3,
+      "encodedBytes": 3831623,
+      "frames": 1047609,
+      "pcmBytes": 6285654,
+      "pcmBlocks": 256,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "ad00f29b53ad6c3fbfa12672cb17168270becc5fb01419ef9ed530476756d725",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:43413b8b197ba8a6be8b706e5173fb5246f4c60c414557dc552d9c65239f9340",
+      "chunkIndex": 0,
+      "encodedBytes": 4695125,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "fda5317be1243b68e09d100738aae8d0d0b835e4b9c42222ceb8637f206fbd23",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:43413b8b197ba8a6be8b706e5173fb5246f4c60c414557dc552d9c65239f9340",
+      "chunkIndex": 1,
+      "encodedBytes": 1733385,
+      "frames": 514531,
+      "pcmBytes": 3087186,
+      "pcmBlocks": 126,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "f12619a013d45d71b3261cc8eaa4bd5777f329942b6c0c49cbe8ca2a5fbc9878",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 0,
+      "encodedBytes": 2818457,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "1ac0d21a2979389605675c51b1da394d304bb096ed5b6f68ef8ffe0c41573dfa",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 1,
+      "encodedBytes": 3471032,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "3514cf02ee43289d552a33de6fc20dc9df401dec16291793e830998f6c9e24cb",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 2,
+      "encodedBytes": 4148907,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "37b45f881e3898b1d03385bc0f9d130454c43830970bdb853803acccc5ae742e",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 3,
+      "encodedBytes": 3908126,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "3d18c069e8d2ab8caddba535d0c8e83e593f350ad8a43728b357745f7b510f18",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 4,
+      "encodedBytes": 4140983,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "361efaa716a4c5a8e7cd18811f99fc1da378df26a01639a0c96da726a2fdc27c",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 5,
+      "encodedBytes": 2579361,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "dd0019f65cb14a6c5f4712f7b96750b71598a71f70c70cd0fbdb110b94954bc3",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 6,
+      "encodedBytes": 1094710,
+      "frames": 561092,
+      "pcmBytes": 3366552,
+      "pcmBlocks": 137,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "e4a0b2b5384e5289ceff5b3ad42ccff678ab6a5d77c96e07a78147a5ed3770a2",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 0,
+      "encodedBytes": 4309544,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "36c35e82c4c4668b94b037bd2e468dbe0abda7fa866332743117f68f21952c22",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 1,
+      "encodedBytes": 4041083,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "9302ab132a16c115924a43d8f99697f902716f84953826be93722c923fcf2a2f",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 2,
+      "encodedBytes": 3563202,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "ead9d5ed0901c2d7a3d05525b352da2320551902855748160e84adaceda9b141",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 3,
+      "encodedBytes": 5437466,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "877ac4eb84976e6047201d0e4e19c27bfa9ea2b04c3564bfffad2eb97105d9b8",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 4,
+      "encodedBytes": 5382399,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "414909b9b21f0017c65c62b309a685ccbd4dcb7c896c25fa86f5e6814426f3a9",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 5,
+      "encodedBytes": 2606507,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "a9aaae89159b3bc3a8ae7b343cee86ceccad6e9156bd051a7907244333351b1f",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 6,
+      "encodedBytes": 1093892,
+      "frames": 561092,
+      "pcmBytes": 3366552,
+      "pcmBlocks": 137,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "1f54adca35b28601e714e675e5f666f57dfc0735aeb743bc06977b8da0a786e1",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 0,
+      "encodedBytes": 2211379,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "65c8f28f921e06d2876ffa35765fefdeaefdfdbef66cdec9b4fda6c837106fc0",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 1,
+      "encodedBytes": 2322749,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "42b9fdbea63544f90e683df82058eca4c5dca23bc3539047be92cf12a7c6d136",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 2,
+      "encodedBytes": 4591315,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "fb3896dd6372aa0b8a3f68df45483ea73b28a18712fffcdf18897ee0a3205b8c",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 3,
+      "encodedBytes": 2390904,
+      "frames": 1046796,
+      "pcmBytes": 6280776,
+      "pcmBlocks": 256,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "712b3b3d76c5042a314846332371f806367b0f8fe2d9f5a0f26f7e234719402f",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:76f8d36d4b2b6ed2efc19418250feaac1fe1868fd919c4c03a6e6f66e3e3f926",
+      "chunkIndex": 0,
+      "encodedBytes": 4937137,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "23c396618176630bd3af2e08a196598454feb5cc088b2f3430eb99dc7b631228",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:76f8d36d4b2b6ed2efc19418250feaac1fe1868fd919c4c03a6e6f66e3e3f926",
+      "chunkIndex": 1,
+      "encodedBytes": 2125904,
+      "frames": 582102,
+      "pcmBytes": 3492612,
+      "pcmBlocks": 143,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "b6f8c245441b191497cbe43678526f07a8c3d3cc12db92b88017a783d6aed512",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:820926ccc8557b4cdf81d0c19933f1115dc371d5b53e46ddedb2a87bf4e4e197",
+      "chunkIndex": 0,
+      "encodedBytes": 3873792,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "024d2eb37862cb6bf6db15b26958f67a4652050a28172bcba4679dd104adab6f",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:820926ccc8557b4cdf81d0c19933f1115dc371d5b53e46ddedb2a87bf4e4e197",
+      "chunkIndex": 1,
+      "encodedBytes": 3785565,
+      "frames": 1201590,
+      "pcmBytes": 7209540,
+      "pcmBlocks": 294,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "125a5e3e22686866f06b6135bc7113921c4b1c3be48bd955ac301d573abf4483",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 0,
+      "encodedBytes": 4192669,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "a0bf84dc4c81916ccd105c692da94fff0a59d39a8154eb6c266a278fb3bd2762",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 1,
+      "encodedBytes": 4848686,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "0bca03d3827a10f809d4f15d1bb053e182507deaeec754edb0e9aed2f795d58f",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 2,
+      "encodedBytes": 4526232,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "a4ff8fea4e0de7fa60fdae51ad711cd91f037cb46d5a9349bf1dca02acbbc5f5",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 3,
+      "encodedBytes": 4906478,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "8f216c2fb91fd3ca55f340129e429be43b6026756b830491ef476ced4bce86ab",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 4,
+      "encodedBytes": 4753431,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "2206e4ac690835dbfca27792f1a86ace07f1ba2690e226e56f6e741e07e8f2e8",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 5,
+      "encodedBytes": 3562872,
+      "frames": 1102500,
+      "pcmBytes": 6615000,
+      "pcmBlocks": 270,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "94d4191d8b99b19a6302a3ea00e8676f4391837f5f323c6eda44ce43119af8ce",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 0,
+      "encodedBytes": 2577349,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "a55e83e9d57a7e0b8a02c1589c368946d107e6fe45bf27732ce74cbf2cf1de14",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 1,
+      "encodedBytes": 3617407,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "2174a88c16a1582e995c5069a5f2887dbfd8b93a7cbd2b3c773cca9811be4835",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 2,
+      "encodedBytes": 3991391,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "9918d016f7c301fc23b8db32bc93184a134378824b8cdb7b3d76348b5d739dcc",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 3,
+      "encodedBytes": 3034301,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "1ecf66d2439e4d20cbe4ff066e34944b60652831ec88cb6a3ddd8fbae4be5832",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 4,
+      "encodedBytes": 4949256,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "00aae3147503f28168368f37d8f2fb603194a4fa8efa2b675b75792282976d98",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 5,
+      "encodedBytes": 2613579,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "92612943d9be9bb9339bf5ab99071d5b42a606add5b2d8d0316702c0cfddb6da",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 6,
+      "encodedBytes": 1108585,
+      "frames": 561092,
+      "pcmBytes": 3366552,
+      "pcmBlocks": 137,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "c28846b24eb143541dfa6661d24ec39cf492210d147cc6af216f98a6d7184e12",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 0,
+      "encodedBytes": 2367250,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "d8821208237f3f366dc6126255ccaeee18763a71346ac327e7e8eb0a254f1ab2",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 1,
+      "encodedBytes": 2658137,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "099b094dc0a74b685de3e0642a5fd801b328cadb5e794248d39e7c9f73161362",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 2,
+      "encodedBytes": 3781317,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "947a4950af1a258c381417d8510da94dd114723b65611f3ae8de07587b0f4726",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 3,
+      "encodedBytes": 2509207,
+      "frames": 916741,
+      "pcmBytes": 5500446,
+      "pcmBlocks": 224,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "1704ebcf5b3c81b703e1ecda346ebfc12a84421a0a83ccb9a75b7a53ddabc86c",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 0,
+      "encodedBytes": 2598964,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "997fc12d1dbcbbf349b26a411d00fed8af4c3132fba56a850d91927b6afd7a19",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 1,
+      "encodedBytes": 2091921,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "bc594e7e42791865271b0235bb7aad216405822db4e107e5bf1e4f46e3666ff4",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 2,
+      "encodedBytes": 2873661,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "a03e75db825cb2754ee597c2a1c4c61e295a9eae5c27932ab847b390f47a5601",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 3,
+      "encodedBytes": 1045514,
+      "frames": 528117,
+      "pcmBytes": 3168702,
+      "pcmBlocks": 129,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "b667bd900e6d2a78c980afce335361280d75a02d45b93afaf53f1b9a6a37df37",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 0,
+      "encodedBytes": 2288163,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "d6dd68e175e45d08fa7fb81c835c58c9fe7da612c54be548767f948ba83d149c",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 1,
+      "encodedBytes": 2522167,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "a013f58057e3192997704773f30e0f9b43251052648c2709523a784dde83d15a",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 2,
+      "encodedBytes": 3396209,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "3b6cd32604fb1bb615b4eefbf0566819bb0fa41f6cec25ccda38473b3b27fe6c",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 3,
+      "encodedBytes": 149411,
+      "frames": 97514,
+      "pcmBytes": 585084,
+      "pcmBlocks": 24,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "8e60ccdf9088a1c5f09ef9dc7ac302dbb9bf22936642e24011f92c0137a7088b",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:b613c11eea1c43c0a0fed317bea191d09146b818c4fe8e7a781cec1061b781f1",
+      "chunkIndex": 0,
+      "encodedBytes": 3711107,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "20e6f57d0c7a4d86fe1d9b41a4589e043a45f28172189bde30d153a30b893295",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:b613c11eea1c43c0a0fed317bea191d09146b818c4fe8e7a781cec1061b781f1",
+      "chunkIndex": 1,
+      "encodedBytes": 509176,
+      "frames": 206195,
+      "pcmBytes": 1237170,
+      "pcmBlocks": 51,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "33d319edbc97be7960054e657ead189865b1441d4771acc21abf99e792d03517",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 0,
+      "encodedBytes": 837717,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "bf0875df024093a82fb77c21c3be693044f912a4f2e659efadfeba298c725d8c",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 1,
+      "encodedBytes": 1898820,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "73a9d535d1674e035dd0f426e0409ac40ee779244220f4c4ea0b274df403038a",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 2,
+      "encodedBytes": 979348,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "4abd9d2c9ef25b837cdda5a8d4b93da148e1877cd3db7b18657b07b75c0df88b",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 3,
+      "encodedBytes": 135582,
+      "frames": 240708,
+      "pcmBytes": 1444248,
+      "pcmBlocks": 59,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "2c0376459f084817fbe05021a99473a51ffac58d3b89f6249a9e608361c24153",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 0,
+      "encodedBytes": 3500055,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "acb2a0065558fa0e65f94f9cbd917cb884ff12da69ef71238056ec3498f89484",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 1,
+      "encodedBytes": 5094024,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "c08dc080013b95d43386834bec404adfadfe00d148e5d8b09aa7133579d651fb",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 2,
+      "encodedBytes": 4681716,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "39151af29546d5b05e982e1c5a5f313b3105eff8a80d9a9cc5f1ebf195a8c389",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 3,
+      "encodedBytes": 5095990,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "649b462aa016a111211498488ffca8da24e16f1a9b594f58bf38fb03933bb4f5",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 4,
+      "encodedBytes": 3704141,
+      "frames": 913965,
+      "pcmBytes": 5483790,
+      "pcmBlocks": 224,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "cc11220dae84517c06488c4397c4f54629614cfb4b1bf99262af541086f86a8b",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 0,
+      "encodedBytes": 3847857,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "4ef0e5b27bc3175da2611e8d22d8352ff615550fd0c8798ef04071383a43a7ca",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 1,
+      "encodedBytes": 3970104,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "587dd69e42fa09749cd48eedf40a783fa77b08725df7cfd075a64584ebb17dbb",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 2,
+      "encodedBytes": 4303218,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "303270e98d22c7b40606f19da04a268425ffac83d8791fda0c1179014baa86c8",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 3,
+      "encodedBytes": 4322990,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "77801ccb085effccbfae0aa9aa1afd856abc76f9c332a1cd0bf949775ca33d4c",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 4,
+      "encodedBytes": 3348207,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "09e611be443a7e3e11fbdce77a600971254eac99a84ceb56e22687ffc6b181ee",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 5,
+      "encodedBytes": 1533304,
+      "frames": 787999,
+      "pcmBytes": 4727994,
+      "pcmBlocks": 193,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "df5cc90e42602310ecdc1aa55a4daf101fc4601d9583db1f84b12c121b25217b",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 0,
+      "encodedBytes": 1077045,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "e4ce6eccdfae581a69ad7d053af770d4dbcd06c793413b03a4ed3fafdd9cc780",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 1,
+      "encodedBytes": 2026471,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "f17804e177224c0871b40263007f2f9197cabb5587de4b02835ae91cbf268f35",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 2,
+      "encodedBytes": 2709350,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "7d0ff510517cdf903b7d82524b87531c1fa8fb4caab35f49c40715da28eb7fed",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 3,
+      "encodedBytes": 3124526,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "d030e1b082aca6c48acb78cef0f175a2385cca984a05c4056ed8b06d7cf33e25",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 4,
+      "encodedBytes": 2993794,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "af48460f9080df1be76b9ff6f454b28edb83901dccf8f3fdc1c76aa34d19269a",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 5,
+      "encodedBytes": 261549,
+      "frames": 129916,
+      "pcmBytes": 779496,
+      "pcmBlocks": 32,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "0dd7eda91b2ac9d352e47627d1a7b2839dc09516301a9dd6c2bb6173902a186b",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:dbb6eda6ecc56c418428f6b41d0b4872948d5be58e6089ecacb538b188dd7a74",
+      "chunkIndex": 0,
+      "encodedBytes": 5150623,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "2e94af2296c79e0acd1352987dad1c0105dcaab2fa5ec62a110a8f3f44a04e24",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:dbb6eda6ecc56c418428f6b41d0b4872948d5be58e6089ecacb538b188dd7a74",
+      "chunkIndex": 1,
+      "encodedBytes": 1981954,
+      "frames": 659918,
+      "pcmBytes": 3959508,
+      "pcmBlocks": 162,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "ba7987b2aeec2b9383b890edb42d2615c9e33220a8a9473f83e5eabd3f81681f",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 0,
+      "encodedBytes": 1873831,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "4930de75afb2d6609f801fa1a01c6015b397e3936b098e014e5960411a62bb8c",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 1,
+      "encodedBytes": 2060264,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "70ea23b1a824512f353489e240fd927f4bd0f8118269c48ac88cf4163f01d227",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 2,
+      "encodedBytes": 1688615,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "bf440567e988c71551be148276316309a1257b2f11b2d1a4bcaea301f1055446",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 3,
+      "encodedBytes": 1687882,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "097716d93dcac0324bbb6e2110b67088938dff5e489c5e6b06d45918b07e8dcf",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 4,
+      "encodedBytes": 1168887,
+      "frames": 915923,
+      "pcmBytes": 5495538,
+      "pcmBlocks": 224,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "af8937f992feb00ab5bb6c0d5a28f80ad75d34e9a9a53439183830e458d8faab",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 0,
+      "encodedBytes": 3007108,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "c153cdd02ee613aa4d856af7b7499256d9a797b85d7f1bf72697b8ebe699572b",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 1,
+      "encodedBytes": 3132254,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "1968944d10881b63a6477b9621071f7f8a56e969b4c0730c2da2b6e27aac62db",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 2,
+      "encodedBytes": 3096300,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "1213ccf392162807582019bde04d3ad714481247b76d1d5f8009a5fc0eb3e069",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 3,
+      "encodedBytes": 2799236,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "dfe83b8d2c67fefec02a01eef4018f786a03ca52e14aff50e9e395301b4fdbbb",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 4,
+      "encodedBytes": 3407792,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "0f55c1534bb29b9fb8258c13985e13aa3d25fd02a6afe6128aaca72caa8cf731",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 5,
+      "encodedBytes": 2657514,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "026e9d73a7ff3851959956aaa58f413a73aae7116da4d14652682b7f14d7c382",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 6,
+      "encodedBytes": 1127015,
+      "frames": 561092,
+      "pcmBytes": 3366552,
+      "pcmBlocks": 137,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "7669dc7fe143e844e6d85fcaf155e41c6b66faada5383275c8f038938422eedf",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 0,
+      "encodedBytes": 4714618,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "907c161b6a6b3fc6be1ac83b0514aa8fbe4b72804d7ff1b2912429cf86c4fa12",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 1,
+      "encodedBytes": 4655199,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "23668afc815608ca7873919d5db8586258717824df6dba0ac7ba65cd56cde2f9",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 2,
+      "encodedBytes": 4262535,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "146a29ebce44459aa8a15c198999ee449e8c6b04c2a8931ac5e9ad86c3920157",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 3,
+      "encodedBytes": 5170291,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "c7fdfc4d8c871b684f0d5a3b0208f2f4d51b66450257b74b6b064b74c789c903",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 4,
+      "encodedBytes": 4202884,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "6f35e69c56cae81692bae02df2074b5aa0d1afc8ca25bdcac9d6c4b3e0133a31",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 5,
+      "encodedBytes": 2584878,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "7663bc6e076e7abf6e495e6f10fe5e511293290188bd2ea42ca8f11dca59c151",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 6,
+      "encodedBytes": 1094741,
+      "frames": 561092,
+      "pcmBytes": 3366552,
+      "pcmBlocks": 137,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "3849a44bffe57ab48954fd37640c9292db6fba2278a1448464f1748d5dc5745e",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 0,
+      "encodedBytes": 5144195,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "1cb3c348a7d541b66309eea6f1aefefb0b02fb421d91b898fadae0733775d780",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 1,
+      "encodedBytes": 5172912,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "ed3b2c8a228e50e3b1a11aafa9f1aae51fa304e559661959c63e10a20c1f48da",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 2,
+      "encodedBytes": 5252207,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "034db1186c1eb61b137691797fea0b93a3aca44c2167924d2d7ac4809ba9ad9f",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 3,
+      "encodedBytes": 5088810,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "85d909ec0f5745a6c02a9b87cf11ab8f35546990395eeecd4059a923084fc6af",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 4,
+      "encodedBytes": 3443938,
+      "frames": 1323000,
+      "pcmBytes": 7938000,
+      "pcmBlocks": 323,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "52739fe2188b8ff3f49b0b6a55444205c91fd05023bfc377d24e7354ad09c665",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    },
+    {
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 5,
+      "encodedBytes": 20011,
+      "frames": 91456,
+      "pcmBytes": 548736,
+      "pcmBlocks": 23,
+      "maximumPcmBlockBytes": 24576,
+      "pcmSha256": "30f490035cb2caaf0b63f57c817211708107df2bb2622eb80a8ca7cf56d41d2d",
+      "metadataMd5Present": true,
+      "completeMd5Checked": true,
+      "completeMd5Verified": true
+    }
+  ],
+  "cold": {
+    "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+    "chunkIndex": 0,
+    "frames": 1323000,
+    "compileMilliseconds": 2.3207629999997152,
+    "compileInstantiateEncodeMilliseconds": 485.60146499999973,
+    "encodedBytes": 4150349,
+    "nativeDecodedPcmSha256": "0ad333131602d2eed204c673014271b346328956a17a459cda005d12aff26324"
+  },
+  "summary": {
+    "selectedChunks": 137,
+    "selectedFrames": 161998099,
+    "decoderQualifiedChunks": 137,
+    "decoderPcmBytes": 971988594,
+    "decoderPcmBlocks": 39562,
+    "decoderMaximumPcmBlockBytes": 24576,
+    "wasmPayloadBytes": 425689892,
+    "nativePayloadBytes": 425690361,
+    "payloadDeltaBytes": -469,
+    "payloadDeltaPercent": -0.00011017397690148778,
+    "wasmMedianMilliseconds": 60579.8109469999,
+    "nativeMedianMilliseconds": 15554.164494000011,
+    "wasmToNativeMedianTimeRatio": 3.8947647088577755
+  },
+  "totals": [
+    {
+      "round": 1,
+      "implementation": "wasm",
+      "chunks": 137,
+      "encodedBytes": 425689892,
+      "elapsedMilliseconds": 59815.16834699998
+    },
+    {
+      "round": 1,
+      "implementation": "native",
+      "chunks": 137,
+      "encodedBytes": 425690361,
+      "elapsedMilliseconds": 15372.619764000123
+    },
+    {
+      "round": 2,
+      "implementation": "wasm",
+      "chunks": 137,
+      "encodedBytes": 425689892,
+      "elapsedMilliseconds": 61804.30543500013
+    },
+    {
+      "round": 2,
+      "implementation": "native",
+      "chunks": 137,
+      "encodedBytes": 425690361,
+      "elapsedMilliseconds": 15554.164494000011
+    },
+    {
+      "round": 3,
+      "implementation": "wasm",
+      "chunks": 137,
+      "encodedBytes": 425689892,
+      "elapsedMilliseconds": 60579.8109469999
+    },
+    {
+      "round": 3,
+      "implementation": "native",
+      "chunks": 137,
+      "encodedBytes": 425690361,
+      "elapsedMilliseconds": 15560.079304999905
+    }
+  ],
+  "rows": [
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "0ad333131602d2eed204c673014271b346328956a17a459cda005d12aff26324",
+      "encodedBytes": 4150349,
+      "elapsedMilliseconds": 464.75299300000006,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1046,
+        "maximumFrameSize": 18240,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5b26e698b3ee07d53f57208d50518553"
+      },
+      "nativeDecodedPcmSha256": "0ad333131602d2eed204c673014271b346328956a17a459cda005d12aff26324"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "0ad333131602d2eed204c673014271b346328956a17a459cda005d12aff26324",
+      "encodedBytes": 4150349,
+      "elapsedMilliseconds": 125.31978199999867,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1046,
+        "maximumFrameSize": 18240,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5b26e698b3ee07d53f57208d50518553"
+      },
+      "nativeDecodedPcmSha256": "0ad333131602d2eed204c673014271b346328956a17a459cda005d12aff26324"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "498bd8b6bfeb1e240e24b0c0f948f26e59259d319adf0e61f5cd7e5ec79d10e8",
+      "encodedBytes": 4371131,
+      "elapsedMilliseconds": 501.0939579999995,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1058,
+        "maximumFrameSize": 18677,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d5817dbd7025dd8dcb122eb5a8c2abff"
+      },
+      "nativeDecodedPcmSha256": "498bd8b6bfeb1e240e24b0c0f948f26e59259d319adf0e61f5cd7e5ec79d10e8"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "498bd8b6bfeb1e240e24b0c0f948f26e59259d319adf0e61f5cd7e5ec79d10e8",
+      "encodedBytes": 4371137,
+      "elapsedMilliseconds": 128.25694999999905,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1058,
+        "maximumFrameSize": 18677,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d5817dbd7025dd8dcb122eb5a8c2abff"
+      },
+      "nativeDecodedPcmSha256": "498bd8b6bfeb1e240e24b0c0f948f26e59259d319adf0e61f5cd7e5ec79d10e8"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "a9b0a5e36c48ce2ecd758f22ba512342b8d6378c86d8a0c95c8b5fb01d86ae7f",
+      "encodedBytes": 2982496,
+      "elapsedMilliseconds": 453.57135299999936,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 19173,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "bc4f583eb83952c7aafa13276e51bfa4"
+      },
+      "nativeDecodedPcmSha256": "a9b0a5e36c48ce2ecd758f22ba512342b8d6378c86d8a0c95c8b5fb01d86ae7f"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "a9b0a5e36c48ce2ecd758f22ba512342b8d6378c86d8a0c95c8b5fb01d86ae7f",
+      "encodedBytes": 2982490,
+      "elapsedMilliseconds": 120.2222180000008,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 19173,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "bc4f583eb83952c7aafa13276e51bfa4"
+      },
+      "nativeDecodedPcmSha256": "a9b0a5e36c48ce2ecd758f22ba512342b8d6378c86d8a0c95c8b5fb01d86ae7f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 3,
+      "frames": 1162869,
+      "expectedPcmSha256": "ad88aea64fa81f9247059b6e75ccbeadd4b350cae9a83d7940f4594e87dd7936",
+      "encodedBytes": 4539491,
+      "elapsedMilliseconds": 439.5470060000007,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 487,
+        "maximumFrameSize": 20237,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1162869",
+        "md5Hex": "7547e0b77aefe7bf646b230d8a47d74e"
+      },
+      "nativeDecodedPcmSha256": "ad88aea64fa81f9247059b6e75ccbeadd4b350cae9a83d7940f4594e87dd7936"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 3,
+      "frames": 1162869,
+      "expectedPcmSha256": "ad88aea64fa81f9247059b6e75ccbeadd4b350cae9a83d7940f4594e87dd7936",
+      "encodedBytes": 4539490,
+      "elapsedMilliseconds": 111.56080100000145,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 487,
+        "maximumFrameSize": 20237,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1162869",
+        "md5Hex": "7547e0b77aefe7bf646b230d8a47d74e"
+      },
+      "nativeDecodedPcmSha256": "ad88aea64fa81f9247059b6e75ccbeadd4b350cae9a83d7940f4594e87dd7936"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "b4d086eb6ea6fb003acaa30cbf00317bb1567dee9c03521701ad60f404f7a2c7",
+      "encodedBytes": 3396576,
+      "elapsedMilliseconds": 415.4244260000014,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7959,
+        "maximumFrameSize": 18028,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9c2393e2f1b5ee54d1253ee3a3dfb992"
+      },
+      "nativeDecodedPcmSha256": "b4d086eb6ea6fb003acaa30cbf00317bb1567dee9c03521701ad60f404f7a2c7"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "b4d086eb6ea6fb003acaa30cbf00317bb1567dee9c03521701ad60f404f7a2c7",
+      "encodedBytes": 3396577,
+      "elapsedMilliseconds": 115.93438600000081,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7959,
+        "maximumFrameSize": 18028,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9c2393e2f1b5ee54d1253ee3a3dfb992"
+      },
+      "nativeDecodedPcmSha256": "b4d086eb6ea6fb003acaa30cbf00317bb1567dee9c03521701ad60f404f7a2c7"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "72e151c5c4f167900d89a7096ea63dcabeb846c160caaeaec4d0711ddbb9ae76",
+      "encodedBytes": 5287166,
+      "elapsedMilliseconds": 529.0797090000015,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5431,
+        "maximumFrameSize": 19445,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "c9cb1466675357641cebeb5032e2f37d"
+      },
+      "nativeDecodedPcmSha256": "72e151c5c4f167900d89a7096ea63dcabeb846c160caaeaec4d0711ddbb9ae76"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "72e151c5c4f167900d89a7096ea63dcabeb846c160caaeaec4d0711ddbb9ae76",
+      "encodedBytes": 5287163,
+      "elapsedMilliseconds": 134.59101100000044,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5431,
+        "maximumFrameSize": 19445,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "c9cb1466675357641cebeb5032e2f37d"
+      },
+      "nativeDecodedPcmSha256": "72e151c5c4f167900d89a7096ea63dcabeb846c160caaeaec4d0711ddbb9ae76"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "4b8d2779ff5af472ae8159a9429aba0befe0eca99cd4b4f29432f8dd33af6c1f",
+      "encodedBytes": 3847608,
+      "elapsedMilliseconds": 481.3795650000029,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8050,
+        "maximumFrameSize": 19330,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "46b620635fb0599fc6f77ce38d08afd6"
+      },
+      "nativeDecodedPcmSha256": "4b8d2779ff5af472ae8159a9429aba0befe0eca99cd4b4f29432f8dd33af6c1f"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "4b8d2779ff5af472ae8159a9429aba0befe0eca99cd4b4f29432f8dd33af6c1f",
+      "encodedBytes": 3847607,
+      "elapsedMilliseconds": 123.69698000000062,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8050,
+        "maximumFrameSize": 19330,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "46b620635fb0599fc6f77ce38d08afd6"
+      },
+      "nativeDecodedPcmSha256": "4b8d2779ff5af472ae8159a9429aba0befe0eca99cd4b4f29432f8dd33af6c1f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "874cb197ccd1ef18c42c4de586b947796463dfaa211978c5ecf747683f20b367",
+      "encodedBytes": 3190338,
+      "elapsedMilliseconds": 492.4536189999999,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7963,
+        "maximumFrameSize": 16584,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d391e230ba796167b53a81a2bbdf2831"
+      },
+      "nativeDecodedPcmSha256": "874cb197ccd1ef18c42c4de586b947796463dfaa211978c5ecf747683f20b367"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "874cb197ccd1ef18c42c4de586b947796463dfaa211978c5ecf747683f20b367",
+      "encodedBytes": 3190350,
+      "elapsedMilliseconds": 125.02666300000055,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7963,
+        "maximumFrameSize": 16584,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d391e230ba796167b53a81a2bbdf2831"
+      },
+      "nativeDecodedPcmSha256": "874cb197ccd1ef18c42c4de586b947796463dfaa211978c5ecf747683f20b367"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "f6ccbd0a0a535ebc8f2b53ae0adeb7fc4796648646edb2caae934f889f6e1bb4",
+      "encodedBytes": 5481625,
+      "elapsedMilliseconds": 526.2515569999996,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7941,
+        "maximumFrameSize": 19501,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fe527fc68042d8fc43a670259d17aa00"
+      },
+      "nativeDecodedPcmSha256": "f6ccbd0a0a535ebc8f2b53ae0adeb7fc4796648646edb2caae934f889f6e1bb4"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "f6ccbd0a0a535ebc8f2b53ae0adeb7fc4796648646edb2caae934f889f6e1bb4",
+      "encodedBytes": 5481625,
+      "elapsedMilliseconds": 131.92364600000292,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7941,
+        "maximumFrameSize": 19501,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fe527fc68042d8fc43a670259d17aa00"
+      },
+      "nativeDecodedPcmSha256": "f6ccbd0a0a535ebc8f2b53ae0adeb7fc4796648646edb2caae934f889f6e1bb4"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "ef9d092ac5241f9d7479dd6098355cf95724cc229b90286b20b48318cd2266f6",
+      "encodedBytes": 2580489,
+      "elapsedMilliseconds": 399.493905000003,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7939,
+        "maximumFrameSize": 8322,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "81b081b322c774cd732dcfa16962c8e9"
+      },
+      "nativeDecodedPcmSha256": "ef9d092ac5241f9d7479dd6098355cf95724cc229b90286b20b48318cd2266f6"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "ef9d092ac5241f9d7479dd6098355cf95724cc229b90286b20b48318cd2266f6",
+      "encodedBytes": 2580489,
+      "elapsedMilliseconds": 112.97790200000236,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7939,
+        "maximumFrameSize": 8322,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "81b081b322c774cd732dcfa16962c8e9"
+      },
+      "nativeDecodedPcmSha256": "ef9d092ac5241f9d7479dd6098355cf95724cc229b90286b20b48318cd2266f6"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "68599d04661ee4e25c2f965d2c5197f84eae66e6b5cd3e52a915d70c44567cbc",
+      "encodedBytes": 1094519,
+      "elapsedMilliseconds": 190.71555699999954,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7867,
+        "maximumFrameSize": 8029,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "d984dcecf62ef48f97716f78896234a3"
+      },
+      "nativeDecodedPcmSha256": "68599d04661ee4e25c2f965d2c5197f84eae66e6b5cd3e52a915d70c44567cbc"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "68599d04661ee4e25c2f965d2c5197f84eae66e6b5cd3e52a915d70c44567cbc",
+      "encodedBytes": 1094519,
+      "elapsedMilliseconds": 48.473737000000256,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7867,
+        "maximumFrameSize": 8029,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "d984dcecf62ef48f97716f78896234a3"
+      },
+      "nativeDecodedPcmSha256": "68599d04661ee4e25c2f965d2c5197f84eae66e6b5cd3e52a915d70c44567cbc"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:1d0544c63bf19bcc8d8b663d73fb9b206f9d107d52f7729ead8fce52aaa9be71",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "3e07a582bb431c6106a0eeea238aeddfd33ab51272f2f4ec19f24461230d6879",
+      "encodedBytes": 4802021,
+      "elapsedMilliseconds": 494.8349959999978,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 639,
+        "maximumFrameSize": 18532,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "7b9be66be751f643ae8fa39cd8ca6184"
+      },
+      "nativeDecodedPcmSha256": "3e07a582bb431c6106a0eeea238aeddfd33ab51272f2f4ec19f24461230d6879"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:1d0544c63bf19bcc8d8b663d73fb9b206f9d107d52f7729ead8fce52aaa9be71",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "3e07a582bb431c6106a0eeea238aeddfd33ab51272f2f4ec19f24461230d6879",
+      "encodedBytes": 4802021,
+      "elapsedMilliseconds": 123.72862999999779,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 639,
+        "maximumFrameSize": 18532,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "7b9be66be751f643ae8fa39cd8ca6184"
+      },
+      "nativeDecodedPcmSha256": "3e07a582bb431c6106a0eeea238aeddfd33ab51272f2f4ec19f24461230d6879"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:1d0544c63bf19bcc8d8b663d73fb9b206f9d107d52f7729ead8fce52aaa9be71",
+      "chunkIndex": 1,
+      "frames": 1179460,
+      "expectedPcmSha256": "b1fed292edbe942de39423402a36ee74165dc92c74d4630e85d8aec07e26f6e2",
+      "encodedBytes": 3270974,
+      "elapsedMilliseconds": 410.5568170000006,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 506,
+        "maximumFrameSize": 18576,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1179460",
+        "md5Hex": "e102779c11c2a0141579ee8a147dad3d"
+      },
+      "nativeDecodedPcmSha256": "b1fed292edbe942de39423402a36ee74165dc92c74d4630e85d8aec07e26f6e2"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:1d0544c63bf19bcc8d8b663d73fb9b206f9d107d52f7729ead8fce52aaa9be71",
+      "chunkIndex": 1,
+      "frames": 1179460,
+      "expectedPcmSha256": "b1fed292edbe942de39423402a36ee74165dc92c74d4630e85d8aec07e26f6e2",
+      "encodedBytes": 3270968,
+      "elapsedMilliseconds": 106.93249099999957,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 506,
+        "maximumFrameSize": 18576,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1179460",
+        "md5Hex": "e102779c11c2a0141579ee8a147dad3d"
+      },
+      "nativeDecodedPcmSha256": "b1fed292edbe942de39423402a36ee74165dc92c74d4630e85d8aec07e26f6e2"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "a19561147112095642424463ea315305b085a03c9c82becb7ac38c3e923c2407",
+      "encodedBytes": 4187420,
+      "elapsedMilliseconds": 571.1105730000018,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1089,
+        "maximumFrameSize": 20569,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "219b7301a904dc1b3b4f430d08a555ae"
+      },
+      "nativeDecodedPcmSha256": "a19561147112095642424463ea315305b085a03c9c82becb7ac38c3e923c2407"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "a19561147112095642424463ea315305b085a03c9c82becb7ac38c3e923c2407",
+      "encodedBytes": 4187419,
+      "elapsedMilliseconds": 134.2553399999997,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1089,
+        "maximumFrameSize": 20569,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "219b7301a904dc1b3b4f430d08a555ae"
+      },
+      "nativeDecodedPcmSha256": "a19561147112095642424463ea315305b085a03c9c82becb7ac38c3e923c2407"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "55a9246cc0cfbf1ea647cad6f98d37f9d9351d2743ea6d09e87afeeeaafd94e3",
+      "encodedBytes": 3050967,
+      "elapsedMilliseconds": 529.4703289999998,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1051,
+        "maximumFrameSize": 20467,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "679b726bb6d3e08e24c3e184f9a9f15e"
+      },
+      "nativeDecodedPcmSha256": "55a9246cc0cfbf1ea647cad6f98d37f9d9351d2743ea6d09e87afeeeaafd94e3"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "55a9246cc0cfbf1ea647cad6f98d37f9d9351d2743ea6d09e87afeeeaafd94e3",
+      "encodedBytes": 3050969,
+      "elapsedMilliseconds": 129.0652590000027,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1051,
+        "maximumFrameSize": 20467,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "679b726bb6d3e08e24c3e184f9a9f15e"
+      },
+      "nativeDecodedPcmSha256": "55a9246cc0cfbf1ea647cad6f98d37f9d9351d2743ea6d09e87afeeeaafd94e3"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "52e84d5ab6f4d8e41262b82fae7a1fc2e774f9d29b10e5e9e7b64592799e27dd",
+      "encodedBytes": 4662993,
+      "elapsedMilliseconds": 559.7685060000003,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1070,
+        "maximumFrameSize": 20658,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "63b1666ccf5139b3eabf2b0b97b289c4"
+      },
+      "nativeDecodedPcmSha256": "52e84d5ab6f4d8e41262b82fae7a1fc2e774f9d29b10e5e9e7b64592799e27dd"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "52e84d5ab6f4d8e41262b82fae7a1fc2e774f9d29b10e5e9e7b64592799e27dd",
+      "encodedBytes": 4662993,
+      "elapsedMilliseconds": 131.5575080000017,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1070,
+        "maximumFrameSize": 20658,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "63b1666ccf5139b3eabf2b0b97b289c4"
+      },
+      "nativeDecodedPcmSha256": "52e84d5ab6f4d8e41262b82fae7a1fc2e774f9d29b10e5e9e7b64592799e27dd"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 3,
+      "frames": 630874,
+      "expectedPcmSha256": "d2903e6abfcf42e70792f30af34c900d64ad340d77ef31a775287c68d17596b9",
+      "encodedBytes": 2161240,
+      "elapsedMilliseconds": 281.6430659999969,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 18,
+        "maximumFrameSize": 20476,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "630874",
+        "md5Hex": "c0d8c46e99c6193df86665e77b15ce15"
+      },
+      "nativeDecodedPcmSha256": "d2903e6abfcf42e70792f30af34c900d64ad340d77ef31a775287c68d17596b9"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 3,
+      "frames": 630874,
+      "expectedPcmSha256": "d2903e6abfcf42e70792f30af34c900d64ad340d77ef31a775287c68d17596b9",
+      "encodedBytes": 2161240,
+      "elapsedMilliseconds": 65.29902999999831,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 18,
+        "maximumFrameSize": 20476,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "630874",
+        "md5Hex": "c0d8c46e99c6193df86665e77b15ce15"
+      },
+      "nativeDecodedPcmSha256": "d2903e6abfcf42e70792f30af34c900d64ad340d77ef31a775287c68d17596b9"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "9cd318a12c7c8fa38f058ab7c8e032b363c431af852557febfc61a2a18c34970",
+      "encodedBytes": 2867123,
+      "elapsedMilliseconds": 447.3071600000003,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 4489,
+        "maximumFrameSize": 16813,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "6357201bd5e0eeb273716afdec214aca"
+      },
+      "nativeDecodedPcmSha256": "9cd318a12c7c8fa38f058ab7c8e032b363c431af852557febfc61a2a18c34970"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "9cd318a12c7c8fa38f058ab7c8e032b363c431af852557febfc61a2a18c34970",
+      "encodedBytes": 2867123,
+      "elapsedMilliseconds": 123.68236999999863,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 4489,
+        "maximumFrameSize": 16813,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "6357201bd5e0eeb273716afdec214aca"
+      },
+      "nativeDecodedPcmSha256": "9cd318a12c7c8fa38f058ab7c8e032b363c431af852557febfc61a2a18c34970"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "0016abd2094e03efc2cb2bf4301934db1c55b68a034ca7a977e1eb4b6bf71799",
+      "encodedBytes": 4455810,
+      "elapsedMilliseconds": 577.8276909999986,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5533,
+        "maximumFrameSize": 18357,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b31c86a1180cf2a42e08aa21582d4907"
+      },
+      "nativeDecodedPcmSha256": "0016abd2094e03efc2cb2bf4301934db1c55b68a034ca7a977e1eb4b6bf71799"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "0016abd2094e03efc2cb2bf4301934db1c55b68a034ca7a977e1eb4b6bf71799",
+      "encodedBytes": 4455811,
+      "elapsedMilliseconds": 142.32523800000126,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5533,
+        "maximumFrameSize": 18357,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b31c86a1180cf2a42e08aa21582d4907"
+      },
+      "nativeDecodedPcmSha256": "0016abd2094e03efc2cb2bf4301934db1c55b68a034ca7a977e1eb4b6bf71799"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "fb92413909c791e44c9aaffed2aa7dd0025bb3af28e6bc54da191243aa2c31da",
+      "encodedBytes": 4664160,
+      "elapsedMilliseconds": 558.5823839999975,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6095,
+        "maximumFrameSize": 17776,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "38e2092fb1dfd7bc419233204dd69922"
+      },
+      "nativeDecodedPcmSha256": "fb92413909c791e44c9aaffed2aa7dd0025bb3af28e6bc54da191243aa2c31da"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "fb92413909c791e44c9aaffed2aa7dd0025bb3af28e6bc54da191243aa2c31da",
+      "encodedBytes": 4664160,
+      "elapsedMilliseconds": 137.5999030000021,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6095,
+        "maximumFrameSize": 17776,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "38e2092fb1dfd7bc419233204dd69922"
+      },
+      "nativeDecodedPcmSha256": "fb92413909c791e44c9aaffed2aa7dd0025bb3af28e6bc54da191243aa2c31da"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "0c53b70e20dad8a58b0ccd63fae413169addf85c2ff23899acb8cfcf9d112f7b",
+      "encodedBytes": 4600172,
+      "elapsedMilliseconds": 554.3125570000011,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5555,
+        "maximumFrameSize": 17032,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9a59c85b30fd8c2e72cd58c43592fd1d"
+      },
+      "nativeDecodedPcmSha256": "0c53b70e20dad8a58b0ccd63fae413169addf85c2ff23899acb8cfcf9d112f7b"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "0c53b70e20dad8a58b0ccd63fae413169addf85c2ff23899acb8cfcf9d112f7b",
+      "encodedBytes": 4600172,
+      "elapsedMilliseconds": 133.09933600000295,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5555,
+        "maximumFrameSize": 17032,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9a59c85b30fd8c2e72cd58c43592fd1d"
+      },
+      "nativeDecodedPcmSha256": "0c53b70e20dad8a58b0ccd63fae413169addf85c2ff23899acb8cfcf9d112f7b"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 4,
+      "frames": 915923,
+      "expectedPcmSha256": "ee9d65603f1b22585957d02a4c56be87be47cf6354808438964a3a1c031cfd9f",
+      "encodedBytes": 2886170,
+      "elapsedMilliseconds": 363.03195499999856,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 3285,
+        "maximumFrameSize": 16807,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "915923",
+        "md5Hex": "d3c4f8f2c76bd1d09d96d04f6dba9f1d"
+      },
+      "nativeDecodedPcmSha256": "ee9d65603f1b22585957d02a4c56be87be47cf6354808438964a3a1c031cfd9f"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 4,
+      "frames": 915923,
+      "expectedPcmSha256": "ee9d65603f1b22585957d02a4c56be87be47cf6354808438964a3a1c031cfd9f",
+      "encodedBytes": 2886170,
+      "elapsedMilliseconds": 93.11335499999768,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 3285,
+        "maximumFrameSize": 16807,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "915923",
+        "md5Hex": "d3c4f8f2c76bd1d09d96d04f6dba9f1d"
+      },
+      "nativeDecodedPcmSha256": "ee9d65603f1b22585957d02a4c56be87be47cf6354808438964a3a1c031cfd9f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "74c0df9dcd402798188e653381e0166de4eb0e9e0e5e7d28de95dc2d7921efc9",
+      "encodedBytes": 2555489,
+      "elapsedMilliseconds": 555.6437130000013,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1119,
+        "maximumFrameSize": 11300,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "246801b775679e817b341b8c39d382cb"
+      },
+      "nativeDecodedPcmSha256": "74c0df9dcd402798188e653381e0166de4eb0e9e0e5e7d28de95dc2d7921efc9"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "74c0df9dcd402798188e653381e0166de4eb0e9e0e5e7d28de95dc2d7921efc9",
+      "encodedBytes": 2556311,
+      "elapsedMilliseconds": 210.57541099999798,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1119,
+        "maximumFrameSize": 11311,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "246801b775679e817b341b8c39d382cb"
+      },
+      "nativeDecodedPcmSha256": "74c0df9dcd402798188e653381e0166de4eb0e9e0e5e7d28de95dc2d7921efc9"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "8f9568ecd4f1890cdd81cb5173c40112d98c1a4d61fd36314e4bb2030124cb2a",
+      "encodedBytes": 1499027,
+      "elapsedMilliseconds": 326.34541199999876,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 19858,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "164ea8991da81f3328f402e47b7e849b"
+      },
+      "nativeDecodedPcmSha256": "8f9568ecd4f1890cdd81cb5173c40112d98c1a4d61fd36314e4bb2030124cb2a"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "8f9568ecd4f1890cdd81cb5173c40112d98c1a4d61fd36314e4bb2030124cb2a",
+      "encodedBytes": 1499027,
+      "elapsedMilliseconds": 103.7770359999995,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 19858,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "164ea8991da81f3328f402e47b7e849b"
+      },
+      "nativeDecodedPcmSha256": "8f9568ecd4f1890cdd81cb5173c40112d98c1a4d61fd36314e4bb2030124cb2a"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "0d76eb91be0008835d5774ac3b2738db6e392d32e4fc767d77a25394f82ba7e4",
+      "encodedBytes": 2203031,
+      "elapsedMilliseconds": 421.87975000000006,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 19224,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "cc6a0db61773a650e936bf526840a278"
+      },
+      "nativeDecodedPcmSha256": "0d76eb91be0008835d5774ac3b2738db6e392d32e4fc767d77a25394f82ba7e4"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "0d76eb91be0008835d5774ac3b2738db6e392d32e4fc767d77a25394f82ba7e4",
+      "encodedBytes": 2203168,
+      "elapsedMilliseconds": 141.79938500000208,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 19224,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "cc6a0db61773a650e936bf526840a278"
+      },
+      "nativeDecodedPcmSha256": "0d76eb91be0008835d5774ac3b2738db6e392d32e4fc767d77a25394f82ba7e4"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "95c4368b4a153a4b38ea1d8f4b4fe10db945dad45351d3a74e5fe38fdc4273fa",
+      "encodedBytes": 4652718,
+      "elapsedMilliseconds": 497.93815299999915,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1047,
+        "maximumFrameSize": 20009,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "27feaa2a2129642bee3dce8784769a30"
+      },
+      "nativeDecodedPcmSha256": "95c4368b4a153a4b38ea1d8f4b4fe10db945dad45351d3a74e5fe38fdc4273fa"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "95c4368b4a153a4b38ea1d8f4b4fe10db945dad45351d3a74e5fe38fdc4273fa",
+      "encodedBytes": 4652717,
+      "elapsedMilliseconds": 128.16278800000146,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1047,
+        "maximumFrameSize": 20009,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "27feaa2a2129642bee3dce8784769a30"
+      },
+      "nativeDecodedPcmSha256": "95c4368b4a153a4b38ea1d8f4b4fe10db945dad45351d3a74e5fe38fdc4273fa"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 4,
+      "frames": 207800,
+      "expectedPcmSha256": "7e432c880c57ed605b55cf95c74625b569353b7df4dc398f731e0b81c40e71ef",
+      "encodedBytes": 465680,
+      "elapsedMilliseconds": 92.87459999999919,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5469,
+        "maximumFrameSize": 15210,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "207800",
+        "md5Hex": "0fffe1f3e6e69d7a3050d32f7fb5d52a"
+      },
+      "nativeDecodedPcmSha256": "7e432c880c57ed605b55cf95c74625b569353b7df4dc398f731e0b81c40e71ef"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 4,
+      "frames": 207800,
+      "expectedPcmSha256": "7e432c880c57ed605b55cf95c74625b569353b7df4dc398f731e0b81c40e71ef",
+      "encodedBytes": 465680,
+      "elapsedMilliseconds": 21.686247000001458,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5469,
+        "maximumFrameSize": 15210,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "207800",
+        "md5Hex": "0fffe1f3e6e69d7a3050d32f7fb5d52a"
+      },
+      "nativeDecodedPcmSha256": "7e432c880c57ed605b55cf95c74625b569353b7df4dc398f731e0b81c40e71ef"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:2dd061241fa7fe3128289427e108ee63501f4ed77c7208f1b37ff49fa6ccff0b",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "ed128680f0adb80432e3cce5156094cb93edefa0d6339dcfa20ee11a3610a693",
+      "encodedBytes": 2892634,
+      "elapsedMilliseconds": 527.0111660000002,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1070,
+        "maximumFrameSize": 19648,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9b820f9751be365c4f499e924aae57e9"
+      },
+      "nativeDecodedPcmSha256": "ed128680f0adb80432e3cce5156094cb93edefa0d6339dcfa20ee11a3610a693"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:2dd061241fa7fe3128289427e108ee63501f4ed77c7208f1b37ff49fa6ccff0b",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "ed128680f0adb80432e3cce5156094cb93edefa0d6339dcfa20ee11a3610a693",
+      "encodedBytes": 2892311,
+      "elapsedMilliseconds": 130.41790499999843,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1070,
+        "maximumFrameSize": 19648,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9b820f9751be365c4f499e924aae57e9"
+      },
+      "nativeDecodedPcmSha256": "ed128680f0adb80432e3cce5156094cb93edefa0d6339dcfa20ee11a3610a693"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:2dd061241fa7fe3128289427e108ee63501f4ed77c7208f1b37ff49fa6ccff0b",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "ea144cffa39519276d7320c735e04874b41c1a26d160703000ab7b0cec8400a8",
+      "encodedBytes": 2726814,
+      "elapsedMilliseconds": 527.1900669999995,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1065,
+        "maximumFrameSize": 19723,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "80dd17665b535e6bef3050d7c6a5c3bc"
+      },
+      "nativeDecodedPcmSha256": "ea144cffa39519276d7320c735e04874b41c1a26d160703000ab7b0cec8400a8"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:2dd061241fa7fe3128289427e108ee63501f4ed77c7208f1b37ff49fa6ccff0b",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "ea144cffa39519276d7320c735e04874b41c1a26d160703000ab7b0cec8400a8",
+      "encodedBytes": 2726860,
+      "elapsedMilliseconds": 129.47045900000012,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1065,
+        "maximumFrameSize": 19723,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "80dd17665b535e6bef3050d7c6a5c3bc"
+      },
+      "nativeDecodedPcmSha256": "ea144cffa39519276d7320c735e04874b41c1a26d160703000ab7b0cec8400a8"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:2dd061241fa7fe3128289427e108ee63501f4ed77c7208f1b37ff49fa6ccff0b",
+      "chunkIndex": 2,
+      "frames": 932160,
+      "expectedPcmSha256": "2fe58c8e997921bfcf38f90cc60e75cdd4693167a6879bb9ce3cd82222f04484",
+      "encodedBytes": 2587977,
+      "elapsedMilliseconds": 363.24621099999786,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 616,
+        "maximumFrameSize": 19678,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "932160",
+        "md5Hex": "82e5df6a400892541bf06d1835cd488e"
+      },
+      "nativeDecodedPcmSha256": "2fe58c8e997921bfcf38f90cc60e75cdd4693167a6879bb9ce3cd82222f04484"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:2dd061241fa7fe3128289427e108ee63501f4ed77c7208f1b37ff49fa6ccff0b",
+      "chunkIndex": 2,
+      "frames": 932160,
+      "expectedPcmSha256": "2fe58c8e997921bfcf38f90cc60e75cdd4693167a6879bb9ce3cd82222f04484",
+      "encodedBytes": 2587993,
+      "elapsedMilliseconds": 92.91231200000038,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 616,
+        "maximumFrameSize": 19678,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "932160",
+        "md5Hex": "82e5df6a400892541bf06d1835cd488e"
+      },
+      "nativeDecodedPcmSha256": "2fe58c8e997921bfcf38f90cc60e75cdd4693167a6879bb9ce3cd82222f04484"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "624eb9b34a886ec6358d888dd40dedbc626eaf8120f5857a4a4a66564d718228",
+      "encodedBytes": 1374986,
+      "elapsedMilliseconds": 443.6637819999996,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 534,
+        "maximumFrameSize": 10206,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "23e4a57a4efdbb27ec686a87520eb52d"
+      },
+      "nativeDecodedPcmSha256": "624eb9b34a886ec6358d888dd40dedbc626eaf8120f5857a4a4a66564d718228"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "624eb9b34a886ec6358d888dd40dedbc626eaf8120f5857a4a4a66564d718228",
+      "encodedBytes": 1374937,
+      "elapsedMilliseconds": 113.84930999999779,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 534,
+        "maximumFrameSize": 10206,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "23e4a57a4efdbb27ec686a87520eb52d"
+      },
+      "nativeDecodedPcmSha256": "624eb9b34a886ec6358d888dd40dedbc626eaf8120f5857a4a4a66564d718228"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "3cc0f29b0fc5ae8aa860430556697b4b2301a5537ab6f417baf667f498c21399",
+      "encodedBytes": 813899,
+      "elapsedMilliseconds": 347.27003500000137,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1059,
+        "maximumFrameSize": 6719,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "942063bb60651f274c2ac31de0ddcbee"
+      },
+      "nativeDecodedPcmSha256": "3cc0f29b0fc5ae8aa860430556697b4b2301a5537ab6f417baf667f498c21399"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "3cc0f29b0fc5ae8aa860430556697b4b2301a5537ab6f417baf667f498c21399",
+      "encodedBytes": 813885,
+      "elapsedMilliseconds": 103.72119999999995,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1059,
+        "maximumFrameSize": 6719,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "942063bb60651f274c2ac31de0ddcbee"
+      },
+      "nativeDecodedPcmSha256": "3cc0f29b0fc5ae8aa860430556697b4b2301a5537ab6f417baf667f498c21399"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "77a7ec33fa71caea53ad8f039c991b547b56dca2f267013b9a91fa1093c6b5f6",
+      "encodedBytes": 701176,
+      "elapsedMilliseconds": 321.76929900000687,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1065,
+        "maximumFrameSize": 7718,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "71304eeb1e3cd469c4f66cc0b2043f3c"
+      },
+      "nativeDecodedPcmSha256": "77a7ec33fa71caea53ad8f039c991b547b56dca2f267013b9a91fa1093c6b5f6"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "77a7ec33fa71caea53ad8f039c991b547b56dca2f267013b9a91fa1093c6b5f6",
+      "encodedBytes": 701130,
+      "elapsedMilliseconds": 117.83231100000557,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1065,
+        "maximumFrameSize": 7718,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "71304eeb1e3cd469c4f66cc0b2043f3c"
+      },
+      "nativeDecodedPcmSha256": "77a7ec33fa71caea53ad8f039c991b547b56dca2f267013b9a91fa1093c6b5f6"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 3,
+      "frames": 1057881,
+      "expectedPcmSha256": "e1c58aca6a4e6b13d373151f083a94be66336f1ea664eb691eb1aaeb3cf234db",
+      "encodedBytes": 876783,
+      "elapsedMilliseconds": 328.5918510000047,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 300,
+        "maximumFrameSize": 7789,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1057881",
+        "md5Hex": "8751673efb6f8957d16ea3204f3c5165"
+      },
+      "nativeDecodedPcmSha256": "e1c58aca6a4e6b13d373151f083a94be66336f1ea664eb691eb1aaeb3cf234db"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 3,
+      "frames": 1057881,
+      "expectedPcmSha256": "e1c58aca6a4e6b13d373151f083a94be66336f1ea664eb691eb1aaeb3cf234db",
+      "encodedBytes": 876850,
+      "elapsedMilliseconds": 91.34602599999926,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 300,
+        "maximumFrameSize": 7789,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1057881",
+        "md5Hex": "8751673efb6f8957d16ea3204f3c5165"
+      },
+      "nativeDecodedPcmSha256": "e1c58aca6a4e6b13d373151f083a94be66336f1ea664eb691eb1aaeb3cf234db"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "d65ddf96ef3551fdd5c08ca4a51b90f1c46ecb35544714d470119b2ba0c5cd63",
+      "encodedBytes": 1943412,
+      "elapsedMilliseconds": 395.86968999999954,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1051,
+        "maximumFrameSize": 18491,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "0d61fa2572913812a15c20371f2bfb80"
+      },
+      "nativeDecodedPcmSha256": "d65ddf96ef3551fdd5c08ca4a51b90f1c46ecb35544714d470119b2ba0c5cd63"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "d65ddf96ef3551fdd5c08ca4a51b90f1c46ecb35544714d470119b2ba0c5cd63",
+      "encodedBytes": 1943384,
+      "elapsedMilliseconds": 114.69026200000371,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1051,
+        "maximumFrameSize": 18491,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "0d61fa2572913812a15c20371f2bfb80"
+      },
+      "nativeDecodedPcmSha256": "d65ddf96ef3551fdd5c08ca4a51b90f1c46ecb35544714d470119b2ba0c5cd63"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "ef94fcfe71b9f59da74d552ee67fd658841d8f4547eca40ef2a928d3431ecbbc",
+      "encodedBytes": 2803573,
+      "elapsedMilliseconds": 447.82576100000006,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1056,
+        "maximumFrameSize": 18346,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "689815531096c080e770d82660e1ccdc"
+      },
+      "nativeDecodedPcmSha256": "ef94fcfe71b9f59da74d552ee67fd658841d8f4547eca40ef2a928d3431ecbbc"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "ef94fcfe71b9f59da74d552ee67fd658841d8f4547eca40ef2a928d3431ecbbc",
+      "encodedBytes": 2803492,
+      "elapsedMilliseconds": 120.29631599999993,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1056,
+        "maximumFrameSize": 18346,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "689815531096c080e770d82660e1ccdc"
+      },
+      "nativeDecodedPcmSha256": "ef94fcfe71b9f59da74d552ee67fd658841d8f4547eca40ef2a928d3431ecbbc"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "836755243b06af4a9fa6dd26a38b6ecb486feddb013575b58f4ed55858794bbf",
+      "encodedBytes": 3690570,
+      "elapsedMilliseconds": 505.3794990000024,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1082,
+        "maximumFrameSize": 18247,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "7e11ce05b0f176124275621fbbeff0ab"
+      },
+      "nativeDecodedPcmSha256": "836755243b06af4a9fa6dd26a38b6ecb486feddb013575b58f4ed55858794bbf"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "836755243b06af4a9fa6dd26a38b6ecb486feddb013575b58f4ed55858794bbf",
+      "encodedBytes": 3690485,
+      "elapsedMilliseconds": 130.68737700000202,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1082,
+        "maximumFrameSize": 18247,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "7e11ce05b0f176124275621fbbeff0ab"
+      },
+      "nativeDecodedPcmSha256": "836755243b06af4a9fa6dd26a38b6ecb486feddb013575b58f4ed55858794bbf"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 3,
+      "frames": 1047609,
+      "expectedPcmSha256": "ad00f29b53ad6c3fbfa12672cb17168270becc5fb01419ef9ed530476756d725",
+      "encodedBytes": 3831622,
+      "elapsedMilliseconds": 431.78740700000344,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 807,
+        "maximumFrameSize": 19674,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1047609",
+        "md5Hex": "36fc61d6543e34a59df4d2ceb3d6678a"
+      },
+      "nativeDecodedPcmSha256": "ad00f29b53ad6c3fbfa12672cb17168270becc5fb01419ef9ed530476756d725"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 3,
+      "frames": 1047609,
+      "expectedPcmSha256": "ad00f29b53ad6c3fbfa12672cb17168270becc5fb01419ef9ed530476756d725",
+      "encodedBytes": 3831623,
+      "elapsedMilliseconds": 107.20332400000188,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 807,
+        "maximumFrameSize": 19674,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1047609",
+        "md5Hex": "36fc61d6543e34a59df4d2ceb3d6678a"
+      },
+      "nativeDecodedPcmSha256": "ad00f29b53ad6c3fbfa12672cb17168270becc5fb01419ef9ed530476756d725"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:43413b8b197ba8a6be8b706e5173fb5246f4c60c414557dc552d9c65239f9340",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "fda5317be1243b68e09d100738aae8d0d0b835e4b9c42222ceb8637f206fbd23",
+      "encodedBytes": 4695124,
+      "elapsedMilliseconds": 563.8763650000037,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1941,
+        "maximumFrameSize": 17360,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "0db7916b9afe1ba846cacae409fd3719"
+      },
+      "nativeDecodedPcmSha256": "fda5317be1243b68e09d100738aae8d0d0b835e4b9c42222ceb8637f206fbd23"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:43413b8b197ba8a6be8b706e5173fb5246f4c60c414557dc552d9c65239f9340",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "fda5317be1243b68e09d100738aae8d0d0b835e4b9c42222ceb8637f206fbd23",
+      "encodedBytes": 4695125,
+      "elapsedMilliseconds": 135.01691800000117,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1941,
+        "maximumFrameSize": 17360,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "0db7916b9afe1ba846cacae409fd3719"
+      },
+      "nativeDecodedPcmSha256": "fda5317be1243b68e09d100738aae8d0d0b835e4b9c42222ceb8637f206fbd23"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:43413b8b197ba8a6be8b706e5173fb5246f4c60c414557dc552d9c65239f9340",
+      "chunkIndex": 1,
+      "frames": 514531,
+      "expectedPcmSha256": "f12619a013d45d71b3261cc8eaa4bd5777f329942b6c0c49cbe8ca2a5fbc9878",
+      "encodedBytes": 1733385,
+      "elapsedMilliseconds": 223.02830900000117,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 16689,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "514531",
+        "md5Hex": "6ab71b21358d04a2bdd04f53483595e9"
+      },
+      "nativeDecodedPcmSha256": "f12619a013d45d71b3261cc8eaa4bd5777f329942b6c0c49cbe8ca2a5fbc9878"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:43413b8b197ba8a6be8b706e5173fb5246f4c60c414557dc552d9c65239f9340",
+      "chunkIndex": 1,
+      "frames": 514531,
+      "expectedPcmSha256": "f12619a013d45d71b3261cc8eaa4bd5777f329942b6c0c49cbe8ca2a5fbc9878",
+      "encodedBytes": 1733385,
+      "elapsedMilliseconds": 54.29035900000599,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 16689,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "514531",
+        "md5Hex": "6ab71b21358d04a2bdd04f53483595e9"
+      },
+      "nativeDecodedPcmSha256": "f12619a013d45d71b3261cc8eaa4bd5777f329942b6c0c49cbe8ca2a5fbc9878"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "1ac0d21a2979389605675c51b1da394d304bb096ed5b6f68ef8ffe0c41573dfa",
+      "encodedBytes": 2818457,
+      "elapsedMilliseconds": 420.15140099999553,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7866,
+        "maximumFrameSize": 19365,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "009617d337fbad5c9834b9ce0e370958"
+      },
+      "nativeDecodedPcmSha256": "1ac0d21a2979389605675c51b1da394d304bb096ed5b6f68ef8ffe0c41573dfa"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "1ac0d21a2979389605675c51b1da394d304bb096ed5b6f68ef8ffe0c41573dfa",
+      "encodedBytes": 2818457,
+      "elapsedMilliseconds": 113.56659000000218,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7866,
+        "maximumFrameSize": 19365,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "009617d337fbad5c9834b9ce0e370958"
+      },
+      "nativeDecodedPcmSha256": "1ac0d21a2979389605675c51b1da394d304bb096ed5b6f68ef8ffe0c41573dfa"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "3514cf02ee43289d552a33de6fc20dc9df401dec16291793e830998f6c9e24cb",
+      "encodedBytes": 3471032,
+      "elapsedMilliseconds": 463.6041370000021,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1972,
+        "maximumFrameSize": 19226,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "6dd907abc466119fefd0accda2e2dcac"
+      },
+      "nativeDecodedPcmSha256": "3514cf02ee43289d552a33de6fc20dc9df401dec16291793e830998f6c9e24cb"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "3514cf02ee43289d552a33de6fc20dc9df401dec16291793e830998f6c9e24cb",
+      "encodedBytes": 3471032,
+      "elapsedMilliseconds": 119.71262299999944,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1972,
+        "maximumFrameSize": 19226,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "6dd907abc466119fefd0accda2e2dcac"
+      },
+      "nativeDecodedPcmSha256": "3514cf02ee43289d552a33de6fc20dc9df401dec16291793e830998f6c9e24cb"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "37b45f881e3898b1d03385bc0f9d130454c43830970bdb853803acccc5ae742e",
+      "encodedBytes": 4148907,
+      "elapsedMilliseconds": 500.93534799999907,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7964,
+        "maximumFrameSize": 20117,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "e7ce31ef6a7fc8d270923fa69283407a"
+      },
+      "nativeDecodedPcmSha256": "37b45f881e3898b1d03385bc0f9d130454c43830970bdb853803acccc5ae742e"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "37b45f881e3898b1d03385bc0f9d130454c43830970bdb853803acccc5ae742e",
+      "encodedBytes": 4148907,
+      "elapsedMilliseconds": 125.81170500000007,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7964,
+        "maximumFrameSize": 20117,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "e7ce31ef6a7fc8d270923fa69283407a"
+      },
+      "nativeDecodedPcmSha256": "37b45f881e3898b1d03385bc0f9d130454c43830970bdb853803acccc5ae742e"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "3d18c069e8d2ab8caddba535d0c8e83e593f350ad8a43728b357745f7b510f18",
+      "encodedBytes": 3908126,
+      "elapsedMilliseconds": 506.68016499999794,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7938,
+        "maximumFrameSize": 18062,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f72b873a9cfcdecb8bffca82dfea5b08"
+      },
+      "nativeDecodedPcmSha256": "3d18c069e8d2ab8caddba535d0c8e83e593f350ad8a43728b357745f7b510f18"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "3d18c069e8d2ab8caddba535d0c8e83e593f350ad8a43728b357745f7b510f18",
+      "encodedBytes": 3908126,
+      "elapsedMilliseconds": 124.9466470000043,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7938,
+        "maximumFrameSize": 18062,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f72b873a9cfcdecb8bffca82dfea5b08"
+      },
+      "nativeDecodedPcmSha256": "3d18c069e8d2ab8caddba535d0c8e83e593f350ad8a43728b357745f7b510f18"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "361efaa716a4c5a8e7cd18811f99fc1da378df26a01639a0c96da726a2fdc27c",
+      "encodedBytes": 4140983,
+      "elapsedMilliseconds": 536.8185079999967,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7912,
+        "maximumFrameSize": 16656,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "47515984c7da3d9064aa8594b71effda"
+      },
+      "nativeDecodedPcmSha256": "361efaa716a4c5a8e7cd18811f99fc1da378df26a01639a0c96da726a2fdc27c"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "361efaa716a4c5a8e7cd18811f99fc1da378df26a01639a0c96da726a2fdc27c",
+      "encodedBytes": 4140983,
+      "elapsedMilliseconds": 135.19985599999927,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7912,
+        "maximumFrameSize": 16656,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "47515984c7da3d9064aa8594b71effda"
+      },
+      "nativeDecodedPcmSha256": "361efaa716a4c5a8e7cd18811f99fc1da378df26a01639a0c96da726a2fdc27c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "dd0019f65cb14a6c5f4712f7b96750b71598a71f70c70cd0fbdb110b94954bc3",
+      "encodedBytes": 2579361,
+      "elapsedMilliseconds": 402.90628599999764,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7912,
+        "maximumFrameSize": 8037,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b850669f2d0338f0745d888777563278"
+      },
+      "nativeDecodedPcmSha256": "dd0019f65cb14a6c5f4712f7b96750b71598a71f70c70cd0fbdb110b94954bc3"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "dd0019f65cb14a6c5f4712f7b96750b71598a71f70c70cd0fbdb110b94954bc3",
+      "encodedBytes": 2579361,
+      "elapsedMilliseconds": 111.81561299999885,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7912,
+        "maximumFrameSize": 8037,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b850669f2d0338f0745d888777563278"
+      },
+      "nativeDecodedPcmSha256": "dd0019f65cb14a6c5f4712f7b96750b71598a71f70c70cd0fbdb110b94954bc3"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "e4a0b2b5384e5289ceff5b3ad42ccff678ab6a5d77c96e07a78147a5ed3770a2",
+      "encodedBytes": 1094710,
+      "elapsedMilliseconds": 178.0076029999982,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7866,
+        "maximumFrameSize": 8030,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "1a6ac668bc13ddfb53097b30403ed296"
+      },
+      "nativeDecodedPcmSha256": "e4a0b2b5384e5289ceff5b3ad42ccff678ab6a5d77c96e07a78147a5ed3770a2"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "e4a0b2b5384e5289ceff5b3ad42ccff678ab6a5d77c96e07a78147a5ed3770a2",
+      "encodedBytes": 1094710,
+      "elapsedMilliseconds": 49.177857000002405,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7866,
+        "maximumFrameSize": 8030,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "1a6ac668bc13ddfb53097b30403ed296"
+      },
+      "nativeDecodedPcmSha256": "e4a0b2b5384e5289ceff5b3ad42ccff678ab6a5d77c96e07a78147a5ed3770a2"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "36c35e82c4c4668b94b037bd2e468dbe0abda7fa866332743117f68f21952c22",
+      "encodedBytes": 4309543,
+      "elapsedMilliseconds": 509.77374899999995,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7915,
+        "maximumFrameSize": 17039,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5b8c234ab79476974554162d38196754"
+      },
+      "nativeDecodedPcmSha256": "36c35e82c4c4668b94b037bd2e468dbe0abda7fa866332743117f68f21952c22"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "36c35e82c4c4668b94b037bd2e468dbe0abda7fa866332743117f68f21952c22",
+      "encodedBytes": 4309544,
+      "elapsedMilliseconds": 124.21371000000363,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7915,
+        "maximumFrameSize": 17039,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5b8c234ab79476974554162d38196754"
+      },
+      "nativeDecodedPcmSha256": "36c35e82c4c4668b94b037bd2e468dbe0abda7fa866332743117f68f21952c22"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "9302ab132a16c115924a43d8f99697f902716f84953826be93722c923fcf2a2f",
+      "encodedBytes": 4041083,
+      "elapsedMilliseconds": 428.54782899999555,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5844,
+        "maximumFrameSize": 17267,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "16509c14a7dad38c60ac5f0fbd9eda83"
+      },
+      "nativeDecodedPcmSha256": "9302ab132a16c115924a43d8f99697f902716f84953826be93722c923fcf2a2f"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "9302ab132a16c115924a43d8f99697f902716f84953826be93722c923fcf2a2f",
+      "encodedBytes": 4041083,
+      "elapsedMilliseconds": 119.26173299999937,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5844,
+        "maximumFrameSize": 17267,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "16509c14a7dad38c60ac5f0fbd9eda83"
+      },
+      "nativeDecodedPcmSha256": "9302ab132a16c115924a43d8f99697f902716f84953826be93722c923fcf2a2f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "ead9d5ed0901c2d7a3d05525b352da2320551902855748160e84adaceda9b141",
+      "encodedBytes": 3563199,
+      "elapsedMilliseconds": 551.9375670000009,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7951,
+        "maximumFrameSize": 17209,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f9e21993a37ef66f175e13c13ca5d81a"
+      },
+      "nativeDecodedPcmSha256": "ead9d5ed0901c2d7a3d05525b352da2320551902855748160e84adaceda9b141"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "ead9d5ed0901c2d7a3d05525b352da2320551902855748160e84adaceda9b141",
+      "encodedBytes": 3563202,
+      "elapsedMilliseconds": 124.23016199999984,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7951,
+        "maximumFrameSize": 17209,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f9e21993a37ef66f175e13c13ca5d81a"
+      },
+      "nativeDecodedPcmSha256": "ead9d5ed0901c2d7a3d05525b352da2320551902855748160e84adaceda9b141"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "877ac4eb84976e6047201d0e4e19c27bfa9ea2b04c3564bfffad2eb97105d9b8",
+      "encodedBytes": 5437467,
+      "elapsedMilliseconds": 483.33956300000136,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8085,
+        "maximumFrameSize": 19284,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "cdd1b064a9f36d6376a7885b13079fe7"
+      },
+      "nativeDecodedPcmSha256": "877ac4eb84976e6047201d0e4e19c27bfa9ea2b04c3564bfffad2eb97105d9b8"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "877ac4eb84976e6047201d0e4e19c27bfa9ea2b04c3564bfffad2eb97105d9b8",
+      "encodedBytes": 5437466,
+      "elapsedMilliseconds": 129.98403600000165,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8085,
+        "maximumFrameSize": 19284,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "cdd1b064a9f36d6376a7885b13079fe7"
+      },
+      "nativeDecodedPcmSha256": "877ac4eb84976e6047201d0e4e19c27bfa9ea2b04c3564bfffad2eb97105d9b8"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "414909b9b21f0017c65c62b309a685ccbd4dcb7c896c25fa86f5e6814426f3a9",
+      "encodedBytes": 5382397,
+      "elapsedMilliseconds": 494.41595999999845,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 4895,
+        "maximumFrameSize": 18771,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "bda5a890031144fbeef2a42f67d3212e"
+      },
+      "nativeDecodedPcmSha256": "414909b9b21f0017c65c62b309a685ccbd4dcb7c896c25fa86f5e6814426f3a9"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "414909b9b21f0017c65c62b309a685ccbd4dcb7c896c25fa86f5e6814426f3a9",
+      "encodedBytes": 5382399,
+      "elapsedMilliseconds": 127.94119300000602,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 4895,
+        "maximumFrameSize": 18771,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "bda5a890031144fbeef2a42f67d3212e"
+      },
+      "nativeDecodedPcmSha256": "414909b9b21f0017c65c62b309a685ccbd4dcb7c896c25fa86f5e6814426f3a9"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "a9aaae89159b3bc3a8ae7b343cee86ceccad6e9156bd051a7907244333351b1f",
+      "encodedBytes": 2606507,
+      "elapsedMilliseconds": 397.7818069999994,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7902,
+        "maximumFrameSize": 9888,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "89db8adaf0c4183346702ead7c61f734"
+      },
+      "nativeDecodedPcmSha256": "a9aaae89159b3bc3a8ae7b343cee86ceccad6e9156bd051a7907244333351b1f"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "a9aaae89159b3bc3a8ae7b343cee86ceccad6e9156bd051a7907244333351b1f",
+      "encodedBytes": 2606507,
+      "elapsedMilliseconds": 116.84996700000193,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7902,
+        "maximumFrameSize": 9888,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "89db8adaf0c4183346702ead7c61f734"
+      },
+      "nativeDecodedPcmSha256": "a9aaae89159b3bc3a8ae7b343cee86ceccad6e9156bd051a7907244333351b1f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "1f54adca35b28601e714e675e5f666f57dfc0735aeb743bc06977b8da0a786e1",
+      "encodedBytes": 1093892,
+      "elapsedMilliseconds": 161.3038699999961,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7894,
+        "maximumFrameSize": 8026,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "e0ab70a4e3a8d9e373f720d5e52cfa68"
+      },
+      "nativeDecodedPcmSha256": "1f54adca35b28601e714e675e5f666f57dfc0735aeb743bc06977b8da0a786e1"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "1f54adca35b28601e714e675e5f666f57dfc0735aeb743bc06977b8da0a786e1",
+      "encodedBytes": 1093892,
+      "elapsedMilliseconds": 51.12087900000188,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7894,
+        "maximumFrameSize": 8026,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "e0ab70a4e3a8d9e373f720d5e52cfa68"
+      },
+      "nativeDecodedPcmSha256": "1f54adca35b28601e714e675e5f666f57dfc0735aeb743bc06977b8da0a786e1"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "65c8f28f921e06d2876ffa35765fefdeaefdfdbef66cdec9b4fda6c837106fc0",
+      "encodedBytes": 2211375,
+      "elapsedMilliseconds": 402.1533479999998,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1548,
+        "maximumFrameSize": 19561,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "852cbcac74613c45cf711c3e56a40ed6"
+      },
+      "nativeDecodedPcmSha256": "65c8f28f921e06d2876ffa35765fefdeaefdfdbef66cdec9b4fda6c837106fc0"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "65c8f28f921e06d2876ffa35765fefdeaefdfdbef66cdec9b4fda6c837106fc0",
+      "encodedBytes": 2211379,
+      "elapsedMilliseconds": 112.57095200000185,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1548,
+        "maximumFrameSize": 19561,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "852cbcac74613c45cf711c3e56a40ed6"
+      },
+      "nativeDecodedPcmSha256": "65c8f28f921e06d2876ffa35765fefdeaefdfdbef66cdec9b4fda6c837106fc0"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "42b9fdbea63544f90e683df82058eca4c5dca23bc3539047be92cf12a7c6d136",
+      "encodedBytes": 2322751,
+      "elapsedMilliseconds": 478.6334229999993,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 2092,
+        "maximumFrameSize": 19334,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "93eaab0be30ed181b4cea3e225c6544e"
+      },
+      "nativeDecodedPcmSha256": "42b9fdbea63544f90e683df82058eca4c5dca23bc3539047be92cf12a7c6d136"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "42b9fdbea63544f90e683df82058eca4c5dca23bc3539047be92cf12a7c6d136",
+      "encodedBytes": 2322749,
+      "elapsedMilliseconds": 125.47837900000013,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 2092,
+        "maximumFrameSize": 19334,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "93eaab0be30ed181b4cea3e225c6544e"
+      },
+      "nativeDecodedPcmSha256": "42b9fdbea63544f90e683df82058eca4c5dca23bc3539047be92cf12a7c6d136"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "fb3896dd6372aa0b8a3f68df45483ea73b28a18712fffcdf18897ee0a3205b8c",
+      "encodedBytes": 4591316,
+      "elapsedMilliseconds": 554.8197870000004,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1187,
+        "maximumFrameSize": 20319,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f9ffaea4787abb17141be3bb2706da0c"
+      },
+      "nativeDecodedPcmSha256": "fb3896dd6372aa0b8a3f68df45483ea73b28a18712fffcdf18897ee0a3205b8c"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "fb3896dd6372aa0b8a3f68df45483ea73b28a18712fffcdf18897ee0a3205b8c",
+      "encodedBytes": 4591315,
+      "elapsedMilliseconds": 132.76863199999934,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1187,
+        "maximumFrameSize": 20319,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f9ffaea4787abb17141be3bb2706da0c"
+      },
+      "nativeDecodedPcmSha256": "fb3896dd6372aa0b8a3f68df45483ea73b28a18712fffcdf18897ee0a3205b8c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 3,
+      "frames": 1046796,
+      "expectedPcmSha256": "712b3b3d76c5042a314846332371f806367b0f8fe2d9f5a0f26f7e234719402f",
+      "encodedBytes": 2390904,
+      "elapsedMilliseconds": 324.5476170000038,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1139,
+        "maximumFrameSize": 19646,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1046796",
+        "md5Hex": "ef20b4d4539a89c71fb61fbfb3974dd9"
+      },
+      "nativeDecodedPcmSha256": "712b3b3d76c5042a314846332371f806367b0f8fe2d9f5a0f26f7e234719402f"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 3,
+      "frames": 1046796,
+      "expectedPcmSha256": "712b3b3d76c5042a314846332371f806367b0f8fe2d9f5a0f26f7e234719402f",
+      "encodedBytes": 2390904,
+      "elapsedMilliseconds": 89.51235000000452,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1139,
+        "maximumFrameSize": 19646,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1046796",
+        "md5Hex": "ef20b4d4539a89c71fb61fbfb3974dd9"
+      },
+      "nativeDecodedPcmSha256": "712b3b3d76c5042a314846332371f806367b0f8fe2d9f5a0f26f7e234719402f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:76f8d36d4b2b6ed2efc19418250feaac1fe1868fd919c4c03a6e6f66e3e3f926",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "23c396618176630bd3af2e08a196598454feb5cc088b2f3430eb99dc7b631228",
+      "encodedBytes": 4937137,
+      "elapsedMilliseconds": 482.926532999998,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 10236,
+        "maximumFrameSize": 17583,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5307bab8edc1efd9a497689333954d72"
+      },
+      "nativeDecodedPcmSha256": "23c396618176630bd3af2e08a196598454feb5cc088b2f3430eb99dc7b631228"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:76f8d36d4b2b6ed2efc19418250feaac1fe1868fd919c4c03a6e6f66e3e3f926",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "23c396618176630bd3af2e08a196598454feb5cc088b2f3430eb99dc7b631228",
+      "encodedBytes": 4937137,
+      "elapsedMilliseconds": 121.04874700000073,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 10236,
+        "maximumFrameSize": 17583,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5307bab8edc1efd9a497689333954d72"
+      },
+      "nativeDecodedPcmSha256": "23c396618176630bd3af2e08a196598454feb5cc088b2f3430eb99dc7b631228"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:76f8d36d4b2b6ed2efc19418250feaac1fe1868fd919c4c03a6e6f66e3e3f926",
+      "chunkIndex": 1,
+      "frames": 582102,
+      "expectedPcmSha256": "b6f8c245441b191497cbe43678526f07a8c3d3cc12db92b88017a783d6aed512",
+      "encodedBytes": 2125904,
+      "elapsedMilliseconds": 189.9580649999989,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 504,
+        "maximumFrameSize": 18089,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "582102",
+        "md5Hex": "a97591cbcdd1cbc312ddbc3e1bcb87fc"
+      },
+      "nativeDecodedPcmSha256": "b6f8c245441b191497cbe43678526f07a8c3d3cc12db92b88017a783d6aed512"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:76f8d36d4b2b6ed2efc19418250feaac1fe1868fd919c4c03a6e6f66e3e3f926",
+      "chunkIndex": 1,
+      "frames": 582102,
+      "expectedPcmSha256": "b6f8c245441b191497cbe43678526f07a8c3d3cc12db92b88017a783d6aed512",
+      "encodedBytes": 2125904,
+      "elapsedMilliseconds": 52.57380800000101,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 504,
+        "maximumFrameSize": 18089,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "582102",
+        "md5Hex": "a97591cbcdd1cbc312ddbc3e1bcb87fc"
+      },
+      "nativeDecodedPcmSha256": "b6f8c245441b191497cbe43678526f07a8c3d3cc12db92b88017a783d6aed512"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:820926ccc8557b4cdf81d0c19933f1115dc371d5b53e46ddedb2a87bf4e4e197",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "024d2eb37862cb6bf6db15b26958f67a4652050a28172bcba4679dd104adab6f",
+      "encodedBytes": 3873752,
+      "elapsedMilliseconds": 549.4224509999985,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 16786,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9b443230fb327c1c66f044b6506908bb"
+      },
+      "nativeDecodedPcmSha256": "024d2eb37862cb6bf6db15b26958f67a4652050a28172bcba4679dd104adab6f"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:820926ccc8557b4cdf81d0c19933f1115dc371d5b53e46ddedb2a87bf4e4e197",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "024d2eb37862cb6bf6db15b26958f67a4652050a28172bcba4679dd104adab6f",
+      "encodedBytes": 3873792,
+      "elapsedMilliseconds": 130.88047299999744,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 16786,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9b443230fb327c1c66f044b6506908bb"
+      },
+      "nativeDecodedPcmSha256": "024d2eb37862cb6bf6db15b26958f67a4652050a28172bcba4679dd104adab6f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:820926ccc8557b4cdf81d0c19933f1115dc371d5b53e46ddedb2a87bf4e4e197",
+      "chunkIndex": 1,
+      "frames": 1201590,
+      "expectedPcmSha256": "125a5e3e22686866f06b6135bc7113921c4b1c3be48bd955ac301d573abf4483",
+      "encodedBytes": 3785562,
+      "elapsedMilliseconds": 513.4552990000011,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 204,
+        "maximumFrameSize": 17630,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1201590",
+        "md5Hex": "b3af88adf8c285751886ec5c7f89058c"
+      },
+      "nativeDecodedPcmSha256": "125a5e3e22686866f06b6135bc7113921c4b1c3be48bd955ac301d573abf4483"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:820926ccc8557b4cdf81d0c19933f1115dc371d5b53e46ddedb2a87bf4e4e197",
+      "chunkIndex": 1,
+      "frames": 1201590,
+      "expectedPcmSha256": "125a5e3e22686866f06b6135bc7113921c4b1c3be48bd955ac301d573abf4483",
+      "encodedBytes": 3785565,
+      "elapsedMilliseconds": 123.68244599999889,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 204,
+        "maximumFrameSize": 17630,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1201590",
+        "md5Hex": "b3af88adf8c285751886ec5c7f89058c"
+      },
+      "nativeDecodedPcmSha256": "125a5e3e22686866f06b6135bc7113921c4b1c3be48bd955ac301d573abf4483"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "a0bf84dc4c81916ccd105c692da94fff0a59d39a8154eb6c266a278fb3bd2762",
+      "encodedBytes": 4192669,
+      "elapsedMilliseconds": 446.8998670000001,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 11422,
+        "maximumFrameSize": 18306,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5b4ba26d280febae8940b7569d82f82d"
+      },
+      "nativeDecodedPcmSha256": "a0bf84dc4c81916ccd105c692da94fff0a59d39a8154eb6c266a278fb3bd2762"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "a0bf84dc4c81916ccd105c692da94fff0a59d39a8154eb6c266a278fb3bd2762",
+      "encodedBytes": 4192669,
+      "elapsedMilliseconds": 117.90356299999985,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 11422,
+        "maximumFrameSize": 18306,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5b4ba26d280febae8940b7569d82f82d"
+      },
+      "nativeDecodedPcmSha256": "a0bf84dc4c81916ccd105c692da94fff0a59d39a8154eb6c266a278fb3bd2762"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "0bca03d3827a10f809d4f15d1bb053e182507deaeec754edb0e9aed2f795d58f",
+      "encodedBytes": 4848686,
+      "elapsedMilliseconds": 516.3576590000011,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 11453,
+        "maximumFrameSize": 18073,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "510cd4f30db1b7a6acf0bbca4df9b291"
+      },
+      "nativeDecodedPcmSha256": "0bca03d3827a10f809d4f15d1bb053e182507deaeec754edb0e9aed2f795d58f"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "0bca03d3827a10f809d4f15d1bb053e182507deaeec754edb0e9aed2f795d58f",
+      "encodedBytes": 4848686,
+      "elapsedMilliseconds": 127.69463199999882,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 11453,
+        "maximumFrameSize": 18073,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "510cd4f30db1b7a6acf0bbca4df9b291"
+      },
+      "nativeDecodedPcmSha256": "0bca03d3827a10f809d4f15d1bb053e182507deaeec754edb0e9aed2f795d58f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "a4ff8fea4e0de7fa60fdae51ad711cd91f037cb46d5a9349bf1dca02acbbc5f5",
+      "encodedBytes": 4526232,
+      "elapsedMilliseconds": 505.8393240000005,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 11459,
+        "maximumFrameSize": 17182,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d8b635c44ececa10b608234674a067d8"
+      },
+      "nativeDecodedPcmSha256": "a4ff8fea4e0de7fa60fdae51ad711cd91f037cb46d5a9349bf1dca02acbbc5f5"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "a4ff8fea4e0de7fa60fdae51ad711cd91f037cb46d5a9349bf1dca02acbbc5f5",
+      "encodedBytes": 4526232,
+      "elapsedMilliseconds": 126.82030600000144,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 11459,
+        "maximumFrameSize": 17182,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d8b635c44ececa10b608234674a067d8"
+      },
+      "nativeDecodedPcmSha256": "a4ff8fea4e0de7fa60fdae51ad711cd91f037cb46d5a9349bf1dca02acbbc5f5"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "8f216c2fb91fd3ca55f340129e429be43b6026756b830491ef476ced4bce86ab",
+      "encodedBytes": 4906482,
+      "elapsedMilliseconds": 538.5536060000013,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 2388,
+        "maximumFrameSize": 18391,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "21ee978805ca43cda3cd06f8cda52115"
+      },
+      "nativeDecodedPcmSha256": "8f216c2fb91fd3ca55f340129e429be43b6026756b830491ef476ced4bce86ab"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "8f216c2fb91fd3ca55f340129e429be43b6026756b830491ef476ced4bce86ab",
+      "encodedBytes": 4906478,
+      "elapsedMilliseconds": 128.35539099999733,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 2388,
+        "maximumFrameSize": 18391,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "21ee978805ca43cda3cd06f8cda52115"
+      },
+      "nativeDecodedPcmSha256": "8f216c2fb91fd3ca55f340129e429be43b6026756b830491ef476ced4bce86ab"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "2206e4ac690835dbfca27792f1a86ace07f1ba2690e226e56f6e741e07e8f2e8",
+      "encodedBytes": 4753432,
+      "elapsedMilliseconds": 545.138202999995,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6945,
+        "maximumFrameSize": 19944,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f0d8a1b4dee3452819937b1150c61245"
+      },
+      "nativeDecodedPcmSha256": "2206e4ac690835dbfca27792f1a86ace07f1ba2690e226e56f6e741e07e8f2e8"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "2206e4ac690835dbfca27792f1a86ace07f1ba2690e226e56f6e741e07e8f2e8",
+      "encodedBytes": 4753431,
+      "elapsedMilliseconds": 132.90301700000418,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6945,
+        "maximumFrameSize": 19944,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f0d8a1b4dee3452819937b1150c61245"
+      },
+      "nativeDecodedPcmSha256": "2206e4ac690835dbfca27792f1a86ace07f1ba2690e226e56f6e741e07e8f2e8"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 5,
+      "frames": 1102500,
+      "expectedPcmSha256": "94d4191d8b99b19a6302a3ea00e8676f4391837f5f323c6eda44ce43119af8ce",
+      "encodedBytes": 3562930,
+      "elapsedMilliseconds": 438.7434710000016,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 419,
+        "maximumFrameSize": 20222,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1102500",
+        "md5Hex": "7d943016a2b411fbf33b8cab0b35910e"
+      },
+      "nativeDecodedPcmSha256": "94d4191d8b99b19a6302a3ea00e8676f4391837f5f323c6eda44ce43119af8ce"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 5,
+      "frames": 1102500,
+      "expectedPcmSha256": "94d4191d8b99b19a6302a3ea00e8676f4391837f5f323c6eda44ce43119af8ce",
+      "encodedBytes": 3562872,
+      "elapsedMilliseconds": 118.6599040000001,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 419,
+        "maximumFrameSize": 20222,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1102500",
+        "md5Hex": "7d943016a2b411fbf33b8cab0b35910e"
+      },
+      "nativeDecodedPcmSha256": "94d4191d8b99b19a6302a3ea00e8676f4391837f5f323c6eda44ce43119af8ce"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "a55e83e9d57a7e0b8a02c1589c368946d107e6fe45bf27732ce74cbf2cf1de14",
+      "encodedBytes": 2577349,
+      "elapsedMilliseconds": 391.0306469999996,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7745,
+        "maximumFrameSize": 8051,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "65d5924a754ff00c55d25d5f7706de7f"
+      },
+      "nativeDecodedPcmSha256": "a55e83e9d57a7e0b8a02c1589c368946d107e6fe45bf27732ce74cbf2cf1de14"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "a55e83e9d57a7e0b8a02c1589c368946d107e6fe45bf27732ce74cbf2cf1de14",
+      "encodedBytes": 2577349,
+      "elapsedMilliseconds": 112.19405199999892,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7745,
+        "maximumFrameSize": 8051,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "65d5924a754ff00c55d25d5f7706de7f"
+      },
+      "nativeDecodedPcmSha256": "a55e83e9d57a7e0b8a02c1589c368946d107e6fe45bf27732ce74cbf2cf1de14"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "2174a88c16a1582e995c5069a5f2887dbfd8b93a7cbd2b3c773cca9811be4835",
+      "encodedBytes": 3617407,
+      "elapsedMilliseconds": 462.4103410000025,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1952,
+        "maximumFrameSize": 16398,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "c1e031e278a7feff877baa055ebfce21"
+      },
+      "nativeDecodedPcmSha256": "2174a88c16a1582e995c5069a5f2887dbfd8b93a7cbd2b3c773cca9811be4835"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "2174a88c16a1582e995c5069a5f2887dbfd8b93a7cbd2b3c773cca9811be4835",
+      "encodedBytes": 3617407,
+      "elapsedMilliseconds": 123.8492929999993,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1952,
+        "maximumFrameSize": 16398,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "c1e031e278a7feff877baa055ebfce21"
+      },
+      "nativeDecodedPcmSha256": "2174a88c16a1582e995c5069a5f2887dbfd8b93a7cbd2b3c773cca9811be4835"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "9918d016f7c301fc23b8db32bc93184a134378824b8cdb7b3d76348b5d739dcc",
+      "encodedBytes": 3991391,
+      "elapsedMilliseconds": 510.09346899999946,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7966,
+        "maximumFrameSize": 16107,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2e2522b2dea00fdbff7d281e86ec99ad"
+      },
+      "nativeDecodedPcmSha256": "9918d016f7c301fc23b8db32bc93184a134378824b8cdb7b3d76348b5d739dcc"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "9918d016f7c301fc23b8db32bc93184a134378824b8cdb7b3d76348b5d739dcc",
+      "encodedBytes": 3991391,
+      "elapsedMilliseconds": 128.25406700000167,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7966,
+        "maximumFrameSize": 16107,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2e2522b2dea00fdbff7d281e86ec99ad"
+      },
+      "nativeDecodedPcmSha256": "9918d016f7c301fc23b8db32bc93184a134378824b8cdb7b3d76348b5d739dcc"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "1ecf66d2439e4d20cbe4ff066e34944b60652831ec88cb6a3ddd8fbae4be5832",
+      "encodedBytes": 3034301,
+      "elapsedMilliseconds": 440.9607860000033,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7959,
+        "maximumFrameSize": 11026,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2ca55659b0c0c12029977a3020fd2187"
+      },
+      "nativeDecodedPcmSha256": "1ecf66d2439e4d20cbe4ff066e34944b60652831ec88cb6a3ddd8fbae4be5832"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "1ecf66d2439e4d20cbe4ff066e34944b60652831ec88cb6a3ddd8fbae4be5832",
+      "encodedBytes": 3034301,
+      "elapsedMilliseconds": 115.95388800000364,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7959,
+        "maximumFrameSize": 11026,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2ca55659b0c0c12029977a3020fd2187"
+      },
+      "nativeDecodedPcmSha256": "1ecf66d2439e4d20cbe4ff066e34944b60652831ec88cb6a3ddd8fbae4be5832"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "00aae3147503f28168368f37d8f2fb603194a4fa8efa2b675b75792282976d98",
+      "encodedBytes": 4949257,
+      "elapsedMilliseconds": 578.7632980000053,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8171,
+        "maximumFrameSize": 16546,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "81235cfc81a4e37833e3ab0b612dd7ad"
+      },
+      "nativeDecodedPcmSha256": "00aae3147503f28168368f37d8f2fb603194a4fa8efa2b675b75792282976d98"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "00aae3147503f28168368f37d8f2fb603194a4fa8efa2b675b75792282976d98",
+      "encodedBytes": 4949256,
+      "elapsedMilliseconds": 136.62574000000313,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8171,
+        "maximumFrameSize": 16546,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "81235cfc81a4e37833e3ab0b612dd7ad"
+      },
+      "nativeDecodedPcmSha256": "00aae3147503f28168368f37d8f2fb603194a4fa8efa2b675b75792282976d98"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "92612943d9be9bb9339bf5ab99071d5b42a606add5b2d8d0316702c0cfddb6da",
+      "encodedBytes": 2613579,
+      "elapsedMilliseconds": 401.71714000000065,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7928,
+        "maximumFrameSize": 8257,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "071cfccfae1495e8786fea88af04f2fd"
+      },
+      "nativeDecodedPcmSha256": "92612943d9be9bb9339bf5ab99071d5b42a606add5b2d8d0316702c0cfddb6da"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "92612943d9be9bb9339bf5ab99071d5b42a606add5b2d8d0316702c0cfddb6da",
+      "encodedBytes": 2613579,
+      "elapsedMilliseconds": 114.28819199999998,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7928,
+        "maximumFrameSize": 8257,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "071cfccfae1495e8786fea88af04f2fd"
+      },
+      "nativeDecodedPcmSha256": "92612943d9be9bb9339bf5ab99071d5b42a606add5b2d8d0316702c0cfddb6da"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "c28846b24eb143541dfa6661d24ec39cf492210d147cc6af216f98a6d7184e12",
+      "encodedBytes": 1108585,
+      "elapsedMilliseconds": 191.3294259999966,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7906,
+        "maximumFrameSize": 8224,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "012effc1b8d5e01259d60b79584a1192"
+      },
+      "nativeDecodedPcmSha256": "c28846b24eb143541dfa6661d24ec39cf492210d147cc6af216f98a6d7184e12"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "c28846b24eb143541dfa6661d24ec39cf492210d147cc6af216f98a6d7184e12",
+      "encodedBytes": 1108585,
+      "elapsedMilliseconds": 50.040569000004325,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7906,
+        "maximumFrameSize": 8224,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "012effc1b8d5e01259d60b79584a1192"
+      },
+      "nativeDecodedPcmSha256": "c28846b24eb143541dfa6661d24ec39cf492210d147cc6af216f98a6d7184e12"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "d8821208237f3f366dc6126255ccaeee18763a71346ac327e7e8eb0a254f1ab2",
+      "encodedBytes": 2367250,
+      "elapsedMilliseconds": 430.4345749999993,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 20391,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "3d61c3e2e8546136541599bab97164ac"
+      },
+      "nativeDecodedPcmSha256": "d8821208237f3f366dc6126255ccaeee18763a71346ac327e7e8eb0a254f1ab2"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "d8821208237f3f366dc6126255ccaeee18763a71346ac327e7e8eb0a254f1ab2",
+      "encodedBytes": 2367250,
+      "elapsedMilliseconds": 114.00880000000325,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 20391,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "3d61c3e2e8546136541599bab97164ac"
+      },
+      "nativeDecodedPcmSha256": "d8821208237f3f366dc6126255ccaeee18763a71346ac327e7e8eb0a254f1ab2"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "099b094dc0a74b685de3e0642a5fd801b328cadb5e794248d39e7c9f73161362",
+      "encodedBytes": 2658138,
+      "elapsedMilliseconds": 444.43997300000046,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1044,
+        "maximumFrameSize": 20238,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "4ce8d2781a93a27607c0f0146fe1d9a2"
+      },
+      "nativeDecodedPcmSha256": "099b094dc0a74b685de3e0642a5fd801b328cadb5e794248d39e7c9f73161362"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "099b094dc0a74b685de3e0642a5fd801b328cadb5e794248d39e7c9f73161362",
+      "encodedBytes": 2658137,
+      "elapsedMilliseconds": 117.49214799999754,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1044,
+        "maximumFrameSize": 20238,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "4ce8d2781a93a27607c0f0146fe1d9a2"
+      },
+      "nativeDecodedPcmSha256": "099b094dc0a74b685de3e0642a5fd801b328cadb5e794248d39e7c9f73161362"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "947a4950af1a258c381417d8510da94dd114723b65611f3ae8de07587b0f4726",
+      "encodedBytes": 3781308,
+      "elapsedMilliseconds": 512.5446569999986,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 20802,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f3e691578150457b93be115a6d7b31f4"
+      },
+      "nativeDecodedPcmSha256": "947a4950af1a258c381417d8510da94dd114723b65611f3ae8de07587b0f4726"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "947a4950af1a258c381417d8510da94dd114723b65611f3ae8de07587b0f4726",
+      "encodedBytes": 3781317,
+      "elapsedMilliseconds": 126.73265700000047,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 20802,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f3e691578150457b93be115a6d7b31f4"
+      },
+      "nativeDecodedPcmSha256": "947a4950af1a258c381417d8510da94dd114723b65611f3ae8de07587b0f4726"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 3,
+      "frames": 916741,
+      "expectedPcmSha256": "1704ebcf5b3c81b703e1ecda346ebfc12a84421a0a83ccb9a75b7a53ddabc86c",
+      "encodedBytes": 2509206,
+      "elapsedMilliseconds": 335.6908260000055,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 20623,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "916741",
+        "md5Hex": "b28f2ba706e0f797f80ef1c129fc1519"
+      },
+      "nativeDecodedPcmSha256": "1704ebcf5b3c81b703e1ecda346ebfc12a84421a0a83ccb9a75b7a53ddabc86c"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 3,
+      "frames": 916741,
+      "expectedPcmSha256": "1704ebcf5b3c81b703e1ecda346ebfc12a84421a0a83ccb9a75b7a53ddabc86c",
+      "encodedBytes": 2509207,
+      "elapsedMilliseconds": 86.197451,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 20623,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "916741",
+        "md5Hex": "b28f2ba706e0f797f80ef1c129fc1519"
+      },
+      "nativeDecodedPcmSha256": "1704ebcf5b3c81b703e1ecda346ebfc12a84421a0a83ccb9a75b7a53ddabc86c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "997fc12d1dbcbbf349b26a411d00fed8af4c3132fba56a850d91927b6afd7a19",
+      "encodedBytes": 2598970,
+      "elapsedMilliseconds": 413.4149800000014,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 531,
+        "maximumFrameSize": 20913,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2eecabe04698ad77539ff46ecb1ffff8"
+      },
+      "nativeDecodedPcmSha256": "997fc12d1dbcbbf349b26a411d00fed8af4c3132fba56a850d91927b6afd7a19"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "997fc12d1dbcbbf349b26a411d00fed8af4c3132fba56a850d91927b6afd7a19",
+      "encodedBytes": 2598964,
+      "elapsedMilliseconds": 112.67887500000506,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 531,
+        "maximumFrameSize": 20913,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2eecabe04698ad77539ff46ecb1ffff8"
+      },
+      "nativeDecodedPcmSha256": "997fc12d1dbcbbf349b26a411d00fed8af4c3132fba56a850d91927b6afd7a19"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "bc594e7e42791865271b0235bb7aad216405822db4e107e5bf1e4f46e3666ff4",
+      "encodedBytes": 2091903,
+      "elapsedMilliseconds": 410.6058059999996,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1041,
+        "maximumFrameSize": 20849,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "786a2e9f69216a3532e7f872d8543dad"
+      },
+      "nativeDecodedPcmSha256": "bc594e7e42791865271b0235bb7aad216405822db4e107e5bf1e4f46e3666ff4"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "bc594e7e42791865271b0235bb7aad216405822db4e107e5bf1e4f46e3666ff4",
+      "encodedBytes": 2091921,
+      "elapsedMilliseconds": 113.77276999999594,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1041,
+        "maximumFrameSize": 20849,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "786a2e9f69216a3532e7f872d8543dad"
+      },
+      "nativeDecodedPcmSha256": "bc594e7e42791865271b0235bb7aad216405822db4e107e5bf1e4f46e3666ff4"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "a03e75db825cb2754ee597c2a1c4c61e295a9eae5c27932ab847b390f47a5601",
+      "encodedBytes": 2873663,
+      "elapsedMilliseconds": 464.00077799999417,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 546,
+        "maximumFrameSize": 20901,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "99f6e579028fe5e4b5eff5eb8deae40d"
+      },
+      "nativeDecodedPcmSha256": "a03e75db825cb2754ee597c2a1c4c61e295a9eae5c27932ab847b390f47a5601"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "a03e75db825cb2754ee597c2a1c4c61e295a9eae5c27932ab847b390f47a5601",
+      "encodedBytes": 2873661,
+      "elapsedMilliseconds": 117.76483699999517,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 546,
+        "maximumFrameSize": 20901,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "99f6e579028fe5e4b5eff5eb8deae40d"
+      },
+      "nativeDecodedPcmSha256": "a03e75db825cb2754ee597c2a1c4c61e295a9eae5c27932ab847b390f47a5601"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 3,
+      "frames": 528117,
+      "expectedPcmSha256": "b667bd900e6d2a78c980afce335361280d75a02d45b93afaf53f1b9a6a37df37",
+      "encodedBytes": 1045515,
+      "elapsedMilliseconds": 163.04610700000194,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 514,
+        "maximumFrameSize": 20819,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "528117",
+        "md5Hex": "bd43c65ac8eb4dd7451a6c8ee685692e"
+      },
+      "nativeDecodedPcmSha256": "b667bd900e6d2a78c980afce335361280d75a02d45b93afaf53f1b9a6a37df37"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 3,
+      "frames": 528117,
+      "expectedPcmSha256": "b667bd900e6d2a78c980afce335361280d75a02d45b93afaf53f1b9a6a37df37",
+      "encodedBytes": 1045514,
+      "elapsedMilliseconds": 46.35675899999478,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 514,
+        "maximumFrameSize": 20819,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "528117",
+        "md5Hex": "bd43c65ac8eb4dd7451a6c8ee685692e"
+      },
+      "nativeDecodedPcmSha256": "b667bd900e6d2a78c980afce335361280d75a02d45b93afaf53f1b9a6a37df37"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "d6dd68e175e45d08fa7fb81c835c58c9fe7da612c54be548767f948ba83d149c",
+      "encodedBytes": 2288154,
+      "elapsedMilliseconds": 498.8007629999993,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 10698,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "3380311316eefe07ca45fd8a6f3239bd"
+      },
+      "nativeDecodedPcmSha256": "d6dd68e175e45d08fa7fb81c835c58c9fe7da612c54be548767f948ba83d149c"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "d6dd68e175e45d08fa7fb81c835c58c9fe7da612c54be548767f948ba83d149c",
+      "encodedBytes": 2288163,
+      "elapsedMilliseconds": 123.5060480000102,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 10698,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "3380311316eefe07ca45fd8a6f3239bd"
+      },
+      "nativeDecodedPcmSha256": "d6dd68e175e45d08fa7fb81c835c58c9fe7da612c54be548767f948ba83d149c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "a013f58057e3192997704773f30e0f9b43251052648c2709523a784dde83d15a",
+      "encodedBytes": 2522256,
+      "elapsedMilliseconds": 488.8558009999979,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 10845,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d8621036960bf9f8a2faf42fe1146622"
+      },
+      "nativeDecodedPcmSha256": "a013f58057e3192997704773f30e0f9b43251052648c2709523a784dde83d15a"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "a013f58057e3192997704773f30e0f9b43251052648c2709523a784dde83d15a",
+      "encodedBytes": 2522167,
+      "elapsedMilliseconds": 122.01344300000346,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 10845,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d8621036960bf9f8a2faf42fe1146622"
+      },
+      "nativeDecodedPcmSha256": "a013f58057e3192997704773f30e0f9b43251052648c2709523a784dde83d15a"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "3b6cd32604fb1bb615b4eefbf0566819bb0fa41f6cec25ccda38473b3b27fe6c",
+      "encodedBytes": 3396221,
+      "elapsedMilliseconds": 520.1848230000032,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 12386,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "909948b003e4e1cf617d6dca19037e7a"
+      },
+      "nativeDecodedPcmSha256": "3b6cd32604fb1bb615b4eefbf0566819bb0fa41f6cec25ccda38473b3b27fe6c"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "3b6cd32604fb1bb615b4eefbf0566819bb0fa41f6cec25ccda38473b3b27fe6c",
+      "encodedBytes": 3396209,
+      "elapsedMilliseconds": 125.5718840000045,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 12386,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "909948b003e4e1cf617d6dca19037e7a"
+      },
+      "nativeDecodedPcmSha256": "3b6cd32604fb1bb615b4eefbf0566819bb0fa41f6cec25ccda38473b3b27fe6c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 3,
+      "frames": 97514,
+      "expectedPcmSha256": "8e60ccdf9088a1c5f09ef9dc7ac302dbb9bf22936642e24011f92c0137a7088b",
+      "encodedBytes": 149408,
+      "elapsedMilliseconds": 44.5074750000058,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 437,
+        "maximumFrameSize": 11467,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "97514",
+        "md5Hex": "b183f306ecf69ca5d8d2c788312be84d"
+      },
+      "nativeDecodedPcmSha256": "8e60ccdf9088a1c5f09ef9dc7ac302dbb9bf22936642e24011f92c0137a7088b"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 3,
+      "frames": 97514,
+      "expectedPcmSha256": "8e60ccdf9088a1c5f09ef9dc7ac302dbb9bf22936642e24011f92c0137a7088b",
+      "encodedBytes": 149411,
+      "elapsedMilliseconds": 10.514898000008543,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 437,
+        "maximumFrameSize": 11467,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "97514",
+        "md5Hex": "b183f306ecf69ca5d8d2c788312be84d"
+      },
+      "nativeDecodedPcmSha256": "8e60ccdf9088a1c5f09ef9dc7ac302dbb9bf22936642e24011f92c0137a7088b"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:b613c11eea1c43c0a0fed317bea191d09146b818c4fe8e7a781cec1061b781f1",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "20e6f57d0c7a4d86fe1d9b41a4589e043a45f28172189bde30d153a30b893295",
+      "encodedBytes": 3711107,
+      "elapsedMilliseconds": 504.3861959999922,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 17631,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f38b4f91f48e87fe5c66e430ac9b6dcf"
+      },
+      "nativeDecodedPcmSha256": "20e6f57d0c7a4d86fe1d9b41a4589e043a45f28172189bde30d153a30b893295"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:b613c11eea1c43c0a0fed317bea191d09146b818c4fe8e7a781cec1061b781f1",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "20e6f57d0c7a4d86fe1d9b41a4589e043a45f28172189bde30d153a30b893295",
+      "encodedBytes": 3711107,
+      "elapsedMilliseconds": 123.8156170000002,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 17631,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f38b4f91f48e87fe5c66e430ac9b6dcf"
+      },
+      "nativeDecodedPcmSha256": "20e6f57d0c7a4d86fe1d9b41a4589e043a45f28172189bde30d153a30b893295"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:b613c11eea1c43c0a0fed317bea191d09146b818c4fe8e7a781cec1061b781f1",
+      "chunkIndex": 1,
+      "frames": 206195,
+      "expectedPcmSha256": "33d319edbc97be7960054e657ead189865b1441d4771acc21abf99e792d03517",
+      "encodedBytes": 509176,
+      "elapsedMilliseconds": 86.95812999999907,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 194,
+        "maximumFrameSize": 17636,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "206195",
+        "md5Hex": "fc2a86a49c985d2344984cb33331c26f"
+      },
+      "nativeDecodedPcmSha256": "33d319edbc97be7960054e657ead189865b1441d4771acc21abf99e792d03517"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:b613c11eea1c43c0a0fed317bea191d09146b818c4fe8e7a781cec1061b781f1",
+      "chunkIndex": 1,
+      "frames": 206195,
+      "expectedPcmSha256": "33d319edbc97be7960054e657ead189865b1441d4771acc21abf99e792d03517",
+      "encodedBytes": 509176,
+      "elapsedMilliseconds": 20.299523000008776,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 194,
+        "maximumFrameSize": 17636,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "206195",
+        "md5Hex": "fc2a86a49c985d2344984cb33331c26f"
+      },
+      "nativeDecodedPcmSha256": "33d319edbc97be7960054e657ead189865b1441d4771acc21abf99e792d03517"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "bf0875df024093a82fb77c21c3be693044f912a4f2e659efadfeba298c725d8c",
+      "encodedBytes": 837695,
+      "elapsedMilliseconds": 323.0182439999917,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 4448,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "0596bd594b76494663e751a8a82158e2"
+      },
+      "nativeDecodedPcmSha256": "bf0875df024093a82fb77c21c3be693044f912a4f2e659efadfeba298c725d8c"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "bf0875df024093a82fb77c21c3be693044f912a4f2e659efadfeba298c725d8c",
+      "encodedBytes": 837717,
+      "elapsedMilliseconds": 93.69093100000464,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 4448,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "0596bd594b76494663e751a8a82158e2"
+      },
+      "nativeDecodedPcmSha256": "bf0875df024093a82fb77c21c3be693044f912a4f2e659efadfeba298c725d8c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "73a9d535d1674e035dd0f426e0409ac40ee779244220f4c4ea0b274df403038a",
+      "encodedBytes": 1898730,
+      "elapsedMilliseconds": 411.24888899999496,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 10673,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fefcbb6dd17769d996c86328d9e28387"
+      },
+      "nativeDecodedPcmSha256": "73a9d535d1674e035dd0f426e0409ac40ee779244220f4c4ea0b274df403038a"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "73a9d535d1674e035dd0f426e0409ac40ee779244220f4c4ea0b274df403038a",
+      "encodedBytes": 1898820,
+      "elapsedMilliseconds": 108.47114600001078,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 10673,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fefcbb6dd17769d996c86328d9e28387"
+      },
+      "nativeDecodedPcmSha256": "73a9d535d1674e035dd0f426e0409ac40ee779244220f4c4ea0b274df403038a"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "4abd9d2c9ef25b837cdda5a8d4b93da148e1877cd3db7b18657b07b75c0df88b",
+      "encodedBytes": 979468,
+      "elapsedMilliseconds": 350.5765400000091,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 5175,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "dcde8895a7df83f9d3e6b74e747e78e9"
+      },
+      "nativeDecodedPcmSha256": "4abd9d2c9ef25b837cdda5a8d4b93da148e1877cd3db7b18657b07b75c0df88b"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "4abd9d2c9ef25b837cdda5a8d4b93da148e1877cd3db7b18657b07b75c0df88b",
+      "encodedBytes": 979348,
+      "elapsedMilliseconds": 94.1005210000003,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 5175,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "dcde8895a7df83f9d3e6b74e747e78e9"
+      },
+      "nativeDecodedPcmSha256": "4abd9d2c9ef25b837cdda5a8d4b93da148e1877cd3db7b18657b07b75c0df88b"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 3,
+      "frames": 240708,
+      "expectedPcmSha256": "2c0376459f084817fbe05021a99473a51ffac58d3b89f6249a9e608361c24153",
+      "encodedBytes": 135559,
+      "elapsedMilliseconds": 56.90012999999453,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 4179,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "240708",
+        "md5Hex": "8cc8b65893452e498d410d6d870f2ce5"
+      },
+      "nativeDecodedPcmSha256": "2c0376459f084817fbe05021a99473a51ffac58d3b89f6249a9e608361c24153"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 3,
+      "frames": 240708,
+      "expectedPcmSha256": "2c0376459f084817fbe05021a99473a51ffac58d3b89f6249a9e608361c24153",
+      "encodedBytes": 135582,
+      "elapsedMilliseconds": 18.432786000004853,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 4179,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "240708",
+        "md5Hex": "8cc8b65893452e498d410d6d870f2ce5"
+      },
+      "nativeDecodedPcmSha256": "2c0376459f084817fbe05021a99473a51ffac58d3b89f6249a9e608361c24153"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "acb2a0065558fa0e65f94f9cbd917cb884ff12da69ef71238056ec3498f89484",
+      "encodedBytes": 3500055,
+      "elapsedMilliseconds": 545.9135300000053,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5516,
+        "maximumFrameSize": 18157,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "23d423ad6ad760b82e3d6c2246d86238"
+      },
+      "nativeDecodedPcmSha256": "acb2a0065558fa0e65f94f9cbd917cb884ff12da69ef71238056ec3498f89484"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "acb2a0065558fa0e65f94f9cbd917cb884ff12da69ef71238056ec3498f89484",
+      "encodedBytes": 3500055,
+      "elapsedMilliseconds": 131.83744399998977,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5516,
+        "maximumFrameSize": 18157,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "23d423ad6ad760b82e3d6c2246d86238"
+      },
+      "nativeDecodedPcmSha256": "acb2a0065558fa0e65f94f9cbd917cb884ff12da69ef71238056ec3498f89484"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "c08dc080013b95d43386834bec404adfadfe00d148e5d8b09aa7133579d651fb",
+      "encodedBytes": 5094024,
+      "elapsedMilliseconds": 554.1746620000049,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6350,
+        "maximumFrameSize": 20480,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "ef76a0cd4dfc91fa32d5e4d3cba91719"
+      },
+      "nativeDecodedPcmSha256": "c08dc080013b95d43386834bec404adfadfe00d148e5d8b09aa7133579d651fb"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "c08dc080013b95d43386834bec404adfadfe00d148e5d8b09aa7133579d651fb",
+      "encodedBytes": 5094024,
+      "elapsedMilliseconds": 130.88223300001118,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6350,
+        "maximumFrameSize": 20480,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "ef76a0cd4dfc91fa32d5e4d3cba91719"
+      },
+      "nativeDecodedPcmSha256": "c08dc080013b95d43386834bec404adfadfe00d148e5d8b09aa7133579d651fb"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "39151af29546d5b05e982e1c5a5f313b3105eff8a80d9a9cc5f1ebf195a8c389",
+      "encodedBytes": 4681716,
+      "elapsedMilliseconds": 579.502146999992,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6331,
+        "maximumFrameSize": 18814,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "774d9efdff3c37ae566ff518b80f8f40"
+      },
+      "nativeDecodedPcmSha256": "39151af29546d5b05e982e1c5a5f313b3105eff8a80d9a9cc5f1ebf195a8c389"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "39151af29546d5b05e982e1c5a5f313b3105eff8a80d9a9cc5f1ebf195a8c389",
+      "encodedBytes": 4681716,
+      "elapsedMilliseconds": 133.76917500000854,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6331,
+        "maximumFrameSize": 18814,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "774d9efdff3c37ae566ff518b80f8f40"
+      },
+      "nativeDecodedPcmSha256": "39151af29546d5b05e982e1c5a5f313b3105eff8a80d9a9cc5f1ebf195a8c389"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "649b462aa016a111211498488ffca8da24e16f1a9b594f58bf38fb03933bb4f5",
+      "encodedBytes": 5095991,
+      "elapsedMilliseconds": 568.9935199999891,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6880,
+        "maximumFrameSize": 20409,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "35bb887ffcd20cc9acb7fe0832ca84dd"
+      },
+      "nativeDecodedPcmSha256": "649b462aa016a111211498488ffca8da24e16f1a9b594f58bf38fb03933bb4f5"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "649b462aa016a111211498488ffca8da24e16f1a9b594f58bf38fb03933bb4f5",
+      "encodedBytes": 5095990,
+      "elapsedMilliseconds": 131.20838399999775,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6880,
+        "maximumFrameSize": 20409,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "35bb887ffcd20cc9acb7fe0832ca84dd"
+      },
+      "nativeDecodedPcmSha256": "649b462aa016a111211498488ffca8da24e16f1a9b594f58bf38fb03933bb4f5"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 4,
+      "frames": 913965,
+      "expectedPcmSha256": "cc11220dae84517c06488c4397c4f54629614cfb4b1bf99262af541086f86a8b",
+      "encodedBytes": 3704141,
+      "elapsedMilliseconds": 392.0316759999987,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 827,
+        "maximumFrameSize": 20547,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "913965",
+        "md5Hex": "0f0a8a4ec11425e8cdef46082e7f031b"
+      },
+      "nativeDecodedPcmSha256": "cc11220dae84517c06488c4397c4f54629614cfb4b1bf99262af541086f86a8b"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 4,
+      "frames": 913965,
+      "expectedPcmSha256": "cc11220dae84517c06488c4397c4f54629614cfb4b1bf99262af541086f86a8b",
+      "encodedBytes": 3704141,
+      "elapsedMilliseconds": 92.37932100000035,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 827,
+        "maximumFrameSize": 20547,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "913965",
+        "md5Hex": "0f0a8a4ec11425e8cdef46082e7f031b"
+      },
+      "nativeDecodedPcmSha256": "cc11220dae84517c06488c4397c4f54629614cfb4b1bf99262af541086f86a8b"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "4ef0e5b27bc3175da2611e8d22d8352ff615550fd0c8798ef04071383a43a7ca",
+      "encodedBytes": 3847857,
+      "elapsedMilliseconds": 501.26266999999643,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6684,
+        "maximumFrameSize": 16691,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2e98a79b3a31ce532600e77f6b5e7e7d"
+      },
+      "nativeDecodedPcmSha256": "4ef0e5b27bc3175da2611e8d22d8352ff615550fd0c8798ef04071383a43a7ca"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "4ef0e5b27bc3175da2611e8d22d8352ff615550fd0c8798ef04071383a43a7ca",
+      "encodedBytes": 3847857,
+      "elapsedMilliseconds": 129.97154699999373,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6684,
+        "maximumFrameSize": 16691,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2e98a79b3a31ce532600e77f6b5e7e7d"
+      },
+      "nativeDecodedPcmSha256": "4ef0e5b27bc3175da2611e8d22d8352ff615550fd0c8798ef04071383a43a7ca"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "587dd69e42fa09749cd48eedf40a783fa77b08725df7cfd075a64584ebb17dbb",
+      "encodedBytes": 3970124,
+      "elapsedMilliseconds": 485.2955409999995,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1196,
+        "maximumFrameSize": 17182,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f5676f5bae407203be9f183bfcaea527"
+      },
+      "nativeDecodedPcmSha256": "587dd69e42fa09749cd48eedf40a783fa77b08725df7cfd075a64584ebb17dbb"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "587dd69e42fa09749cd48eedf40a783fa77b08725df7cfd075a64584ebb17dbb",
+      "encodedBytes": 3970104,
+      "elapsedMilliseconds": 126.5947029999952,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1196,
+        "maximumFrameSize": 17182,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f5676f5bae407203be9f183bfcaea527"
+      },
+      "nativeDecodedPcmSha256": "587dd69e42fa09749cd48eedf40a783fa77b08725df7cfd075a64584ebb17dbb"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "303270e98d22c7b40606f19da04a268425ffac83d8791fda0c1179014baa86c8",
+      "encodedBytes": 4303215,
+      "elapsedMilliseconds": 536.4173609999998,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5428,
+        "maximumFrameSize": 16965,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "07bbb32ad29a4ed4c59d9f2b2da5ea43"
+      },
+      "nativeDecodedPcmSha256": "303270e98d22c7b40606f19da04a268425ffac83d8791fda0c1179014baa86c8"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "303270e98d22c7b40606f19da04a268425ffac83d8791fda0c1179014baa86c8",
+      "encodedBytes": 4303218,
+      "elapsedMilliseconds": 130.3423039999907,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5428,
+        "maximumFrameSize": 16965,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "07bbb32ad29a4ed4c59d9f2b2da5ea43"
+      },
+      "nativeDecodedPcmSha256": "303270e98d22c7b40606f19da04a268425ffac83d8791fda0c1179014baa86c8"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "77801ccb085effccbfae0aa9aa1afd856abc76f9c332a1cd0bf949775ca33d4c",
+      "encodedBytes": 4322996,
+      "elapsedMilliseconds": 478.16813900000125,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1089,
+        "maximumFrameSize": 17827,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "c7fe1b47b098ffe3917cc8c54dd51e94"
+      },
+      "nativeDecodedPcmSha256": "77801ccb085effccbfae0aa9aa1afd856abc76f9c332a1cd0bf949775ca33d4c"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "77801ccb085effccbfae0aa9aa1afd856abc76f9c332a1cd0bf949775ca33d4c",
+      "encodedBytes": 4322990,
+      "elapsedMilliseconds": 122.47983999999997,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1089,
+        "maximumFrameSize": 17827,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "c7fe1b47b098ffe3917cc8c54dd51e94"
+      },
+      "nativeDecodedPcmSha256": "77801ccb085effccbfae0aa9aa1afd856abc76f9c332a1cd0bf949775ca33d4c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "09e611be443a7e3e11fbdce77a600971254eac99a84ceb56e22687ffc6b181ee",
+      "encodedBytes": 3348173,
+      "elapsedMilliseconds": 548.1215430000011,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 4639,
+        "maximumFrameSize": 15549,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d34c75f3326ffaa632879bf0c4bcf6e4"
+      },
+      "nativeDecodedPcmSha256": "09e611be443a7e3e11fbdce77a600971254eac99a84ceb56e22687ffc6b181ee"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "09e611be443a7e3e11fbdce77a600971254eac99a84ceb56e22687ffc6b181ee",
+      "encodedBytes": 3348207,
+      "elapsedMilliseconds": 133.06999099999666,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 4639,
+        "maximumFrameSize": 15549,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d34c75f3326ffaa632879bf0c4bcf6e4"
+      },
+      "nativeDecodedPcmSha256": "09e611be443a7e3e11fbdce77a600971254eac99a84ceb56e22687ffc6b181ee"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 5,
+      "frames": 787999,
+      "expectedPcmSha256": "df5cc90e42602310ecdc1aa55a4daf101fc4601d9583db1f84b12c121b25217b",
+      "encodedBytes": 1533261,
+      "elapsedMilliseconds": 305.3178199999966,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1273,
+        "maximumFrameSize": 10344,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "787999",
+        "md5Hex": "79380b4778c85cd98c9c12b0f00ace39"
+      },
+      "nativeDecodedPcmSha256": "df5cc90e42602310ecdc1aa55a4daf101fc4601d9583db1f84b12c121b25217b"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 5,
+      "frames": 787999,
+      "expectedPcmSha256": "df5cc90e42602310ecdc1aa55a4daf101fc4601d9583db1f84b12c121b25217b",
+      "encodedBytes": 1533304,
+      "elapsedMilliseconds": 72.07522800000152,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1273,
+        "maximumFrameSize": 10344,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "787999",
+        "md5Hex": "79380b4778c85cd98c9c12b0f00ace39"
+      },
+      "nativeDecodedPcmSha256": "df5cc90e42602310ecdc1aa55a4daf101fc4601d9583db1f84b12c121b25217b"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "e4ce6eccdfae581a69ad7d053af770d4dbcd06c793413b03a4ed3fafdd9cc780",
+      "encodedBytes": 1077045,
+      "elapsedMilliseconds": 412.0910799999983,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1098,
+        "maximumFrameSize": 8211,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "4aff88652345da2edbd6a527805f7254"
+      },
+      "nativeDecodedPcmSha256": "e4ce6eccdfae581a69ad7d053af770d4dbcd06c793413b03a4ed3fafdd9cc780"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "e4ce6eccdfae581a69ad7d053af770d4dbcd06c793413b03a4ed3fafdd9cc780",
+      "encodedBytes": 1077045,
+      "elapsedMilliseconds": 109.61492500000168,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1098,
+        "maximumFrameSize": 8211,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "4aff88652345da2edbd6a527805f7254"
+      },
+      "nativeDecodedPcmSha256": "e4ce6eccdfae581a69ad7d053af770d4dbcd06c793413b03a4ed3fafdd9cc780"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "f17804e177224c0871b40263007f2f9197cabb5587de4b02835ae91cbf268f35",
+      "encodedBytes": 2026435,
+      "elapsedMilliseconds": 561.7443619999976,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5105,
+        "maximumFrameSize": 8224,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "36407f1308b1957e1b6144f30aa22a38"
+      },
+      "nativeDecodedPcmSha256": "f17804e177224c0871b40263007f2f9197cabb5587de4b02835ae91cbf268f35"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "f17804e177224c0871b40263007f2f9197cabb5587de4b02835ae91cbf268f35",
+      "encodedBytes": 2026471,
+      "elapsedMilliseconds": 132.6114280000038,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5105,
+        "maximumFrameSize": 8220,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "36407f1308b1957e1b6144f30aa22a38"
+      },
+      "nativeDecodedPcmSha256": "f17804e177224c0871b40263007f2f9197cabb5587de4b02835ae91cbf268f35"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "7d0ff510517cdf903b7d82524b87531c1fa8fb4caab35f49c40715da28eb7fed",
+      "encodedBytes": 2709275,
+      "elapsedMilliseconds": 564.6863069999963,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7303,
+        "maximumFrameSize": 9110,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "86d21455e0c45c41c61c1067efc5e624"
+      },
+      "nativeDecodedPcmSha256": "7d0ff510517cdf903b7d82524b87531c1fa8fb4caab35f49c40715da28eb7fed"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "7d0ff510517cdf903b7d82524b87531c1fa8fb4caab35f49c40715da28eb7fed",
+      "encodedBytes": 2709350,
+      "elapsedMilliseconds": 133.90364899999986,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7303,
+        "maximumFrameSize": 9110,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "86d21455e0c45c41c61c1067efc5e624"
+      },
+      "nativeDecodedPcmSha256": "7d0ff510517cdf903b7d82524b87531c1fa8fb4caab35f49c40715da28eb7fed"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "d030e1b082aca6c48acb78cef0f175a2385cca984a05c4056ed8b06d7cf33e25",
+      "encodedBytes": 3124543,
+      "elapsedMilliseconds": 597.1103350000049,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8177,
+        "maximumFrameSize": 11438,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "e924974998afc7ee2ecb97289590446f"
+      },
+      "nativeDecodedPcmSha256": "d030e1b082aca6c48acb78cef0f175a2385cca984a05c4056ed8b06d7cf33e25"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "d030e1b082aca6c48acb78cef0f175a2385cca984a05c4056ed8b06d7cf33e25",
+      "encodedBytes": 3124526,
+      "elapsedMilliseconds": 147.57751600000483,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8177,
+        "maximumFrameSize": 11439,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "e924974998afc7ee2ecb97289590446f"
+      },
+      "nativeDecodedPcmSha256": "d030e1b082aca6c48acb78cef0f175a2385cca984a05c4056ed8b06d7cf33e25"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "af48460f9080df1be76b9ff6f454b28edb83901dccf8f3fdc1c76aa34d19269a",
+      "encodedBytes": 2993865,
+      "elapsedMilliseconds": 589.4661780000024,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8260,
+        "maximumFrameSize": 11365,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b5d1e81a1ee43f3aaedc77d43ef8b663"
+      },
+      "nativeDecodedPcmSha256": "af48460f9080df1be76b9ff6f454b28edb83901dccf8f3fdc1c76aa34d19269a"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "af48460f9080df1be76b9ff6f454b28edb83901dccf8f3fdc1c76aa34d19269a",
+      "encodedBytes": 2993794,
+      "elapsedMilliseconds": 137.69346099998802,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8260,
+        "maximumFrameSize": 11368,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b5d1e81a1ee43f3aaedc77d43ef8b663"
+      },
+      "nativeDecodedPcmSha256": "af48460f9080df1be76b9ff6f454b28edb83901dccf8f3fdc1c76aa34d19269a"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 5,
+      "frames": 129916,
+      "expectedPcmSha256": "0dd7eda91b2ac9d352e47627d1a7b2839dc09516301a9dd6c2bb6173902a186b",
+      "encodedBytes": 261549,
+      "elapsedMilliseconds": 61.79067899999791,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5936,
+        "maximumFrameSize": 8364,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "129916",
+        "md5Hex": "9116c4c4f5077be0f78a40cecf3edc9d"
+      },
+      "nativeDecodedPcmSha256": "0dd7eda91b2ac9d352e47627d1a7b2839dc09516301a9dd6c2bb6173902a186b"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 5,
+      "frames": 129916,
+      "expectedPcmSha256": "0dd7eda91b2ac9d352e47627d1a7b2839dc09516301a9dd6c2bb6173902a186b",
+      "encodedBytes": 261549,
+      "elapsedMilliseconds": 15.561595000006491,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5936,
+        "maximumFrameSize": 8364,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "129916",
+        "md5Hex": "9116c4c4f5077be0f78a40cecf3edc9d"
+      },
+      "nativeDecodedPcmSha256": "0dd7eda91b2ac9d352e47627d1a7b2839dc09516301a9dd6c2bb6173902a186b"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:dbb6eda6ecc56c418428f6b41d0b4872948d5be58e6089ecacb538b188dd7a74",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "2e94af2296c79e0acd1352987dad1c0105dcaab2fa5ec62a110a8f3f44a04e24",
+      "encodedBytes": 5150623,
+      "elapsedMilliseconds": 513.5730130000011,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 19736,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "26053a4513b282f554697b99442d10d4"
+      },
+      "nativeDecodedPcmSha256": "2e94af2296c79e0acd1352987dad1c0105dcaab2fa5ec62a110a8f3f44a04e24"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:dbb6eda6ecc56c418428f6b41d0b4872948d5be58e6089ecacb538b188dd7a74",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "2e94af2296c79e0acd1352987dad1c0105dcaab2fa5ec62a110a8f3f44a04e24",
+      "encodedBytes": 5150623,
+      "elapsedMilliseconds": 129.66951999999583,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 19736,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "26053a4513b282f554697b99442d10d4"
+      },
+      "nativeDecodedPcmSha256": "2e94af2296c79e0acd1352987dad1c0105dcaab2fa5ec62a110a8f3f44a04e24"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:dbb6eda6ecc56c418428f6b41d0b4872948d5be58e6089ecacb538b188dd7a74",
+      "chunkIndex": 1,
+      "frames": 659918,
+      "expectedPcmSha256": "ba7987b2aeec2b9383b890edb42d2615c9e33220a8a9473f83e5eabd3f81681f",
+      "encodedBytes": 1981971,
+      "elapsedMilliseconds": 240.01282200000423,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 79,
+        "maximumFrameSize": 19765,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "659918",
+        "md5Hex": "bcd7209885a540ae40a0fed23f840025"
+      },
+      "nativeDecodedPcmSha256": "ba7987b2aeec2b9383b890edb42d2615c9e33220a8a9473f83e5eabd3f81681f"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:dbb6eda6ecc56c418428f6b41d0b4872948d5be58e6089ecacb538b188dd7a74",
+      "chunkIndex": 1,
+      "frames": 659918,
+      "expectedPcmSha256": "ba7987b2aeec2b9383b890edb42d2615c9e33220a8a9473f83e5eabd3f81681f",
+      "encodedBytes": 1981954,
+      "elapsedMilliseconds": 62.72412899999472,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 79,
+        "maximumFrameSize": 19765,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "659918",
+        "md5Hex": "bcd7209885a540ae40a0fed23f840025"
+      },
+      "nativeDecodedPcmSha256": "ba7987b2aeec2b9383b890edb42d2615c9e33220a8a9473f83e5eabd3f81681f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "4930de75afb2d6609f801fa1a01c6015b397e3936b098e014e5960411a62bb8c",
+      "encodedBytes": 1873787,
+      "elapsedMilliseconds": 537.7043080000003,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5172,
+        "maximumFrameSize": 10592,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "1df6349a9a1200e5db6488580cfe5609"
+      },
+      "nativeDecodedPcmSha256": "4930de75afb2d6609f801fa1a01c6015b397e3936b098e014e5960411a62bb8c"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "4930de75afb2d6609f801fa1a01c6015b397e3936b098e014e5960411a62bb8c",
+      "encodedBytes": 1873831,
+      "elapsedMilliseconds": 125.39165800000774,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5172,
+        "maximumFrameSize": 10597,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "1df6349a9a1200e5db6488580cfe5609"
+      },
+      "nativeDecodedPcmSha256": "4930de75afb2d6609f801fa1a01c6015b397e3936b098e014e5960411a62bb8c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "70ea23b1a824512f353489e240fd927f4bd0f8118269c48ac88cf4163f01d227",
+      "encodedBytes": 2060276,
+      "elapsedMilliseconds": 539.1983150000015,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5164,
+        "maximumFrameSize": 12080,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "02c109983d30694eeccf693591d4814c"
+      },
+      "nativeDecodedPcmSha256": "70ea23b1a824512f353489e240fd927f4bd0f8118269c48ac88cf4163f01d227"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "70ea23b1a824512f353489e240fd927f4bd0f8118269c48ac88cf4163f01d227",
+      "encodedBytes": 2060264,
+      "elapsedMilliseconds": 126.41910599998664,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5164,
+        "maximumFrameSize": 12080,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "02c109983d30694eeccf693591d4814c"
+      },
+      "nativeDecodedPcmSha256": "70ea23b1a824512f353489e240fd927f4bd0f8118269c48ac88cf4163f01d227"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "bf440567e988c71551be148276316309a1257b2f11b2d1a4bcaea301f1055446",
+      "encodedBytes": 1688615,
+      "elapsedMilliseconds": 525.5032769999962,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5156,
+        "maximumFrameSize": 5282,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "e4ff153fefd0b5983adecdf954619e16"
+      },
+      "nativeDecodedPcmSha256": "bf440567e988c71551be148276316309a1257b2f11b2d1a4bcaea301f1055446"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "bf440567e988c71551be148276316309a1257b2f11b2d1a4bcaea301f1055446",
+      "encodedBytes": 1688615,
+      "elapsedMilliseconds": 125.77992800000357,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5156,
+        "maximumFrameSize": 5282,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "e4ff153fefd0b5983adecdf954619e16"
+      },
+      "nativeDecodedPcmSha256": "bf440567e988c71551be148276316309a1257b2f11b2d1a4bcaea301f1055446"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "097716d93dcac0324bbb6e2110b67088938dff5e489c5e6b06d45918b07e8dcf",
+      "encodedBytes": 1687882,
+      "elapsedMilliseconds": 522.0321709999989,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5164,
+        "maximumFrameSize": 5273,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5f23f612eae3ff947a33c28f917fb0c3"
+      },
+      "nativeDecodedPcmSha256": "097716d93dcac0324bbb6e2110b67088938dff5e489c5e6b06d45918b07e8dcf"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "097716d93dcac0324bbb6e2110b67088938dff5e489c5e6b06d45918b07e8dcf",
+      "encodedBytes": 1687882,
+      "elapsedMilliseconds": 125.08338100000401,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5164,
+        "maximumFrameSize": 5273,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5f23f612eae3ff947a33c28f917fb0c3"
+      },
+      "nativeDecodedPcmSha256": "097716d93dcac0324bbb6e2110b67088938dff5e489c5e6b06d45918b07e8dcf"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 4,
+      "frames": 915923,
+      "expectedPcmSha256": "af8937f992feb00ab5bb6c0d5a28f80ad75d34e9a9a53439183830e458d8faab",
+      "encodedBytes": 1168887,
+      "elapsedMilliseconds": 367.88333299999067,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 3248,
+        "maximumFrameSize": 5320,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "915923",
+        "md5Hex": "7605d09ff6c2b92d6c7ec2cad106a44a"
+      },
+      "nativeDecodedPcmSha256": "af8937f992feb00ab5bb6c0d5a28f80ad75d34e9a9a53439183830e458d8faab"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 4,
+      "frames": 915923,
+      "expectedPcmSha256": "af8937f992feb00ab5bb6c0d5a28f80ad75d34e9a9a53439183830e458d8faab",
+      "encodedBytes": 1168887,
+      "elapsedMilliseconds": 87.18505000000005,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 3248,
+        "maximumFrameSize": 5320,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "915923",
+        "md5Hex": "7605d09ff6c2b92d6c7ec2cad106a44a"
+      },
+      "nativeDecodedPcmSha256": "af8937f992feb00ab5bb6c0d5a28f80ad75d34e9a9a53439183830e458d8faab"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "c153cdd02ee613aa4d856af7b7499256d9a797b85d7f1bf72697b8ebe699572b",
+      "encodedBytes": 3007114,
+      "elapsedMilliseconds": 454.3386129999999,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7681,
+        "maximumFrameSize": 12705,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "251ca0665436123f9e152c2958ab9922"
+      },
+      "nativeDecodedPcmSha256": "c153cdd02ee613aa4d856af7b7499256d9a797b85d7f1bf72697b8ebe699572b"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "c153cdd02ee613aa4d856af7b7499256d9a797b85d7f1bf72697b8ebe699572b",
+      "encodedBytes": 3007108,
+      "elapsedMilliseconds": 119.3810739999899,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7681,
+        "maximumFrameSize": 12705,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "251ca0665436123f9e152c2958ab9922"
+      },
+      "nativeDecodedPcmSha256": "c153cdd02ee613aa4d856af7b7499256d9a797b85d7f1bf72697b8ebe699572b"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "1968944d10881b63a6477b9621071f7f8a56e969b4c0730c2da2b6e27aac62db",
+      "encodedBytes": 3132254,
+      "elapsedMilliseconds": 493.03792899999826,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 2289,
+        "maximumFrameSize": 12504,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f3d43a6b0fbccd05351d16c9ed6a2593"
+      },
+      "nativeDecodedPcmSha256": "1968944d10881b63a6477b9621071f7f8a56e969b4c0730c2da2b6e27aac62db"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "1968944d10881b63a6477b9621071f7f8a56e969b4c0730c2da2b6e27aac62db",
+      "encodedBytes": 3132254,
+      "elapsedMilliseconds": 124.66736700000183,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 2289,
+        "maximumFrameSize": 12504,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f3d43a6b0fbccd05351d16c9ed6a2593"
+      },
+      "nativeDecodedPcmSha256": "1968944d10881b63a6477b9621071f7f8a56e969b4c0730c2da2b6e27aac62db"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "1213ccf392162807582019bde04d3ad714481247b76d1d5f8009a5fc0eb3e069",
+      "encodedBytes": 3096303,
+      "elapsedMilliseconds": 456.57328099998995,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7951,
+        "maximumFrameSize": 12269,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b7de8fa8b924474bd9231a3e5800598b"
+      },
+      "nativeDecodedPcmSha256": "1213ccf392162807582019bde04d3ad714481247b76d1d5f8009a5fc0eb3e069"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "1213ccf392162807582019bde04d3ad714481247b76d1d5f8009a5fc0eb3e069",
+      "encodedBytes": 3096300,
+      "elapsedMilliseconds": 120.81135900001391,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7951,
+        "maximumFrameSize": 12269,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b7de8fa8b924474bd9231a3e5800598b"
+      },
+      "nativeDecodedPcmSha256": "1213ccf392162807582019bde04d3ad714481247b76d1d5f8009a5fc0eb3e069"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "dfe83b8d2c67fefec02a01eef4018f786a03ca52e14aff50e9e395301b4fdbbb",
+      "encodedBytes": 2799241,
+      "elapsedMilliseconds": 404.97067600001174,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7928,
+        "maximumFrameSize": 11232,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f2bb2279e28a8a66a0ce46987a9ff1c7"
+      },
+      "nativeDecodedPcmSha256": "dfe83b8d2c67fefec02a01eef4018f786a03ca52e14aff50e9e395301b4fdbbb"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "dfe83b8d2c67fefec02a01eef4018f786a03ca52e14aff50e9e395301b4fdbbb",
+      "encodedBytes": 2799236,
+      "elapsedMilliseconds": 118.14226300000155,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7928,
+        "maximumFrameSize": 11232,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f2bb2279e28a8a66a0ce46987a9ff1c7"
+      },
+      "nativeDecodedPcmSha256": "dfe83b8d2c67fefec02a01eef4018f786a03ca52e14aff50e9e395301b4fdbbb"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "0f55c1534bb29b9fb8258c13985e13aa3d25fd02a6afe6128aaca72caa8cf731",
+      "encodedBytes": 3407791,
+      "elapsedMilliseconds": 432.76635399999213,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 3152,
+        "maximumFrameSize": 12897,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "22a374fce66170497a8c490eb83cacb3"
+      },
+      "nativeDecodedPcmSha256": "0f55c1534bb29b9fb8258c13985e13aa3d25fd02a6afe6128aaca72caa8cf731"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "0f55c1534bb29b9fb8258c13985e13aa3d25fd02a6afe6128aaca72caa8cf731",
+      "encodedBytes": 3407792,
+      "elapsedMilliseconds": 118.18776999998954,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 3152,
+        "maximumFrameSize": 12897,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "22a374fce66170497a8c490eb83cacb3"
+      },
+      "nativeDecodedPcmSha256": "0f55c1534bb29b9fb8258c13985e13aa3d25fd02a6afe6128aaca72caa8cf731"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "026e9d73a7ff3851959956aaa58f413a73aae7116da4d14652682b7f14d7c382",
+      "encodedBytes": 2657514,
+      "elapsedMilliseconds": 348.67238199998974,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7957,
+        "maximumFrameSize": 8424,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "50c204d2c3ca112cb6d2dfc4574a6b7b"
+      },
+      "nativeDecodedPcmSha256": "026e9d73a7ff3851959956aaa58f413a73aae7116da4d14652682b7f14d7c382"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "026e9d73a7ff3851959956aaa58f413a73aae7116da4d14652682b7f14d7c382",
+      "encodedBytes": 2657514,
+      "elapsedMilliseconds": 108.06319600000279,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7957,
+        "maximumFrameSize": 8424,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "50c204d2c3ca112cb6d2dfc4574a6b7b"
+      },
+      "nativeDecodedPcmSha256": "026e9d73a7ff3851959956aaa58f413a73aae7116da4d14652682b7f14d7c382"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "7669dc7fe143e844e6d85fcaf155e41c6b66faada5383275c8f038938422eedf",
+      "encodedBytes": 1127015,
+      "elapsedMilliseconds": 145.14383700001054,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7943,
+        "maximumFrameSize": 8396,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "61212883dedb8671dfaf0c6b3a48cf26"
+      },
+      "nativeDecodedPcmSha256": "7669dc7fe143e844e6d85fcaf155e41c6b66faada5383275c8f038938422eedf"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "7669dc7fe143e844e6d85fcaf155e41c6b66faada5383275c8f038938422eedf",
+      "encodedBytes": 1127015,
+      "elapsedMilliseconds": 46.734588000006624,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7943,
+        "maximumFrameSize": 8396,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "61212883dedb8671dfaf0c6b3a48cf26"
+      },
+      "nativeDecodedPcmSha256": "7669dc7fe143e844e6d85fcaf155e41c6b66faada5383275c8f038938422eedf"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "907c161b6a6b3fc6be1ac83b0514aa8fbe4b72804d7ff1b2912429cf86c4fa12",
+      "encodedBytes": 4714618,
+      "elapsedMilliseconds": 523.4498290000047,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7910,
+        "maximumFrameSize": 18654,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f4eae4970a525ffe360ec2518db524da"
+      },
+      "nativeDecodedPcmSha256": "907c161b6a6b3fc6be1ac83b0514aa8fbe4b72804d7ff1b2912429cf86c4fa12"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "907c161b6a6b3fc6be1ac83b0514aa8fbe4b72804d7ff1b2912429cf86c4fa12",
+      "encodedBytes": 4714618,
+      "elapsedMilliseconds": 133.54477400000906,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7910,
+        "maximumFrameSize": 18654,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f4eae4970a525ffe360ec2518db524da"
+      },
+      "nativeDecodedPcmSha256": "907c161b6a6b3fc6be1ac83b0514aa8fbe4b72804d7ff1b2912429cf86c4fa12"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "23668afc815608ca7873919d5db8586258717824df6dba0ac7ba65cd56cde2f9",
+      "encodedBytes": 4655200,
+      "elapsedMilliseconds": 563.9451970000082,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5540,
+        "maximumFrameSize": 19005,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "25825cf8c20414d3ce15b75e73bd0da0"
+      },
+      "nativeDecodedPcmSha256": "23668afc815608ca7873919d5db8586258717824df6dba0ac7ba65cd56cde2f9"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "23668afc815608ca7873919d5db8586258717824df6dba0ac7ba65cd56cde2f9",
+      "encodedBytes": 4655199,
+      "elapsedMilliseconds": 137.7372430000105,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5540,
+        "maximumFrameSize": 19005,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "25825cf8c20414d3ce15b75e73bd0da0"
+      },
+      "nativeDecodedPcmSha256": "23668afc815608ca7873919d5db8586258717824df6dba0ac7ba65cd56cde2f9"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "146a29ebce44459aa8a15c198999ee449e8c6b04c2a8931ac5e9ad86c3920157",
+      "encodedBytes": 4262536,
+      "elapsedMilliseconds": 521.8610009999975,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7955,
+        "maximumFrameSize": 18639,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "eab602a474d9616842a1c3a10793eab8"
+      },
+      "nativeDecodedPcmSha256": "146a29ebce44459aa8a15c198999ee449e8c6b04c2a8931ac5e9ad86c3920157"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "146a29ebce44459aa8a15c198999ee449e8c6b04c2a8931ac5e9ad86c3920157",
+      "encodedBytes": 4262535,
+      "elapsedMilliseconds": 129.42972200000077,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7955,
+        "maximumFrameSize": 18639,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "eab602a474d9616842a1c3a10793eab8"
+      },
+      "nativeDecodedPcmSha256": "146a29ebce44459aa8a15c198999ee449e8c6b04c2a8931ac5e9ad86c3920157"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "c7fdfc4d8c871b684f0d5a3b0208f2f4d51b66450257b74b6b064b74c789c903",
+      "encodedBytes": 5170292,
+      "elapsedMilliseconds": 571.7312240000028,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 10522,
+        "maximumFrameSize": 18823,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fcdccbdef2ee2c7ee8b74f8bd64abb7f"
+      },
+      "nativeDecodedPcmSha256": "c7fdfc4d8c871b684f0d5a3b0208f2f4d51b66450257b74b6b064b74c789c903"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "c7fdfc4d8c871b684f0d5a3b0208f2f4d51b66450257b74b6b064b74c789c903",
+      "encodedBytes": 5170291,
+      "elapsedMilliseconds": 136.45443800000066,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 10522,
+        "maximumFrameSize": 18823,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fcdccbdef2ee2c7ee8b74f8bd64abb7f"
+      },
+      "nativeDecodedPcmSha256": "c7fdfc4d8c871b684f0d5a3b0208f2f4d51b66450257b74b6b064b74c789c903"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "6f35e69c56cae81692bae02df2074b5aa0d1afc8ca25bdcac9d6c4b3e0133a31",
+      "encodedBytes": 4202886,
+      "elapsedMilliseconds": 528.1147670000064,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8425,
+        "maximumFrameSize": 17842,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b4aa781a52d5d7b5f47f9852b0121c46"
+      },
+      "nativeDecodedPcmSha256": "6f35e69c56cae81692bae02df2074b5aa0d1afc8ca25bdcac9d6c4b3e0133a31"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "6f35e69c56cae81692bae02df2074b5aa0d1afc8ca25bdcac9d6c4b3e0133a31",
+      "encodedBytes": 4202884,
+      "elapsedMilliseconds": 129.2138100000011,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8425,
+        "maximumFrameSize": 17842,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b4aa781a52d5d7b5f47f9852b0121c46"
+      },
+      "nativeDecodedPcmSha256": "6f35e69c56cae81692bae02df2074b5aa0d1afc8ca25bdcac9d6c4b3e0133a31"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "7663bc6e076e7abf6e495e6f10fe5e511293290188bd2ea42ca8f11dca59c151",
+      "encodedBytes": 2584878,
+      "elapsedMilliseconds": 395.8664439999993,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7955,
+        "maximumFrameSize": 8561,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fc08cdf3e808dc6e0745ddfece913484"
+      },
+      "nativeDecodedPcmSha256": "7663bc6e076e7abf6e495e6f10fe5e511293290188bd2ea42ca8f11dca59c151"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "7663bc6e076e7abf6e495e6f10fe5e511293290188bd2ea42ca8f11dca59c151",
+      "encodedBytes": 2584878,
+      "elapsedMilliseconds": 112.86725999999908,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7955,
+        "maximumFrameSize": 8561,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fc08cdf3e808dc6e0745ddfece913484"
+      },
+      "nativeDecodedPcmSha256": "7663bc6e076e7abf6e495e6f10fe5e511293290188bd2ea42ca8f11dca59c151"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "3849a44bffe57ab48954fd37640c9292db6fba2278a1448464f1748d5dc5745e",
+      "encodedBytes": 1094741,
+      "elapsedMilliseconds": 171.00014800000645,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7864,
+        "maximumFrameSize": 8021,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "e40441b3fc17e9aeaf045157bcb09627"
+      },
+      "nativeDecodedPcmSha256": "3849a44bffe57ab48954fd37640c9292db6fba2278a1448464f1748d5dc5745e"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "3849a44bffe57ab48954fd37640c9292db6fba2278a1448464f1748d5dc5745e",
+      "encodedBytes": 1094741,
+      "elapsedMilliseconds": 49.53794999999809,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7864,
+        "maximumFrameSize": 8021,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "e40441b3fc17e9aeaf045157bcb09627"
+      },
+      "nativeDecodedPcmSha256": "3849a44bffe57ab48954fd37640c9292db6fba2278a1448464f1748d5dc5745e"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "1cb3c348a7d541b66309eea6f1aefefb0b02fb421d91b898fadae0733775d780",
+      "encodedBytes": 5144195,
+      "elapsedMilliseconds": 548.2602049999987,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1048,
+        "maximumFrameSize": 19125,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "3f301ecc694f663741a2b783c29dc8f1"
+      },
+      "nativeDecodedPcmSha256": "1cb3c348a7d541b66309eea6f1aefefb0b02fb421d91b898fadae0733775d780"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "1cb3c348a7d541b66309eea6f1aefefb0b02fb421d91b898fadae0733775d780",
+      "encodedBytes": 5144195,
+      "elapsedMilliseconds": 132.3179450000025,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1048,
+        "maximumFrameSize": 19125,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "3f301ecc694f663741a2b783c29dc8f1"
+      },
+      "nativeDecodedPcmSha256": "1cb3c348a7d541b66309eea6f1aefefb0b02fb421d91b898fadae0733775d780"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "ed3b2c8a228e50e3b1a11aafa9f1aae51fa304e559661959c63e10a20c1f48da",
+      "encodedBytes": 5172912,
+      "elapsedMilliseconds": 564.8399789999967,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1115,
+        "maximumFrameSize": 19757,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d520abf87f30a1be09fc659b464ce855"
+      },
+      "nativeDecodedPcmSha256": "ed3b2c8a228e50e3b1a11aafa9f1aae51fa304e559661959c63e10a20c1f48da"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "ed3b2c8a228e50e3b1a11aafa9f1aae51fa304e559661959c63e10a20c1f48da",
+      "encodedBytes": 5172912,
+      "elapsedMilliseconds": 135.466975000003,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1115,
+        "maximumFrameSize": 19757,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d520abf87f30a1be09fc659b464ce855"
+      },
+      "nativeDecodedPcmSha256": "ed3b2c8a228e50e3b1a11aafa9f1aae51fa304e559661959c63e10a20c1f48da"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "034db1186c1eb61b137691797fea0b93a3aca44c2167924d2d7ac4809ba9ad9f",
+      "encodedBytes": 5252207,
+      "elapsedMilliseconds": 544.5542629999982,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6915,
+        "maximumFrameSize": 18956,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "36e9ce530e6f5228f07bcf0b1c6dfb95"
+      },
+      "nativeDecodedPcmSha256": "034db1186c1eb61b137691797fea0b93a3aca44c2167924d2d7ac4809ba9ad9f"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "034db1186c1eb61b137691797fea0b93a3aca44c2167924d2d7ac4809ba9ad9f",
+      "encodedBytes": 5252207,
+      "elapsedMilliseconds": 132.25716900000407,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6915,
+        "maximumFrameSize": 18956,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "36e9ce530e6f5228f07bcf0b1c6dfb95"
+      },
+      "nativeDecodedPcmSha256": "034db1186c1eb61b137691797fea0b93a3aca44c2167924d2d7ac4809ba9ad9f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "85d909ec0f5745a6c02a9b87cf11ab8f35546990395eeecd4059a923084fc6af",
+      "encodedBytes": 5088811,
+      "elapsedMilliseconds": 561.3658370000048,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1068,
+        "maximumFrameSize": 19622,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "a5db113db1af2e6a236797876d040bcc"
+      },
+      "nativeDecodedPcmSha256": "85d909ec0f5745a6c02a9b87cf11ab8f35546990395eeecd4059a923084fc6af"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "85d909ec0f5745a6c02a9b87cf11ab8f35546990395eeecd4059a923084fc6af",
+      "encodedBytes": 5088810,
+      "elapsedMilliseconds": 133.68218400000478,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1068,
+        "maximumFrameSize": 19622,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "a5db113db1af2e6a236797876d040bcc"
+      },
+      "nativeDecodedPcmSha256": "85d909ec0f5745a6c02a9b87cf11ab8f35546990395eeecd4059a923084fc6af"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "52739fe2188b8ff3f49b0b6a55444205c91fd05023bfc377d24e7354ad09c665",
+      "encodedBytes": 3443937,
+      "elapsedMilliseconds": 508.1884929999942,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1167,
+        "maximumFrameSize": 19515,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "98aafbd3bbe5b47e9b3591cc435b11e2"
+      },
+      "nativeDecodedPcmSha256": "52739fe2188b8ff3f49b0b6a55444205c91fd05023bfc377d24e7354ad09c665"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "52739fe2188b8ff3f49b0b6a55444205c91fd05023bfc377d24e7354ad09c665",
+      "encodedBytes": 3443938,
+      "elapsedMilliseconds": 134.5216539999965,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1167,
+        "maximumFrameSize": 19515,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "98aafbd3bbe5b47e9b3591cc435b11e2"
+      },
+      "nativeDecodedPcmSha256": "52739fe2188b8ff3f49b0b6a55444205c91fd05023bfc377d24e7354ad09c665"
+    },
+    {
+      "implementation": "wasm",
+      "round": 1,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 5,
+      "frames": 91456,
+      "expectedPcmSha256": "30f490035cb2caaf0b63f57c817211708107df2bb2622eb80a8ca7cf56d41d2d",
+      "encodedBytes": 20011,
+      "elapsedMilliseconds": 25.520101000001887,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 189,
+        "maximumFrameSize": 1171,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "91456",
+        "md5Hex": "4f1a221fa641e39e32e602a5a4648686"
+      },
+      "nativeDecodedPcmSha256": "30f490035cb2caaf0b63f57c817211708107df2bb2622eb80a8ca7cf56d41d2d"
+    },
+    {
+      "implementation": "native",
+      "round": 1,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 5,
+      "frames": 91456,
+      "expectedPcmSha256": "30f490035cb2caaf0b63f57c817211708107df2bb2622eb80a8ca7cf56d41d2d",
+      "encodedBytes": 20011,
+      "elapsedMilliseconds": 8.085958999989089,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 189,
+        "maximumFrameSize": 1171,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "91456",
+        "md5Hex": "4f1a221fa641e39e32e602a5a4648686"
+      },
+      "nativeDecodedPcmSha256": "30f490035cb2caaf0b63f57c817211708107df2bb2622eb80a8ca7cf56d41d2d"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "0ad333131602d2eed204c673014271b346328956a17a459cda005d12aff26324",
+      "encodedBytes": 4150349,
+      "elapsedMilliseconds": 498.00080900000466,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1046,
+        "maximumFrameSize": 18240,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5b26e698b3ee07d53f57208d50518553"
+      },
+      "nativeDecodedPcmSha256": "0ad333131602d2eed204c673014271b346328956a17a459cda005d12aff26324"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "0ad333131602d2eed204c673014271b346328956a17a459cda005d12aff26324",
+      "encodedBytes": 4150349,
+      "elapsedMilliseconds": 128.73219100000279,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1046,
+        "maximumFrameSize": 18240,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5b26e698b3ee07d53f57208d50518553"
+      },
+      "nativeDecodedPcmSha256": "0ad333131602d2eed204c673014271b346328956a17a459cda005d12aff26324"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "498bd8b6bfeb1e240e24b0c0f948f26e59259d319adf0e61f5cd7e5ec79d10e8",
+      "encodedBytes": 4371131,
+      "elapsedMilliseconds": 532.2706729999918,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1058,
+        "maximumFrameSize": 18677,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d5817dbd7025dd8dcb122eb5a8c2abff"
+      },
+      "nativeDecodedPcmSha256": "498bd8b6bfeb1e240e24b0c0f948f26e59259d319adf0e61f5cd7e5ec79d10e8"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "498bd8b6bfeb1e240e24b0c0f948f26e59259d319adf0e61f5cd7e5ec79d10e8",
+      "encodedBytes": 4371137,
+      "elapsedMilliseconds": 130.9284859999898,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1058,
+        "maximumFrameSize": 18677,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d5817dbd7025dd8dcb122eb5a8c2abff"
+      },
+      "nativeDecodedPcmSha256": "498bd8b6bfeb1e240e24b0c0f948f26e59259d319adf0e61f5cd7e5ec79d10e8"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "a9b0a5e36c48ce2ecd758f22ba512342b8d6378c86d8a0c95c8b5fb01d86ae7f",
+      "encodedBytes": 2982496,
+      "elapsedMilliseconds": 478.5970120000129,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 19173,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "bc4f583eb83952c7aafa13276e51bfa4"
+      },
+      "nativeDecodedPcmSha256": "a9b0a5e36c48ce2ecd758f22ba512342b8d6378c86d8a0c95c8b5fb01d86ae7f"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "a9b0a5e36c48ce2ecd758f22ba512342b8d6378c86d8a0c95c8b5fb01d86ae7f",
+      "encodedBytes": 2982490,
+      "elapsedMilliseconds": 125.04077700000198,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 19173,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "bc4f583eb83952c7aafa13276e51bfa4"
+      },
+      "nativeDecodedPcmSha256": "a9b0a5e36c48ce2ecd758f22ba512342b8d6378c86d8a0c95c8b5fb01d86ae7f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 3,
+      "frames": 1162869,
+      "expectedPcmSha256": "ad88aea64fa81f9247059b6e75ccbeadd4b350cae9a83d7940f4594e87dd7936",
+      "encodedBytes": 4539491,
+      "elapsedMilliseconds": 458.20739699999103,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 487,
+        "maximumFrameSize": 20237,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1162869",
+        "md5Hex": "7547e0b77aefe7bf646b230d8a47d74e"
+      },
+      "nativeDecodedPcmSha256": "ad88aea64fa81f9247059b6e75ccbeadd4b350cae9a83d7940f4594e87dd7936"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 3,
+      "frames": 1162869,
+      "expectedPcmSha256": "ad88aea64fa81f9247059b6e75ccbeadd4b350cae9a83d7940f4594e87dd7936",
+      "encodedBytes": 4539490,
+      "elapsedMilliseconds": 114.11308300000383,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 487,
+        "maximumFrameSize": 20237,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1162869",
+        "md5Hex": "7547e0b77aefe7bf646b230d8a47d74e"
+      },
+      "nativeDecodedPcmSha256": "ad88aea64fa81f9247059b6e75ccbeadd4b350cae9a83d7940f4594e87dd7936"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "b4d086eb6ea6fb003acaa30cbf00317bb1567dee9c03521701ad60f404f7a2c7",
+      "encodedBytes": 3396576,
+      "elapsedMilliseconds": 433.67148199999065,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7959,
+        "maximumFrameSize": 18028,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9c2393e2f1b5ee54d1253ee3a3dfb992"
+      },
+      "nativeDecodedPcmSha256": "b4d086eb6ea6fb003acaa30cbf00317bb1567dee9c03521701ad60f404f7a2c7"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "b4d086eb6ea6fb003acaa30cbf00317bb1567dee9c03521701ad60f404f7a2c7",
+      "encodedBytes": 3396577,
+      "elapsedMilliseconds": 117.67030199999863,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7959,
+        "maximumFrameSize": 18028,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9c2393e2f1b5ee54d1253ee3a3dfb992"
+      },
+      "nativeDecodedPcmSha256": "b4d086eb6ea6fb003acaa30cbf00317bb1567dee9c03521701ad60f404f7a2c7"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "72e151c5c4f167900d89a7096ea63dcabeb846c160caaeaec4d0711ddbb9ae76",
+      "encodedBytes": 5287166,
+      "elapsedMilliseconds": 554.9043220000021,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5431,
+        "maximumFrameSize": 19445,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "c9cb1466675357641cebeb5032e2f37d"
+      },
+      "nativeDecodedPcmSha256": "72e151c5c4f167900d89a7096ea63dcabeb846c160caaeaec4d0711ddbb9ae76"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "72e151c5c4f167900d89a7096ea63dcabeb846c160caaeaec4d0711ddbb9ae76",
+      "encodedBytes": 5287163,
+      "elapsedMilliseconds": 133.84967300000426,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5431,
+        "maximumFrameSize": 19445,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "c9cb1466675357641cebeb5032e2f37d"
+      },
+      "nativeDecodedPcmSha256": "72e151c5c4f167900d89a7096ea63dcabeb846c160caaeaec4d0711ddbb9ae76"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "4b8d2779ff5af472ae8159a9429aba0befe0eca99cd4b4f29432f8dd33af6c1f",
+      "encodedBytes": 3847608,
+      "elapsedMilliseconds": 490.0091769999999,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8050,
+        "maximumFrameSize": 19330,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "46b620635fb0599fc6f77ce38d08afd6"
+      },
+      "nativeDecodedPcmSha256": "4b8d2779ff5af472ae8159a9429aba0befe0eca99cd4b4f29432f8dd33af6c1f"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "4b8d2779ff5af472ae8159a9429aba0befe0eca99cd4b4f29432f8dd33af6c1f",
+      "encodedBytes": 3847607,
+      "elapsedMilliseconds": 127.40358900000865,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8050,
+        "maximumFrameSize": 19330,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "46b620635fb0599fc6f77ce38d08afd6"
+      },
+      "nativeDecodedPcmSha256": "4b8d2779ff5af472ae8159a9429aba0befe0eca99cd4b4f29432f8dd33af6c1f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "874cb197ccd1ef18c42c4de586b947796463dfaa211978c5ecf747683f20b367",
+      "encodedBytes": 3190338,
+      "elapsedMilliseconds": 511.0624759999919,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7963,
+        "maximumFrameSize": 16584,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d391e230ba796167b53a81a2bbdf2831"
+      },
+      "nativeDecodedPcmSha256": "874cb197ccd1ef18c42c4de586b947796463dfaa211978c5ecf747683f20b367"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "874cb197ccd1ef18c42c4de586b947796463dfaa211978c5ecf747683f20b367",
+      "encodedBytes": 3190350,
+      "elapsedMilliseconds": 126.96087500000431,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7963,
+        "maximumFrameSize": 16584,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d391e230ba796167b53a81a2bbdf2831"
+      },
+      "nativeDecodedPcmSha256": "874cb197ccd1ef18c42c4de586b947796463dfaa211978c5ecf747683f20b367"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "f6ccbd0a0a535ebc8f2b53ae0adeb7fc4796648646edb2caae934f889f6e1bb4",
+      "encodedBytes": 5481625,
+      "elapsedMilliseconds": 543.238949999999,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7941,
+        "maximumFrameSize": 19501,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fe527fc68042d8fc43a670259d17aa00"
+      },
+      "nativeDecodedPcmSha256": "f6ccbd0a0a535ebc8f2b53ae0adeb7fc4796648646edb2caae934f889f6e1bb4"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "f6ccbd0a0a535ebc8f2b53ae0adeb7fc4796648646edb2caae934f889f6e1bb4",
+      "encodedBytes": 5481625,
+      "elapsedMilliseconds": 137.85357200000726,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7941,
+        "maximumFrameSize": 19501,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fe527fc68042d8fc43a670259d17aa00"
+      },
+      "nativeDecodedPcmSha256": "f6ccbd0a0a535ebc8f2b53ae0adeb7fc4796648646edb2caae934f889f6e1bb4"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "ef9d092ac5241f9d7479dd6098355cf95724cc229b90286b20b48318cd2266f6",
+      "encodedBytes": 2580489,
+      "elapsedMilliseconds": 399.3441560000065,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7939,
+        "maximumFrameSize": 8322,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "81b081b322c774cd732dcfa16962c8e9"
+      },
+      "nativeDecodedPcmSha256": "ef9d092ac5241f9d7479dd6098355cf95724cc229b90286b20b48318cd2266f6"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "ef9d092ac5241f9d7479dd6098355cf95724cc229b90286b20b48318cd2266f6",
+      "encodedBytes": 2580489,
+      "elapsedMilliseconds": 113.78063900000416,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7939,
+        "maximumFrameSize": 8322,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "81b081b322c774cd732dcfa16962c8e9"
+      },
+      "nativeDecodedPcmSha256": "ef9d092ac5241f9d7479dd6098355cf95724cc229b90286b20b48318cd2266f6"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "68599d04661ee4e25c2f965d2c5197f84eae66e6b5cd3e52a915d70c44567cbc",
+      "encodedBytes": 1094519,
+      "elapsedMilliseconds": 186.25683900000877,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7867,
+        "maximumFrameSize": 8029,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "d984dcecf62ef48f97716f78896234a3"
+      },
+      "nativeDecodedPcmSha256": "68599d04661ee4e25c2f965d2c5197f84eae66e6b5cd3e52a915d70c44567cbc"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "68599d04661ee4e25c2f965d2c5197f84eae66e6b5cd3e52a915d70c44567cbc",
+      "encodedBytes": 1094519,
+      "elapsedMilliseconds": 49.22398100000282,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7867,
+        "maximumFrameSize": 8029,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "d984dcecf62ef48f97716f78896234a3"
+      },
+      "nativeDecodedPcmSha256": "68599d04661ee4e25c2f965d2c5197f84eae66e6b5cd3e52a915d70c44567cbc"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:1d0544c63bf19bcc8d8b663d73fb9b206f9d107d52f7729ead8fce52aaa9be71",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "3e07a582bb431c6106a0eeea238aeddfd33ab51272f2f4ec19f24461230d6879",
+      "encodedBytes": 4802021,
+      "elapsedMilliseconds": 499.2294750000001,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 639,
+        "maximumFrameSize": 18532,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "7b9be66be751f643ae8fa39cd8ca6184"
+      },
+      "nativeDecodedPcmSha256": "3e07a582bb431c6106a0eeea238aeddfd33ab51272f2f4ec19f24461230d6879"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:1d0544c63bf19bcc8d8b663d73fb9b206f9d107d52f7729ead8fce52aaa9be71",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "3e07a582bb431c6106a0eeea238aeddfd33ab51272f2f4ec19f24461230d6879",
+      "encodedBytes": 4802021,
+      "elapsedMilliseconds": 126.83947399999306,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 639,
+        "maximumFrameSize": 18532,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "7b9be66be751f643ae8fa39cd8ca6184"
+      },
+      "nativeDecodedPcmSha256": "3e07a582bb431c6106a0eeea238aeddfd33ab51272f2f4ec19f24461230d6879"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:1d0544c63bf19bcc8d8b663d73fb9b206f9d107d52f7729ead8fce52aaa9be71",
+      "chunkIndex": 1,
+      "frames": 1179460,
+      "expectedPcmSha256": "b1fed292edbe942de39423402a36ee74165dc92c74d4630e85d8aec07e26f6e2",
+      "encodedBytes": 3270974,
+      "elapsedMilliseconds": 432.9100279999984,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 506,
+        "maximumFrameSize": 18576,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1179460",
+        "md5Hex": "e102779c11c2a0141579ee8a147dad3d"
+      },
+      "nativeDecodedPcmSha256": "b1fed292edbe942de39423402a36ee74165dc92c74d4630e85d8aec07e26f6e2"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:1d0544c63bf19bcc8d8b663d73fb9b206f9d107d52f7729ead8fce52aaa9be71",
+      "chunkIndex": 1,
+      "frames": 1179460,
+      "expectedPcmSha256": "b1fed292edbe942de39423402a36ee74165dc92c74d4630e85d8aec07e26f6e2",
+      "encodedBytes": 3270968,
+      "elapsedMilliseconds": 108.15433699999994,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 506,
+        "maximumFrameSize": 18576,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1179460",
+        "md5Hex": "e102779c11c2a0141579ee8a147dad3d"
+      },
+      "nativeDecodedPcmSha256": "b1fed292edbe942de39423402a36ee74165dc92c74d4630e85d8aec07e26f6e2"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "a19561147112095642424463ea315305b085a03c9c82becb7ac38c3e923c2407",
+      "encodedBytes": 4187420,
+      "elapsedMilliseconds": 578.4442249999993,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1089,
+        "maximumFrameSize": 20569,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "219b7301a904dc1b3b4f430d08a555ae"
+      },
+      "nativeDecodedPcmSha256": "a19561147112095642424463ea315305b085a03c9c82becb7ac38c3e923c2407"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "a19561147112095642424463ea315305b085a03c9c82becb7ac38c3e923c2407",
+      "encodedBytes": 4187419,
+      "elapsedMilliseconds": 135.5908000000054,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1089,
+        "maximumFrameSize": 20569,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "219b7301a904dc1b3b4f430d08a555ae"
+      },
+      "nativeDecodedPcmSha256": "a19561147112095642424463ea315305b085a03c9c82becb7ac38c3e923c2407"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "55a9246cc0cfbf1ea647cad6f98d37f9d9351d2743ea6d09e87afeeeaafd94e3",
+      "encodedBytes": 3050967,
+      "elapsedMilliseconds": 544.0695209999976,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1051,
+        "maximumFrameSize": 20467,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "679b726bb6d3e08e24c3e184f9a9f15e"
+      },
+      "nativeDecodedPcmSha256": "55a9246cc0cfbf1ea647cad6f98d37f9d9351d2743ea6d09e87afeeeaafd94e3"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "55a9246cc0cfbf1ea647cad6f98d37f9d9351d2743ea6d09e87afeeeaafd94e3",
+      "encodedBytes": 3050969,
+      "elapsedMilliseconds": 130.62977599998703,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1051,
+        "maximumFrameSize": 20467,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "679b726bb6d3e08e24c3e184f9a9f15e"
+      },
+      "nativeDecodedPcmSha256": "55a9246cc0cfbf1ea647cad6f98d37f9d9351d2743ea6d09e87afeeeaafd94e3"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "52e84d5ab6f4d8e41262b82fae7a1fc2e774f9d29b10e5e9e7b64592799e27dd",
+      "encodedBytes": 4662993,
+      "elapsedMilliseconds": 561.0004240000126,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1070,
+        "maximumFrameSize": 20658,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "63b1666ccf5139b3eabf2b0b97b289c4"
+      },
+      "nativeDecodedPcmSha256": "52e84d5ab6f4d8e41262b82fae7a1fc2e774f9d29b10e5e9e7b64592799e27dd"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "52e84d5ab6f4d8e41262b82fae7a1fc2e774f9d29b10e5e9e7b64592799e27dd",
+      "encodedBytes": 4662993,
+      "elapsedMilliseconds": 133.36276400000497,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1070,
+        "maximumFrameSize": 20658,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "63b1666ccf5139b3eabf2b0b97b289c4"
+      },
+      "nativeDecodedPcmSha256": "52e84d5ab6f4d8e41262b82fae7a1fc2e774f9d29b10e5e9e7b64592799e27dd"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 3,
+      "frames": 630874,
+      "expectedPcmSha256": "d2903e6abfcf42e70792f30af34c900d64ad340d77ef31a775287c68d17596b9",
+      "encodedBytes": 2161240,
+      "elapsedMilliseconds": 295.1779360000073,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 18,
+        "maximumFrameSize": 20476,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "630874",
+        "md5Hex": "c0d8c46e99c6193df86665e77b15ce15"
+      },
+      "nativeDecodedPcmSha256": "d2903e6abfcf42e70792f30af34c900d64ad340d77ef31a775287c68d17596b9"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 3,
+      "frames": 630874,
+      "expectedPcmSha256": "d2903e6abfcf42e70792f30af34c900d64ad340d77ef31a775287c68d17596b9",
+      "encodedBytes": 2161240,
+      "elapsedMilliseconds": 66.07383999999729,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 18,
+        "maximumFrameSize": 20476,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "630874",
+        "md5Hex": "c0d8c46e99c6193df86665e77b15ce15"
+      },
+      "nativeDecodedPcmSha256": "d2903e6abfcf42e70792f30af34c900d64ad340d77ef31a775287c68d17596b9"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "9cd318a12c7c8fa38f058ab7c8e032b363c431af852557febfc61a2a18c34970",
+      "encodedBytes": 2867123,
+      "elapsedMilliseconds": 468.8284410000051,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 4489,
+        "maximumFrameSize": 16813,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "6357201bd5e0eeb273716afdec214aca"
+      },
+      "nativeDecodedPcmSha256": "9cd318a12c7c8fa38f058ab7c8e032b363c431af852557febfc61a2a18c34970"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "9cd318a12c7c8fa38f058ab7c8e032b363c431af852557febfc61a2a18c34970",
+      "encodedBytes": 2867123,
+      "elapsedMilliseconds": 122.99805299998843,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 4489,
+        "maximumFrameSize": 16813,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "6357201bd5e0eeb273716afdec214aca"
+      },
+      "nativeDecodedPcmSha256": "9cd318a12c7c8fa38f058ab7c8e032b363c431af852557febfc61a2a18c34970"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "0016abd2094e03efc2cb2bf4301934db1c55b68a034ca7a977e1eb4b6bf71799",
+      "encodedBytes": 4455810,
+      "elapsedMilliseconds": 563.9850000000006,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5533,
+        "maximumFrameSize": 18357,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b31c86a1180cf2a42e08aa21582d4907"
+      },
+      "nativeDecodedPcmSha256": "0016abd2094e03efc2cb2bf4301934db1c55b68a034ca7a977e1eb4b6bf71799"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "0016abd2094e03efc2cb2bf4301934db1c55b68a034ca7a977e1eb4b6bf71799",
+      "encodedBytes": 4455811,
+      "elapsedMilliseconds": 133.48538800000097,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5533,
+        "maximumFrameSize": 18357,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b31c86a1180cf2a42e08aa21582d4907"
+      },
+      "nativeDecodedPcmSha256": "0016abd2094e03efc2cb2bf4301934db1c55b68a034ca7a977e1eb4b6bf71799"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "fb92413909c791e44c9aaffed2aa7dd0025bb3af28e6bc54da191243aa2c31da",
+      "encodedBytes": 4664160,
+      "elapsedMilliseconds": 600.3311499999982,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6095,
+        "maximumFrameSize": 17776,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "38e2092fb1dfd7bc419233204dd69922"
+      },
+      "nativeDecodedPcmSha256": "fb92413909c791e44c9aaffed2aa7dd0025bb3af28e6bc54da191243aa2c31da"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "fb92413909c791e44c9aaffed2aa7dd0025bb3af28e6bc54da191243aa2c31da",
+      "encodedBytes": 4664160,
+      "elapsedMilliseconds": 136.27598500000022,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6095,
+        "maximumFrameSize": 17776,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "38e2092fb1dfd7bc419233204dd69922"
+      },
+      "nativeDecodedPcmSha256": "fb92413909c791e44c9aaffed2aa7dd0025bb3af28e6bc54da191243aa2c31da"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "0c53b70e20dad8a58b0ccd63fae413169addf85c2ff23899acb8cfcf9d112f7b",
+      "encodedBytes": 4600172,
+      "elapsedMilliseconds": 567.5947369999922,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5555,
+        "maximumFrameSize": 17032,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9a59c85b30fd8c2e72cd58c43592fd1d"
+      },
+      "nativeDecodedPcmSha256": "0c53b70e20dad8a58b0ccd63fae413169addf85c2ff23899acb8cfcf9d112f7b"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "0c53b70e20dad8a58b0ccd63fae413169addf85c2ff23899acb8cfcf9d112f7b",
+      "encodedBytes": 4600172,
+      "elapsedMilliseconds": 135.63174700000673,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5555,
+        "maximumFrameSize": 17032,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9a59c85b30fd8c2e72cd58c43592fd1d"
+      },
+      "nativeDecodedPcmSha256": "0c53b70e20dad8a58b0ccd63fae413169addf85c2ff23899acb8cfcf9d112f7b"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 4,
+      "frames": 915923,
+      "expectedPcmSha256": "ee9d65603f1b22585957d02a4c56be87be47cf6354808438964a3a1c031cfd9f",
+      "encodedBytes": 2886170,
+      "elapsedMilliseconds": 384.0322040000028,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 3285,
+        "maximumFrameSize": 16807,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "915923",
+        "md5Hex": "d3c4f8f2c76bd1d09d96d04f6dba9f1d"
+      },
+      "nativeDecodedPcmSha256": "ee9d65603f1b22585957d02a4c56be87be47cf6354808438964a3a1c031cfd9f"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 4,
+      "frames": 915923,
+      "expectedPcmSha256": "ee9d65603f1b22585957d02a4c56be87be47cf6354808438964a3a1c031cfd9f",
+      "encodedBytes": 2886170,
+      "elapsedMilliseconds": 93.27174699999159,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 3285,
+        "maximumFrameSize": 16807,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "915923",
+        "md5Hex": "d3c4f8f2c76bd1d09d96d04f6dba9f1d"
+      },
+      "nativeDecodedPcmSha256": "ee9d65603f1b22585957d02a4c56be87be47cf6354808438964a3a1c031cfd9f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "74c0df9dcd402798188e653381e0166de4eb0e9e0e5e7d28de95dc2d7921efc9",
+      "encodedBytes": 2555489,
+      "elapsedMilliseconds": 589.5597830000042,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1119,
+        "maximumFrameSize": 11300,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "246801b775679e817b341b8c39d382cb"
+      },
+      "nativeDecodedPcmSha256": "74c0df9dcd402798188e653381e0166de4eb0e9e0e5e7d28de95dc2d7921efc9"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "74c0df9dcd402798188e653381e0166de4eb0e9e0e5e7d28de95dc2d7921efc9",
+      "encodedBytes": 2556311,
+      "elapsedMilliseconds": 207.9535809999943,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1119,
+        "maximumFrameSize": 11311,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "246801b775679e817b341b8c39d382cb"
+      },
+      "nativeDecodedPcmSha256": "74c0df9dcd402798188e653381e0166de4eb0e9e0e5e7d28de95dc2d7921efc9"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "8f9568ecd4f1890cdd81cb5173c40112d98c1a4d61fd36314e4bb2030124cb2a",
+      "encodedBytes": 1499027,
+      "elapsedMilliseconds": 351.595874000006,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 19858,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "164ea8991da81f3328f402e47b7e849b"
+      },
+      "nativeDecodedPcmSha256": "8f9568ecd4f1890cdd81cb5173c40112d98c1a4d61fd36314e4bb2030124cb2a"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "8f9568ecd4f1890cdd81cb5173c40112d98c1a4d61fd36314e4bb2030124cb2a",
+      "encodedBytes": 1499027,
+      "elapsedMilliseconds": 103.43889099999797,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 19858,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "164ea8991da81f3328f402e47b7e849b"
+      },
+      "nativeDecodedPcmSha256": "8f9568ecd4f1890cdd81cb5173c40112d98c1a4d61fd36314e4bb2030124cb2a"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "0d76eb91be0008835d5774ac3b2738db6e392d32e4fc767d77a25394f82ba7e4",
+      "encodedBytes": 2203031,
+      "elapsedMilliseconds": 449.64073500000814,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 19224,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "cc6a0db61773a650e936bf526840a278"
+      },
+      "nativeDecodedPcmSha256": "0d76eb91be0008835d5774ac3b2738db6e392d32e4fc767d77a25394f82ba7e4"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "0d76eb91be0008835d5774ac3b2738db6e392d32e4fc767d77a25394f82ba7e4",
+      "encodedBytes": 2203168,
+      "elapsedMilliseconds": 138.64044100001047,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 19224,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "cc6a0db61773a650e936bf526840a278"
+      },
+      "nativeDecodedPcmSha256": "0d76eb91be0008835d5774ac3b2738db6e392d32e4fc767d77a25394f82ba7e4"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "95c4368b4a153a4b38ea1d8f4b4fe10db945dad45351d3a74e5fe38fdc4273fa",
+      "encodedBytes": 4652718,
+      "elapsedMilliseconds": 509.1002299999964,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1047,
+        "maximumFrameSize": 20009,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "27feaa2a2129642bee3dce8784769a30"
+      },
+      "nativeDecodedPcmSha256": "95c4368b4a153a4b38ea1d8f4b4fe10db945dad45351d3a74e5fe38fdc4273fa"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "95c4368b4a153a4b38ea1d8f4b4fe10db945dad45351d3a74e5fe38fdc4273fa",
+      "encodedBytes": 4652717,
+      "elapsedMilliseconds": 128.93304100001114,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1047,
+        "maximumFrameSize": 20009,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "27feaa2a2129642bee3dce8784769a30"
+      },
+      "nativeDecodedPcmSha256": "95c4368b4a153a4b38ea1d8f4b4fe10db945dad45351d3a74e5fe38fdc4273fa"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 4,
+      "frames": 207800,
+      "expectedPcmSha256": "7e432c880c57ed605b55cf95c74625b569353b7df4dc398f731e0b81c40e71ef",
+      "encodedBytes": 465680,
+      "elapsedMilliseconds": 98.83086000000185,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5469,
+        "maximumFrameSize": 15210,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "207800",
+        "md5Hex": "0fffe1f3e6e69d7a3050d32f7fb5d52a"
+      },
+      "nativeDecodedPcmSha256": "7e432c880c57ed605b55cf95c74625b569353b7df4dc398f731e0b81c40e71ef"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 4,
+      "frames": 207800,
+      "expectedPcmSha256": "7e432c880c57ed605b55cf95c74625b569353b7df4dc398f731e0b81c40e71ef",
+      "encodedBytes": 465680,
+      "elapsedMilliseconds": 22.41812899999786,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5469,
+        "maximumFrameSize": 15210,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "207800",
+        "md5Hex": "0fffe1f3e6e69d7a3050d32f7fb5d52a"
+      },
+      "nativeDecodedPcmSha256": "7e432c880c57ed605b55cf95c74625b569353b7df4dc398f731e0b81c40e71ef"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:2dd061241fa7fe3128289427e108ee63501f4ed77c7208f1b37ff49fa6ccff0b",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "ed128680f0adb80432e3cce5156094cb93edefa0d6339dcfa20ee11a3610a693",
+      "encodedBytes": 2892634,
+      "elapsedMilliseconds": 553.4364849999984,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1070,
+        "maximumFrameSize": 19648,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9b820f9751be365c4f499e924aae57e9"
+      },
+      "nativeDecodedPcmSha256": "ed128680f0adb80432e3cce5156094cb93edefa0d6339dcfa20ee11a3610a693"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:2dd061241fa7fe3128289427e108ee63501f4ed77c7208f1b37ff49fa6ccff0b",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "ed128680f0adb80432e3cce5156094cb93edefa0d6339dcfa20ee11a3610a693",
+      "encodedBytes": 2892311,
+      "elapsedMilliseconds": 132.34480299999996,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1070,
+        "maximumFrameSize": 19648,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9b820f9751be365c4f499e924aae57e9"
+      },
+      "nativeDecodedPcmSha256": "ed128680f0adb80432e3cce5156094cb93edefa0d6339dcfa20ee11a3610a693"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:2dd061241fa7fe3128289427e108ee63501f4ed77c7208f1b37ff49fa6ccff0b",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "ea144cffa39519276d7320c735e04874b41c1a26d160703000ab7b0cec8400a8",
+      "encodedBytes": 2726814,
+      "elapsedMilliseconds": 557.7086259999924,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1065,
+        "maximumFrameSize": 19723,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "80dd17665b535e6bef3050d7c6a5c3bc"
+      },
+      "nativeDecodedPcmSha256": "ea144cffa39519276d7320c735e04874b41c1a26d160703000ab7b0cec8400a8"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:2dd061241fa7fe3128289427e108ee63501f4ed77c7208f1b37ff49fa6ccff0b",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "ea144cffa39519276d7320c735e04874b41c1a26d160703000ab7b0cec8400a8",
+      "encodedBytes": 2726860,
+      "elapsedMilliseconds": 131.59501399999135,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1065,
+        "maximumFrameSize": 19723,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "80dd17665b535e6bef3050d7c6a5c3bc"
+      },
+      "nativeDecodedPcmSha256": "ea144cffa39519276d7320c735e04874b41c1a26d160703000ab7b0cec8400a8"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:2dd061241fa7fe3128289427e108ee63501f4ed77c7208f1b37ff49fa6ccff0b",
+      "chunkIndex": 2,
+      "frames": 932160,
+      "expectedPcmSha256": "2fe58c8e997921bfcf38f90cc60e75cdd4693167a6879bb9ce3cd82222f04484",
+      "encodedBytes": 2587977,
+      "elapsedMilliseconds": 407.50319700001273,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 616,
+        "maximumFrameSize": 19678,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "932160",
+        "md5Hex": "82e5df6a400892541bf06d1835cd488e"
+      },
+      "nativeDecodedPcmSha256": "2fe58c8e997921bfcf38f90cc60e75cdd4693167a6879bb9ce3cd82222f04484"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:2dd061241fa7fe3128289427e108ee63501f4ed77c7208f1b37ff49fa6ccff0b",
+      "chunkIndex": 2,
+      "frames": 932160,
+      "expectedPcmSha256": "2fe58c8e997921bfcf38f90cc60e75cdd4693167a6879bb9ce3cd82222f04484",
+      "encodedBytes": 2587993,
+      "elapsedMilliseconds": 95.48614500000258,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 616,
+        "maximumFrameSize": 19678,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "932160",
+        "md5Hex": "82e5df6a400892541bf06d1835cd488e"
+      },
+      "nativeDecodedPcmSha256": "2fe58c8e997921bfcf38f90cc60e75cdd4693167a6879bb9ce3cd82222f04484"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "624eb9b34a886ec6358d888dd40dedbc626eaf8120f5857a4a4a66564d718228",
+      "encodedBytes": 1374986,
+      "elapsedMilliseconds": 493.45386199999484,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 534,
+        "maximumFrameSize": 10206,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "23e4a57a4efdbb27ec686a87520eb52d"
+      },
+      "nativeDecodedPcmSha256": "624eb9b34a886ec6358d888dd40dedbc626eaf8120f5857a4a4a66564d718228"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "624eb9b34a886ec6358d888dd40dedbc626eaf8120f5857a4a4a66564d718228",
+      "encodedBytes": 1374937,
+      "elapsedMilliseconds": 115.76122099999338,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 534,
+        "maximumFrameSize": 10206,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "23e4a57a4efdbb27ec686a87520eb52d"
+      },
+      "nativeDecodedPcmSha256": "624eb9b34a886ec6358d888dd40dedbc626eaf8120f5857a4a4a66564d718228"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "3cc0f29b0fc5ae8aa860430556697b4b2301a5537ab6f417baf667f498c21399",
+      "encodedBytes": 813899,
+      "elapsedMilliseconds": 362.6699940000108,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1059,
+        "maximumFrameSize": 6719,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "942063bb60651f274c2ac31de0ddcbee"
+      },
+      "nativeDecodedPcmSha256": "3cc0f29b0fc5ae8aa860430556697b4b2301a5537ab6f417baf667f498c21399"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "3cc0f29b0fc5ae8aa860430556697b4b2301a5537ab6f417baf667f498c21399",
+      "encodedBytes": 813885,
+      "elapsedMilliseconds": 107.69317699999374,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1059,
+        "maximumFrameSize": 6719,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "942063bb60651f274c2ac31de0ddcbee"
+      },
+      "nativeDecodedPcmSha256": "3cc0f29b0fc5ae8aa860430556697b4b2301a5537ab6f417baf667f498c21399"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "77a7ec33fa71caea53ad8f039c991b547b56dca2f267013b9a91fa1093c6b5f6",
+      "encodedBytes": 701176,
+      "elapsedMilliseconds": 346.5494750000071,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1065,
+        "maximumFrameSize": 7718,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "71304eeb1e3cd469c4f66cc0b2043f3c"
+      },
+      "nativeDecodedPcmSha256": "77a7ec33fa71caea53ad8f039c991b547b56dca2f267013b9a91fa1093c6b5f6"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "77a7ec33fa71caea53ad8f039c991b547b56dca2f267013b9a91fa1093c6b5f6",
+      "encodedBytes": 701130,
+      "elapsedMilliseconds": 102.82759500000975,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1065,
+        "maximumFrameSize": 7718,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "71304eeb1e3cd469c4f66cc0b2043f3c"
+      },
+      "nativeDecodedPcmSha256": "77a7ec33fa71caea53ad8f039c991b547b56dca2f267013b9a91fa1093c6b5f6"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 3,
+      "frames": 1057881,
+      "expectedPcmSha256": "e1c58aca6a4e6b13d373151f083a94be66336f1ea664eb691eb1aaeb3cf234db",
+      "encodedBytes": 876783,
+      "elapsedMilliseconds": 347.9178819999943,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 300,
+        "maximumFrameSize": 7789,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1057881",
+        "md5Hex": "8751673efb6f8957d16ea3204f3c5165"
+      },
+      "nativeDecodedPcmSha256": "e1c58aca6a4e6b13d373151f083a94be66336f1ea664eb691eb1aaeb3cf234db"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 3,
+      "frames": 1057881,
+      "expectedPcmSha256": "e1c58aca6a4e6b13d373151f083a94be66336f1ea664eb691eb1aaeb3cf234db",
+      "encodedBytes": 876850,
+      "elapsedMilliseconds": 91.86519600001338,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 300,
+        "maximumFrameSize": 7789,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1057881",
+        "md5Hex": "8751673efb6f8957d16ea3204f3c5165"
+      },
+      "nativeDecodedPcmSha256": "e1c58aca6a4e6b13d373151f083a94be66336f1ea664eb691eb1aaeb3cf234db"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "d65ddf96ef3551fdd5c08ca4a51b90f1c46ecb35544714d470119b2ba0c5cd63",
+      "encodedBytes": 1943412,
+      "elapsedMilliseconds": 428.4394719999982,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1051,
+        "maximumFrameSize": 18491,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "0d61fa2572913812a15c20371f2bfb80"
+      },
+      "nativeDecodedPcmSha256": "d65ddf96ef3551fdd5c08ca4a51b90f1c46ecb35544714d470119b2ba0c5cd63"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "d65ddf96ef3551fdd5c08ca4a51b90f1c46ecb35544714d470119b2ba0c5cd63",
+      "encodedBytes": 1943384,
+      "elapsedMilliseconds": 115.34184199999436,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1051,
+        "maximumFrameSize": 18491,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "0d61fa2572913812a15c20371f2bfb80"
+      },
+      "nativeDecodedPcmSha256": "d65ddf96ef3551fdd5c08ca4a51b90f1c46ecb35544714d470119b2ba0c5cd63"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "ef94fcfe71b9f59da74d552ee67fd658841d8f4547eca40ef2a928d3431ecbbc",
+      "encodedBytes": 2803573,
+      "elapsedMilliseconds": 489.3180500000017,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1056,
+        "maximumFrameSize": 18346,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "689815531096c080e770d82660e1ccdc"
+      },
+      "nativeDecodedPcmSha256": "ef94fcfe71b9f59da74d552ee67fd658841d8f4547eca40ef2a928d3431ecbbc"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "ef94fcfe71b9f59da74d552ee67fd658841d8f4547eca40ef2a928d3431ecbbc",
+      "encodedBytes": 2803492,
+      "elapsedMilliseconds": 122.50051399999938,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1056,
+        "maximumFrameSize": 18346,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "689815531096c080e770d82660e1ccdc"
+      },
+      "nativeDecodedPcmSha256": "ef94fcfe71b9f59da74d552ee67fd658841d8f4547eca40ef2a928d3431ecbbc"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "836755243b06af4a9fa6dd26a38b6ecb486feddb013575b58f4ed55858794bbf",
+      "encodedBytes": 3690570,
+      "elapsedMilliseconds": 547.4427299999952,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1082,
+        "maximumFrameSize": 18247,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "7e11ce05b0f176124275621fbbeff0ab"
+      },
+      "nativeDecodedPcmSha256": "836755243b06af4a9fa6dd26a38b6ecb486feddb013575b58f4ed55858794bbf"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "836755243b06af4a9fa6dd26a38b6ecb486feddb013575b58f4ed55858794bbf",
+      "encodedBytes": 3690485,
+      "elapsedMilliseconds": 132.10104700000375,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1082,
+        "maximumFrameSize": 18247,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "7e11ce05b0f176124275621fbbeff0ab"
+      },
+      "nativeDecodedPcmSha256": "836755243b06af4a9fa6dd26a38b6ecb486feddb013575b58f4ed55858794bbf"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 3,
+      "frames": 1047609,
+      "expectedPcmSha256": "ad00f29b53ad6c3fbfa12672cb17168270becc5fb01419ef9ed530476756d725",
+      "encodedBytes": 3831622,
+      "elapsedMilliseconds": 457.7961110000033,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 807,
+        "maximumFrameSize": 19674,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1047609",
+        "md5Hex": "36fc61d6543e34a59df4d2ceb3d6678a"
+      },
+      "nativeDecodedPcmSha256": "ad00f29b53ad6c3fbfa12672cb17168270becc5fb01419ef9ed530476756d725"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 3,
+      "frames": 1047609,
+      "expectedPcmSha256": "ad00f29b53ad6c3fbfa12672cb17168270becc5fb01419ef9ed530476756d725",
+      "encodedBytes": 3831623,
+      "elapsedMilliseconds": 108.6329870000045,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 807,
+        "maximumFrameSize": 19674,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1047609",
+        "md5Hex": "36fc61d6543e34a59df4d2ceb3d6678a"
+      },
+      "nativeDecodedPcmSha256": "ad00f29b53ad6c3fbfa12672cb17168270becc5fb01419ef9ed530476756d725"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:43413b8b197ba8a6be8b706e5173fb5246f4c60c414557dc552d9c65239f9340",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "fda5317be1243b68e09d100738aae8d0d0b835e4b9c42222ceb8637f206fbd23",
+      "encodedBytes": 4695124,
+      "elapsedMilliseconds": 569.7687730000034,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1941,
+        "maximumFrameSize": 17360,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "0db7916b9afe1ba846cacae409fd3719"
+      },
+      "nativeDecodedPcmSha256": "fda5317be1243b68e09d100738aae8d0d0b835e4b9c42222ceb8637f206fbd23"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:43413b8b197ba8a6be8b706e5173fb5246f4c60c414557dc552d9c65239f9340",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "fda5317be1243b68e09d100738aae8d0d0b835e4b9c42222ceb8637f206fbd23",
+      "encodedBytes": 4695125,
+      "elapsedMilliseconds": 137.13826600000903,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1941,
+        "maximumFrameSize": 17360,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "0db7916b9afe1ba846cacae409fd3719"
+      },
+      "nativeDecodedPcmSha256": "fda5317be1243b68e09d100738aae8d0d0b835e4b9c42222ceb8637f206fbd23"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:43413b8b197ba8a6be8b706e5173fb5246f4c60c414557dc552d9c65239f9340",
+      "chunkIndex": 1,
+      "frames": 514531,
+      "expectedPcmSha256": "f12619a013d45d71b3261cc8eaa4bd5777f329942b6c0c49cbe8ca2a5fbc9878",
+      "encodedBytes": 1733385,
+      "elapsedMilliseconds": 232.5151130000013,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 16689,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "514531",
+        "md5Hex": "6ab71b21358d04a2bdd04f53483595e9"
+      },
+      "nativeDecodedPcmSha256": "f12619a013d45d71b3261cc8eaa4bd5777f329942b6c0c49cbe8ca2a5fbc9878"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:43413b8b197ba8a6be8b706e5173fb5246f4c60c414557dc552d9c65239f9340",
+      "chunkIndex": 1,
+      "frames": 514531,
+      "expectedPcmSha256": "f12619a013d45d71b3261cc8eaa4bd5777f329942b6c0c49cbe8ca2a5fbc9878",
+      "encodedBytes": 1733385,
+      "elapsedMilliseconds": 54.62903899999219,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 16689,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "514531",
+        "md5Hex": "6ab71b21358d04a2bdd04f53483595e9"
+      },
+      "nativeDecodedPcmSha256": "f12619a013d45d71b3261cc8eaa4bd5777f329942b6c0c49cbe8ca2a5fbc9878"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "1ac0d21a2979389605675c51b1da394d304bb096ed5b6f68ef8ffe0c41573dfa",
+      "encodedBytes": 2818457,
+      "elapsedMilliseconds": 437.03118199999153,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7866,
+        "maximumFrameSize": 19365,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "009617d337fbad5c9834b9ce0e370958"
+      },
+      "nativeDecodedPcmSha256": "1ac0d21a2979389605675c51b1da394d304bb096ed5b6f68ef8ffe0c41573dfa"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "1ac0d21a2979389605675c51b1da394d304bb096ed5b6f68ef8ffe0c41573dfa",
+      "encodedBytes": 2818457,
+      "elapsedMilliseconds": 114.67186500001117,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7866,
+        "maximumFrameSize": 19365,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "009617d337fbad5c9834b9ce0e370958"
+      },
+      "nativeDecodedPcmSha256": "1ac0d21a2979389605675c51b1da394d304bb096ed5b6f68ef8ffe0c41573dfa"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "3514cf02ee43289d552a33de6fc20dc9df401dec16291793e830998f6c9e24cb",
+      "encodedBytes": 3471032,
+      "elapsedMilliseconds": 498.7426570000098,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1972,
+        "maximumFrameSize": 19226,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "6dd907abc466119fefd0accda2e2dcac"
+      },
+      "nativeDecodedPcmSha256": "3514cf02ee43289d552a33de6fc20dc9df401dec16291793e830998f6c9e24cb"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "3514cf02ee43289d552a33de6fc20dc9df401dec16291793e830998f6c9e24cb",
+      "encodedBytes": 3471032,
+      "elapsedMilliseconds": 121.89938699999766,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1972,
+        "maximumFrameSize": 19226,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "6dd907abc466119fefd0accda2e2dcac"
+      },
+      "nativeDecodedPcmSha256": "3514cf02ee43289d552a33de6fc20dc9df401dec16291793e830998f6c9e24cb"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "37b45f881e3898b1d03385bc0f9d130454c43830970bdb853803acccc5ae742e",
+      "encodedBytes": 4148907,
+      "elapsedMilliseconds": 524.0235300000058,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7964,
+        "maximumFrameSize": 20117,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "e7ce31ef6a7fc8d270923fa69283407a"
+      },
+      "nativeDecodedPcmSha256": "37b45f881e3898b1d03385bc0f9d130454c43830970bdb853803acccc5ae742e"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "37b45f881e3898b1d03385bc0f9d130454c43830970bdb853803acccc5ae742e",
+      "encodedBytes": 4148907,
+      "elapsedMilliseconds": 128.02195399999619,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7964,
+        "maximumFrameSize": 20117,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "e7ce31ef6a7fc8d270923fa69283407a"
+      },
+      "nativeDecodedPcmSha256": "37b45f881e3898b1d03385bc0f9d130454c43830970bdb853803acccc5ae742e"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "3d18c069e8d2ab8caddba535d0c8e83e593f350ad8a43728b357745f7b510f18",
+      "encodedBytes": 3908126,
+      "elapsedMilliseconds": 520.2435770000011,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7938,
+        "maximumFrameSize": 18062,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f72b873a9cfcdecb8bffca82dfea5b08"
+      },
+      "nativeDecodedPcmSha256": "3d18c069e8d2ab8caddba535d0c8e83e593f350ad8a43728b357745f7b510f18"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "3d18c069e8d2ab8caddba535d0c8e83e593f350ad8a43728b357745f7b510f18",
+      "encodedBytes": 3908126,
+      "elapsedMilliseconds": 129.39333700000134,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7938,
+        "maximumFrameSize": 18062,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f72b873a9cfcdecb8bffca82dfea5b08"
+      },
+      "nativeDecodedPcmSha256": "3d18c069e8d2ab8caddba535d0c8e83e593f350ad8a43728b357745f7b510f18"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "361efaa716a4c5a8e7cd18811f99fc1da378df26a01639a0c96da726a2fdc27c",
+      "encodedBytes": 4140983,
+      "elapsedMilliseconds": 574.5678759999864,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7912,
+        "maximumFrameSize": 16656,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "47515984c7da3d9064aa8594b71effda"
+      },
+      "nativeDecodedPcmSha256": "361efaa716a4c5a8e7cd18811f99fc1da378df26a01639a0c96da726a2fdc27c"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "361efaa716a4c5a8e7cd18811f99fc1da378df26a01639a0c96da726a2fdc27c",
+      "encodedBytes": 4140983,
+      "elapsedMilliseconds": 133.2054119999957,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7912,
+        "maximumFrameSize": 16656,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "47515984c7da3d9064aa8594b71effda"
+      },
+      "nativeDecodedPcmSha256": "361efaa716a4c5a8e7cd18811f99fc1da378df26a01639a0c96da726a2fdc27c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "dd0019f65cb14a6c5f4712f7b96750b71598a71f70c70cd0fbdb110b94954bc3",
+      "encodedBytes": 2579361,
+      "elapsedMilliseconds": 419.29766799999925,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7912,
+        "maximumFrameSize": 8037,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b850669f2d0338f0745d888777563278"
+      },
+      "nativeDecodedPcmSha256": "dd0019f65cb14a6c5f4712f7b96750b71598a71f70c70cd0fbdb110b94954bc3"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "dd0019f65cb14a6c5f4712f7b96750b71598a71f70c70cd0fbdb110b94954bc3",
+      "encodedBytes": 2579361,
+      "elapsedMilliseconds": 112.87671300000511,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7912,
+        "maximumFrameSize": 8037,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b850669f2d0338f0745d888777563278"
+      },
+      "nativeDecodedPcmSha256": "dd0019f65cb14a6c5f4712f7b96750b71598a71f70c70cd0fbdb110b94954bc3"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "e4a0b2b5384e5289ceff5b3ad42ccff678ab6a5d77c96e07a78147a5ed3770a2",
+      "encodedBytes": 1094710,
+      "elapsedMilliseconds": 209.34915699998965,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7866,
+        "maximumFrameSize": 8030,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "1a6ac668bc13ddfb53097b30403ed296"
+      },
+      "nativeDecodedPcmSha256": "e4a0b2b5384e5289ceff5b3ad42ccff678ab6a5d77c96e07a78147a5ed3770a2"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "e4a0b2b5384e5289ceff5b3ad42ccff678ab6a5d77c96e07a78147a5ed3770a2",
+      "encodedBytes": 1094710,
+      "elapsedMilliseconds": 49.50453400000697,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7866,
+        "maximumFrameSize": 8030,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "1a6ac668bc13ddfb53097b30403ed296"
+      },
+      "nativeDecodedPcmSha256": "e4a0b2b5384e5289ceff5b3ad42ccff678ab6a5d77c96e07a78147a5ed3770a2"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "36c35e82c4c4668b94b037bd2e468dbe0abda7fa866332743117f68f21952c22",
+      "encodedBytes": 4309543,
+      "elapsedMilliseconds": 525.229256000006,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7915,
+        "maximumFrameSize": 17039,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5b8c234ab79476974554162d38196754"
+      },
+      "nativeDecodedPcmSha256": "36c35e82c4c4668b94b037bd2e468dbe0abda7fa866332743117f68f21952c22"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "36c35e82c4c4668b94b037bd2e468dbe0abda7fa866332743117f68f21952c22",
+      "encodedBytes": 4309544,
+      "elapsedMilliseconds": 125.91782499999681,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7915,
+        "maximumFrameSize": 17039,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5b8c234ab79476974554162d38196754"
+      },
+      "nativeDecodedPcmSha256": "36c35e82c4c4668b94b037bd2e468dbe0abda7fa866332743117f68f21952c22"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "9302ab132a16c115924a43d8f99697f902716f84953826be93722c923fcf2a2f",
+      "encodedBytes": 4041083,
+      "elapsedMilliseconds": 455.5315830000036,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5844,
+        "maximumFrameSize": 17267,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "16509c14a7dad38c60ac5f0fbd9eda83"
+      },
+      "nativeDecodedPcmSha256": "9302ab132a16c115924a43d8f99697f902716f84953826be93722c923fcf2a2f"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "9302ab132a16c115924a43d8f99697f902716f84953826be93722c923fcf2a2f",
+      "encodedBytes": 4041083,
+      "elapsedMilliseconds": 121.48249199999555,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5844,
+        "maximumFrameSize": 17267,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "16509c14a7dad38c60ac5f0fbd9eda83"
+      },
+      "nativeDecodedPcmSha256": "9302ab132a16c115924a43d8f99697f902716f84953826be93722c923fcf2a2f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "ead9d5ed0901c2d7a3d05525b352da2320551902855748160e84adaceda9b141",
+      "encodedBytes": 3563199,
+      "elapsedMilliseconds": 511.3996030000126,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7951,
+        "maximumFrameSize": 17209,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f9e21993a37ef66f175e13c13ca5d81a"
+      },
+      "nativeDecodedPcmSha256": "ead9d5ed0901c2d7a3d05525b352da2320551902855748160e84adaceda9b141"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "ead9d5ed0901c2d7a3d05525b352da2320551902855748160e84adaceda9b141",
+      "encodedBytes": 3563202,
+      "elapsedMilliseconds": 126.44665100000566,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7951,
+        "maximumFrameSize": 17209,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f9e21993a37ef66f175e13c13ca5d81a"
+      },
+      "nativeDecodedPcmSha256": "ead9d5ed0901c2d7a3d05525b352da2320551902855748160e84adaceda9b141"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "877ac4eb84976e6047201d0e4e19c27bfa9ea2b04c3564bfffad2eb97105d9b8",
+      "encodedBytes": 5437467,
+      "elapsedMilliseconds": 501.3665929999843,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8085,
+        "maximumFrameSize": 19284,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "cdd1b064a9f36d6376a7885b13079fe7"
+      },
+      "nativeDecodedPcmSha256": "877ac4eb84976e6047201d0e4e19c27bfa9ea2b04c3564bfffad2eb97105d9b8"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "877ac4eb84976e6047201d0e4e19c27bfa9ea2b04c3564bfffad2eb97105d9b8",
+      "encodedBytes": 5437466,
+      "elapsedMilliseconds": 127.04252700001234,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8085,
+        "maximumFrameSize": 19284,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "cdd1b064a9f36d6376a7885b13079fe7"
+      },
+      "nativeDecodedPcmSha256": "877ac4eb84976e6047201d0e4e19c27bfa9ea2b04c3564bfffad2eb97105d9b8"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "414909b9b21f0017c65c62b309a685ccbd4dcb7c896c25fa86f5e6814426f3a9",
+      "encodedBytes": 5382397,
+      "elapsedMilliseconds": 538.545019000012,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 4895,
+        "maximumFrameSize": 18771,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "bda5a890031144fbeef2a42f67d3212e"
+      },
+      "nativeDecodedPcmSha256": "414909b9b21f0017c65c62b309a685ccbd4dcb7c896c25fa86f5e6814426f3a9"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "414909b9b21f0017c65c62b309a685ccbd4dcb7c896c25fa86f5e6814426f3a9",
+      "encodedBytes": 5382399,
+      "elapsedMilliseconds": 132.7929239999794,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 4895,
+        "maximumFrameSize": 18771,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "bda5a890031144fbeef2a42f67d3212e"
+      },
+      "nativeDecodedPcmSha256": "414909b9b21f0017c65c62b309a685ccbd4dcb7c896c25fa86f5e6814426f3a9"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "a9aaae89159b3bc3a8ae7b343cee86ceccad6e9156bd051a7907244333351b1f",
+      "encodedBytes": 2606507,
+      "elapsedMilliseconds": 426.9893030000094,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7902,
+        "maximumFrameSize": 9888,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "89db8adaf0c4183346702ead7c61f734"
+      },
+      "nativeDecodedPcmSha256": "a9aaae89159b3bc3a8ae7b343cee86ceccad6e9156bd051a7907244333351b1f"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "a9aaae89159b3bc3a8ae7b343cee86ceccad6e9156bd051a7907244333351b1f",
+      "encodedBytes": 2606507,
+      "elapsedMilliseconds": 114.119841000007,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7902,
+        "maximumFrameSize": 9888,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "89db8adaf0c4183346702ead7c61f734"
+      },
+      "nativeDecodedPcmSha256": "a9aaae89159b3bc3a8ae7b343cee86ceccad6e9156bd051a7907244333351b1f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "1f54adca35b28601e714e675e5f666f57dfc0735aeb743bc06977b8da0a786e1",
+      "encodedBytes": 1093892,
+      "elapsedMilliseconds": 183.89895999999135,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7894,
+        "maximumFrameSize": 8026,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "e0ab70a4e3a8d9e373f720d5e52cfa68"
+      },
+      "nativeDecodedPcmSha256": "1f54adca35b28601e714e675e5f666f57dfc0735aeb743bc06977b8da0a786e1"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "1f54adca35b28601e714e675e5f666f57dfc0735aeb743bc06977b8da0a786e1",
+      "encodedBytes": 1093892,
+      "elapsedMilliseconds": 49.83100599999307,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7894,
+        "maximumFrameSize": 8026,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "e0ab70a4e3a8d9e373f720d5e52cfa68"
+      },
+      "nativeDecodedPcmSha256": "1f54adca35b28601e714e675e5f666f57dfc0735aeb743bc06977b8da0a786e1"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "65c8f28f921e06d2876ffa35765fefdeaefdfdbef66cdec9b4fda6c837106fc0",
+      "encodedBytes": 2211375,
+      "elapsedMilliseconds": 403.06849999999395,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1548,
+        "maximumFrameSize": 19561,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "852cbcac74613c45cf711c3e56a40ed6"
+      },
+      "nativeDecodedPcmSha256": "65c8f28f921e06d2876ffa35765fefdeaefdfdbef66cdec9b4fda6c837106fc0"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "65c8f28f921e06d2876ffa35765fefdeaefdfdbef66cdec9b4fda6c837106fc0",
+      "encodedBytes": 2211379,
+      "elapsedMilliseconds": 113.35689699999057,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1548,
+        "maximumFrameSize": 19561,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "852cbcac74613c45cf711c3e56a40ed6"
+      },
+      "nativeDecodedPcmSha256": "65c8f28f921e06d2876ffa35765fefdeaefdfdbef66cdec9b4fda6c837106fc0"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "42b9fdbea63544f90e683df82058eca4c5dca23bc3539047be92cf12a7c6d136",
+      "encodedBytes": 2322751,
+      "elapsedMilliseconds": 494.30248099999153,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 2092,
+        "maximumFrameSize": 19334,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "93eaab0be30ed181b4cea3e225c6544e"
+      },
+      "nativeDecodedPcmSha256": "42b9fdbea63544f90e683df82058eca4c5dca23bc3539047be92cf12a7c6d136"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "42b9fdbea63544f90e683df82058eca4c5dca23bc3539047be92cf12a7c6d136",
+      "encodedBytes": 2322749,
+      "elapsedMilliseconds": 127.95441400000709,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 2092,
+        "maximumFrameSize": 19334,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "93eaab0be30ed181b4cea3e225c6544e"
+      },
+      "nativeDecodedPcmSha256": "42b9fdbea63544f90e683df82058eca4c5dca23bc3539047be92cf12a7c6d136"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "fb3896dd6372aa0b8a3f68df45483ea73b28a18712fffcdf18897ee0a3205b8c",
+      "encodedBytes": 4591316,
+      "elapsedMilliseconds": 575.5398829999904,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1187,
+        "maximumFrameSize": 20319,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f9ffaea4787abb17141be3bb2706da0c"
+      },
+      "nativeDecodedPcmSha256": "fb3896dd6372aa0b8a3f68df45483ea73b28a18712fffcdf18897ee0a3205b8c"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "fb3896dd6372aa0b8a3f68df45483ea73b28a18712fffcdf18897ee0a3205b8c",
+      "encodedBytes": 4591315,
+      "elapsedMilliseconds": 134.24453999998514,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1187,
+        "maximumFrameSize": 20319,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f9ffaea4787abb17141be3bb2706da0c"
+      },
+      "nativeDecodedPcmSha256": "fb3896dd6372aa0b8a3f68df45483ea73b28a18712fffcdf18897ee0a3205b8c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 3,
+      "frames": 1046796,
+      "expectedPcmSha256": "712b3b3d76c5042a314846332371f806367b0f8fe2d9f5a0f26f7e234719402f",
+      "encodedBytes": 2390904,
+      "elapsedMilliseconds": 339.7187219999905,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1139,
+        "maximumFrameSize": 19646,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1046796",
+        "md5Hex": "ef20b4d4539a89c71fb61fbfb3974dd9"
+      },
+      "nativeDecodedPcmSha256": "712b3b3d76c5042a314846332371f806367b0f8fe2d9f5a0f26f7e234719402f"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 3,
+      "frames": 1046796,
+      "expectedPcmSha256": "712b3b3d76c5042a314846332371f806367b0f8fe2d9f5a0f26f7e234719402f",
+      "encodedBytes": 2390904,
+      "elapsedMilliseconds": 90.62754600000335,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1139,
+        "maximumFrameSize": 19646,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1046796",
+        "md5Hex": "ef20b4d4539a89c71fb61fbfb3974dd9"
+      },
+      "nativeDecodedPcmSha256": "712b3b3d76c5042a314846332371f806367b0f8fe2d9f5a0f26f7e234719402f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:76f8d36d4b2b6ed2efc19418250feaac1fe1868fd919c4c03a6e6f66e3e3f926",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "23c396618176630bd3af2e08a196598454feb5cc088b2f3430eb99dc7b631228",
+      "encodedBytes": 4937137,
+      "elapsedMilliseconds": 482.46936100002495,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 10236,
+        "maximumFrameSize": 17583,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5307bab8edc1efd9a497689333954d72"
+      },
+      "nativeDecodedPcmSha256": "23c396618176630bd3af2e08a196598454feb5cc088b2f3430eb99dc7b631228"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:76f8d36d4b2b6ed2efc19418250feaac1fe1868fd919c4c03a6e6f66e3e3f926",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "23c396618176630bd3af2e08a196598454feb5cc088b2f3430eb99dc7b631228",
+      "encodedBytes": 4937137,
+      "elapsedMilliseconds": 124.67543599999044,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 10236,
+        "maximumFrameSize": 17583,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5307bab8edc1efd9a497689333954d72"
+      },
+      "nativeDecodedPcmSha256": "23c396618176630bd3af2e08a196598454feb5cc088b2f3430eb99dc7b631228"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:76f8d36d4b2b6ed2efc19418250feaac1fe1868fd919c4c03a6e6f66e3e3f926",
+      "chunkIndex": 1,
+      "frames": 582102,
+      "expectedPcmSha256": "b6f8c245441b191497cbe43678526f07a8c3d3cc12db92b88017a783d6aed512",
+      "encodedBytes": 2125904,
+      "elapsedMilliseconds": 209.80476400000043,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 504,
+        "maximumFrameSize": 18089,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "582102",
+        "md5Hex": "a97591cbcdd1cbc312ddbc3e1bcb87fc"
+      },
+      "nativeDecodedPcmSha256": "b6f8c245441b191497cbe43678526f07a8c3d3cc12db92b88017a783d6aed512"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:76f8d36d4b2b6ed2efc19418250feaac1fe1868fd919c4c03a6e6f66e3e3f926",
+      "chunkIndex": 1,
+      "frames": 582102,
+      "expectedPcmSha256": "b6f8c245441b191497cbe43678526f07a8c3d3cc12db92b88017a783d6aed512",
+      "encodedBytes": 2125904,
+      "elapsedMilliseconds": 54.45720099998289,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 504,
+        "maximumFrameSize": 18089,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "582102",
+        "md5Hex": "a97591cbcdd1cbc312ddbc3e1bcb87fc"
+      },
+      "nativeDecodedPcmSha256": "b6f8c245441b191497cbe43678526f07a8c3d3cc12db92b88017a783d6aed512"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:820926ccc8557b4cdf81d0c19933f1115dc371d5b53e46ddedb2a87bf4e4e197",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "024d2eb37862cb6bf6db15b26958f67a4652050a28172bcba4679dd104adab6f",
+      "encodedBytes": 3873752,
+      "elapsedMilliseconds": 563.1431990000128,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 16786,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9b443230fb327c1c66f044b6506908bb"
+      },
+      "nativeDecodedPcmSha256": "024d2eb37862cb6bf6db15b26958f67a4652050a28172bcba4679dd104adab6f"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:820926ccc8557b4cdf81d0c19933f1115dc371d5b53e46ddedb2a87bf4e4e197",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "024d2eb37862cb6bf6db15b26958f67a4652050a28172bcba4679dd104adab6f",
+      "encodedBytes": 3873792,
+      "elapsedMilliseconds": 134.37217300001066,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 16786,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9b443230fb327c1c66f044b6506908bb"
+      },
+      "nativeDecodedPcmSha256": "024d2eb37862cb6bf6db15b26958f67a4652050a28172bcba4679dd104adab6f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:820926ccc8557b4cdf81d0c19933f1115dc371d5b53e46ddedb2a87bf4e4e197",
+      "chunkIndex": 1,
+      "frames": 1201590,
+      "expectedPcmSha256": "125a5e3e22686866f06b6135bc7113921c4b1c3be48bd955ac301d573abf4483",
+      "encodedBytes": 3785562,
+      "elapsedMilliseconds": 534.5459849999752,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 204,
+        "maximumFrameSize": 17630,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1201590",
+        "md5Hex": "b3af88adf8c285751886ec5c7f89058c"
+      },
+      "nativeDecodedPcmSha256": "125a5e3e22686866f06b6135bc7113921c4b1c3be48bd955ac301d573abf4483"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:820926ccc8557b4cdf81d0c19933f1115dc371d5b53e46ddedb2a87bf4e4e197",
+      "chunkIndex": 1,
+      "frames": 1201590,
+      "expectedPcmSha256": "125a5e3e22686866f06b6135bc7113921c4b1c3be48bd955ac301d573abf4483",
+      "encodedBytes": 3785565,
+      "elapsedMilliseconds": 125.75623500000802,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 204,
+        "maximumFrameSize": 17630,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1201590",
+        "md5Hex": "b3af88adf8c285751886ec5c7f89058c"
+      },
+      "nativeDecodedPcmSha256": "125a5e3e22686866f06b6135bc7113921c4b1c3be48bd955ac301d573abf4483"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "a0bf84dc4c81916ccd105c692da94fff0a59d39a8154eb6c266a278fb3bd2762",
+      "encodedBytes": 4192669,
+      "elapsedMilliseconds": 459.6274740000081,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 11422,
+        "maximumFrameSize": 18306,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5b4ba26d280febae8940b7569d82f82d"
+      },
+      "nativeDecodedPcmSha256": "a0bf84dc4c81916ccd105c692da94fff0a59d39a8154eb6c266a278fb3bd2762"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "a0bf84dc4c81916ccd105c692da94fff0a59d39a8154eb6c266a278fb3bd2762",
+      "encodedBytes": 4192669,
+      "elapsedMilliseconds": 120.65075600001728,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 11422,
+        "maximumFrameSize": 18306,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5b4ba26d280febae8940b7569d82f82d"
+      },
+      "nativeDecodedPcmSha256": "a0bf84dc4c81916ccd105c692da94fff0a59d39a8154eb6c266a278fb3bd2762"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "0bca03d3827a10f809d4f15d1bb053e182507deaeec754edb0e9aed2f795d58f",
+      "encodedBytes": 4848686,
+      "elapsedMilliseconds": 545.0139320000017,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 11453,
+        "maximumFrameSize": 18073,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "510cd4f30db1b7a6acf0bbca4df9b291"
+      },
+      "nativeDecodedPcmSha256": "0bca03d3827a10f809d4f15d1bb053e182507deaeec754edb0e9aed2f795d58f"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "0bca03d3827a10f809d4f15d1bb053e182507deaeec754edb0e9aed2f795d58f",
+      "encodedBytes": 4848686,
+      "elapsedMilliseconds": 131.6404179999954,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 11453,
+        "maximumFrameSize": 18073,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "510cd4f30db1b7a6acf0bbca4df9b291"
+      },
+      "nativeDecodedPcmSha256": "0bca03d3827a10f809d4f15d1bb053e182507deaeec754edb0e9aed2f795d58f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "a4ff8fea4e0de7fa60fdae51ad711cd91f037cb46d5a9349bf1dca02acbbc5f5",
+      "encodedBytes": 4526232,
+      "elapsedMilliseconds": 540.3987870000128,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 11459,
+        "maximumFrameSize": 17182,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d8b635c44ececa10b608234674a067d8"
+      },
+      "nativeDecodedPcmSha256": "a4ff8fea4e0de7fa60fdae51ad711cd91f037cb46d5a9349bf1dca02acbbc5f5"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "a4ff8fea4e0de7fa60fdae51ad711cd91f037cb46d5a9349bf1dca02acbbc5f5",
+      "encodedBytes": 4526232,
+      "elapsedMilliseconds": 130.02501899999334,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 11459,
+        "maximumFrameSize": 17182,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d8b635c44ececa10b608234674a067d8"
+      },
+      "nativeDecodedPcmSha256": "a4ff8fea4e0de7fa60fdae51ad711cd91f037cb46d5a9349bf1dca02acbbc5f5"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "8f216c2fb91fd3ca55f340129e429be43b6026756b830491ef476ced4bce86ab",
+      "encodedBytes": 4906482,
+      "elapsedMilliseconds": 558.6123729999817,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 2388,
+        "maximumFrameSize": 18391,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "21ee978805ca43cda3cd06f8cda52115"
+      },
+      "nativeDecodedPcmSha256": "8f216c2fb91fd3ca55f340129e429be43b6026756b830491ef476ced4bce86ab"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "8f216c2fb91fd3ca55f340129e429be43b6026756b830491ef476ced4bce86ab",
+      "encodedBytes": 4906478,
+      "elapsedMilliseconds": 131.4525990000111,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 2388,
+        "maximumFrameSize": 18391,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "21ee978805ca43cda3cd06f8cda52115"
+      },
+      "nativeDecodedPcmSha256": "8f216c2fb91fd3ca55f340129e429be43b6026756b830491ef476ced4bce86ab"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "2206e4ac690835dbfca27792f1a86ace07f1ba2690e226e56f6e741e07e8f2e8",
+      "encodedBytes": 4753432,
+      "elapsedMilliseconds": 570.4265149999992,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6945,
+        "maximumFrameSize": 19944,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f0d8a1b4dee3452819937b1150c61245"
+      },
+      "nativeDecodedPcmSha256": "2206e4ac690835dbfca27792f1a86ace07f1ba2690e226e56f6e741e07e8f2e8"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "2206e4ac690835dbfca27792f1a86ace07f1ba2690e226e56f6e741e07e8f2e8",
+      "encodedBytes": 4753431,
+      "elapsedMilliseconds": 135.3407479999878,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6945,
+        "maximumFrameSize": 19944,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f0d8a1b4dee3452819937b1150c61245"
+      },
+      "nativeDecodedPcmSha256": "2206e4ac690835dbfca27792f1a86ace07f1ba2690e226e56f6e741e07e8f2e8"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 5,
+      "frames": 1102500,
+      "expectedPcmSha256": "94d4191d8b99b19a6302a3ea00e8676f4391837f5f323c6eda44ce43119af8ce",
+      "encodedBytes": 3562930,
+      "elapsedMilliseconds": 463.064681000018,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 419,
+        "maximumFrameSize": 20222,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1102500",
+        "md5Hex": "7d943016a2b411fbf33b8cab0b35910e"
+      },
+      "nativeDecodedPcmSha256": "94d4191d8b99b19a6302a3ea00e8676f4391837f5f323c6eda44ce43119af8ce"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 5,
+      "frames": 1102500,
+      "expectedPcmSha256": "94d4191d8b99b19a6302a3ea00e8676f4391837f5f323c6eda44ce43119af8ce",
+      "encodedBytes": 3562872,
+      "elapsedMilliseconds": 121.07966300001135,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 419,
+        "maximumFrameSize": 20222,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1102500",
+        "md5Hex": "7d943016a2b411fbf33b8cab0b35910e"
+      },
+      "nativeDecodedPcmSha256": "94d4191d8b99b19a6302a3ea00e8676f4391837f5f323c6eda44ce43119af8ce"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "a55e83e9d57a7e0b8a02c1589c368946d107e6fe45bf27732ce74cbf2cf1de14",
+      "encodedBytes": 2577349,
+      "elapsedMilliseconds": 415.464948000008,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7745,
+        "maximumFrameSize": 8051,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "65d5924a754ff00c55d25d5f7706de7f"
+      },
+      "nativeDecodedPcmSha256": "a55e83e9d57a7e0b8a02c1589c368946d107e6fe45bf27732ce74cbf2cf1de14"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "a55e83e9d57a7e0b8a02c1589c368946d107e6fe45bf27732ce74cbf2cf1de14",
+      "encodedBytes": 2577349,
+      "elapsedMilliseconds": 113.43194999999832,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7745,
+        "maximumFrameSize": 8051,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "65d5924a754ff00c55d25d5f7706de7f"
+      },
+      "nativeDecodedPcmSha256": "a55e83e9d57a7e0b8a02c1589c368946d107e6fe45bf27732ce74cbf2cf1de14"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "2174a88c16a1582e995c5069a5f2887dbfd8b93a7cbd2b3c773cca9811be4835",
+      "encodedBytes": 3617407,
+      "elapsedMilliseconds": 486.92905499998596,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1952,
+        "maximumFrameSize": 16398,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "c1e031e278a7feff877baa055ebfce21"
+      },
+      "nativeDecodedPcmSha256": "2174a88c16a1582e995c5069a5f2887dbfd8b93a7cbd2b3c773cca9811be4835"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "2174a88c16a1582e995c5069a5f2887dbfd8b93a7cbd2b3c773cca9811be4835",
+      "encodedBytes": 3617407,
+      "elapsedMilliseconds": 126.18014199999743,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1952,
+        "maximumFrameSize": 16398,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "c1e031e278a7feff877baa055ebfce21"
+      },
+      "nativeDecodedPcmSha256": "2174a88c16a1582e995c5069a5f2887dbfd8b93a7cbd2b3c773cca9811be4835"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "9918d016f7c301fc23b8db32bc93184a134378824b8cdb7b3d76348b5d739dcc",
+      "encodedBytes": 3991391,
+      "elapsedMilliseconds": 541.1288350000104,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7966,
+        "maximumFrameSize": 16107,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2e2522b2dea00fdbff7d281e86ec99ad"
+      },
+      "nativeDecodedPcmSha256": "9918d016f7c301fc23b8db32bc93184a134378824b8cdb7b3d76348b5d739dcc"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "9918d016f7c301fc23b8db32bc93184a134378824b8cdb7b3d76348b5d739dcc",
+      "encodedBytes": 3991391,
+      "elapsedMilliseconds": 130.9807499999879,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7966,
+        "maximumFrameSize": 16107,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2e2522b2dea00fdbff7d281e86ec99ad"
+      },
+      "nativeDecodedPcmSha256": "9918d016f7c301fc23b8db32bc93184a134378824b8cdb7b3d76348b5d739dcc"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "1ecf66d2439e4d20cbe4ff066e34944b60652831ec88cb6a3ddd8fbae4be5832",
+      "encodedBytes": 3034301,
+      "elapsedMilliseconds": 444.5595880000037,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7959,
+        "maximumFrameSize": 11026,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2ca55659b0c0c12029977a3020fd2187"
+      },
+      "nativeDecodedPcmSha256": "1ecf66d2439e4d20cbe4ff066e34944b60652831ec88cb6a3ddd8fbae4be5832"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "1ecf66d2439e4d20cbe4ff066e34944b60652831ec88cb6a3ddd8fbae4be5832",
+      "encodedBytes": 3034301,
+      "elapsedMilliseconds": 117.44094900001073,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7959,
+        "maximumFrameSize": 11026,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2ca55659b0c0c12029977a3020fd2187"
+      },
+      "nativeDecodedPcmSha256": "1ecf66d2439e4d20cbe4ff066e34944b60652831ec88cb6a3ddd8fbae4be5832"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "00aae3147503f28168368f37d8f2fb603194a4fa8efa2b675b75792282976d98",
+      "encodedBytes": 4949257,
+      "elapsedMilliseconds": 577.5344259999983,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8171,
+        "maximumFrameSize": 16546,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "81235cfc81a4e37833e3ab0b612dd7ad"
+      },
+      "nativeDecodedPcmSha256": "00aae3147503f28168368f37d8f2fb603194a4fa8efa2b675b75792282976d98"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "00aae3147503f28168368f37d8f2fb603194a4fa8efa2b675b75792282976d98",
+      "encodedBytes": 4949256,
+      "elapsedMilliseconds": 138.43671700000414,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8171,
+        "maximumFrameSize": 16546,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "81235cfc81a4e37833e3ab0b612dd7ad"
+      },
+      "nativeDecodedPcmSha256": "00aae3147503f28168368f37d8f2fb603194a4fa8efa2b675b75792282976d98"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "92612943d9be9bb9339bf5ab99071d5b42a606add5b2d8d0316702c0cfddb6da",
+      "encodedBytes": 2613579,
+      "elapsedMilliseconds": 442.3577310000255,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7928,
+        "maximumFrameSize": 8257,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "071cfccfae1495e8786fea88af04f2fd"
+      },
+      "nativeDecodedPcmSha256": "92612943d9be9bb9339bf5ab99071d5b42a606add5b2d8d0316702c0cfddb6da"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "92612943d9be9bb9339bf5ab99071d5b42a606add5b2d8d0316702c0cfddb6da",
+      "encodedBytes": 2613579,
+      "elapsedMilliseconds": 116.04789399998845,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7928,
+        "maximumFrameSize": 8257,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "071cfccfae1495e8786fea88af04f2fd"
+      },
+      "nativeDecodedPcmSha256": "92612943d9be9bb9339bf5ab99071d5b42a606add5b2d8d0316702c0cfddb6da"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "c28846b24eb143541dfa6661d24ec39cf492210d147cc6af216f98a6d7184e12",
+      "encodedBytes": 1108585,
+      "elapsedMilliseconds": 187.66166700000758,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7906,
+        "maximumFrameSize": 8224,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "012effc1b8d5e01259d60b79584a1192"
+      },
+      "nativeDecodedPcmSha256": "c28846b24eb143541dfa6661d24ec39cf492210d147cc6af216f98a6d7184e12"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "c28846b24eb143541dfa6661d24ec39cf492210d147cc6af216f98a6d7184e12",
+      "encodedBytes": 1108585,
+      "elapsedMilliseconds": 50.67963199998485,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7906,
+        "maximumFrameSize": 8224,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "012effc1b8d5e01259d60b79584a1192"
+      },
+      "nativeDecodedPcmSha256": "c28846b24eb143541dfa6661d24ec39cf492210d147cc6af216f98a6d7184e12"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "d8821208237f3f366dc6126255ccaeee18763a71346ac327e7e8eb0a254f1ab2",
+      "encodedBytes": 2367250,
+      "elapsedMilliseconds": 435.9745980000007,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 20391,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "3d61c3e2e8546136541599bab97164ac"
+      },
+      "nativeDecodedPcmSha256": "d8821208237f3f366dc6126255ccaeee18763a71346ac327e7e8eb0a254f1ab2"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "d8821208237f3f366dc6126255ccaeee18763a71346ac327e7e8eb0a254f1ab2",
+      "encodedBytes": 2367250,
+      "elapsedMilliseconds": 114.70691899998928,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 20391,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "3d61c3e2e8546136541599bab97164ac"
+      },
+      "nativeDecodedPcmSha256": "d8821208237f3f366dc6126255ccaeee18763a71346ac327e7e8eb0a254f1ab2"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "099b094dc0a74b685de3e0642a5fd801b328cadb5e794248d39e7c9f73161362",
+      "encodedBytes": 2658138,
+      "elapsedMilliseconds": 461.56762600000366,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1044,
+        "maximumFrameSize": 20238,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "4ce8d2781a93a27607c0f0146fe1d9a2"
+      },
+      "nativeDecodedPcmSha256": "099b094dc0a74b685de3e0642a5fd801b328cadb5e794248d39e7c9f73161362"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "099b094dc0a74b685de3e0642a5fd801b328cadb5e794248d39e7c9f73161362",
+      "encodedBytes": 2658137,
+      "elapsedMilliseconds": 118.6614240000199,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1044,
+        "maximumFrameSize": 20238,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "4ce8d2781a93a27607c0f0146fe1d9a2"
+      },
+      "nativeDecodedPcmSha256": "099b094dc0a74b685de3e0642a5fd801b328cadb5e794248d39e7c9f73161362"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "947a4950af1a258c381417d8510da94dd114723b65611f3ae8de07587b0f4726",
+      "encodedBytes": 3781308,
+      "elapsedMilliseconds": 507.106031000003,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 20802,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f3e691578150457b93be115a6d7b31f4"
+      },
+      "nativeDecodedPcmSha256": "947a4950af1a258c381417d8510da94dd114723b65611f3ae8de07587b0f4726"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "947a4950af1a258c381417d8510da94dd114723b65611f3ae8de07587b0f4726",
+      "encodedBytes": 3781317,
+      "elapsedMilliseconds": 128.15983400002006,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 20802,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f3e691578150457b93be115a6d7b31f4"
+      },
+      "nativeDecodedPcmSha256": "947a4950af1a258c381417d8510da94dd114723b65611f3ae8de07587b0f4726"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 3,
+      "frames": 916741,
+      "expectedPcmSha256": "1704ebcf5b3c81b703e1ecda346ebfc12a84421a0a83ccb9a75b7a53ddabc86c",
+      "encodedBytes": 2509206,
+      "elapsedMilliseconds": 351.61465599999065,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 20623,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "916741",
+        "md5Hex": "b28f2ba706e0f797f80ef1c129fc1519"
+      },
+      "nativeDecodedPcmSha256": "1704ebcf5b3c81b703e1ecda346ebfc12a84421a0a83ccb9a75b7a53ddabc86c"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 3,
+      "frames": 916741,
+      "expectedPcmSha256": "1704ebcf5b3c81b703e1ecda346ebfc12a84421a0a83ccb9a75b7a53ddabc86c",
+      "encodedBytes": 2509207,
+      "elapsedMilliseconds": 87.36332400000538,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 20623,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "916741",
+        "md5Hex": "b28f2ba706e0f797f80ef1c129fc1519"
+      },
+      "nativeDecodedPcmSha256": "1704ebcf5b3c81b703e1ecda346ebfc12a84421a0a83ccb9a75b7a53ddabc86c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "997fc12d1dbcbbf349b26a411d00fed8af4c3132fba56a850d91927b6afd7a19",
+      "encodedBytes": 2598970,
+      "elapsedMilliseconds": 429.90186400001403,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 531,
+        "maximumFrameSize": 20913,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2eecabe04698ad77539ff46ecb1ffff8"
+      },
+      "nativeDecodedPcmSha256": "997fc12d1dbcbbf349b26a411d00fed8af4c3132fba56a850d91927b6afd7a19"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "997fc12d1dbcbbf349b26a411d00fed8af4c3132fba56a850d91927b6afd7a19",
+      "encodedBytes": 2598964,
+      "elapsedMilliseconds": 114.26864300001762,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 531,
+        "maximumFrameSize": 20913,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2eecabe04698ad77539ff46ecb1ffff8"
+      },
+      "nativeDecodedPcmSha256": "997fc12d1dbcbbf349b26a411d00fed8af4c3132fba56a850d91927b6afd7a19"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "bc594e7e42791865271b0235bb7aad216405822db4e107e5bf1e4f46e3666ff4",
+      "encodedBytes": 2091903,
+      "elapsedMilliseconds": 433.68948199998704,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1041,
+        "maximumFrameSize": 20849,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "786a2e9f69216a3532e7f872d8543dad"
+      },
+      "nativeDecodedPcmSha256": "bc594e7e42791865271b0235bb7aad216405822db4e107e5bf1e4f46e3666ff4"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "bc594e7e42791865271b0235bb7aad216405822db4e107e5bf1e4f46e3666ff4",
+      "encodedBytes": 2091921,
+      "elapsedMilliseconds": 115.26828799999203,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1041,
+        "maximumFrameSize": 20849,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "786a2e9f69216a3532e7f872d8543dad"
+      },
+      "nativeDecodedPcmSha256": "bc594e7e42791865271b0235bb7aad216405822db4e107e5bf1e4f46e3666ff4"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "a03e75db825cb2754ee597c2a1c4c61e295a9eae5c27932ab847b390f47a5601",
+      "encodedBytes": 2873663,
+      "elapsedMilliseconds": 463.1685850000067,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 546,
+        "maximumFrameSize": 20901,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "99f6e579028fe5e4b5eff5eb8deae40d"
+      },
+      "nativeDecodedPcmSha256": "a03e75db825cb2754ee597c2a1c4c61e295a9eae5c27932ab847b390f47a5601"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "a03e75db825cb2754ee597c2a1c4c61e295a9eae5c27932ab847b390f47a5601",
+      "encodedBytes": 2873661,
+      "elapsedMilliseconds": 119.73572999998578,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 546,
+        "maximumFrameSize": 20901,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "99f6e579028fe5e4b5eff5eb8deae40d"
+      },
+      "nativeDecodedPcmSha256": "a03e75db825cb2754ee597c2a1c4c61e295a9eae5c27932ab847b390f47a5601"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 3,
+      "frames": 528117,
+      "expectedPcmSha256": "b667bd900e6d2a78c980afce335361280d75a02d45b93afaf53f1b9a6a37df37",
+      "encodedBytes": 1045515,
+      "elapsedMilliseconds": 178.036815999978,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 514,
+        "maximumFrameSize": 20819,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "528117",
+        "md5Hex": "bd43c65ac8eb4dd7451a6c8ee685692e"
+      },
+      "nativeDecodedPcmSha256": "b667bd900e6d2a78c980afce335361280d75a02d45b93afaf53f1b9a6a37df37"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 3,
+      "frames": 528117,
+      "expectedPcmSha256": "b667bd900e6d2a78c980afce335361280d75a02d45b93afaf53f1b9a6a37df37",
+      "encodedBytes": 1045514,
+      "elapsedMilliseconds": 47.79526499999338,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 514,
+        "maximumFrameSize": 20819,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "528117",
+        "md5Hex": "bd43c65ac8eb4dd7451a6c8ee685692e"
+      },
+      "nativeDecodedPcmSha256": "b667bd900e6d2a78c980afce335361280d75a02d45b93afaf53f1b9a6a37df37"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "d6dd68e175e45d08fa7fb81c835c58c9fe7da612c54be548767f948ba83d149c",
+      "encodedBytes": 2288154,
+      "elapsedMilliseconds": 494.57799600000726,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 10698,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "3380311316eefe07ca45fd8a6f3239bd"
+      },
+      "nativeDecodedPcmSha256": "d6dd68e175e45d08fa7fb81c835c58c9fe7da612c54be548767f948ba83d149c"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "d6dd68e175e45d08fa7fb81c835c58c9fe7da612c54be548767f948ba83d149c",
+      "encodedBytes": 2288163,
+      "elapsedMilliseconds": 124.59655299998121,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 10698,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "3380311316eefe07ca45fd8a6f3239bd"
+      },
+      "nativeDecodedPcmSha256": "d6dd68e175e45d08fa7fb81c835c58c9fe7da612c54be548767f948ba83d149c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "a013f58057e3192997704773f30e0f9b43251052648c2709523a784dde83d15a",
+      "encodedBytes": 2522256,
+      "elapsedMilliseconds": 476.17964700001176,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 10845,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d8621036960bf9f8a2faf42fe1146622"
+      },
+      "nativeDecodedPcmSha256": "a013f58057e3192997704773f30e0f9b43251052648c2709523a784dde83d15a"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "a013f58057e3192997704773f30e0f9b43251052648c2709523a784dde83d15a",
+      "encodedBytes": 2522167,
+      "elapsedMilliseconds": 123.08069500001147,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 10845,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d8621036960bf9f8a2faf42fe1146622"
+      },
+      "nativeDecodedPcmSha256": "a013f58057e3192997704773f30e0f9b43251052648c2709523a784dde83d15a"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "3b6cd32604fb1bb615b4eefbf0566819bb0fa41f6cec25ccda38473b3b27fe6c",
+      "encodedBytes": 3396221,
+      "elapsedMilliseconds": 534.3753199999919,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 12386,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "909948b003e4e1cf617d6dca19037e7a"
+      },
+      "nativeDecodedPcmSha256": "3b6cd32604fb1bb615b4eefbf0566819bb0fa41f6cec25ccda38473b3b27fe6c"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "3b6cd32604fb1bb615b4eefbf0566819bb0fa41f6cec25ccda38473b3b27fe6c",
+      "encodedBytes": 3396209,
+      "elapsedMilliseconds": 128.14422400001786,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 12386,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "909948b003e4e1cf617d6dca19037e7a"
+      },
+      "nativeDecodedPcmSha256": "3b6cd32604fb1bb615b4eefbf0566819bb0fa41f6cec25ccda38473b3b27fe6c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 3,
+      "frames": 97514,
+      "expectedPcmSha256": "8e60ccdf9088a1c5f09ef9dc7ac302dbb9bf22936642e24011f92c0137a7088b",
+      "encodedBytes": 149408,
+      "elapsedMilliseconds": 39.640898000012385,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 437,
+        "maximumFrameSize": 11467,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "97514",
+        "md5Hex": "b183f306ecf69ca5d8d2c788312be84d"
+      },
+      "nativeDecodedPcmSha256": "8e60ccdf9088a1c5f09ef9dc7ac302dbb9bf22936642e24011f92c0137a7088b"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 3,
+      "frames": 97514,
+      "expectedPcmSha256": "8e60ccdf9088a1c5f09ef9dc7ac302dbb9bf22936642e24011f92c0137a7088b",
+      "encodedBytes": 149411,
+      "elapsedMilliseconds": 10.39079999999376,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 437,
+        "maximumFrameSize": 11467,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "97514",
+        "md5Hex": "b183f306ecf69ca5d8d2c788312be84d"
+      },
+      "nativeDecodedPcmSha256": "8e60ccdf9088a1c5f09ef9dc7ac302dbb9bf22936642e24011f92c0137a7088b"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:b613c11eea1c43c0a0fed317bea191d09146b818c4fe8e7a781cec1061b781f1",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "20e6f57d0c7a4d86fe1d9b41a4589e043a45f28172189bde30d153a30b893295",
+      "encodedBytes": 3711107,
+      "elapsedMilliseconds": 491.00868400000036,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 17631,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f38b4f91f48e87fe5c66e430ac9b6dcf"
+      },
+      "nativeDecodedPcmSha256": "20e6f57d0c7a4d86fe1d9b41a4589e043a45f28172189bde30d153a30b893295"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:b613c11eea1c43c0a0fed317bea191d09146b818c4fe8e7a781cec1061b781f1",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "20e6f57d0c7a4d86fe1d9b41a4589e043a45f28172189bde30d153a30b893295",
+      "encodedBytes": 3711107,
+      "elapsedMilliseconds": 131.5102070000139,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 17631,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f38b4f91f48e87fe5c66e430ac9b6dcf"
+      },
+      "nativeDecodedPcmSha256": "20e6f57d0c7a4d86fe1d9b41a4589e043a45f28172189bde30d153a30b893295"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:b613c11eea1c43c0a0fed317bea191d09146b818c4fe8e7a781cec1061b781f1",
+      "chunkIndex": 1,
+      "frames": 206195,
+      "expectedPcmSha256": "33d319edbc97be7960054e657ead189865b1441d4771acc21abf99e792d03517",
+      "encodedBytes": 509176,
+      "elapsedMilliseconds": 79.9898230000108,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 194,
+        "maximumFrameSize": 17636,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "206195",
+        "md5Hex": "fc2a86a49c985d2344984cb33331c26f"
+      },
+      "nativeDecodedPcmSha256": "33d319edbc97be7960054e657ead189865b1441d4771acc21abf99e792d03517"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:b613c11eea1c43c0a0fed317bea191d09146b818c4fe8e7a781cec1061b781f1",
+      "chunkIndex": 1,
+      "frames": 206195,
+      "expectedPcmSha256": "33d319edbc97be7960054e657ead189865b1441d4771acc21abf99e792d03517",
+      "encodedBytes": 509176,
+      "elapsedMilliseconds": 20.70498400001088,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 194,
+        "maximumFrameSize": 17636,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "206195",
+        "md5Hex": "fc2a86a49c985d2344984cb33331c26f"
+      },
+      "nativeDecodedPcmSha256": "33d319edbc97be7960054e657ead189865b1441d4771acc21abf99e792d03517"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "bf0875df024093a82fb77c21c3be693044f912a4f2e659efadfeba298c725d8c",
+      "encodedBytes": 837695,
+      "elapsedMilliseconds": 326.13873800000874,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 4448,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "0596bd594b76494663e751a8a82158e2"
+      },
+      "nativeDecodedPcmSha256": "bf0875df024093a82fb77c21c3be693044f912a4f2e659efadfeba298c725d8c"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "bf0875df024093a82fb77c21c3be693044f912a4f2e659efadfeba298c725d8c",
+      "encodedBytes": 837717,
+      "elapsedMilliseconds": 90.43870400000014,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 4448,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "0596bd594b76494663e751a8a82158e2"
+      },
+      "nativeDecodedPcmSha256": "bf0875df024093a82fb77c21c3be693044f912a4f2e659efadfeba298c725d8c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "73a9d535d1674e035dd0f426e0409ac40ee779244220f4c4ea0b274df403038a",
+      "encodedBytes": 1898730,
+      "elapsedMilliseconds": 406.74914299999364,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 10673,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fefcbb6dd17769d996c86328d9e28387"
+      },
+      "nativeDecodedPcmSha256": "73a9d535d1674e035dd0f426e0409ac40ee779244220f4c4ea0b274df403038a"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "73a9d535d1674e035dd0f426e0409ac40ee779244220f4c4ea0b274df403038a",
+      "encodedBytes": 1898820,
+      "elapsedMilliseconds": 109.61297099999501,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 10673,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fefcbb6dd17769d996c86328d9e28387"
+      },
+      "nativeDecodedPcmSha256": "73a9d535d1674e035dd0f426e0409ac40ee779244220f4c4ea0b274df403038a"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "4abd9d2c9ef25b837cdda5a8d4b93da148e1877cd3db7b18657b07b75c0df88b",
+      "encodedBytes": 979468,
+      "elapsedMilliseconds": 340.93479199998546,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 5175,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "dcde8895a7df83f9d3e6b74e747e78e9"
+      },
+      "nativeDecodedPcmSha256": "4abd9d2c9ef25b837cdda5a8d4b93da148e1877cd3db7b18657b07b75c0df88b"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "4abd9d2c9ef25b837cdda5a8d4b93da148e1877cd3db7b18657b07b75c0df88b",
+      "encodedBytes": 979348,
+      "elapsedMilliseconds": 95.30964500000118,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 5175,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "dcde8895a7df83f9d3e6b74e747e78e9"
+      },
+      "nativeDecodedPcmSha256": "4abd9d2c9ef25b837cdda5a8d4b93da148e1877cd3db7b18657b07b75c0df88b"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 3,
+      "frames": 240708,
+      "expectedPcmSha256": "2c0376459f084817fbe05021a99473a51ffac58d3b89f6249a9e608361c24153",
+      "encodedBytes": 135559,
+      "elapsedMilliseconds": 67.72806799999671,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 4179,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "240708",
+        "md5Hex": "8cc8b65893452e498d410d6d870f2ce5"
+      },
+      "nativeDecodedPcmSha256": "2c0376459f084817fbe05021a99473a51ffac58d3b89f6249a9e608361c24153"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 3,
+      "frames": 240708,
+      "expectedPcmSha256": "2c0376459f084817fbe05021a99473a51ffac58d3b89f6249a9e608361c24153",
+      "encodedBytes": 135582,
+      "elapsedMilliseconds": 17.74589500000002,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 4179,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "240708",
+        "md5Hex": "8cc8b65893452e498d410d6d870f2ce5"
+      },
+      "nativeDecodedPcmSha256": "2c0376459f084817fbe05021a99473a51ffac58d3b89f6249a9e608361c24153"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "acb2a0065558fa0e65f94f9cbd917cb884ff12da69ef71238056ec3498f89484",
+      "encodedBytes": 3500055,
+      "elapsedMilliseconds": 545.6521570000041,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5516,
+        "maximumFrameSize": 18157,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "23d423ad6ad760b82e3d6c2246d86238"
+      },
+      "nativeDecodedPcmSha256": "acb2a0065558fa0e65f94f9cbd917cb884ff12da69ef71238056ec3498f89484"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "acb2a0065558fa0e65f94f9cbd917cb884ff12da69ef71238056ec3498f89484",
+      "encodedBytes": 3500055,
+      "elapsedMilliseconds": 133.86172699998133,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5516,
+        "maximumFrameSize": 18157,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "23d423ad6ad760b82e3d6c2246d86238"
+      },
+      "nativeDecodedPcmSha256": "acb2a0065558fa0e65f94f9cbd917cb884ff12da69ef71238056ec3498f89484"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "c08dc080013b95d43386834bec404adfadfe00d148e5d8b09aa7133579d651fb",
+      "encodedBytes": 5094024,
+      "elapsedMilliseconds": 547.7973240000138,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6350,
+        "maximumFrameSize": 20480,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "ef76a0cd4dfc91fa32d5e4d3cba91719"
+      },
+      "nativeDecodedPcmSha256": "c08dc080013b95d43386834bec404adfadfe00d148e5d8b09aa7133579d651fb"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "c08dc080013b95d43386834bec404adfadfe00d148e5d8b09aa7133579d651fb",
+      "encodedBytes": 5094024,
+      "elapsedMilliseconds": 133.9408880000119,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6350,
+        "maximumFrameSize": 20480,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "ef76a0cd4dfc91fa32d5e4d3cba91719"
+      },
+      "nativeDecodedPcmSha256": "c08dc080013b95d43386834bec404adfadfe00d148e5d8b09aa7133579d651fb"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "39151af29546d5b05e982e1c5a5f313b3105eff8a80d9a9cc5f1ebf195a8c389",
+      "encodedBytes": 4681716,
+      "elapsedMilliseconds": 565.3188720000035,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6331,
+        "maximumFrameSize": 18814,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "774d9efdff3c37ae566ff518b80f8f40"
+      },
+      "nativeDecodedPcmSha256": "39151af29546d5b05e982e1c5a5f313b3105eff8a80d9a9cc5f1ebf195a8c389"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "39151af29546d5b05e982e1c5a5f313b3105eff8a80d9a9cc5f1ebf195a8c389",
+      "encodedBytes": 4681716,
+      "elapsedMilliseconds": 134.64635200001067,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6331,
+        "maximumFrameSize": 18814,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "774d9efdff3c37ae566ff518b80f8f40"
+      },
+      "nativeDecodedPcmSha256": "39151af29546d5b05e982e1c5a5f313b3105eff8a80d9a9cc5f1ebf195a8c389"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "649b462aa016a111211498488ffca8da24e16f1a9b594f58bf38fb03933bb4f5",
+      "encodedBytes": 5095991,
+      "elapsedMilliseconds": 565.4181909999752,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6880,
+        "maximumFrameSize": 20409,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "35bb887ffcd20cc9acb7fe0832ca84dd"
+      },
+      "nativeDecodedPcmSha256": "649b462aa016a111211498488ffca8da24e16f1a9b594f58bf38fb03933bb4f5"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "649b462aa016a111211498488ffca8da24e16f1a9b594f58bf38fb03933bb4f5",
+      "encodedBytes": 5095990,
+      "elapsedMilliseconds": 134.62898999999743,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6880,
+        "maximumFrameSize": 20409,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "35bb887ffcd20cc9acb7fe0832ca84dd"
+      },
+      "nativeDecodedPcmSha256": "649b462aa016a111211498488ffca8da24e16f1a9b594f58bf38fb03933bb4f5"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 4,
+      "frames": 913965,
+      "expectedPcmSha256": "cc11220dae84517c06488c4397c4f54629614cfb4b1bf99262af541086f86a8b",
+      "encodedBytes": 3704141,
+      "elapsedMilliseconds": 388.644472999993,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 827,
+        "maximumFrameSize": 20547,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "913965",
+        "md5Hex": "0f0a8a4ec11425e8cdef46082e7f031b"
+      },
+      "nativeDecodedPcmSha256": "cc11220dae84517c06488c4397c4f54629614cfb4b1bf99262af541086f86a8b"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 4,
+      "frames": 913965,
+      "expectedPcmSha256": "cc11220dae84517c06488c4397c4f54629614cfb4b1bf99262af541086f86a8b",
+      "encodedBytes": 3704141,
+      "elapsedMilliseconds": 95.28490800000145,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 827,
+        "maximumFrameSize": 20547,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "913965",
+        "md5Hex": "0f0a8a4ec11425e8cdef46082e7f031b"
+      },
+      "nativeDecodedPcmSha256": "cc11220dae84517c06488c4397c4f54629614cfb4b1bf99262af541086f86a8b"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "4ef0e5b27bc3175da2611e8d22d8352ff615550fd0c8798ef04071383a43a7ca",
+      "encodedBytes": 3847857,
+      "elapsedMilliseconds": 489.61834099999396,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6684,
+        "maximumFrameSize": 16691,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2e98a79b3a31ce532600e77f6b5e7e7d"
+      },
+      "nativeDecodedPcmSha256": "4ef0e5b27bc3175da2611e8d22d8352ff615550fd0c8798ef04071383a43a7ca"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "4ef0e5b27bc3175da2611e8d22d8352ff615550fd0c8798ef04071383a43a7ca",
+      "encodedBytes": 3847857,
+      "elapsedMilliseconds": 131.35587199998554,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6684,
+        "maximumFrameSize": 16691,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2e98a79b3a31ce532600e77f6b5e7e7d"
+      },
+      "nativeDecodedPcmSha256": "4ef0e5b27bc3175da2611e8d22d8352ff615550fd0c8798ef04071383a43a7ca"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "587dd69e42fa09749cd48eedf40a783fa77b08725df7cfd075a64584ebb17dbb",
+      "encodedBytes": 3970124,
+      "elapsedMilliseconds": 477.58246599999256,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1196,
+        "maximumFrameSize": 17182,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f5676f5bae407203be9f183bfcaea527"
+      },
+      "nativeDecodedPcmSha256": "587dd69e42fa09749cd48eedf40a783fa77b08725df7cfd075a64584ebb17dbb"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "587dd69e42fa09749cd48eedf40a783fa77b08725df7cfd075a64584ebb17dbb",
+      "encodedBytes": 3970104,
+      "elapsedMilliseconds": 125.97594099998241,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1196,
+        "maximumFrameSize": 17182,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f5676f5bae407203be9f183bfcaea527"
+      },
+      "nativeDecodedPcmSha256": "587dd69e42fa09749cd48eedf40a783fa77b08725df7cfd075a64584ebb17dbb"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "303270e98d22c7b40606f19da04a268425ffac83d8791fda0c1179014baa86c8",
+      "encodedBytes": 4303215,
+      "elapsedMilliseconds": 541.3512190000038,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5428,
+        "maximumFrameSize": 16965,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "07bbb32ad29a4ed4c59d9f2b2da5ea43"
+      },
+      "nativeDecodedPcmSha256": "303270e98d22c7b40606f19da04a268425ffac83d8791fda0c1179014baa86c8"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "303270e98d22c7b40606f19da04a268425ffac83d8791fda0c1179014baa86c8",
+      "encodedBytes": 4303218,
+      "elapsedMilliseconds": 131.2320260000124,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5428,
+        "maximumFrameSize": 16965,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "07bbb32ad29a4ed4c59d9f2b2da5ea43"
+      },
+      "nativeDecodedPcmSha256": "303270e98d22c7b40606f19da04a268425ffac83d8791fda0c1179014baa86c8"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "77801ccb085effccbfae0aa9aa1afd856abc76f9c332a1cd0bf949775ca33d4c",
+      "encodedBytes": 4322996,
+      "elapsedMilliseconds": 458.17835000000196,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1089,
+        "maximumFrameSize": 17827,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "c7fe1b47b098ffe3917cc8c54dd51e94"
+      },
+      "nativeDecodedPcmSha256": "77801ccb085effccbfae0aa9aa1afd856abc76f9c332a1cd0bf949775ca33d4c"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "77801ccb085effccbfae0aa9aa1afd856abc76f9c332a1cd0bf949775ca33d4c",
+      "encodedBytes": 4322990,
+      "elapsedMilliseconds": 125.02588900001138,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1089,
+        "maximumFrameSize": 17827,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "c7fe1b47b098ffe3917cc8c54dd51e94"
+      },
+      "nativeDecodedPcmSha256": "77801ccb085effccbfae0aa9aa1afd856abc76f9c332a1cd0bf949775ca33d4c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "09e611be443a7e3e11fbdce77a600971254eac99a84ceb56e22687ffc6b181ee",
+      "encodedBytes": 3348173,
+      "elapsedMilliseconds": 541.677108999982,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 4639,
+        "maximumFrameSize": 15549,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d34c75f3326ffaa632879bf0c4bcf6e4"
+      },
+      "nativeDecodedPcmSha256": "09e611be443a7e3e11fbdce77a600971254eac99a84ceb56e22687ffc6b181ee"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "09e611be443a7e3e11fbdce77a600971254eac99a84ceb56e22687ffc6b181ee",
+      "encodedBytes": 3348207,
+      "elapsedMilliseconds": 134.73838699999033,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 4639,
+        "maximumFrameSize": 15549,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d34c75f3326ffaa632879bf0c4bcf6e4"
+      },
+      "nativeDecodedPcmSha256": "09e611be443a7e3e11fbdce77a600971254eac99a84ceb56e22687ffc6b181ee"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 5,
+      "frames": 787999,
+      "expectedPcmSha256": "df5cc90e42602310ecdc1aa55a4daf101fc4601d9583db1f84b12c121b25217b",
+      "encodedBytes": 1533261,
+      "elapsedMilliseconds": 296.45010300001013,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1273,
+        "maximumFrameSize": 10344,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "787999",
+        "md5Hex": "79380b4778c85cd98c9c12b0f00ace39"
+      },
+      "nativeDecodedPcmSha256": "df5cc90e42602310ecdc1aa55a4daf101fc4601d9583db1f84b12c121b25217b"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 5,
+      "frames": 787999,
+      "expectedPcmSha256": "df5cc90e42602310ecdc1aa55a4daf101fc4601d9583db1f84b12c121b25217b",
+      "encodedBytes": 1533304,
+      "elapsedMilliseconds": 73.19866100000218,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1273,
+        "maximumFrameSize": 10344,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "787999",
+        "md5Hex": "79380b4778c85cd98c9c12b0f00ace39"
+      },
+      "nativeDecodedPcmSha256": "df5cc90e42602310ecdc1aa55a4daf101fc4601d9583db1f84b12c121b25217b"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "e4ce6eccdfae581a69ad7d053af770d4dbcd06c793413b03a4ed3fafdd9cc780",
+      "encodedBytes": 1077045,
+      "elapsedMilliseconds": 412.5423589999846,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1098,
+        "maximumFrameSize": 8211,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "4aff88652345da2edbd6a527805f7254"
+      },
+      "nativeDecodedPcmSha256": "e4ce6eccdfae581a69ad7d053af770d4dbcd06c793413b03a4ed3fafdd9cc780"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "e4ce6eccdfae581a69ad7d053af770d4dbcd06c793413b03a4ed3fafdd9cc780",
+      "encodedBytes": 1077045,
+      "elapsedMilliseconds": 109.81266999998479,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1098,
+        "maximumFrameSize": 8211,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "4aff88652345da2edbd6a527805f7254"
+      },
+      "nativeDecodedPcmSha256": "e4ce6eccdfae581a69ad7d053af770d4dbcd06c793413b03a4ed3fafdd9cc780"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "f17804e177224c0871b40263007f2f9197cabb5587de4b02835ae91cbf268f35",
+      "encodedBytes": 2026435,
+      "elapsedMilliseconds": 592.851101999986,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5105,
+        "maximumFrameSize": 8224,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "36407f1308b1957e1b6144f30aa22a38"
+      },
+      "nativeDecodedPcmSha256": "f17804e177224c0871b40263007f2f9197cabb5587de4b02835ae91cbf268f35"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "f17804e177224c0871b40263007f2f9197cabb5587de4b02835ae91cbf268f35",
+      "encodedBytes": 2026471,
+      "elapsedMilliseconds": 134.09681399998954,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5105,
+        "maximumFrameSize": 8220,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "36407f1308b1957e1b6144f30aa22a38"
+      },
+      "nativeDecodedPcmSha256": "f17804e177224c0871b40263007f2f9197cabb5587de4b02835ae91cbf268f35"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "7d0ff510517cdf903b7d82524b87531c1fa8fb4caab35f49c40715da28eb7fed",
+      "encodedBytes": 2709275,
+      "elapsedMilliseconds": 592.1622079999943,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7303,
+        "maximumFrameSize": 9110,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "86d21455e0c45c41c61c1067efc5e624"
+      },
+      "nativeDecodedPcmSha256": "7d0ff510517cdf903b7d82524b87531c1fa8fb4caab35f49c40715da28eb7fed"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "7d0ff510517cdf903b7d82524b87531c1fa8fb4caab35f49c40715da28eb7fed",
+      "encodedBytes": 2709350,
+      "elapsedMilliseconds": 135.04933000000892,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7303,
+        "maximumFrameSize": 9110,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "86d21455e0c45c41c61c1067efc5e624"
+      },
+      "nativeDecodedPcmSha256": "7d0ff510517cdf903b7d82524b87531c1fa8fb4caab35f49c40715da28eb7fed"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "d030e1b082aca6c48acb78cef0f175a2385cca984a05c4056ed8b06d7cf33e25",
+      "encodedBytes": 3124543,
+      "elapsedMilliseconds": 597.7261300000246,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8177,
+        "maximumFrameSize": 11438,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "e924974998afc7ee2ecb97289590446f"
+      },
+      "nativeDecodedPcmSha256": "d030e1b082aca6c48acb78cef0f175a2385cca984a05c4056ed8b06d7cf33e25"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "d030e1b082aca6c48acb78cef0f175a2385cca984a05c4056ed8b06d7cf33e25",
+      "encodedBytes": 3124526,
+      "elapsedMilliseconds": 148.61712300000363,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8177,
+        "maximumFrameSize": 11439,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "e924974998afc7ee2ecb97289590446f"
+      },
+      "nativeDecodedPcmSha256": "d030e1b082aca6c48acb78cef0f175a2385cca984a05c4056ed8b06d7cf33e25"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "af48460f9080df1be76b9ff6f454b28edb83901dccf8f3fdc1c76aa34d19269a",
+      "encodedBytes": 2993865,
+      "elapsedMilliseconds": 602.1351200000208,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8260,
+        "maximumFrameSize": 11365,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b5d1e81a1ee43f3aaedc77d43ef8b663"
+      },
+      "nativeDecodedPcmSha256": "af48460f9080df1be76b9ff6f454b28edb83901dccf8f3fdc1c76aa34d19269a"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "af48460f9080df1be76b9ff6f454b28edb83901dccf8f3fdc1c76aa34d19269a",
+      "encodedBytes": 2993794,
+      "elapsedMilliseconds": 138.87270499998704,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8260,
+        "maximumFrameSize": 11368,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b5d1e81a1ee43f3aaedc77d43ef8b663"
+      },
+      "nativeDecodedPcmSha256": "af48460f9080df1be76b9ff6f454b28edb83901dccf8f3fdc1c76aa34d19269a"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 5,
+      "frames": 129916,
+      "expectedPcmSha256": "0dd7eda91b2ac9d352e47627d1a7b2839dc09516301a9dd6c2bb6173902a186b",
+      "encodedBytes": 261549,
+      "elapsedMilliseconds": 68.79749500000617,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5936,
+        "maximumFrameSize": 8364,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "129916",
+        "md5Hex": "9116c4c4f5077be0f78a40cecf3edc9d"
+      },
+      "nativeDecodedPcmSha256": "0dd7eda91b2ac9d352e47627d1a7b2839dc09516301a9dd6c2bb6173902a186b"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 5,
+      "frames": 129916,
+      "expectedPcmSha256": "0dd7eda91b2ac9d352e47627d1a7b2839dc09516301a9dd6c2bb6173902a186b",
+      "encodedBytes": 261549,
+      "elapsedMilliseconds": 15.575508999987505,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5936,
+        "maximumFrameSize": 8364,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "129916",
+        "md5Hex": "9116c4c4f5077be0f78a40cecf3edc9d"
+      },
+      "nativeDecodedPcmSha256": "0dd7eda91b2ac9d352e47627d1a7b2839dc09516301a9dd6c2bb6173902a186b"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:dbb6eda6ecc56c418428f6b41d0b4872948d5be58e6089ecacb538b188dd7a74",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "2e94af2296c79e0acd1352987dad1c0105dcaab2fa5ec62a110a8f3f44a04e24",
+      "encodedBytes": 5150623,
+      "elapsedMilliseconds": 526.9032440000155,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 19736,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "26053a4513b282f554697b99442d10d4"
+      },
+      "nativeDecodedPcmSha256": "2e94af2296c79e0acd1352987dad1c0105dcaab2fa5ec62a110a8f3f44a04e24"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:dbb6eda6ecc56c418428f6b41d0b4872948d5be58e6089ecacb538b188dd7a74",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "2e94af2296c79e0acd1352987dad1c0105dcaab2fa5ec62a110a8f3f44a04e24",
+      "encodedBytes": 5150623,
+      "elapsedMilliseconds": 131.833781000023,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 19736,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "26053a4513b282f554697b99442d10d4"
+      },
+      "nativeDecodedPcmSha256": "2e94af2296c79e0acd1352987dad1c0105dcaab2fa5ec62a110a8f3f44a04e24"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:dbb6eda6ecc56c418428f6b41d0b4872948d5be58e6089ecacb538b188dd7a74",
+      "chunkIndex": 1,
+      "frames": 659918,
+      "expectedPcmSha256": "ba7987b2aeec2b9383b890edb42d2615c9e33220a8a9473f83e5eabd3f81681f",
+      "encodedBytes": 1981971,
+      "elapsedMilliseconds": 252.83373900002334,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 79,
+        "maximumFrameSize": 19765,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "659918",
+        "md5Hex": "bcd7209885a540ae40a0fed23f840025"
+      },
+      "nativeDecodedPcmSha256": "ba7987b2aeec2b9383b890edb42d2615c9e33220a8a9473f83e5eabd3f81681f"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:dbb6eda6ecc56c418428f6b41d0b4872948d5be58e6089ecacb538b188dd7a74",
+      "chunkIndex": 1,
+      "frames": 659918,
+      "expectedPcmSha256": "ba7987b2aeec2b9383b890edb42d2615c9e33220a8a9473f83e5eabd3f81681f",
+      "encodedBytes": 1981954,
+      "elapsedMilliseconds": 64.15262400000938,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 79,
+        "maximumFrameSize": 19765,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "659918",
+        "md5Hex": "bcd7209885a540ae40a0fed23f840025"
+      },
+      "nativeDecodedPcmSha256": "ba7987b2aeec2b9383b890edb42d2615c9e33220a8a9473f83e5eabd3f81681f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "4930de75afb2d6609f801fa1a01c6015b397e3936b098e014e5960411a62bb8c",
+      "encodedBytes": 1873787,
+      "elapsedMilliseconds": 531.7806970000092,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5172,
+        "maximumFrameSize": 10592,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "1df6349a9a1200e5db6488580cfe5609"
+      },
+      "nativeDecodedPcmSha256": "4930de75afb2d6609f801fa1a01c6015b397e3936b098e014e5960411a62bb8c"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "4930de75afb2d6609f801fa1a01c6015b397e3936b098e014e5960411a62bb8c",
+      "encodedBytes": 1873831,
+      "elapsedMilliseconds": 126.89335800000117,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5172,
+        "maximumFrameSize": 10597,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "1df6349a9a1200e5db6488580cfe5609"
+      },
+      "nativeDecodedPcmSha256": "4930de75afb2d6609f801fa1a01c6015b397e3936b098e014e5960411a62bb8c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "70ea23b1a824512f353489e240fd927f4bd0f8118269c48ac88cf4163f01d227",
+      "encodedBytes": 2060276,
+      "elapsedMilliseconds": 546.3789150000084,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5164,
+        "maximumFrameSize": 12080,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "02c109983d30694eeccf693591d4814c"
+      },
+      "nativeDecodedPcmSha256": "70ea23b1a824512f353489e240fd927f4bd0f8118269c48ac88cf4163f01d227"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "70ea23b1a824512f353489e240fd927f4bd0f8118269c48ac88cf4163f01d227",
+      "encodedBytes": 2060264,
+      "elapsedMilliseconds": 131.46643100000801,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5164,
+        "maximumFrameSize": 12080,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "02c109983d30694eeccf693591d4814c"
+      },
+      "nativeDecodedPcmSha256": "70ea23b1a824512f353489e240fd927f4bd0f8118269c48ac88cf4163f01d227"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "bf440567e988c71551be148276316309a1257b2f11b2d1a4bcaea301f1055446",
+      "encodedBytes": 1688615,
+      "elapsedMilliseconds": 531.2602250000054,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5156,
+        "maximumFrameSize": 5282,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "e4ff153fefd0b5983adecdf954619e16"
+      },
+      "nativeDecodedPcmSha256": "bf440567e988c71551be148276316309a1257b2f11b2d1a4bcaea301f1055446"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "bf440567e988c71551be148276316309a1257b2f11b2d1a4bcaea301f1055446",
+      "encodedBytes": 1688615,
+      "elapsedMilliseconds": 126.78409900001134,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5156,
+        "maximumFrameSize": 5282,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "e4ff153fefd0b5983adecdf954619e16"
+      },
+      "nativeDecodedPcmSha256": "bf440567e988c71551be148276316309a1257b2f11b2d1a4bcaea301f1055446"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "097716d93dcac0324bbb6e2110b67088938dff5e489c5e6b06d45918b07e8dcf",
+      "encodedBytes": 1687882,
+      "elapsedMilliseconds": 540.2814439999929,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5164,
+        "maximumFrameSize": 5273,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5f23f612eae3ff947a33c28f917fb0c3"
+      },
+      "nativeDecodedPcmSha256": "097716d93dcac0324bbb6e2110b67088938dff5e489c5e6b06d45918b07e8dcf"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "097716d93dcac0324bbb6e2110b67088938dff5e489c5e6b06d45918b07e8dcf",
+      "encodedBytes": 1687882,
+      "elapsedMilliseconds": 126.12042399999336,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5164,
+        "maximumFrameSize": 5273,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5f23f612eae3ff947a33c28f917fb0c3"
+      },
+      "nativeDecodedPcmSha256": "097716d93dcac0324bbb6e2110b67088938dff5e489c5e6b06d45918b07e8dcf"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 4,
+      "frames": 915923,
+      "expectedPcmSha256": "af8937f992feb00ab5bb6c0d5a28f80ad75d34e9a9a53439183830e458d8faab",
+      "encodedBytes": 1168887,
+      "elapsedMilliseconds": 373.8735120000201,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 3248,
+        "maximumFrameSize": 5320,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "915923",
+        "md5Hex": "7605d09ff6c2b92d6c7ec2cad106a44a"
+      },
+      "nativeDecodedPcmSha256": "af8937f992feb00ab5bb6c0d5a28f80ad75d34e9a9a53439183830e458d8faab"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 4,
+      "frames": 915923,
+      "expectedPcmSha256": "af8937f992feb00ab5bb6c0d5a28f80ad75d34e9a9a53439183830e458d8faab",
+      "encodedBytes": 1168887,
+      "elapsedMilliseconds": 88.05336699998588,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 3248,
+        "maximumFrameSize": 5320,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "915923",
+        "md5Hex": "7605d09ff6c2b92d6c7ec2cad106a44a"
+      },
+      "nativeDecodedPcmSha256": "af8937f992feb00ab5bb6c0d5a28f80ad75d34e9a9a53439183830e458d8faab"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "c153cdd02ee613aa4d856af7b7499256d9a797b85d7f1bf72697b8ebe699572b",
+      "encodedBytes": 3007114,
+      "elapsedMilliseconds": 461.81813099997817,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7681,
+        "maximumFrameSize": 12705,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "251ca0665436123f9e152c2958ab9922"
+      },
+      "nativeDecodedPcmSha256": "c153cdd02ee613aa4d856af7b7499256d9a797b85d7f1bf72697b8ebe699572b"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "c153cdd02ee613aa4d856af7b7499256d9a797b85d7f1bf72697b8ebe699572b",
+      "encodedBytes": 3007108,
+      "elapsedMilliseconds": 124.87554199999431,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7681,
+        "maximumFrameSize": 12705,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "251ca0665436123f9e152c2958ab9922"
+      },
+      "nativeDecodedPcmSha256": "c153cdd02ee613aa4d856af7b7499256d9a797b85d7f1bf72697b8ebe699572b"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "1968944d10881b63a6477b9621071f7f8a56e969b4c0730c2da2b6e27aac62db",
+      "encodedBytes": 3132254,
+      "elapsedMilliseconds": 504.8038499999966,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 2289,
+        "maximumFrameSize": 12504,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f3d43a6b0fbccd05351d16c9ed6a2593"
+      },
+      "nativeDecodedPcmSha256": "1968944d10881b63a6477b9621071f7f8a56e969b4c0730c2da2b6e27aac62db"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "1968944d10881b63a6477b9621071f7f8a56e969b4c0730c2da2b6e27aac62db",
+      "encodedBytes": 3132254,
+      "elapsedMilliseconds": 125.63119200000074,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 2289,
+        "maximumFrameSize": 12504,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f3d43a6b0fbccd05351d16c9ed6a2593"
+      },
+      "nativeDecodedPcmSha256": "1968944d10881b63a6477b9621071f7f8a56e969b4c0730c2da2b6e27aac62db"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "1213ccf392162807582019bde04d3ad714481247b76d1d5f8009a5fc0eb3e069",
+      "encodedBytes": 3096303,
+      "elapsedMilliseconds": 489.9317109999829,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7951,
+        "maximumFrameSize": 12269,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b7de8fa8b924474bd9231a3e5800598b"
+      },
+      "nativeDecodedPcmSha256": "1213ccf392162807582019bde04d3ad714481247b76d1d5f8009a5fc0eb3e069"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "1213ccf392162807582019bde04d3ad714481247b76d1d5f8009a5fc0eb3e069",
+      "encodedBytes": 3096300,
+      "elapsedMilliseconds": 122.75511100000585,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7951,
+        "maximumFrameSize": 12269,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b7de8fa8b924474bd9231a3e5800598b"
+      },
+      "nativeDecodedPcmSha256": "1213ccf392162807582019bde04d3ad714481247b76d1d5f8009a5fc0eb3e069"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "dfe83b8d2c67fefec02a01eef4018f786a03ca52e14aff50e9e395301b4fdbbb",
+      "encodedBytes": 2799241,
+      "elapsedMilliseconds": 434.3933309999993,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7928,
+        "maximumFrameSize": 11232,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f2bb2279e28a8a66a0ce46987a9ff1c7"
+      },
+      "nativeDecodedPcmSha256": "dfe83b8d2c67fefec02a01eef4018f786a03ca52e14aff50e9e395301b4fdbbb"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "dfe83b8d2c67fefec02a01eef4018f786a03ca52e14aff50e9e395301b4fdbbb",
+      "encodedBytes": 2799236,
+      "elapsedMilliseconds": 117.26725400000578,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7928,
+        "maximumFrameSize": 11232,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f2bb2279e28a8a66a0ce46987a9ff1c7"
+      },
+      "nativeDecodedPcmSha256": "dfe83b8d2c67fefec02a01eef4018f786a03ca52e14aff50e9e395301b4fdbbb"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "0f55c1534bb29b9fb8258c13985e13aa3d25fd02a6afe6128aaca72caa8cf731",
+      "encodedBytes": 3407791,
+      "elapsedMilliseconds": 450.1102700000047,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 3152,
+        "maximumFrameSize": 12897,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "22a374fce66170497a8c490eb83cacb3"
+      },
+      "nativeDecodedPcmSha256": "0f55c1534bb29b9fb8258c13985e13aa3d25fd02a6afe6128aaca72caa8cf731"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "0f55c1534bb29b9fb8258c13985e13aa3d25fd02a6afe6128aaca72caa8cf731",
+      "encodedBytes": 3407792,
+      "elapsedMilliseconds": 120.76087200001348,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 3152,
+        "maximumFrameSize": 12897,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "22a374fce66170497a8c490eb83cacb3"
+      },
+      "nativeDecodedPcmSha256": "0f55c1534bb29b9fb8258c13985e13aa3d25fd02a6afe6128aaca72caa8cf731"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "026e9d73a7ff3851959956aaa58f413a73aae7116da4d14652682b7f14d7c382",
+      "encodedBytes": 2657514,
+      "elapsedMilliseconds": 372.6018580000091,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7957,
+        "maximumFrameSize": 8424,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "50c204d2c3ca112cb6d2dfc4574a6b7b"
+      },
+      "nativeDecodedPcmSha256": "026e9d73a7ff3851959956aaa58f413a73aae7116da4d14652682b7f14d7c382"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "026e9d73a7ff3851959956aaa58f413a73aae7116da4d14652682b7f14d7c382",
+      "encodedBytes": 2657514,
+      "elapsedMilliseconds": 108.6133039999986,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7957,
+        "maximumFrameSize": 8424,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "50c204d2c3ca112cb6d2dfc4574a6b7b"
+      },
+      "nativeDecodedPcmSha256": "026e9d73a7ff3851959956aaa58f413a73aae7116da4d14652682b7f14d7c382"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "7669dc7fe143e844e6d85fcaf155e41c6b66faada5383275c8f038938422eedf",
+      "encodedBytes": 1127015,
+      "elapsedMilliseconds": 166.15540100002545,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7943,
+        "maximumFrameSize": 8396,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "61212883dedb8671dfaf0c6b3a48cf26"
+      },
+      "nativeDecodedPcmSha256": "7669dc7fe143e844e6d85fcaf155e41c6b66faada5383275c8f038938422eedf"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "7669dc7fe143e844e6d85fcaf155e41c6b66faada5383275c8f038938422eedf",
+      "encodedBytes": 1127015,
+      "elapsedMilliseconds": 46.775912000011886,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7943,
+        "maximumFrameSize": 8396,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "61212883dedb8671dfaf0c6b3a48cf26"
+      },
+      "nativeDecodedPcmSha256": "7669dc7fe143e844e6d85fcaf155e41c6b66faada5383275c8f038938422eedf"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "907c161b6a6b3fc6be1ac83b0514aa8fbe4b72804d7ff1b2912429cf86c4fa12",
+      "encodedBytes": 4714618,
+      "elapsedMilliseconds": 554.5831939999771,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7910,
+        "maximumFrameSize": 18654,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f4eae4970a525ffe360ec2518db524da"
+      },
+      "nativeDecodedPcmSha256": "907c161b6a6b3fc6be1ac83b0514aa8fbe4b72804d7ff1b2912429cf86c4fa12"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "907c161b6a6b3fc6be1ac83b0514aa8fbe4b72804d7ff1b2912429cf86c4fa12",
+      "encodedBytes": 4714618,
+      "elapsedMilliseconds": 134.1540719999757,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7910,
+        "maximumFrameSize": 18654,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f4eae4970a525ffe360ec2518db524da"
+      },
+      "nativeDecodedPcmSha256": "907c161b6a6b3fc6be1ac83b0514aa8fbe4b72804d7ff1b2912429cf86c4fa12"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "23668afc815608ca7873919d5db8586258717824df6dba0ac7ba65cd56cde2f9",
+      "encodedBytes": 4655200,
+      "elapsedMilliseconds": 584.9385959999927,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5540,
+        "maximumFrameSize": 19005,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "25825cf8c20414d3ce15b75e73bd0da0"
+      },
+      "nativeDecodedPcmSha256": "23668afc815608ca7873919d5db8586258717824df6dba0ac7ba65cd56cde2f9"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "23668afc815608ca7873919d5db8586258717824df6dba0ac7ba65cd56cde2f9",
+      "encodedBytes": 4655199,
+      "elapsedMilliseconds": 134.90449200000148,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5540,
+        "maximumFrameSize": 19005,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "25825cf8c20414d3ce15b75e73bd0da0"
+      },
+      "nativeDecodedPcmSha256": "23668afc815608ca7873919d5db8586258717824df6dba0ac7ba65cd56cde2f9"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "146a29ebce44459aa8a15c198999ee449e8c6b04c2a8931ac5e9ad86c3920157",
+      "encodedBytes": 4262536,
+      "elapsedMilliseconds": 556.9175709999981,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7955,
+        "maximumFrameSize": 18639,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "eab602a474d9616842a1c3a10793eab8"
+      },
+      "nativeDecodedPcmSha256": "146a29ebce44459aa8a15c198999ee449e8c6b04c2a8931ac5e9ad86c3920157"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "146a29ebce44459aa8a15c198999ee449e8c6b04c2a8931ac5e9ad86c3920157",
+      "encodedBytes": 4262535,
+      "elapsedMilliseconds": 133.75488100000075,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7955,
+        "maximumFrameSize": 18639,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "eab602a474d9616842a1c3a10793eab8"
+      },
+      "nativeDecodedPcmSha256": "146a29ebce44459aa8a15c198999ee449e8c6b04c2a8931ac5e9ad86c3920157"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "c7fdfc4d8c871b684f0d5a3b0208f2f4d51b66450257b74b6b064b74c789c903",
+      "encodedBytes": 5170292,
+      "elapsedMilliseconds": 598.4639270000043,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 10522,
+        "maximumFrameSize": 18823,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fcdccbdef2ee2c7ee8b74f8bd64abb7f"
+      },
+      "nativeDecodedPcmSha256": "c7fdfc4d8c871b684f0d5a3b0208f2f4d51b66450257b74b6b064b74c789c903"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "c7fdfc4d8c871b684f0d5a3b0208f2f4d51b66450257b74b6b064b74c789c903",
+      "encodedBytes": 5170291,
+      "elapsedMilliseconds": 139.82655100000557,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 10522,
+        "maximumFrameSize": 18823,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fcdccbdef2ee2c7ee8b74f8bd64abb7f"
+      },
+      "nativeDecodedPcmSha256": "c7fdfc4d8c871b684f0d5a3b0208f2f4d51b66450257b74b6b064b74c789c903"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "6f35e69c56cae81692bae02df2074b5aa0d1afc8ca25bdcac9d6c4b3e0133a31",
+      "encodedBytes": 4202886,
+      "elapsedMilliseconds": 569.2933929999999,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8425,
+        "maximumFrameSize": 17842,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b4aa781a52d5d7b5f47f9852b0121c46"
+      },
+      "nativeDecodedPcmSha256": "6f35e69c56cae81692bae02df2074b5aa0d1afc8ca25bdcac9d6c4b3e0133a31"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "6f35e69c56cae81692bae02df2074b5aa0d1afc8ca25bdcac9d6c4b3e0133a31",
+      "encodedBytes": 4202884,
+      "elapsedMilliseconds": 132.5187159999914,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8425,
+        "maximumFrameSize": 17842,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b4aa781a52d5d7b5f47f9852b0121c46"
+      },
+      "nativeDecodedPcmSha256": "6f35e69c56cae81692bae02df2074b5aa0d1afc8ca25bdcac9d6c4b3e0133a31"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "7663bc6e076e7abf6e495e6f10fe5e511293290188bd2ea42ca8f11dca59c151",
+      "encodedBytes": 2584878,
+      "elapsedMilliseconds": 404.8093860000081,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7955,
+        "maximumFrameSize": 8561,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fc08cdf3e808dc6e0745ddfece913484"
+      },
+      "nativeDecodedPcmSha256": "7663bc6e076e7abf6e495e6f10fe5e511293290188bd2ea42ca8f11dca59c151"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "7663bc6e076e7abf6e495e6f10fe5e511293290188bd2ea42ca8f11dca59c151",
+      "encodedBytes": 2584878,
+      "elapsedMilliseconds": 113.5787249999994,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7955,
+        "maximumFrameSize": 8561,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fc08cdf3e808dc6e0745ddfece913484"
+      },
+      "nativeDecodedPcmSha256": "7663bc6e076e7abf6e495e6f10fe5e511293290188bd2ea42ca8f11dca59c151"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "3849a44bffe57ab48954fd37640c9292db6fba2278a1448464f1748d5dc5745e",
+      "encodedBytes": 1094741,
+      "elapsedMilliseconds": 165.01939500001026,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7864,
+        "maximumFrameSize": 8021,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "e40441b3fc17e9aeaf045157bcb09627"
+      },
+      "nativeDecodedPcmSha256": "3849a44bffe57ab48954fd37640c9292db6fba2278a1448464f1748d5dc5745e"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "3849a44bffe57ab48954fd37640c9292db6fba2278a1448464f1748d5dc5745e",
+      "encodedBytes": 1094741,
+      "elapsedMilliseconds": 49.33025899998029,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7864,
+        "maximumFrameSize": 8021,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "e40441b3fc17e9aeaf045157bcb09627"
+      },
+      "nativeDecodedPcmSha256": "3849a44bffe57ab48954fd37640c9292db6fba2278a1448464f1748d5dc5745e"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "1cb3c348a7d541b66309eea6f1aefefb0b02fb421d91b898fadae0733775d780",
+      "encodedBytes": 5144195,
+      "elapsedMilliseconds": 563.5751960000198,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1048,
+        "maximumFrameSize": 19125,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "3f301ecc694f663741a2b783c29dc8f1"
+      },
+      "nativeDecodedPcmSha256": "1cb3c348a7d541b66309eea6f1aefefb0b02fb421d91b898fadae0733775d780"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "1cb3c348a7d541b66309eea6f1aefefb0b02fb421d91b898fadae0733775d780",
+      "encodedBytes": 5144195,
+      "elapsedMilliseconds": 134.57267900000443,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1048,
+        "maximumFrameSize": 19125,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "3f301ecc694f663741a2b783c29dc8f1"
+      },
+      "nativeDecodedPcmSha256": "1cb3c348a7d541b66309eea6f1aefefb0b02fb421d91b898fadae0733775d780"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "ed3b2c8a228e50e3b1a11aafa9f1aae51fa304e559661959c63e10a20c1f48da",
+      "encodedBytes": 5172912,
+      "elapsedMilliseconds": 572.5711759999976,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1115,
+        "maximumFrameSize": 19757,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d520abf87f30a1be09fc659b464ce855"
+      },
+      "nativeDecodedPcmSha256": "ed3b2c8a228e50e3b1a11aafa9f1aae51fa304e559661959c63e10a20c1f48da"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "ed3b2c8a228e50e3b1a11aafa9f1aae51fa304e559661959c63e10a20c1f48da",
+      "encodedBytes": 5172912,
+      "elapsedMilliseconds": 137.8146059999999,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1115,
+        "maximumFrameSize": 19757,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d520abf87f30a1be09fc659b464ce855"
+      },
+      "nativeDecodedPcmSha256": "ed3b2c8a228e50e3b1a11aafa9f1aae51fa304e559661959c63e10a20c1f48da"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "034db1186c1eb61b137691797fea0b93a3aca44c2167924d2d7ac4809ba9ad9f",
+      "encodedBytes": 5252207,
+      "elapsedMilliseconds": 568.528674000001,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6915,
+        "maximumFrameSize": 18956,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "36e9ce530e6f5228f07bcf0b1c6dfb95"
+      },
+      "nativeDecodedPcmSha256": "034db1186c1eb61b137691797fea0b93a3aca44c2167924d2d7ac4809ba9ad9f"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "034db1186c1eb61b137691797fea0b93a3aca44c2167924d2d7ac4809ba9ad9f",
+      "encodedBytes": 5252207,
+      "elapsedMilliseconds": 134.66866199998185,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6915,
+        "maximumFrameSize": 18956,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "36e9ce530e6f5228f07bcf0b1c6dfb95"
+      },
+      "nativeDecodedPcmSha256": "034db1186c1eb61b137691797fea0b93a3aca44c2167924d2d7ac4809ba9ad9f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "85d909ec0f5745a6c02a9b87cf11ab8f35546990395eeecd4059a923084fc6af",
+      "encodedBytes": 5088811,
+      "elapsedMilliseconds": 586.050430000003,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1068,
+        "maximumFrameSize": 19622,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "a5db113db1af2e6a236797876d040bcc"
+      },
+      "nativeDecodedPcmSha256": "85d909ec0f5745a6c02a9b87cf11ab8f35546990395eeecd4059a923084fc6af"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "85d909ec0f5745a6c02a9b87cf11ab8f35546990395eeecd4059a923084fc6af",
+      "encodedBytes": 5088810,
+      "elapsedMilliseconds": 136.90385100001004,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1068,
+        "maximumFrameSize": 19622,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "a5db113db1af2e6a236797876d040bcc"
+      },
+      "nativeDecodedPcmSha256": "85d909ec0f5745a6c02a9b87cf11ab8f35546990395eeecd4059a923084fc6af"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "52739fe2188b8ff3f49b0b6a55444205c91fd05023bfc377d24e7354ad09c665",
+      "encodedBytes": 3443937,
+      "elapsedMilliseconds": 531.6767009999894,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1167,
+        "maximumFrameSize": 19515,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "98aafbd3bbe5b47e9b3591cc435b11e2"
+      },
+      "nativeDecodedPcmSha256": "52739fe2188b8ff3f49b0b6a55444205c91fd05023bfc377d24e7354ad09c665"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "52739fe2188b8ff3f49b0b6a55444205c91fd05023bfc377d24e7354ad09c665",
+      "encodedBytes": 3443938,
+      "elapsedMilliseconds": 135.5531970000011,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1167,
+        "maximumFrameSize": 19515,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "98aafbd3bbe5b47e9b3591cc435b11e2"
+      },
+      "nativeDecodedPcmSha256": "52739fe2188b8ff3f49b0b6a55444205c91fd05023bfc377d24e7354ad09c665"
+    },
+    {
+      "implementation": "wasm",
+      "round": 2,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 5,
+      "frames": 91456,
+      "expectedPcmSha256": "30f490035cb2caaf0b63f57c817211708107df2bb2622eb80a8ca7cf56d41d2d",
+      "encodedBytes": 20011,
+      "elapsedMilliseconds": 26.46312499998021,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 189,
+        "maximumFrameSize": 1171,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "91456",
+        "md5Hex": "4f1a221fa641e39e32e602a5a4648686"
+      },
+      "nativeDecodedPcmSha256": "30f490035cb2caaf0b63f57c817211708107df2bb2622eb80a8ca7cf56d41d2d"
+    },
+    {
+      "implementation": "native",
+      "round": 2,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 5,
+      "frames": 91456,
+      "expectedPcmSha256": "30f490035cb2caaf0b63f57c817211708107df2bb2622eb80a8ca7cf56d41d2d",
+      "encodedBytes": 20011,
+      "elapsedMilliseconds": 7.982480000006035,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 189,
+        "maximumFrameSize": 1171,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "91456",
+        "md5Hex": "4f1a221fa641e39e32e602a5a4648686"
+      },
+      "nativeDecodedPcmSha256": "30f490035cb2caaf0b63f57c817211708107df2bb2622eb80a8ca7cf56d41d2d"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "0ad333131602d2eed204c673014271b346328956a17a459cda005d12aff26324",
+      "encodedBytes": 4150349,
+      "elapsedMilliseconds": 510.07468799999333,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1046,
+        "maximumFrameSize": 18240,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5b26e698b3ee07d53f57208d50518553"
+      },
+      "nativeDecodedPcmSha256": "0ad333131602d2eed204c673014271b346328956a17a459cda005d12aff26324"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "0ad333131602d2eed204c673014271b346328956a17a459cda005d12aff26324",
+      "encodedBytes": 4150349,
+      "elapsedMilliseconds": 128.77661400000216,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1046,
+        "maximumFrameSize": 18240,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5b26e698b3ee07d53f57208d50518553"
+      },
+      "nativeDecodedPcmSha256": "0ad333131602d2eed204c673014271b346328956a17a459cda005d12aff26324"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "498bd8b6bfeb1e240e24b0c0f948f26e59259d319adf0e61f5cd7e5ec79d10e8",
+      "encodedBytes": 4371131,
+      "elapsedMilliseconds": 527.6508590000158,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1058,
+        "maximumFrameSize": 18677,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d5817dbd7025dd8dcb122eb5a8c2abff"
+      },
+      "nativeDecodedPcmSha256": "498bd8b6bfeb1e240e24b0c0f948f26e59259d319adf0e61f5cd7e5ec79d10e8"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "498bd8b6bfeb1e240e24b0c0f948f26e59259d319adf0e61f5cd7e5ec79d10e8",
+      "encodedBytes": 4371137,
+      "elapsedMilliseconds": 134.71446800002013,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1058,
+        "maximumFrameSize": 18677,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d5817dbd7025dd8dcb122eb5a8c2abff"
+      },
+      "nativeDecodedPcmSha256": "498bd8b6bfeb1e240e24b0c0f948f26e59259d319adf0e61f5cd7e5ec79d10e8"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "a9b0a5e36c48ce2ecd758f22ba512342b8d6378c86d8a0c95c8b5fb01d86ae7f",
+      "encodedBytes": 2982496,
+      "elapsedMilliseconds": 499.80302500000107,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 19173,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "bc4f583eb83952c7aafa13276e51bfa4"
+      },
+      "nativeDecodedPcmSha256": "a9b0a5e36c48ce2ecd758f22ba512342b8d6378c86d8a0c95c8b5fb01d86ae7f"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "a9b0a5e36c48ce2ecd758f22ba512342b8d6378c86d8a0c95c8b5fb01d86ae7f",
+      "encodedBytes": 2982490,
+      "elapsedMilliseconds": 122.04855400000815,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 19173,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "bc4f583eb83952c7aafa13276e51bfa4"
+      },
+      "nativeDecodedPcmSha256": "a9b0a5e36c48ce2ecd758f22ba512342b8d6378c86d8a0c95c8b5fb01d86ae7f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 3,
+      "frames": 1162869,
+      "expectedPcmSha256": "ad88aea64fa81f9247059b6e75ccbeadd4b350cae9a83d7940f4594e87dd7936",
+      "encodedBytes": 4539491,
+      "elapsedMilliseconds": 457.35591099999147,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 487,
+        "maximumFrameSize": 20237,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1162869",
+        "md5Hex": "7547e0b77aefe7bf646b230d8a47d74e"
+      },
+      "nativeDecodedPcmSha256": "ad88aea64fa81f9247059b6e75ccbeadd4b350cae9a83d7940f4594e87dd7936"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:03328fc288eda889bb9bb7813a48bf87d3e011b1698778fc456f57c8561b9db2",
+      "chunkIndex": 3,
+      "frames": 1162869,
+      "expectedPcmSha256": "ad88aea64fa81f9247059b6e75ccbeadd4b350cae9a83d7940f4594e87dd7936",
+      "encodedBytes": 4539490,
+      "elapsedMilliseconds": 114.11777099999017,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 487,
+        "maximumFrameSize": 20237,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1162869",
+        "md5Hex": "7547e0b77aefe7bf646b230d8a47d74e"
+      },
+      "nativeDecodedPcmSha256": "ad88aea64fa81f9247059b6e75ccbeadd4b350cae9a83d7940f4594e87dd7936"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "b4d086eb6ea6fb003acaa30cbf00317bb1567dee9c03521701ad60f404f7a2c7",
+      "encodedBytes": 3396576,
+      "elapsedMilliseconds": 428.08127799999784,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7959,
+        "maximumFrameSize": 18028,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9c2393e2f1b5ee54d1253ee3a3dfb992"
+      },
+      "nativeDecodedPcmSha256": "b4d086eb6ea6fb003acaa30cbf00317bb1567dee9c03521701ad60f404f7a2c7"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "b4d086eb6ea6fb003acaa30cbf00317bb1567dee9c03521701ad60f404f7a2c7",
+      "encodedBytes": 3396577,
+      "elapsedMilliseconds": 116.95411599997897,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7959,
+        "maximumFrameSize": 18028,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9c2393e2f1b5ee54d1253ee3a3dfb992"
+      },
+      "nativeDecodedPcmSha256": "b4d086eb6ea6fb003acaa30cbf00317bb1567dee9c03521701ad60f404f7a2c7"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "72e151c5c4f167900d89a7096ea63dcabeb846c160caaeaec4d0711ddbb9ae76",
+      "encodedBytes": 5287166,
+      "elapsedMilliseconds": 537.3709690000105,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5431,
+        "maximumFrameSize": 19445,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "c9cb1466675357641cebeb5032e2f37d"
+      },
+      "nativeDecodedPcmSha256": "72e151c5c4f167900d89a7096ea63dcabeb846c160caaeaec4d0711ddbb9ae76"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "72e151c5c4f167900d89a7096ea63dcabeb846c160caaeaec4d0711ddbb9ae76",
+      "encodedBytes": 5287163,
+      "elapsedMilliseconds": 133.64805600000545,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5431,
+        "maximumFrameSize": 19445,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "c9cb1466675357641cebeb5032e2f37d"
+      },
+      "nativeDecodedPcmSha256": "72e151c5c4f167900d89a7096ea63dcabeb846c160caaeaec4d0711ddbb9ae76"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "4b8d2779ff5af472ae8159a9429aba0befe0eca99cd4b4f29432f8dd33af6c1f",
+      "encodedBytes": 3847608,
+      "elapsedMilliseconds": 490.5661629999813,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8050,
+        "maximumFrameSize": 19330,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "46b620635fb0599fc6f77ce38d08afd6"
+      },
+      "nativeDecodedPcmSha256": "4b8d2779ff5af472ae8159a9429aba0befe0eca99cd4b4f29432f8dd33af6c1f"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "4b8d2779ff5af472ae8159a9429aba0befe0eca99cd4b4f29432f8dd33af6c1f",
+      "encodedBytes": 3847607,
+      "elapsedMilliseconds": 125.83219299998018,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8050,
+        "maximumFrameSize": 19330,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "46b620635fb0599fc6f77ce38d08afd6"
+      },
+      "nativeDecodedPcmSha256": "4b8d2779ff5af472ae8159a9429aba0befe0eca99cd4b4f29432f8dd33af6c1f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "874cb197ccd1ef18c42c4de586b947796463dfaa211978c5ecf747683f20b367",
+      "encodedBytes": 3190338,
+      "elapsedMilliseconds": 518.7993800000113,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7963,
+        "maximumFrameSize": 16584,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d391e230ba796167b53a81a2bbdf2831"
+      },
+      "nativeDecodedPcmSha256": "874cb197ccd1ef18c42c4de586b947796463dfaa211978c5ecf747683f20b367"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "874cb197ccd1ef18c42c4de586b947796463dfaa211978c5ecf747683f20b367",
+      "encodedBytes": 3190350,
+      "elapsedMilliseconds": 126.03946800000267,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7963,
+        "maximumFrameSize": 16584,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d391e230ba796167b53a81a2bbdf2831"
+      },
+      "nativeDecodedPcmSha256": "874cb197ccd1ef18c42c4de586b947796463dfaa211978c5ecf747683f20b367"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "f6ccbd0a0a535ebc8f2b53ae0adeb7fc4796648646edb2caae934f889f6e1bb4",
+      "encodedBytes": 5481625,
+      "elapsedMilliseconds": 560.7727899999882,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7941,
+        "maximumFrameSize": 19501,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fe527fc68042d8fc43a670259d17aa00"
+      },
+      "nativeDecodedPcmSha256": "f6ccbd0a0a535ebc8f2b53ae0adeb7fc4796648646edb2caae934f889f6e1bb4"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "f6ccbd0a0a535ebc8f2b53ae0adeb7fc4796648646edb2caae934f889f6e1bb4",
+      "encodedBytes": 5481625,
+      "elapsedMilliseconds": 134.32190999999875,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7941,
+        "maximumFrameSize": 19501,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fe527fc68042d8fc43a670259d17aa00"
+      },
+      "nativeDecodedPcmSha256": "f6ccbd0a0a535ebc8f2b53ae0adeb7fc4796648646edb2caae934f889f6e1bb4"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "ef9d092ac5241f9d7479dd6098355cf95724cc229b90286b20b48318cd2266f6",
+      "encodedBytes": 2580489,
+      "elapsedMilliseconds": 402.78044599998975,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7939,
+        "maximumFrameSize": 8322,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "81b081b322c774cd732dcfa16962c8e9"
+      },
+      "nativeDecodedPcmSha256": "ef9d092ac5241f9d7479dd6098355cf95724cc229b90286b20b48318cd2266f6"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "ef9d092ac5241f9d7479dd6098355cf95724cc229b90286b20b48318cd2266f6",
+      "encodedBytes": 2580489,
+      "elapsedMilliseconds": 113.0677999999898,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7939,
+        "maximumFrameSize": 8322,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "81b081b322c774cd732dcfa16962c8e9"
+      },
+      "nativeDecodedPcmSha256": "ef9d092ac5241f9d7479dd6098355cf95724cc229b90286b20b48318cd2266f6"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "68599d04661ee4e25c2f965d2c5197f84eae66e6b5cd3e52a915d70c44567cbc",
+      "encodedBytes": 1094519,
+      "elapsedMilliseconds": 175.41158499999437,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7867,
+        "maximumFrameSize": 8029,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "d984dcecf62ef48f97716f78896234a3"
+      },
+      "nativeDecodedPcmSha256": "68599d04661ee4e25c2f965d2c5197f84eae66e6b5cd3e52a915d70c44567cbc"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:18a73d7d7a47ec6ccd306235bb921dc8760ecce468b0cb5b4860ef94b898bba6",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "68599d04661ee4e25c2f965d2c5197f84eae66e6b5cd3e52a915d70c44567cbc",
+      "encodedBytes": 1094519,
+      "elapsedMilliseconds": 48.99794500001008,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7867,
+        "maximumFrameSize": 8029,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "d984dcecf62ef48f97716f78896234a3"
+      },
+      "nativeDecodedPcmSha256": "68599d04661ee4e25c2f965d2c5197f84eae66e6b5cd3e52a915d70c44567cbc"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:1d0544c63bf19bcc8d8b663d73fb9b206f9d107d52f7729ead8fce52aaa9be71",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "3e07a582bb431c6106a0eeea238aeddfd33ab51272f2f4ec19f24461230d6879",
+      "encodedBytes": 4802021,
+      "elapsedMilliseconds": 490.93286999998963,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 639,
+        "maximumFrameSize": 18532,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "7b9be66be751f643ae8fa39cd8ca6184"
+      },
+      "nativeDecodedPcmSha256": "3e07a582bb431c6106a0eeea238aeddfd33ab51272f2f4ec19f24461230d6879"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:1d0544c63bf19bcc8d8b663d73fb9b206f9d107d52f7729ead8fce52aaa9be71",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "3e07a582bb431c6106a0eeea238aeddfd33ab51272f2f4ec19f24461230d6879",
+      "encodedBytes": 4802021,
+      "elapsedMilliseconds": 126.77442800000426,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 639,
+        "maximumFrameSize": 18532,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "7b9be66be751f643ae8fa39cd8ca6184"
+      },
+      "nativeDecodedPcmSha256": "3e07a582bb431c6106a0eeea238aeddfd33ab51272f2f4ec19f24461230d6879"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:1d0544c63bf19bcc8d8b663d73fb9b206f9d107d52f7729ead8fce52aaa9be71",
+      "chunkIndex": 1,
+      "frames": 1179460,
+      "expectedPcmSha256": "b1fed292edbe942de39423402a36ee74165dc92c74d4630e85d8aec07e26f6e2",
+      "encodedBytes": 3270974,
+      "elapsedMilliseconds": 400.28859800001374,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 506,
+        "maximumFrameSize": 18576,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1179460",
+        "md5Hex": "e102779c11c2a0141579ee8a147dad3d"
+      },
+      "nativeDecodedPcmSha256": "b1fed292edbe942de39423402a36ee74165dc92c74d4630e85d8aec07e26f6e2"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:1d0544c63bf19bcc8d8b663d73fb9b206f9d107d52f7729ead8fce52aaa9be71",
+      "chunkIndex": 1,
+      "frames": 1179460,
+      "expectedPcmSha256": "b1fed292edbe942de39423402a36ee74165dc92c74d4630e85d8aec07e26f6e2",
+      "encodedBytes": 3270968,
+      "elapsedMilliseconds": 111.51015099999495,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 506,
+        "maximumFrameSize": 18576,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1179460",
+        "md5Hex": "e102779c11c2a0141579ee8a147dad3d"
+      },
+      "nativeDecodedPcmSha256": "b1fed292edbe942de39423402a36ee74165dc92c74d4630e85d8aec07e26f6e2"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "a19561147112095642424463ea315305b085a03c9c82becb7ac38c3e923c2407",
+      "encodedBytes": 4187420,
+      "elapsedMilliseconds": 542.9866570000013,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1089,
+        "maximumFrameSize": 20569,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "219b7301a904dc1b3b4f430d08a555ae"
+      },
+      "nativeDecodedPcmSha256": "a19561147112095642424463ea315305b085a03c9c82becb7ac38c3e923c2407"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "a19561147112095642424463ea315305b085a03c9c82becb7ac38c3e923c2407",
+      "encodedBytes": 4187419,
+      "elapsedMilliseconds": 136.12926300000981,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1089,
+        "maximumFrameSize": 20569,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "219b7301a904dc1b3b4f430d08a555ae"
+      },
+      "nativeDecodedPcmSha256": "a19561147112095642424463ea315305b085a03c9c82becb7ac38c3e923c2407"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "55a9246cc0cfbf1ea647cad6f98d37f9d9351d2743ea6d09e87afeeeaafd94e3",
+      "encodedBytes": 3050967,
+      "elapsedMilliseconds": 541.0431730000128,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1051,
+        "maximumFrameSize": 20467,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "679b726bb6d3e08e24c3e184f9a9f15e"
+      },
+      "nativeDecodedPcmSha256": "55a9246cc0cfbf1ea647cad6f98d37f9d9351d2743ea6d09e87afeeeaafd94e3"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "55a9246cc0cfbf1ea647cad6f98d37f9d9351d2743ea6d09e87afeeeaafd94e3",
+      "encodedBytes": 3050969,
+      "elapsedMilliseconds": 133.64309599998523,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1051,
+        "maximumFrameSize": 20467,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "679b726bb6d3e08e24c3e184f9a9f15e"
+      },
+      "nativeDecodedPcmSha256": "55a9246cc0cfbf1ea647cad6f98d37f9d9351d2743ea6d09e87afeeeaafd94e3"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "52e84d5ab6f4d8e41262b82fae7a1fc2e774f9d29b10e5e9e7b64592799e27dd",
+      "encodedBytes": 4662993,
+      "elapsedMilliseconds": 566.9844540000195,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1070,
+        "maximumFrameSize": 20658,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "63b1666ccf5139b3eabf2b0b97b289c4"
+      },
+      "nativeDecodedPcmSha256": "52e84d5ab6f4d8e41262b82fae7a1fc2e774f9d29b10e5e9e7b64592799e27dd"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "52e84d5ab6f4d8e41262b82fae7a1fc2e774f9d29b10e5e9e7b64592799e27dd",
+      "encodedBytes": 4662993,
+      "elapsedMilliseconds": 136.62464699998964,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1070,
+        "maximumFrameSize": 20658,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "63b1666ccf5139b3eabf2b0b97b289c4"
+      },
+      "nativeDecodedPcmSha256": "52e84d5ab6f4d8e41262b82fae7a1fc2e774f9d29b10e5e9e7b64592799e27dd"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 3,
+      "frames": 630874,
+      "expectedPcmSha256": "d2903e6abfcf42e70792f30af34c900d64ad340d77ef31a775287c68d17596b9",
+      "encodedBytes": 2161240,
+      "elapsedMilliseconds": 276.05156399999396,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 18,
+        "maximumFrameSize": 20476,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "630874",
+        "md5Hex": "c0d8c46e99c6193df86665e77b15ce15"
+      },
+      "nativeDecodedPcmSha256": "d2903e6abfcf42e70792f30af34c900d64ad340d77ef31a775287c68d17596b9"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:2726b0d1370fdf4924bc2a3509533c4fbb914a9ff45c54e7b010be71a4adfb76",
+      "chunkIndex": 3,
+      "frames": 630874,
+      "expectedPcmSha256": "d2903e6abfcf42e70792f30af34c900d64ad340d77ef31a775287c68d17596b9",
+      "encodedBytes": 2161240,
+      "elapsedMilliseconds": 66.13030999997864,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 18,
+        "maximumFrameSize": 20476,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "630874",
+        "md5Hex": "c0d8c46e99c6193df86665e77b15ce15"
+      },
+      "nativeDecodedPcmSha256": "d2903e6abfcf42e70792f30af34c900d64ad340d77ef31a775287c68d17596b9"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "9cd318a12c7c8fa38f058ab7c8e032b363c431af852557febfc61a2a18c34970",
+      "encodedBytes": 2867123,
+      "elapsedMilliseconds": 487.79566999999224,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 4489,
+        "maximumFrameSize": 16813,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "6357201bd5e0eeb273716afdec214aca"
+      },
+      "nativeDecodedPcmSha256": "9cd318a12c7c8fa38f058ab7c8e032b363c431af852557febfc61a2a18c34970"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "9cd318a12c7c8fa38f058ab7c8e032b363c431af852557febfc61a2a18c34970",
+      "encodedBytes": 2867123,
+      "elapsedMilliseconds": 123.03250699999626,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 4489,
+        "maximumFrameSize": 16813,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "6357201bd5e0eeb273716afdec214aca"
+      },
+      "nativeDecodedPcmSha256": "9cd318a12c7c8fa38f058ab7c8e032b363c431af852557febfc61a2a18c34970"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "0016abd2094e03efc2cb2bf4301934db1c55b68a034ca7a977e1eb4b6bf71799",
+      "encodedBytes": 4455810,
+      "elapsedMilliseconds": 563.8418450000172,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5533,
+        "maximumFrameSize": 18357,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b31c86a1180cf2a42e08aa21582d4907"
+      },
+      "nativeDecodedPcmSha256": "0016abd2094e03efc2cb2bf4301934db1c55b68a034ca7a977e1eb4b6bf71799"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "0016abd2094e03efc2cb2bf4301934db1c55b68a034ca7a977e1eb4b6bf71799",
+      "encodedBytes": 4455811,
+      "elapsedMilliseconds": 137.95312799999374,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5533,
+        "maximumFrameSize": 18357,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b31c86a1180cf2a42e08aa21582d4907"
+      },
+      "nativeDecodedPcmSha256": "0016abd2094e03efc2cb2bf4301934db1c55b68a034ca7a977e1eb4b6bf71799"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "fb92413909c791e44c9aaffed2aa7dd0025bb3af28e6bc54da191243aa2c31da",
+      "encodedBytes": 4664160,
+      "elapsedMilliseconds": 584.1640079999925,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6095,
+        "maximumFrameSize": 17776,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "38e2092fb1dfd7bc419233204dd69922"
+      },
+      "nativeDecodedPcmSha256": "fb92413909c791e44c9aaffed2aa7dd0025bb3af28e6bc54da191243aa2c31da"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "fb92413909c791e44c9aaffed2aa7dd0025bb3af28e6bc54da191243aa2c31da",
+      "encodedBytes": 4664160,
+      "elapsedMilliseconds": 136.23115700000199,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6095,
+        "maximumFrameSize": 17776,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "38e2092fb1dfd7bc419233204dd69922"
+      },
+      "nativeDecodedPcmSha256": "fb92413909c791e44c9aaffed2aa7dd0025bb3af28e6bc54da191243aa2c31da"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "0c53b70e20dad8a58b0ccd63fae413169addf85c2ff23899acb8cfcf9d112f7b",
+      "encodedBytes": 4600172,
+      "elapsedMilliseconds": 561.5031369999924,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5555,
+        "maximumFrameSize": 17032,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9a59c85b30fd8c2e72cd58c43592fd1d"
+      },
+      "nativeDecodedPcmSha256": "0c53b70e20dad8a58b0ccd63fae413169addf85c2ff23899acb8cfcf9d112f7b"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "0c53b70e20dad8a58b0ccd63fae413169addf85c2ff23899acb8cfcf9d112f7b",
+      "encodedBytes": 4600172,
+      "elapsedMilliseconds": 135.36775199999101,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5555,
+        "maximumFrameSize": 17032,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9a59c85b30fd8c2e72cd58c43592fd1d"
+      },
+      "nativeDecodedPcmSha256": "0c53b70e20dad8a58b0ccd63fae413169addf85c2ff23899acb8cfcf9d112f7b"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 4,
+      "frames": 915923,
+      "expectedPcmSha256": "ee9d65603f1b22585957d02a4c56be87be47cf6354808438964a3a1c031cfd9f",
+      "encodedBytes": 2886170,
+      "elapsedMilliseconds": 374.0006730000023,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 3285,
+        "maximumFrameSize": 16807,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "915923",
+        "md5Hex": "d3c4f8f2c76bd1d09d96d04f6dba9f1d"
+      },
+      "nativeDecodedPcmSha256": "ee9d65603f1b22585957d02a4c56be87be47cf6354808438964a3a1c031cfd9f"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:27c2485abef9b9791cf127b08108e9982383fdbf7736095f8411647e5b82a7ac",
+      "chunkIndex": 4,
+      "frames": 915923,
+      "expectedPcmSha256": "ee9d65603f1b22585957d02a4c56be87be47cf6354808438964a3a1c031cfd9f",
+      "encodedBytes": 2886170,
+      "elapsedMilliseconds": 93.23876500001643,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 3285,
+        "maximumFrameSize": 16807,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "915923",
+        "md5Hex": "d3c4f8f2c76bd1d09d96d04f6dba9f1d"
+      },
+      "nativeDecodedPcmSha256": "ee9d65603f1b22585957d02a4c56be87be47cf6354808438964a3a1c031cfd9f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "74c0df9dcd402798188e653381e0166de4eb0e9e0e5e7d28de95dc2d7921efc9",
+      "encodedBytes": 2555489,
+      "elapsedMilliseconds": 578.9839360000042,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1119,
+        "maximumFrameSize": 11300,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "246801b775679e817b341b8c39d382cb"
+      },
+      "nativeDecodedPcmSha256": "74c0df9dcd402798188e653381e0166de4eb0e9e0e5e7d28de95dc2d7921efc9"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "74c0df9dcd402798188e653381e0166de4eb0e9e0e5e7d28de95dc2d7921efc9",
+      "encodedBytes": 2556311,
+      "elapsedMilliseconds": 208.98113100000774,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1119,
+        "maximumFrameSize": 11311,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "246801b775679e817b341b8c39d382cb"
+      },
+      "nativeDecodedPcmSha256": "74c0df9dcd402798188e653381e0166de4eb0e9e0e5e7d28de95dc2d7921efc9"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "8f9568ecd4f1890cdd81cb5173c40112d98c1a4d61fd36314e4bb2030124cb2a",
+      "encodedBytes": 1499027,
+      "elapsedMilliseconds": 365.27819300000556,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 19858,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "164ea8991da81f3328f402e47b7e849b"
+      },
+      "nativeDecodedPcmSha256": "8f9568ecd4f1890cdd81cb5173c40112d98c1a4d61fd36314e4bb2030124cb2a"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "8f9568ecd4f1890cdd81cb5173c40112d98c1a4d61fd36314e4bb2030124cb2a",
+      "encodedBytes": 1499027,
+      "elapsedMilliseconds": 103.05135300001712,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 19858,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "164ea8991da81f3328f402e47b7e849b"
+      },
+      "nativeDecodedPcmSha256": "8f9568ecd4f1890cdd81cb5173c40112d98c1a4d61fd36314e4bb2030124cb2a"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "0d76eb91be0008835d5774ac3b2738db6e392d32e4fc767d77a25394f82ba7e4",
+      "encodedBytes": 2203031,
+      "elapsedMilliseconds": 439.0527989999973,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 19224,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "cc6a0db61773a650e936bf526840a278"
+      },
+      "nativeDecodedPcmSha256": "0d76eb91be0008835d5774ac3b2738db6e392d32e4fc767d77a25394f82ba7e4"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "0d76eb91be0008835d5774ac3b2738db6e392d32e4fc767d77a25394f82ba7e4",
+      "encodedBytes": 2203168,
+      "elapsedMilliseconds": 138.94807300000684,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 19224,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "cc6a0db61773a650e936bf526840a278"
+      },
+      "nativeDecodedPcmSha256": "0d76eb91be0008835d5774ac3b2738db6e392d32e4fc767d77a25394f82ba7e4"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "95c4368b4a153a4b38ea1d8f4b4fe10db945dad45351d3a74e5fe38fdc4273fa",
+      "encodedBytes": 4652718,
+      "elapsedMilliseconds": 521.6764660000044,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1047,
+        "maximumFrameSize": 20009,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "27feaa2a2129642bee3dce8784769a30"
+      },
+      "nativeDecodedPcmSha256": "95c4368b4a153a4b38ea1d8f4b4fe10db945dad45351d3a74e5fe38fdc4273fa"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "95c4368b4a153a4b38ea1d8f4b4fe10db945dad45351d3a74e5fe38fdc4273fa",
+      "encodedBytes": 4652717,
+      "elapsedMilliseconds": 128.7298019999871,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1047,
+        "maximumFrameSize": 20009,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "27feaa2a2129642bee3dce8784769a30"
+      },
+      "nativeDecodedPcmSha256": "95c4368b4a153a4b38ea1d8f4b4fe10db945dad45351d3a74e5fe38fdc4273fa"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 4,
+      "frames": 207800,
+      "expectedPcmSha256": "7e432c880c57ed605b55cf95c74625b569353b7df4dc398f731e0b81c40e71ef",
+      "encodedBytes": 465680,
+      "elapsedMilliseconds": 102.13590799999656,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5469,
+        "maximumFrameSize": 15210,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "207800",
+        "md5Hex": "0fffe1f3e6e69d7a3050d32f7fb5d52a"
+      },
+      "nativeDecodedPcmSha256": "7e432c880c57ed605b55cf95c74625b569353b7df4dc398f731e0b81c40e71ef"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:2bf5cb8199b9d347a6a94d10c52b770148efda9073069e4aeeafaa866030a846",
+      "chunkIndex": 4,
+      "frames": 207800,
+      "expectedPcmSha256": "7e432c880c57ed605b55cf95c74625b569353b7df4dc398f731e0b81c40e71ef",
+      "encodedBytes": 465680,
+      "elapsedMilliseconds": 22.37839100000565,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5469,
+        "maximumFrameSize": 15210,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "207800",
+        "md5Hex": "0fffe1f3e6e69d7a3050d32f7fb5d52a"
+      },
+      "nativeDecodedPcmSha256": "7e432c880c57ed605b55cf95c74625b569353b7df4dc398f731e0b81c40e71ef"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:2dd061241fa7fe3128289427e108ee63501f4ed77c7208f1b37ff49fa6ccff0b",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "ed128680f0adb80432e3cce5156094cb93edefa0d6339dcfa20ee11a3610a693",
+      "encodedBytes": 2892634,
+      "elapsedMilliseconds": 553.4127490000101,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1070,
+        "maximumFrameSize": 19648,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9b820f9751be365c4f499e924aae57e9"
+      },
+      "nativeDecodedPcmSha256": "ed128680f0adb80432e3cce5156094cb93edefa0d6339dcfa20ee11a3610a693"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:2dd061241fa7fe3128289427e108ee63501f4ed77c7208f1b37ff49fa6ccff0b",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "ed128680f0adb80432e3cce5156094cb93edefa0d6339dcfa20ee11a3610a693",
+      "encodedBytes": 2892311,
+      "elapsedMilliseconds": 132.47862599999644,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1070,
+        "maximumFrameSize": 19648,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9b820f9751be365c4f499e924aae57e9"
+      },
+      "nativeDecodedPcmSha256": "ed128680f0adb80432e3cce5156094cb93edefa0d6339dcfa20ee11a3610a693"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:2dd061241fa7fe3128289427e108ee63501f4ed77c7208f1b37ff49fa6ccff0b",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "ea144cffa39519276d7320c735e04874b41c1a26d160703000ab7b0cec8400a8",
+      "encodedBytes": 2726814,
+      "elapsedMilliseconds": 547.6476930000063,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1065,
+        "maximumFrameSize": 19723,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "80dd17665b535e6bef3050d7c6a5c3bc"
+      },
+      "nativeDecodedPcmSha256": "ea144cffa39519276d7320c735e04874b41c1a26d160703000ab7b0cec8400a8"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:2dd061241fa7fe3128289427e108ee63501f4ed77c7208f1b37ff49fa6ccff0b",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "ea144cffa39519276d7320c735e04874b41c1a26d160703000ab7b0cec8400a8",
+      "encodedBytes": 2726860,
+      "elapsedMilliseconds": 131.4815959999978,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1065,
+        "maximumFrameSize": 19723,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "80dd17665b535e6bef3050d7c6a5c3bc"
+      },
+      "nativeDecodedPcmSha256": "ea144cffa39519276d7320c735e04874b41c1a26d160703000ab7b0cec8400a8"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:2dd061241fa7fe3128289427e108ee63501f4ed77c7208f1b37ff49fa6ccff0b",
+      "chunkIndex": 2,
+      "frames": 932160,
+      "expectedPcmSha256": "2fe58c8e997921bfcf38f90cc60e75cdd4693167a6879bb9ce3cd82222f04484",
+      "encodedBytes": 2587977,
+      "elapsedMilliseconds": 390.6144379999896,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 616,
+        "maximumFrameSize": 19678,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "932160",
+        "md5Hex": "82e5df6a400892541bf06d1835cd488e"
+      },
+      "nativeDecodedPcmSha256": "2fe58c8e997921bfcf38f90cc60e75cdd4693167a6879bb9ce3cd82222f04484"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:2dd061241fa7fe3128289427e108ee63501f4ed77c7208f1b37ff49fa6ccff0b",
+      "chunkIndex": 2,
+      "frames": 932160,
+      "expectedPcmSha256": "2fe58c8e997921bfcf38f90cc60e75cdd4693167a6879bb9ce3cd82222f04484",
+      "encodedBytes": 2587993,
+      "elapsedMilliseconds": 94.7354869999981,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 616,
+        "maximumFrameSize": 19678,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "932160",
+        "md5Hex": "82e5df6a400892541bf06d1835cd488e"
+      },
+      "nativeDecodedPcmSha256": "2fe58c8e997921bfcf38f90cc60e75cdd4693167a6879bb9ce3cd82222f04484"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "624eb9b34a886ec6358d888dd40dedbc626eaf8120f5857a4a4a66564d718228",
+      "encodedBytes": 1374986,
+      "elapsedMilliseconds": 480.37422499997774,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 534,
+        "maximumFrameSize": 10206,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "23e4a57a4efdbb27ec686a87520eb52d"
+      },
+      "nativeDecodedPcmSha256": "624eb9b34a886ec6358d888dd40dedbc626eaf8120f5857a4a4a66564d718228"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "624eb9b34a886ec6358d888dd40dedbc626eaf8120f5857a4a4a66564d718228",
+      "encodedBytes": 1374937,
+      "elapsedMilliseconds": 115.6443380000128,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 534,
+        "maximumFrameSize": 10206,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "23e4a57a4efdbb27ec686a87520eb52d"
+      },
+      "nativeDecodedPcmSha256": "624eb9b34a886ec6358d888dd40dedbc626eaf8120f5857a4a4a66564d718228"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "3cc0f29b0fc5ae8aa860430556697b4b2301a5537ab6f417baf667f498c21399",
+      "encodedBytes": 813899,
+      "elapsedMilliseconds": 372.52730399998836,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1059,
+        "maximumFrameSize": 6719,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "942063bb60651f274c2ac31de0ddcbee"
+      },
+      "nativeDecodedPcmSha256": "3cc0f29b0fc5ae8aa860430556697b4b2301a5537ab6f417baf667f498c21399"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "3cc0f29b0fc5ae8aa860430556697b4b2301a5537ab6f417baf667f498c21399",
+      "encodedBytes": 813885,
+      "elapsedMilliseconds": 105.1911099999852,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1059,
+        "maximumFrameSize": 6719,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "942063bb60651f274c2ac31de0ddcbee"
+      },
+      "nativeDecodedPcmSha256": "3cc0f29b0fc5ae8aa860430556697b4b2301a5537ab6f417baf667f498c21399"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "77a7ec33fa71caea53ad8f039c991b547b56dca2f267013b9a91fa1093c6b5f6",
+      "encodedBytes": 701176,
+      "elapsedMilliseconds": 339.6081160000176,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1065,
+        "maximumFrameSize": 7718,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "71304eeb1e3cd469c4f66cc0b2043f3c"
+      },
+      "nativeDecodedPcmSha256": "77a7ec33fa71caea53ad8f039c991b547b56dca2f267013b9a91fa1093c6b5f6"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "77a7ec33fa71caea53ad8f039c991b547b56dca2f267013b9a91fa1093c6b5f6",
+      "encodedBytes": 701130,
+      "elapsedMilliseconds": 102.93475999997463,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1065,
+        "maximumFrameSize": 7718,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "71304eeb1e3cd469c4f66cc0b2043f3c"
+      },
+      "nativeDecodedPcmSha256": "77a7ec33fa71caea53ad8f039c991b547b56dca2f267013b9a91fa1093c6b5f6"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 3,
+      "frames": 1057881,
+      "expectedPcmSha256": "e1c58aca6a4e6b13d373151f083a94be66336f1ea664eb691eb1aaeb3cf234db",
+      "encodedBytes": 876783,
+      "elapsedMilliseconds": 336.98273399999016,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 300,
+        "maximumFrameSize": 7789,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1057881",
+        "md5Hex": "8751673efb6f8957d16ea3204f3c5165"
+      },
+      "nativeDecodedPcmSha256": "e1c58aca6a4e6b13d373151f083a94be66336f1ea664eb691eb1aaeb3cf234db"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:361eb2581ace51a5a34c59d83c06ebe6dad73300115db995e6c0692fb4061ae3",
+      "chunkIndex": 3,
+      "frames": 1057881,
+      "expectedPcmSha256": "e1c58aca6a4e6b13d373151f083a94be66336f1ea664eb691eb1aaeb3cf234db",
+      "encodedBytes": 876850,
+      "elapsedMilliseconds": 91.5899329999811,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 300,
+        "maximumFrameSize": 7789,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1057881",
+        "md5Hex": "8751673efb6f8957d16ea3204f3c5165"
+      },
+      "nativeDecodedPcmSha256": "e1c58aca6a4e6b13d373151f083a94be66336f1ea664eb691eb1aaeb3cf234db"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "d65ddf96ef3551fdd5c08ca4a51b90f1c46ecb35544714d470119b2ba0c5cd63",
+      "encodedBytes": 1943412,
+      "elapsedMilliseconds": 430.750956999982,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1051,
+        "maximumFrameSize": 18491,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "0d61fa2572913812a15c20371f2bfb80"
+      },
+      "nativeDecodedPcmSha256": "d65ddf96ef3551fdd5c08ca4a51b90f1c46ecb35544714d470119b2ba0c5cd63"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "d65ddf96ef3551fdd5c08ca4a51b90f1c46ecb35544714d470119b2ba0c5cd63",
+      "encodedBytes": 1943384,
+      "elapsedMilliseconds": 115.64185300000827,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1051,
+        "maximumFrameSize": 18491,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "0d61fa2572913812a15c20371f2bfb80"
+      },
+      "nativeDecodedPcmSha256": "d65ddf96ef3551fdd5c08ca4a51b90f1c46ecb35544714d470119b2ba0c5cd63"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "ef94fcfe71b9f59da74d552ee67fd658841d8f4547eca40ef2a928d3431ecbbc",
+      "encodedBytes": 2803573,
+      "elapsedMilliseconds": 460.7830529999919,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1056,
+        "maximumFrameSize": 18346,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "689815531096c080e770d82660e1ccdc"
+      },
+      "nativeDecodedPcmSha256": "ef94fcfe71b9f59da74d552ee67fd658841d8f4547eca40ef2a928d3431ecbbc"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "ef94fcfe71b9f59da74d552ee67fd658841d8f4547eca40ef2a928d3431ecbbc",
+      "encodedBytes": 2803492,
+      "elapsedMilliseconds": 122.16678599998704,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1056,
+        "maximumFrameSize": 18346,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "689815531096c080e770d82660e1ccdc"
+      },
+      "nativeDecodedPcmSha256": "ef94fcfe71b9f59da74d552ee67fd658841d8f4547eca40ef2a928d3431ecbbc"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "836755243b06af4a9fa6dd26a38b6ecb486feddb013575b58f4ed55858794bbf",
+      "encodedBytes": 3690570,
+      "elapsedMilliseconds": 521.1459119999781,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1082,
+        "maximumFrameSize": 18247,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "7e11ce05b0f176124275621fbbeff0ab"
+      },
+      "nativeDecodedPcmSha256": "836755243b06af4a9fa6dd26a38b6ecb486feddb013575b58f4ed55858794bbf"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "836755243b06af4a9fa6dd26a38b6ecb486feddb013575b58f4ed55858794bbf",
+      "encodedBytes": 3690485,
+      "elapsedMilliseconds": 132.00917999999365,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1082,
+        "maximumFrameSize": 18247,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "7e11ce05b0f176124275621fbbeff0ab"
+      },
+      "nativeDecodedPcmSha256": "836755243b06af4a9fa6dd26a38b6ecb486feddb013575b58f4ed55858794bbf"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 3,
+      "frames": 1047609,
+      "expectedPcmSha256": "ad00f29b53ad6c3fbfa12672cb17168270becc5fb01419ef9ed530476756d725",
+      "encodedBytes": 3831622,
+      "elapsedMilliseconds": 442.34354599998915,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 807,
+        "maximumFrameSize": 19674,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1047609",
+        "md5Hex": "36fc61d6543e34a59df4d2ceb3d6678a"
+      },
+      "nativeDecodedPcmSha256": "ad00f29b53ad6c3fbfa12672cb17168270becc5fb01419ef9ed530476756d725"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:3d60f314574aed4bfafde8b53df7e0e555f367325ba6daad6ec8db9c4dee48c6",
+      "chunkIndex": 3,
+      "frames": 1047609,
+      "expectedPcmSha256": "ad00f29b53ad6c3fbfa12672cb17168270becc5fb01419ef9ed530476756d725",
+      "encodedBytes": 3831623,
+      "elapsedMilliseconds": 107.23821000001044,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 807,
+        "maximumFrameSize": 19674,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1047609",
+        "md5Hex": "36fc61d6543e34a59df4d2ceb3d6678a"
+      },
+      "nativeDecodedPcmSha256": "ad00f29b53ad6c3fbfa12672cb17168270becc5fb01419ef9ed530476756d725"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:43413b8b197ba8a6be8b706e5173fb5246f4c60c414557dc552d9c65239f9340",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "fda5317be1243b68e09d100738aae8d0d0b835e4b9c42222ceb8637f206fbd23",
+      "encodedBytes": 4695124,
+      "elapsedMilliseconds": 563.9263090000022,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1941,
+        "maximumFrameSize": 17360,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "0db7916b9afe1ba846cacae409fd3719"
+      },
+      "nativeDecodedPcmSha256": "fda5317be1243b68e09d100738aae8d0d0b835e4b9c42222ceb8637f206fbd23"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:43413b8b197ba8a6be8b706e5173fb5246f4c60c414557dc552d9c65239f9340",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "fda5317be1243b68e09d100738aae8d0d0b835e4b9c42222ceb8637f206fbd23",
+      "encodedBytes": 4695125,
+      "elapsedMilliseconds": 137.61219699998037,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1941,
+        "maximumFrameSize": 17360,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "0db7916b9afe1ba846cacae409fd3719"
+      },
+      "nativeDecodedPcmSha256": "fda5317be1243b68e09d100738aae8d0d0b835e4b9c42222ceb8637f206fbd23"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:43413b8b197ba8a6be8b706e5173fb5246f4c60c414557dc552d9c65239f9340",
+      "chunkIndex": 1,
+      "frames": 514531,
+      "expectedPcmSha256": "f12619a013d45d71b3261cc8eaa4bd5777f329942b6c0c49cbe8ca2a5fbc9878",
+      "encodedBytes": 1733385,
+      "elapsedMilliseconds": 219.5609879999829,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 16689,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "514531",
+        "md5Hex": "6ab71b21358d04a2bdd04f53483595e9"
+      },
+      "nativeDecodedPcmSha256": "f12619a013d45d71b3261cc8eaa4bd5777f329942b6c0c49cbe8ca2a5fbc9878"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:43413b8b197ba8a6be8b706e5173fb5246f4c60c414557dc552d9c65239f9340",
+      "chunkIndex": 1,
+      "frames": 514531,
+      "expectedPcmSha256": "f12619a013d45d71b3261cc8eaa4bd5777f329942b6c0c49cbe8ca2a5fbc9878",
+      "encodedBytes": 1733385,
+      "elapsedMilliseconds": 54.94457500000135,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 16689,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "514531",
+        "md5Hex": "6ab71b21358d04a2bdd04f53483595e9"
+      },
+      "nativeDecodedPcmSha256": "f12619a013d45d71b3261cc8eaa4bd5777f329942b6c0c49cbe8ca2a5fbc9878"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "1ac0d21a2979389605675c51b1da394d304bb096ed5b6f68ef8ffe0c41573dfa",
+      "encodedBytes": 2818457,
+      "elapsedMilliseconds": 406.4567939999979,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7866,
+        "maximumFrameSize": 19365,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "009617d337fbad5c9834b9ce0e370958"
+      },
+      "nativeDecodedPcmSha256": "1ac0d21a2979389605675c51b1da394d304bb096ed5b6f68ef8ffe0c41573dfa"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "1ac0d21a2979389605675c51b1da394d304bb096ed5b6f68ef8ffe0c41573dfa",
+      "encodedBytes": 2818457,
+      "elapsedMilliseconds": 115.98078900002292,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7866,
+        "maximumFrameSize": 19365,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "009617d337fbad5c9834b9ce0e370958"
+      },
+      "nativeDecodedPcmSha256": "1ac0d21a2979389605675c51b1da394d304bb096ed5b6f68ef8ffe0c41573dfa"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "3514cf02ee43289d552a33de6fc20dc9df401dec16291793e830998f6c9e24cb",
+      "encodedBytes": 3471032,
+      "elapsedMilliseconds": 467.4792910000251,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1972,
+        "maximumFrameSize": 19226,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "6dd907abc466119fefd0accda2e2dcac"
+      },
+      "nativeDecodedPcmSha256": "3514cf02ee43289d552a33de6fc20dc9df401dec16291793e830998f6c9e24cb"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "3514cf02ee43289d552a33de6fc20dc9df401dec16291793e830998f6c9e24cb",
+      "encodedBytes": 3471032,
+      "elapsedMilliseconds": 121.53450100001646,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1972,
+        "maximumFrameSize": 19226,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "6dd907abc466119fefd0accda2e2dcac"
+      },
+      "nativeDecodedPcmSha256": "3514cf02ee43289d552a33de6fc20dc9df401dec16291793e830998f6c9e24cb"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "37b45f881e3898b1d03385bc0f9d130454c43830970bdb853803acccc5ae742e",
+      "encodedBytes": 4148907,
+      "elapsedMilliseconds": 486.32719499999075,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7964,
+        "maximumFrameSize": 20117,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "e7ce31ef6a7fc8d270923fa69283407a"
+      },
+      "nativeDecodedPcmSha256": "37b45f881e3898b1d03385bc0f9d130454c43830970bdb853803acccc5ae742e"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "37b45f881e3898b1d03385bc0f9d130454c43830970bdb853803acccc5ae742e",
+      "encodedBytes": 4148907,
+      "elapsedMilliseconds": 128.0330740000063,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7964,
+        "maximumFrameSize": 20117,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "e7ce31ef6a7fc8d270923fa69283407a"
+      },
+      "nativeDecodedPcmSha256": "37b45f881e3898b1d03385bc0f9d130454c43830970bdb853803acccc5ae742e"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "3d18c069e8d2ab8caddba535d0c8e83e593f350ad8a43728b357745f7b510f18",
+      "encodedBytes": 3908126,
+      "elapsedMilliseconds": 474.38686200001393,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7938,
+        "maximumFrameSize": 18062,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f72b873a9cfcdecb8bffca82dfea5b08"
+      },
+      "nativeDecodedPcmSha256": "3d18c069e8d2ab8caddba535d0c8e83e593f350ad8a43728b357745f7b510f18"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "3d18c069e8d2ab8caddba535d0c8e83e593f350ad8a43728b357745f7b510f18",
+      "encodedBytes": 3908126,
+      "elapsedMilliseconds": 126.76086999999825,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7938,
+        "maximumFrameSize": 18062,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f72b873a9cfcdecb8bffca82dfea5b08"
+      },
+      "nativeDecodedPcmSha256": "3d18c069e8d2ab8caddba535d0c8e83e593f350ad8a43728b357745f7b510f18"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "361efaa716a4c5a8e7cd18811f99fc1da378df26a01639a0c96da726a2fdc27c",
+      "encodedBytes": 4140983,
+      "elapsedMilliseconds": 540.1280300000217,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7912,
+        "maximumFrameSize": 16656,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "47515984c7da3d9064aa8594b71effda"
+      },
+      "nativeDecodedPcmSha256": "361efaa716a4c5a8e7cd18811f99fc1da378df26a01639a0c96da726a2fdc27c"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "361efaa716a4c5a8e7cd18811f99fc1da378df26a01639a0c96da726a2fdc27c",
+      "encodedBytes": 4140983,
+      "elapsedMilliseconds": 133.08079199999338,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7912,
+        "maximumFrameSize": 16656,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "47515984c7da3d9064aa8594b71effda"
+      },
+      "nativeDecodedPcmSha256": "361efaa716a4c5a8e7cd18811f99fc1da378df26a01639a0c96da726a2fdc27c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "dd0019f65cb14a6c5f4712f7b96750b71598a71f70c70cd0fbdb110b94954bc3",
+      "encodedBytes": 2579361,
+      "elapsedMilliseconds": 407.12095799998497,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7912,
+        "maximumFrameSize": 8037,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b850669f2d0338f0745d888777563278"
+      },
+      "nativeDecodedPcmSha256": "dd0019f65cb14a6c5f4712f7b96750b71598a71f70c70cd0fbdb110b94954bc3"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "dd0019f65cb14a6c5f4712f7b96750b71598a71f70c70cd0fbdb110b94954bc3",
+      "encodedBytes": 2579361,
+      "elapsedMilliseconds": 113.51368800000637,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7912,
+        "maximumFrameSize": 8037,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b850669f2d0338f0745d888777563278"
+      },
+      "nativeDecodedPcmSha256": "dd0019f65cb14a6c5f4712f7b96750b71598a71f70c70cd0fbdb110b94954bc3"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "e4a0b2b5384e5289ceff5b3ad42ccff678ab6a5d77c96e07a78147a5ed3770a2",
+      "encodedBytes": 1094710,
+      "elapsedMilliseconds": 167.65299899998354,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7866,
+        "maximumFrameSize": 8030,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "1a6ac668bc13ddfb53097b30403ed296"
+      },
+      "nativeDecodedPcmSha256": "e4a0b2b5384e5289ceff5b3ad42ccff678ab6a5d77c96e07a78147a5ed3770a2"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:462c511e3c244e805eeaf8c592c2cf35b8e9e9fab0d3074aad52e7304e6572f6",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "e4a0b2b5384e5289ceff5b3ad42ccff678ab6a5d77c96e07a78147a5ed3770a2",
+      "encodedBytes": 1094710,
+      "elapsedMilliseconds": 49.65484599999036,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7866,
+        "maximumFrameSize": 8030,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "1a6ac668bc13ddfb53097b30403ed296"
+      },
+      "nativeDecodedPcmSha256": "e4a0b2b5384e5289ceff5b3ad42ccff678ab6a5d77c96e07a78147a5ed3770a2"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "36c35e82c4c4668b94b037bd2e468dbe0abda7fa866332743117f68f21952c22",
+      "encodedBytes": 4309543,
+      "elapsedMilliseconds": 508.8771809999889,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7915,
+        "maximumFrameSize": 17039,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5b8c234ab79476974554162d38196754"
+      },
+      "nativeDecodedPcmSha256": "36c35e82c4c4668b94b037bd2e468dbe0abda7fa866332743117f68f21952c22"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "36c35e82c4c4668b94b037bd2e468dbe0abda7fa866332743117f68f21952c22",
+      "encodedBytes": 4309544,
+      "elapsedMilliseconds": 127.51011699999799,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7915,
+        "maximumFrameSize": 17039,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5b8c234ab79476974554162d38196754"
+      },
+      "nativeDecodedPcmSha256": "36c35e82c4c4668b94b037bd2e468dbe0abda7fa866332743117f68f21952c22"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "9302ab132a16c115924a43d8f99697f902716f84953826be93722c923fcf2a2f",
+      "encodedBytes": 4041083,
+      "elapsedMilliseconds": 450.1103019999864,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5844,
+        "maximumFrameSize": 17267,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "16509c14a7dad38c60ac5f0fbd9eda83"
+      },
+      "nativeDecodedPcmSha256": "9302ab132a16c115924a43d8f99697f902716f84953826be93722c923fcf2a2f"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "9302ab132a16c115924a43d8f99697f902716f84953826be93722c923fcf2a2f",
+      "encodedBytes": 4041083,
+      "elapsedMilliseconds": 120.56276900001103,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5844,
+        "maximumFrameSize": 17267,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "16509c14a7dad38c60ac5f0fbd9eda83"
+      },
+      "nativeDecodedPcmSha256": "9302ab132a16c115924a43d8f99697f902716f84953826be93722c923fcf2a2f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "ead9d5ed0901c2d7a3d05525b352da2320551902855748160e84adaceda9b141",
+      "encodedBytes": 3563199,
+      "elapsedMilliseconds": 502.79546200000914,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7951,
+        "maximumFrameSize": 17209,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f9e21993a37ef66f175e13c13ca5d81a"
+      },
+      "nativeDecodedPcmSha256": "ead9d5ed0901c2d7a3d05525b352da2320551902855748160e84adaceda9b141"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "ead9d5ed0901c2d7a3d05525b352da2320551902855748160e84adaceda9b141",
+      "encodedBytes": 3563202,
+      "elapsedMilliseconds": 126.48976299999049,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7951,
+        "maximumFrameSize": 17209,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f9e21993a37ef66f175e13c13ca5d81a"
+      },
+      "nativeDecodedPcmSha256": "ead9d5ed0901c2d7a3d05525b352da2320551902855748160e84adaceda9b141"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "877ac4eb84976e6047201d0e4e19c27bfa9ea2b04c3564bfffad2eb97105d9b8",
+      "encodedBytes": 5437467,
+      "elapsedMilliseconds": 493.6806340000185,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8085,
+        "maximumFrameSize": 19284,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "cdd1b064a9f36d6376a7885b13079fe7"
+      },
+      "nativeDecodedPcmSha256": "877ac4eb84976e6047201d0e4e19c27bfa9ea2b04c3564bfffad2eb97105d9b8"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "877ac4eb84976e6047201d0e4e19c27bfa9ea2b04c3564bfffad2eb97105d9b8",
+      "encodedBytes": 5437466,
+      "elapsedMilliseconds": 127.36317699999199,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8085,
+        "maximumFrameSize": 19284,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "cdd1b064a9f36d6376a7885b13079fe7"
+      },
+      "nativeDecodedPcmSha256": "877ac4eb84976e6047201d0e4e19c27bfa9ea2b04c3564bfffad2eb97105d9b8"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "414909b9b21f0017c65c62b309a685ccbd4dcb7c896c25fa86f5e6814426f3a9",
+      "encodedBytes": 5382397,
+      "elapsedMilliseconds": 516.1297399999748,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 4895,
+        "maximumFrameSize": 18771,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "bda5a890031144fbeef2a42f67d3212e"
+      },
+      "nativeDecodedPcmSha256": "414909b9b21f0017c65c62b309a685ccbd4dcb7c896c25fa86f5e6814426f3a9"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "414909b9b21f0017c65c62b309a685ccbd4dcb7c896c25fa86f5e6814426f3a9",
+      "encodedBytes": 5382399,
+      "elapsedMilliseconds": 131.15460099998745,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 4895,
+        "maximumFrameSize": 18771,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "bda5a890031144fbeef2a42f67d3212e"
+      },
+      "nativeDecodedPcmSha256": "414909b9b21f0017c65c62b309a685ccbd4dcb7c896c25fa86f5e6814426f3a9"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "a9aaae89159b3bc3a8ae7b343cee86ceccad6e9156bd051a7907244333351b1f",
+      "encodedBytes": 2606507,
+      "elapsedMilliseconds": 408.2846839999838,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7902,
+        "maximumFrameSize": 9888,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "89db8adaf0c4183346702ead7c61f734"
+      },
+      "nativeDecodedPcmSha256": "a9aaae89159b3bc3a8ae7b343cee86ceccad6e9156bd051a7907244333351b1f"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "a9aaae89159b3bc3a8ae7b343cee86ceccad6e9156bd051a7907244333351b1f",
+      "encodedBytes": 2606507,
+      "elapsedMilliseconds": 114.10565499999211,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7902,
+        "maximumFrameSize": 9888,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "89db8adaf0c4183346702ead7c61f734"
+      },
+      "nativeDecodedPcmSha256": "a9aaae89159b3bc3a8ae7b343cee86ceccad6e9156bd051a7907244333351b1f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "1f54adca35b28601e714e675e5f666f57dfc0735aeb743bc06977b8da0a786e1",
+      "encodedBytes": 1093892,
+      "elapsedMilliseconds": 193.55036399999517,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7894,
+        "maximumFrameSize": 8026,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "e0ab70a4e3a8d9e373f720d5e52cfa68"
+      },
+      "nativeDecodedPcmSha256": "1f54adca35b28601e714e675e5f666f57dfc0735aeb743bc06977b8da0a786e1"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:68f41fc0dfa18e77e77ab99f931dc647d9b1c3d60afd981f9b4917c85986532f",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "1f54adca35b28601e714e675e5f666f57dfc0735aeb743bc06977b8da0a786e1",
+      "encodedBytes": 1093892,
+      "elapsedMilliseconds": 49.325628999999026,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7894,
+        "maximumFrameSize": 8026,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "e0ab70a4e3a8d9e373f720d5e52cfa68"
+      },
+      "nativeDecodedPcmSha256": "1f54adca35b28601e714e675e5f666f57dfc0735aeb743bc06977b8da0a786e1"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "65c8f28f921e06d2876ffa35765fefdeaefdfdbef66cdec9b4fda6c837106fc0",
+      "encodedBytes": 2211375,
+      "elapsedMilliseconds": 420.8463500000071,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1548,
+        "maximumFrameSize": 19561,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "852cbcac74613c45cf711c3e56a40ed6"
+      },
+      "nativeDecodedPcmSha256": "65c8f28f921e06d2876ffa35765fefdeaefdfdbef66cdec9b4fda6c837106fc0"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "65c8f28f921e06d2876ffa35765fefdeaefdfdbef66cdec9b4fda6c837106fc0",
+      "encodedBytes": 2211379,
+      "elapsedMilliseconds": 112.15228300000308,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1548,
+        "maximumFrameSize": 19561,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "852cbcac74613c45cf711c3e56a40ed6"
+      },
+      "nativeDecodedPcmSha256": "65c8f28f921e06d2876ffa35765fefdeaefdfdbef66cdec9b4fda6c837106fc0"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "42b9fdbea63544f90e683df82058eca4c5dca23bc3539047be92cf12a7c6d136",
+      "encodedBytes": 2322751,
+      "elapsedMilliseconds": 516.9594989999896,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 2092,
+        "maximumFrameSize": 19334,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "93eaab0be30ed181b4cea3e225c6544e"
+      },
+      "nativeDecodedPcmSha256": "42b9fdbea63544f90e683df82058eca4c5dca23bc3539047be92cf12a7c6d136"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "42b9fdbea63544f90e683df82058eca4c5dca23bc3539047be92cf12a7c6d136",
+      "encodedBytes": 2322749,
+      "elapsedMilliseconds": 126.2126939999871,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 2092,
+        "maximumFrameSize": 19334,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "93eaab0be30ed181b4cea3e225c6544e"
+      },
+      "nativeDecodedPcmSha256": "42b9fdbea63544f90e683df82058eca4c5dca23bc3539047be92cf12a7c6d136"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "fb3896dd6372aa0b8a3f68df45483ea73b28a18712fffcdf18897ee0a3205b8c",
+      "encodedBytes": 4591316,
+      "elapsedMilliseconds": 583.2217200000014,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1187,
+        "maximumFrameSize": 20319,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f9ffaea4787abb17141be3bb2706da0c"
+      },
+      "nativeDecodedPcmSha256": "fb3896dd6372aa0b8a3f68df45483ea73b28a18712fffcdf18897ee0a3205b8c"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "fb3896dd6372aa0b8a3f68df45483ea73b28a18712fffcdf18897ee0a3205b8c",
+      "encodedBytes": 4591315,
+      "elapsedMilliseconds": 135.26238800000283,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1187,
+        "maximumFrameSize": 20319,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f9ffaea4787abb17141be3bb2706da0c"
+      },
+      "nativeDecodedPcmSha256": "fb3896dd6372aa0b8a3f68df45483ea73b28a18712fffcdf18897ee0a3205b8c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 3,
+      "frames": 1046796,
+      "expectedPcmSha256": "712b3b3d76c5042a314846332371f806367b0f8fe2d9f5a0f26f7e234719402f",
+      "encodedBytes": 2390904,
+      "elapsedMilliseconds": 319.82812099999865,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1139,
+        "maximumFrameSize": 19646,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1046796",
+        "md5Hex": "ef20b4d4539a89c71fb61fbfb3974dd9"
+      },
+      "nativeDecodedPcmSha256": "712b3b3d76c5042a314846332371f806367b0f8fe2d9f5a0f26f7e234719402f"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:75e819632163ccc65f63fde122cea33b199b559c931ebf68b14b5f8c72520629",
+      "chunkIndex": 3,
+      "frames": 1046796,
+      "expectedPcmSha256": "712b3b3d76c5042a314846332371f806367b0f8fe2d9f5a0f26f7e234719402f",
+      "encodedBytes": 2390904,
+      "elapsedMilliseconds": 91.23094799998216,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1139,
+        "maximumFrameSize": 19646,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1046796",
+        "md5Hex": "ef20b4d4539a89c71fb61fbfb3974dd9"
+      },
+      "nativeDecodedPcmSha256": "712b3b3d76c5042a314846332371f806367b0f8fe2d9f5a0f26f7e234719402f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:76f8d36d4b2b6ed2efc19418250feaac1fe1868fd919c4c03a6e6f66e3e3f926",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "23c396618176630bd3af2e08a196598454feb5cc088b2f3430eb99dc7b631228",
+      "encodedBytes": 4937137,
+      "elapsedMilliseconds": 464.56901000000653,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 10236,
+        "maximumFrameSize": 17583,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5307bab8edc1efd9a497689333954d72"
+      },
+      "nativeDecodedPcmSha256": "23c396618176630bd3af2e08a196598454feb5cc088b2f3430eb99dc7b631228"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:76f8d36d4b2b6ed2efc19418250feaac1fe1868fd919c4c03a6e6f66e3e3f926",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "23c396618176630bd3af2e08a196598454feb5cc088b2f3430eb99dc7b631228",
+      "encodedBytes": 4937137,
+      "elapsedMilliseconds": 123.60180899998522,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 10236,
+        "maximumFrameSize": 17583,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5307bab8edc1efd9a497689333954d72"
+      },
+      "nativeDecodedPcmSha256": "23c396618176630bd3af2e08a196598454feb5cc088b2f3430eb99dc7b631228"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:76f8d36d4b2b6ed2efc19418250feaac1fe1868fd919c4c03a6e6f66e3e3f926",
+      "chunkIndex": 1,
+      "frames": 582102,
+      "expectedPcmSha256": "b6f8c245441b191497cbe43678526f07a8c3d3cc12db92b88017a783d6aed512",
+      "encodedBytes": 2125904,
+      "elapsedMilliseconds": 199.1306860000186,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 504,
+        "maximumFrameSize": 18089,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "582102",
+        "md5Hex": "a97591cbcdd1cbc312ddbc3e1bcb87fc"
+      },
+      "nativeDecodedPcmSha256": "b6f8c245441b191497cbe43678526f07a8c3d3cc12db92b88017a783d6aed512"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:76f8d36d4b2b6ed2efc19418250feaac1fe1868fd919c4c03a6e6f66e3e3f926",
+      "chunkIndex": 1,
+      "frames": 582102,
+      "expectedPcmSha256": "b6f8c245441b191497cbe43678526f07a8c3d3cc12db92b88017a783d6aed512",
+      "encodedBytes": 2125904,
+      "elapsedMilliseconds": 54.337377999996534,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 504,
+        "maximumFrameSize": 18089,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "582102",
+        "md5Hex": "a97591cbcdd1cbc312ddbc3e1bcb87fc"
+      },
+      "nativeDecodedPcmSha256": "b6f8c245441b191497cbe43678526f07a8c3d3cc12db92b88017a783d6aed512"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:820926ccc8557b4cdf81d0c19933f1115dc371d5b53e46ddedb2a87bf4e4e197",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "024d2eb37862cb6bf6db15b26958f67a4652050a28172bcba4679dd104adab6f",
+      "encodedBytes": 3873752,
+      "elapsedMilliseconds": 537.7096759999986,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 16786,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9b443230fb327c1c66f044b6506908bb"
+      },
+      "nativeDecodedPcmSha256": "024d2eb37862cb6bf6db15b26958f67a4652050a28172bcba4679dd104adab6f"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:820926ccc8557b4cdf81d0c19933f1115dc371d5b53e46ddedb2a87bf4e4e197",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "024d2eb37862cb6bf6db15b26958f67a4652050a28172bcba4679dd104adab6f",
+      "encodedBytes": 3873792,
+      "elapsedMilliseconds": 134.04152100000647,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 16786,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "9b443230fb327c1c66f044b6506908bb"
+      },
+      "nativeDecodedPcmSha256": "024d2eb37862cb6bf6db15b26958f67a4652050a28172bcba4679dd104adab6f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:820926ccc8557b4cdf81d0c19933f1115dc371d5b53e46ddedb2a87bf4e4e197",
+      "chunkIndex": 1,
+      "frames": 1201590,
+      "expectedPcmSha256": "125a5e3e22686866f06b6135bc7113921c4b1c3be48bd955ac301d573abf4483",
+      "encodedBytes": 3785562,
+      "elapsedMilliseconds": 505.754277,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 204,
+        "maximumFrameSize": 17630,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1201590",
+        "md5Hex": "b3af88adf8c285751886ec5c7f89058c"
+      },
+      "nativeDecodedPcmSha256": "125a5e3e22686866f06b6135bc7113921c4b1c3be48bd955ac301d573abf4483"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:820926ccc8557b4cdf81d0c19933f1115dc371d5b53e46ddedb2a87bf4e4e197",
+      "chunkIndex": 1,
+      "frames": 1201590,
+      "expectedPcmSha256": "125a5e3e22686866f06b6135bc7113921c4b1c3be48bd955ac301d573abf4483",
+      "encodedBytes": 3785565,
+      "elapsedMilliseconds": 131.79777599999215,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 204,
+        "maximumFrameSize": 17630,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1201590",
+        "md5Hex": "b3af88adf8c285751886ec5c7f89058c"
+      },
+      "nativeDecodedPcmSha256": "125a5e3e22686866f06b6135bc7113921c4b1c3be48bd955ac301d573abf4483"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "a0bf84dc4c81916ccd105c692da94fff0a59d39a8154eb6c266a278fb3bd2762",
+      "encodedBytes": 4192669,
+      "elapsedMilliseconds": 440.0777919999964,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 11422,
+        "maximumFrameSize": 18306,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5b4ba26d280febae8940b7569d82f82d"
+      },
+      "nativeDecodedPcmSha256": "a0bf84dc4c81916ccd105c692da94fff0a59d39a8154eb6c266a278fb3bd2762"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "a0bf84dc4c81916ccd105c692da94fff0a59d39a8154eb6c266a278fb3bd2762",
+      "encodedBytes": 4192669,
+      "elapsedMilliseconds": 121.2851049999881,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 11422,
+        "maximumFrameSize": 18306,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5b4ba26d280febae8940b7569d82f82d"
+      },
+      "nativeDecodedPcmSha256": "a0bf84dc4c81916ccd105c692da94fff0a59d39a8154eb6c266a278fb3bd2762"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "0bca03d3827a10f809d4f15d1bb053e182507deaeec754edb0e9aed2f795d58f",
+      "encodedBytes": 4848686,
+      "elapsedMilliseconds": 524.3369439999806,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 11453,
+        "maximumFrameSize": 18073,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "510cd4f30db1b7a6acf0bbca4df9b291"
+      },
+      "nativeDecodedPcmSha256": "0bca03d3827a10f809d4f15d1bb053e182507deaeec754edb0e9aed2f795d58f"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "0bca03d3827a10f809d4f15d1bb053e182507deaeec754edb0e9aed2f795d58f",
+      "encodedBytes": 4848686,
+      "elapsedMilliseconds": 130.5232370000158,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 11453,
+        "maximumFrameSize": 18073,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "510cd4f30db1b7a6acf0bbca4df9b291"
+      },
+      "nativeDecodedPcmSha256": "0bca03d3827a10f809d4f15d1bb053e182507deaeec754edb0e9aed2f795d58f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "a4ff8fea4e0de7fa60fdae51ad711cd91f037cb46d5a9349bf1dca02acbbc5f5",
+      "encodedBytes": 4526232,
+      "elapsedMilliseconds": 504.29602700000396,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 11459,
+        "maximumFrameSize": 17182,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d8b635c44ececa10b608234674a067d8"
+      },
+      "nativeDecodedPcmSha256": "a4ff8fea4e0de7fa60fdae51ad711cd91f037cb46d5a9349bf1dca02acbbc5f5"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "a4ff8fea4e0de7fa60fdae51ad711cd91f037cb46d5a9349bf1dca02acbbc5f5",
+      "encodedBytes": 4526232,
+      "elapsedMilliseconds": 129.72507600000245,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 11459,
+        "maximumFrameSize": 17182,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d8b635c44ececa10b608234674a067d8"
+      },
+      "nativeDecodedPcmSha256": "a4ff8fea4e0de7fa60fdae51ad711cd91f037cb46d5a9349bf1dca02acbbc5f5"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "8f216c2fb91fd3ca55f340129e429be43b6026756b830491ef476ced4bce86ab",
+      "encodedBytes": 4906482,
+      "elapsedMilliseconds": 518.4131360000174,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 2388,
+        "maximumFrameSize": 18391,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "21ee978805ca43cda3cd06f8cda52115"
+      },
+      "nativeDecodedPcmSha256": "8f216c2fb91fd3ca55f340129e429be43b6026756b830491ef476ced4bce86ab"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "8f216c2fb91fd3ca55f340129e429be43b6026756b830491ef476ced4bce86ab",
+      "encodedBytes": 4906478,
+      "elapsedMilliseconds": 132.02288500001305,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 2388,
+        "maximumFrameSize": 18391,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "21ee978805ca43cda3cd06f8cda52115"
+      },
+      "nativeDecodedPcmSha256": "8f216c2fb91fd3ca55f340129e429be43b6026756b830491ef476ced4bce86ab"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "2206e4ac690835dbfca27792f1a86ace07f1ba2690e226e56f6e741e07e8f2e8",
+      "encodedBytes": 4753432,
+      "elapsedMilliseconds": 579.8530570000003,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6945,
+        "maximumFrameSize": 19944,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f0d8a1b4dee3452819937b1150c61245"
+      },
+      "nativeDecodedPcmSha256": "2206e4ac690835dbfca27792f1a86ace07f1ba2690e226e56f6e741e07e8f2e8"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "2206e4ac690835dbfca27792f1a86ace07f1ba2690e226e56f6e741e07e8f2e8",
+      "encodedBytes": 4753431,
+      "elapsedMilliseconds": 135.4049890000024,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6945,
+        "maximumFrameSize": 19944,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f0d8a1b4dee3452819937b1150c61245"
+      },
+      "nativeDecodedPcmSha256": "2206e4ac690835dbfca27792f1a86ace07f1ba2690e226e56f6e741e07e8f2e8"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 5,
+      "frames": 1102500,
+      "expectedPcmSha256": "94d4191d8b99b19a6302a3ea00e8676f4391837f5f323c6eda44ce43119af8ce",
+      "encodedBytes": 3562930,
+      "elapsedMilliseconds": 442.1694060000009,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 419,
+        "maximumFrameSize": 20222,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1102500",
+        "md5Hex": "7d943016a2b411fbf33b8cab0b35910e"
+      },
+      "nativeDecodedPcmSha256": "94d4191d8b99b19a6302a3ea00e8676f4391837f5f323c6eda44ce43119af8ce"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:83cc4bfabbda2bb1b0b9fda8bfc7307d190844be9e01cd8ed53b2b904369b147",
+      "chunkIndex": 5,
+      "frames": 1102500,
+      "expectedPcmSha256": "94d4191d8b99b19a6302a3ea00e8676f4391837f5f323c6eda44ce43119af8ce",
+      "encodedBytes": 3562872,
+      "elapsedMilliseconds": 120.11665800001356,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 419,
+        "maximumFrameSize": 20222,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1102500",
+        "md5Hex": "7d943016a2b411fbf33b8cab0b35910e"
+      },
+      "nativeDecodedPcmSha256": "94d4191d8b99b19a6302a3ea00e8676f4391837f5f323c6eda44ce43119af8ce"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "a55e83e9d57a7e0b8a02c1589c368946d107e6fe45bf27732ce74cbf2cf1de14",
+      "encodedBytes": 2577349,
+      "elapsedMilliseconds": 394.37650899999426,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7745,
+        "maximumFrameSize": 8051,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "65d5924a754ff00c55d25d5f7706de7f"
+      },
+      "nativeDecodedPcmSha256": "a55e83e9d57a7e0b8a02c1589c368946d107e6fe45bf27732ce74cbf2cf1de14"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "a55e83e9d57a7e0b8a02c1589c368946d107e6fe45bf27732ce74cbf2cf1de14",
+      "encodedBytes": 2577349,
+      "elapsedMilliseconds": 113.64611800000421,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7745,
+        "maximumFrameSize": 8051,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "65d5924a754ff00c55d25d5f7706de7f"
+      },
+      "nativeDecodedPcmSha256": "a55e83e9d57a7e0b8a02c1589c368946d107e6fe45bf27732ce74cbf2cf1de14"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "2174a88c16a1582e995c5069a5f2887dbfd8b93a7cbd2b3c773cca9811be4835",
+      "encodedBytes": 3617407,
+      "elapsedMilliseconds": 491.3541850000038,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1952,
+        "maximumFrameSize": 16398,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "c1e031e278a7feff877baa055ebfce21"
+      },
+      "nativeDecodedPcmSha256": "2174a88c16a1582e995c5069a5f2887dbfd8b93a7cbd2b3c773cca9811be4835"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "2174a88c16a1582e995c5069a5f2887dbfd8b93a7cbd2b3c773cca9811be4835",
+      "encodedBytes": 3617407,
+      "elapsedMilliseconds": 126.74889499999699,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1952,
+        "maximumFrameSize": 16398,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "c1e031e278a7feff877baa055ebfce21"
+      },
+      "nativeDecodedPcmSha256": "2174a88c16a1582e995c5069a5f2887dbfd8b93a7cbd2b3c773cca9811be4835"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "9918d016f7c301fc23b8db32bc93184a134378824b8cdb7b3d76348b5d739dcc",
+      "encodedBytes": 3991391,
+      "elapsedMilliseconds": 520.4843010000186,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7966,
+        "maximumFrameSize": 16107,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2e2522b2dea00fdbff7d281e86ec99ad"
+      },
+      "nativeDecodedPcmSha256": "9918d016f7c301fc23b8db32bc93184a134378824b8cdb7b3d76348b5d739dcc"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "9918d016f7c301fc23b8db32bc93184a134378824b8cdb7b3d76348b5d739dcc",
+      "encodedBytes": 3991391,
+      "elapsedMilliseconds": 130.21447800000897,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7966,
+        "maximumFrameSize": 16107,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2e2522b2dea00fdbff7d281e86ec99ad"
+      },
+      "nativeDecodedPcmSha256": "9918d016f7c301fc23b8db32bc93184a134378824b8cdb7b3d76348b5d739dcc"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "1ecf66d2439e4d20cbe4ff066e34944b60652831ec88cb6a3ddd8fbae4be5832",
+      "encodedBytes": 3034301,
+      "elapsedMilliseconds": 430.1726249999774,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7959,
+        "maximumFrameSize": 11026,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2ca55659b0c0c12029977a3020fd2187"
+      },
+      "nativeDecodedPcmSha256": "1ecf66d2439e4d20cbe4ff066e34944b60652831ec88cb6a3ddd8fbae4be5832"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "1ecf66d2439e4d20cbe4ff066e34944b60652831ec88cb6a3ddd8fbae4be5832",
+      "encodedBytes": 3034301,
+      "elapsedMilliseconds": 117.57390200000373,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7959,
+        "maximumFrameSize": 11026,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2ca55659b0c0c12029977a3020fd2187"
+      },
+      "nativeDecodedPcmSha256": "1ecf66d2439e4d20cbe4ff066e34944b60652831ec88cb6a3ddd8fbae4be5832"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "00aae3147503f28168368f37d8f2fb603194a4fa8efa2b675b75792282976d98",
+      "encodedBytes": 4949257,
+      "elapsedMilliseconds": 582.7534420000156,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8171,
+        "maximumFrameSize": 16546,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "81235cfc81a4e37833e3ab0b612dd7ad"
+      },
+      "nativeDecodedPcmSha256": "00aae3147503f28168368f37d8f2fb603194a4fa8efa2b675b75792282976d98"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "00aae3147503f28168368f37d8f2fb603194a4fa8efa2b675b75792282976d98",
+      "encodedBytes": 4949256,
+      "elapsedMilliseconds": 141.57407300002524,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8171,
+        "maximumFrameSize": 16546,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "81235cfc81a4e37833e3ab0b612dd7ad"
+      },
+      "nativeDecodedPcmSha256": "00aae3147503f28168368f37d8f2fb603194a4fa8efa2b675b75792282976d98"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "92612943d9be9bb9339bf5ab99071d5b42a606add5b2d8d0316702c0cfddb6da",
+      "encodedBytes": 2613579,
+      "elapsedMilliseconds": 411.6471759999986,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7928,
+        "maximumFrameSize": 8257,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "071cfccfae1495e8786fea88af04f2fd"
+      },
+      "nativeDecodedPcmSha256": "92612943d9be9bb9339bf5ab99071d5b42a606add5b2d8d0316702c0cfddb6da"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "92612943d9be9bb9339bf5ab99071d5b42a606add5b2d8d0316702c0cfddb6da",
+      "encodedBytes": 2613579,
+      "elapsedMilliseconds": 115.47790800000075,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7928,
+        "maximumFrameSize": 8257,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "071cfccfae1495e8786fea88af04f2fd"
+      },
+      "nativeDecodedPcmSha256": "92612943d9be9bb9339bf5ab99071d5b42a606add5b2d8d0316702c0cfddb6da"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "c28846b24eb143541dfa6661d24ec39cf492210d147cc6af216f98a6d7184e12",
+      "encodedBytes": 1108585,
+      "elapsedMilliseconds": 175.68633299999055,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7906,
+        "maximumFrameSize": 8224,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "012effc1b8d5e01259d60b79584a1192"
+      },
+      "nativeDecodedPcmSha256": "c28846b24eb143541dfa6661d24ec39cf492210d147cc6af216f98a6d7184e12"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:8b374c1219541d61371b2eacf78d1ddd01acf4e9e7422b369044f7c1df5475e1",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "c28846b24eb143541dfa6661d24ec39cf492210d147cc6af216f98a6d7184e12",
+      "encodedBytes": 1108585,
+      "elapsedMilliseconds": 50.125250999990385,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7906,
+        "maximumFrameSize": 8224,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "012effc1b8d5e01259d60b79584a1192"
+      },
+      "nativeDecodedPcmSha256": "c28846b24eb143541dfa6661d24ec39cf492210d147cc6af216f98a6d7184e12"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "d8821208237f3f366dc6126255ccaeee18763a71346ac327e7e8eb0a254f1ab2",
+      "encodedBytes": 2367250,
+      "elapsedMilliseconds": 407.55399600000237,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 20391,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "3d61c3e2e8546136541599bab97164ac"
+      },
+      "nativeDecodedPcmSha256": "d8821208237f3f366dc6126255ccaeee18763a71346ac327e7e8eb0a254f1ab2"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "d8821208237f3f366dc6126255ccaeee18763a71346ac327e7e8eb0a254f1ab2",
+      "encodedBytes": 2367250,
+      "elapsedMilliseconds": 115.0047959999938,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 20391,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "3d61c3e2e8546136541599bab97164ac"
+      },
+      "nativeDecodedPcmSha256": "d8821208237f3f366dc6126255ccaeee18763a71346ac327e7e8eb0a254f1ab2"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "099b094dc0a74b685de3e0642a5fd801b328cadb5e794248d39e7c9f73161362",
+      "encodedBytes": 2658138,
+      "elapsedMilliseconds": 436.4205699999875,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1044,
+        "maximumFrameSize": 20238,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "4ce8d2781a93a27607c0f0146fe1d9a2"
+      },
+      "nativeDecodedPcmSha256": "099b094dc0a74b685de3e0642a5fd801b328cadb5e794248d39e7c9f73161362"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "099b094dc0a74b685de3e0642a5fd801b328cadb5e794248d39e7c9f73161362",
+      "encodedBytes": 2658137,
+      "elapsedMilliseconds": 120.87087400001474,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1044,
+        "maximumFrameSize": 20238,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "4ce8d2781a93a27607c0f0146fe1d9a2"
+      },
+      "nativeDecodedPcmSha256": "099b094dc0a74b685de3e0642a5fd801b328cadb5e794248d39e7c9f73161362"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "947a4950af1a258c381417d8510da94dd114723b65611f3ae8de07587b0f4726",
+      "encodedBytes": 3781308,
+      "elapsedMilliseconds": 485.57625300000655,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 20802,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f3e691578150457b93be115a6d7b31f4"
+      },
+      "nativeDecodedPcmSha256": "947a4950af1a258c381417d8510da94dd114723b65611f3ae8de07587b0f4726"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "947a4950af1a258c381417d8510da94dd114723b65611f3ae8de07587b0f4726",
+      "encodedBytes": 3781317,
+      "elapsedMilliseconds": 127.83508399999118,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 20802,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f3e691578150457b93be115a6d7b31f4"
+      },
+      "nativeDecodedPcmSha256": "947a4950af1a258c381417d8510da94dd114723b65611f3ae8de07587b0f4726"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 3,
+      "frames": 916741,
+      "expectedPcmSha256": "1704ebcf5b3c81b703e1ecda346ebfc12a84421a0a83ccb9a75b7a53ddabc86c",
+      "encodedBytes": 2509206,
+      "elapsedMilliseconds": 324.0658929999918,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 20623,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "916741",
+        "md5Hex": "b28f2ba706e0f797f80ef1c129fc1519"
+      },
+      "nativeDecodedPcmSha256": "1704ebcf5b3c81b703e1ecda346ebfc12a84421a0a83ccb9a75b7a53ddabc86c"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:8faf64b1ebce116931951541fcb35fd000fc9b5f929ae15e47c30ae8666b76a0",
+      "chunkIndex": 3,
+      "frames": 916741,
+      "expectedPcmSha256": "1704ebcf5b3c81b703e1ecda346ebfc12a84421a0a83ccb9a75b7a53ddabc86c",
+      "encodedBytes": 2509207,
+      "elapsedMilliseconds": 88.03505599999335,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 20623,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "916741",
+        "md5Hex": "b28f2ba706e0f797f80ef1c129fc1519"
+      },
+      "nativeDecodedPcmSha256": "1704ebcf5b3c81b703e1ecda346ebfc12a84421a0a83ccb9a75b7a53ddabc86c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "997fc12d1dbcbbf349b26a411d00fed8af4c3132fba56a850d91927b6afd7a19",
+      "encodedBytes": 2598970,
+      "elapsedMilliseconds": 409.9394800000009,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 531,
+        "maximumFrameSize": 20913,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2eecabe04698ad77539ff46ecb1ffff8"
+      },
+      "nativeDecodedPcmSha256": "997fc12d1dbcbbf349b26a411d00fed8af4c3132fba56a850d91927b6afd7a19"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "997fc12d1dbcbbf349b26a411d00fed8af4c3132fba56a850d91927b6afd7a19",
+      "encodedBytes": 2598964,
+      "elapsedMilliseconds": 115.03847100000712,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 531,
+        "maximumFrameSize": 20913,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2eecabe04698ad77539ff46ecb1ffff8"
+      },
+      "nativeDecodedPcmSha256": "997fc12d1dbcbbf349b26a411d00fed8af4c3132fba56a850d91927b6afd7a19"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "bc594e7e42791865271b0235bb7aad216405822db4e107e5bf1e4f46e3666ff4",
+      "encodedBytes": 2091903,
+      "elapsedMilliseconds": 410.0382180000015,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1041,
+        "maximumFrameSize": 20849,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "786a2e9f69216a3532e7f872d8543dad"
+      },
+      "nativeDecodedPcmSha256": "bc594e7e42791865271b0235bb7aad216405822db4e107e5bf1e4f46e3666ff4"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "bc594e7e42791865271b0235bb7aad216405822db4e107e5bf1e4f46e3666ff4",
+      "encodedBytes": 2091921,
+      "elapsedMilliseconds": 115.67175700000371,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1041,
+        "maximumFrameSize": 20849,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "786a2e9f69216a3532e7f872d8543dad"
+      },
+      "nativeDecodedPcmSha256": "bc594e7e42791865271b0235bb7aad216405822db4e107e5bf1e4f46e3666ff4"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "a03e75db825cb2754ee597c2a1c4c61e295a9eae5c27932ab847b390f47a5601",
+      "encodedBytes": 2873663,
+      "elapsedMilliseconds": 439.57107200002065,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 546,
+        "maximumFrameSize": 20901,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "99f6e579028fe5e4b5eff5eb8deae40d"
+      },
+      "nativeDecodedPcmSha256": "a03e75db825cb2754ee597c2a1c4c61e295a9eae5c27932ab847b390f47a5601"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "a03e75db825cb2754ee597c2a1c4c61e295a9eae5c27932ab847b390f47a5601",
+      "encodedBytes": 2873661,
+      "elapsedMilliseconds": 118.60554699998465,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 546,
+        "maximumFrameSize": 20901,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "99f6e579028fe5e4b5eff5eb8deae40d"
+      },
+      "nativeDecodedPcmSha256": "a03e75db825cb2754ee597c2a1c4c61e295a9eae5c27932ab847b390f47a5601"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 3,
+      "frames": 528117,
+      "expectedPcmSha256": "b667bd900e6d2a78c980afce335361280d75a02d45b93afaf53f1b9a6a37df37",
+      "encodedBytes": 1045515,
+      "elapsedMilliseconds": 157.55826999997953,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 514,
+        "maximumFrameSize": 20819,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "528117",
+        "md5Hex": "bd43c65ac8eb4dd7451a6c8ee685692e"
+      },
+      "nativeDecodedPcmSha256": "b667bd900e6d2a78c980afce335361280d75a02d45b93afaf53f1b9a6a37df37"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:9184f49ee35fa748ecf4d898eb06058d2f499b8348b80736c5c252a99fe36b98",
+      "chunkIndex": 3,
+      "frames": 528117,
+      "expectedPcmSha256": "b667bd900e6d2a78c980afce335361280d75a02d45b93afaf53f1b9a6a37df37",
+      "encodedBytes": 1045514,
+      "elapsedMilliseconds": 46.16888199999812,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 514,
+        "maximumFrameSize": 20819,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "528117",
+        "md5Hex": "bd43c65ac8eb4dd7451a6c8ee685692e"
+      },
+      "nativeDecodedPcmSha256": "b667bd900e6d2a78c980afce335361280d75a02d45b93afaf53f1b9a6a37df37"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "d6dd68e175e45d08fa7fb81c835c58c9fe7da612c54be548767f948ba83d149c",
+      "encodedBytes": 2288154,
+      "elapsedMilliseconds": 483.7047759999987,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 10698,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "3380311316eefe07ca45fd8a6f3239bd"
+      },
+      "nativeDecodedPcmSha256": "d6dd68e175e45d08fa7fb81c835c58c9fe7da612c54be548767f948ba83d149c"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "d6dd68e175e45d08fa7fb81c835c58c9fe7da612c54be548767f948ba83d149c",
+      "encodedBytes": 2288163,
+      "elapsedMilliseconds": 124.8740810000163,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 10698,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "3380311316eefe07ca45fd8a6f3239bd"
+      },
+      "nativeDecodedPcmSha256": "d6dd68e175e45d08fa7fb81c835c58c9fe7da612c54be548767f948ba83d149c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "a013f58057e3192997704773f30e0f9b43251052648c2709523a784dde83d15a",
+      "encodedBytes": 2522256,
+      "elapsedMilliseconds": 463.2194019999879,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 10845,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d8621036960bf9f8a2faf42fe1146622"
+      },
+      "nativeDecodedPcmSha256": "a013f58057e3192997704773f30e0f9b43251052648c2709523a784dde83d15a"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "a013f58057e3192997704773f30e0f9b43251052648c2709523a784dde83d15a",
+      "encodedBytes": 2522167,
+      "elapsedMilliseconds": 122.56343799998285,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 10845,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d8621036960bf9f8a2faf42fe1146622"
+      },
+      "nativeDecodedPcmSha256": "a013f58057e3192997704773f30e0f9b43251052648c2709523a784dde83d15a"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "3b6cd32604fb1bb615b4eefbf0566819bb0fa41f6cec25ccda38473b3b27fe6c",
+      "encodedBytes": 3396221,
+      "elapsedMilliseconds": 516.1798249999993,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 12386,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "909948b003e4e1cf617d6dca19037e7a"
+      },
+      "nativeDecodedPcmSha256": "3b6cd32604fb1bb615b4eefbf0566819bb0fa41f6cec25ccda38473b3b27fe6c"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "3b6cd32604fb1bb615b4eefbf0566819bb0fa41f6cec25ccda38473b3b27fe6c",
+      "encodedBytes": 3396209,
+      "elapsedMilliseconds": 128.67532500001835,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 12386,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "909948b003e4e1cf617d6dca19037e7a"
+      },
+      "nativeDecodedPcmSha256": "3b6cd32604fb1bb615b4eefbf0566819bb0fa41f6cec25ccda38473b3b27fe6c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 3,
+      "frames": 97514,
+      "expectedPcmSha256": "8e60ccdf9088a1c5f09ef9dc7ac302dbb9bf22936642e24011f92c0137a7088b",
+      "encodedBytes": 149408,
+      "elapsedMilliseconds": 42.07309799999348,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 437,
+        "maximumFrameSize": 11467,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "97514",
+        "md5Hex": "b183f306ecf69ca5d8d2c788312be84d"
+      },
+      "nativeDecodedPcmSha256": "8e60ccdf9088a1c5f09ef9dc7ac302dbb9bf22936642e24011f92c0137a7088b"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:9a57207ac802bad426435d920b77048ba9dd391797c6a462444c6e375716d36f",
+      "chunkIndex": 3,
+      "frames": 97514,
+      "expectedPcmSha256": "8e60ccdf9088a1c5f09ef9dc7ac302dbb9bf22936642e24011f92c0137a7088b",
+      "encodedBytes": 149411,
+      "elapsedMilliseconds": 10.805117999989307,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 437,
+        "maximumFrameSize": 11467,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "97514",
+        "md5Hex": "b183f306ecf69ca5d8d2c788312be84d"
+      },
+      "nativeDecodedPcmSha256": "8e60ccdf9088a1c5f09ef9dc7ac302dbb9bf22936642e24011f92c0137a7088b"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:b613c11eea1c43c0a0fed317bea191d09146b818c4fe8e7a781cec1061b781f1",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "20e6f57d0c7a4d86fe1d9b41a4589e043a45f28172189bde30d153a30b893295",
+      "encodedBytes": 3711107,
+      "elapsedMilliseconds": 481.53965999998036,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 17631,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f38b4f91f48e87fe5c66e430ac9b6dcf"
+      },
+      "nativeDecodedPcmSha256": "20e6f57d0c7a4d86fe1d9b41a4589e043a45f28172189bde30d153a30b893295"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:b613c11eea1c43c0a0fed317bea191d09146b818c4fe8e7a781cec1061b781f1",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "20e6f57d0c7a4d86fe1d9b41a4589e043a45f28172189bde30d153a30b893295",
+      "encodedBytes": 3711107,
+      "elapsedMilliseconds": 124.62896400000318,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 17631,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f38b4f91f48e87fe5c66e430ac9b6dcf"
+      },
+      "nativeDecodedPcmSha256": "20e6f57d0c7a4d86fe1d9b41a4589e043a45f28172189bde30d153a30b893295"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:b613c11eea1c43c0a0fed317bea191d09146b818c4fe8e7a781cec1061b781f1",
+      "chunkIndex": 1,
+      "frames": 206195,
+      "expectedPcmSha256": "33d319edbc97be7960054e657ead189865b1441d4771acc21abf99e792d03517",
+      "encodedBytes": 509176,
+      "elapsedMilliseconds": 83.90569800001686,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 194,
+        "maximumFrameSize": 17636,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "206195",
+        "md5Hex": "fc2a86a49c985d2344984cb33331c26f"
+      },
+      "nativeDecodedPcmSha256": "33d319edbc97be7960054e657ead189865b1441d4771acc21abf99e792d03517"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:b613c11eea1c43c0a0fed317bea191d09146b818c4fe8e7a781cec1061b781f1",
+      "chunkIndex": 1,
+      "frames": 206195,
+      "expectedPcmSha256": "33d319edbc97be7960054e657ead189865b1441d4771acc21abf99e792d03517",
+      "encodedBytes": 509176,
+      "elapsedMilliseconds": 20.272979000001214,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 194,
+        "maximumFrameSize": 17636,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "206195",
+        "md5Hex": "fc2a86a49c985d2344984cb33331c26f"
+      },
+      "nativeDecodedPcmSha256": "33d319edbc97be7960054e657ead189865b1441d4771acc21abf99e792d03517"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "bf0875df024093a82fb77c21c3be693044f912a4f2e659efadfeba298c725d8c",
+      "encodedBytes": 837695,
+      "elapsedMilliseconds": 315.0373370000161,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 4448,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "0596bd594b76494663e751a8a82158e2"
+      },
+      "nativeDecodedPcmSha256": "bf0875df024093a82fb77c21c3be693044f912a4f2e659efadfeba298c725d8c"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "bf0875df024093a82fb77c21c3be693044f912a4f2e659efadfeba298c725d8c",
+      "encodedBytes": 837717,
+      "elapsedMilliseconds": 90.39904099999694,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 4448,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "0596bd594b76494663e751a8a82158e2"
+      },
+      "nativeDecodedPcmSha256": "bf0875df024093a82fb77c21c3be693044f912a4f2e659efadfeba298c725d8c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "73a9d535d1674e035dd0f426e0409ac40ee779244220f4c4ea0b274df403038a",
+      "encodedBytes": 1898730,
+      "elapsedMilliseconds": 409.01491699999315,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 10673,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fefcbb6dd17769d996c86328d9e28387"
+      },
+      "nativeDecodedPcmSha256": "73a9d535d1674e035dd0f426e0409ac40ee779244220f4c4ea0b274df403038a"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "73a9d535d1674e035dd0f426e0409ac40ee779244220f4c4ea0b274df403038a",
+      "encodedBytes": 1898820,
+      "elapsedMilliseconds": 109.54390000001877,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 10673,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fefcbb6dd17769d996c86328d9e28387"
+      },
+      "nativeDecodedPcmSha256": "73a9d535d1674e035dd0f426e0409ac40ee779244220f4c4ea0b274df403038a"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "4abd9d2c9ef25b837cdda5a8d4b93da148e1877cd3db7b18657b07b75c0df88b",
+      "encodedBytes": 979468,
+      "elapsedMilliseconds": 349.9167979999911,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 5175,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "dcde8895a7df83f9d3e6b74e747e78e9"
+      },
+      "nativeDecodedPcmSha256": "4abd9d2c9ef25b837cdda5a8d4b93da148e1877cd3db7b18657b07b75c0df88b"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "4abd9d2c9ef25b837cdda5a8d4b93da148e1877cd3db7b18657b07b75c0df88b",
+      "encodedBytes": 979348,
+      "elapsedMilliseconds": 94.73327899997821,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 5175,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "dcde8895a7df83f9d3e6b74e747e78e9"
+      },
+      "nativeDecodedPcmSha256": "4abd9d2c9ef25b837cdda5a8d4b93da148e1877cd3db7b18657b07b75c0df88b"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 3,
+      "frames": 240708,
+      "expectedPcmSha256": "2c0376459f084817fbe05021a99473a51ffac58d3b89f6249a9e608361c24153",
+      "encodedBytes": 135559,
+      "elapsedMilliseconds": 66.41042200001539,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 4179,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "240708",
+        "md5Hex": "8cc8b65893452e498d410d6d870f2ce5"
+      },
+      "nativeDecodedPcmSha256": "2c0376459f084817fbe05021a99473a51ffac58d3b89f6249a9e608361c24153"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:ba8f39a6c7b1f22bded6ce6d97361a01ce751282b3f1ab08f931b876c6734ae1",
+      "chunkIndex": 3,
+      "frames": 240708,
+      "expectedPcmSha256": "2c0376459f084817fbe05021a99473a51ffac58d3b89f6249a9e608361c24153",
+      "encodedBytes": 135582,
+      "elapsedMilliseconds": 18.15094599997974,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 16,
+        "maximumFrameSize": 4179,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "240708",
+        "md5Hex": "8cc8b65893452e498d410d6d870f2ce5"
+      },
+      "nativeDecodedPcmSha256": "2c0376459f084817fbe05021a99473a51ffac58d3b89f6249a9e608361c24153"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "acb2a0065558fa0e65f94f9cbd917cb884ff12da69ef71238056ec3498f89484",
+      "encodedBytes": 3500055,
+      "elapsedMilliseconds": 538.2728500000085,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5516,
+        "maximumFrameSize": 18157,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "23d423ad6ad760b82e3d6c2246d86238"
+      },
+      "nativeDecodedPcmSha256": "acb2a0065558fa0e65f94f9cbd917cb884ff12da69ef71238056ec3498f89484"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "acb2a0065558fa0e65f94f9cbd917cb884ff12da69ef71238056ec3498f89484",
+      "encodedBytes": 3500055,
+      "elapsedMilliseconds": 133.51075800001854,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5516,
+        "maximumFrameSize": 18157,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "23d423ad6ad760b82e3d6c2246d86238"
+      },
+      "nativeDecodedPcmSha256": "acb2a0065558fa0e65f94f9cbd917cb884ff12da69ef71238056ec3498f89484"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "c08dc080013b95d43386834bec404adfadfe00d148e5d8b09aa7133579d651fb",
+      "encodedBytes": 5094024,
+      "elapsedMilliseconds": 562.7910080000001,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6350,
+        "maximumFrameSize": 20480,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "ef76a0cd4dfc91fa32d5e4d3cba91719"
+      },
+      "nativeDecodedPcmSha256": "c08dc080013b95d43386834bec404adfadfe00d148e5d8b09aa7133579d651fb"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "c08dc080013b95d43386834bec404adfadfe00d148e5d8b09aa7133579d651fb",
+      "encodedBytes": 5094024,
+      "elapsedMilliseconds": 134.37351199999102,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6350,
+        "maximumFrameSize": 20480,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "ef76a0cd4dfc91fa32d5e4d3cba91719"
+      },
+      "nativeDecodedPcmSha256": "c08dc080013b95d43386834bec404adfadfe00d148e5d8b09aa7133579d651fb"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "39151af29546d5b05e982e1c5a5f313b3105eff8a80d9a9cc5f1ebf195a8c389",
+      "encodedBytes": 4681716,
+      "elapsedMilliseconds": 535.0415119999961,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6331,
+        "maximumFrameSize": 18814,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "774d9efdff3c37ae566ff518b80f8f40"
+      },
+      "nativeDecodedPcmSha256": "39151af29546d5b05e982e1c5a5f313b3105eff8a80d9a9cc5f1ebf195a8c389"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "39151af29546d5b05e982e1c5a5f313b3105eff8a80d9a9cc5f1ebf195a8c389",
+      "encodedBytes": 4681716,
+      "elapsedMilliseconds": 134.18211599998176,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6331,
+        "maximumFrameSize": 18814,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "774d9efdff3c37ae566ff518b80f8f40"
+      },
+      "nativeDecodedPcmSha256": "39151af29546d5b05e982e1c5a5f313b3105eff8a80d9a9cc5f1ebf195a8c389"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "649b462aa016a111211498488ffca8da24e16f1a9b594f58bf38fb03933bb4f5",
+      "encodedBytes": 5095991,
+      "elapsedMilliseconds": 556.1610140000121,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6880,
+        "maximumFrameSize": 20409,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "35bb887ffcd20cc9acb7fe0832ca84dd"
+      },
+      "nativeDecodedPcmSha256": "649b462aa016a111211498488ffca8da24e16f1a9b594f58bf38fb03933bb4f5"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "649b462aa016a111211498488ffca8da24e16f1a9b594f58bf38fb03933bb4f5",
+      "encodedBytes": 5095990,
+      "elapsedMilliseconds": 134.47476399998413,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6880,
+        "maximumFrameSize": 20409,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "35bb887ffcd20cc9acb7fe0832ca84dd"
+      },
+      "nativeDecodedPcmSha256": "649b462aa016a111211498488ffca8da24e16f1a9b594f58bf38fb03933bb4f5"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 4,
+      "frames": 913965,
+      "expectedPcmSha256": "cc11220dae84517c06488c4397c4f54629614cfb4b1bf99262af541086f86a8b",
+      "encodedBytes": 3704141,
+      "elapsedMilliseconds": 391.3203290000092,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 827,
+        "maximumFrameSize": 20547,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "913965",
+        "md5Hex": "0f0a8a4ec11425e8cdef46082e7f031b"
+      },
+      "nativeDecodedPcmSha256": "cc11220dae84517c06488c4397c4f54629614cfb4b1bf99262af541086f86a8b"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:c48e9a6b5621bb213de9d6c0c016c557a4516ba0e02de06deb1141fe7946332f",
+      "chunkIndex": 4,
+      "frames": 913965,
+      "expectedPcmSha256": "cc11220dae84517c06488c4397c4f54629614cfb4b1bf99262af541086f86a8b",
+      "encodedBytes": 3704141,
+      "elapsedMilliseconds": 94.44010999999591,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 827,
+        "maximumFrameSize": 20547,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "913965",
+        "md5Hex": "0f0a8a4ec11425e8cdef46082e7f031b"
+      },
+      "nativeDecodedPcmSha256": "cc11220dae84517c06488c4397c4f54629614cfb4b1bf99262af541086f86a8b"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "4ef0e5b27bc3175da2611e8d22d8352ff615550fd0c8798ef04071383a43a7ca",
+      "encodedBytes": 3847857,
+      "elapsedMilliseconds": 493.3226490000088,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6684,
+        "maximumFrameSize": 16691,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2e98a79b3a31ce532600e77f6b5e7e7d"
+      },
+      "nativeDecodedPcmSha256": "4ef0e5b27bc3175da2611e8d22d8352ff615550fd0c8798ef04071383a43a7ca"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "4ef0e5b27bc3175da2611e8d22d8352ff615550fd0c8798ef04071383a43a7ca",
+      "encodedBytes": 3847857,
+      "elapsedMilliseconds": 132.00334500000463,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6684,
+        "maximumFrameSize": 16691,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "2e98a79b3a31ce532600e77f6b5e7e7d"
+      },
+      "nativeDecodedPcmSha256": "4ef0e5b27bc3175da2611e8d22d8352ff615550fd0c8798ef04071383a43a7ca"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "587dd69e42fa09749cd48eedf40a783fa77b08725df7cfd075a64584ebb17dbb",
+      "encodedBytes": 3970124,
+      "elapsedMilliseconds": 438.0089410000073,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1196,
+        "maximumFrameSize": 17182,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f5676f5bae407203be9f183bfcaea527"
+      },
+      "nativeDecodedPcmSha256": "587dd69e42fa09749cd48eedf40a783fa77b08725df7cfd075a64584ebb17dbb"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "587dd69e42fa09749cd48eedf40a783fa77b08725df7cfd075a64584ebb17dbb",
+      "encodedBytes": 3970104,
+      "elapsedMilliseconds": 129.2355009999883,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1196,
+        "maximumFrameSize": 17182,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f5676f5bae407203be9f183bfcaea527"
+      },
+      "nativeDecodedPcmSha256": "587dd69e42fa09749cd48eedf40a783fa77b08725df7cfd075a64584ebb17dbb"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "303270e98d22c7b40606f19da04a268425ffac83d8791fda0c1179014baa86c8",
+      "encodedBytes": 4303215,
+      "elapsedMilliseconds": 484.99688300001435,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5428,
+        "maximumFrameSize": 16965,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "07bbb32ad29a4ed4c59d9f2b2da5ea43"
+      },
+      "nativeDecodedPcmSha256": "303270e98d22c7b40606f19da04a268425ffac83d8791fda0c1179014baa86c8"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "303270e98d22c7b40606f19da04a268425ffac83d8791fda0c1179014baa86c8",
+      "encodedBytes": 4303218,
+      "elapsedMilliseconds": 130.7283560000069,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5428,
+        "maximumFrameSize": 16965,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "07bbb32ad29a4ed4c59d9f2b2da5ea43"
+      },
+      "nativeDecodedPcmSha256": "303270e98d22c7b40606f19da04a268425ffac83d8791fda0c1179014baa86c8"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "77801ccb085effccbfae0aa9aa1afd856abc76f9c332a1cd0bf949775ca33d4c",
+      "encodedBytes": 4322996,
+      "elapsedMilliseconds": 458.3365140000242,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1089,
+        "maximumFrameSize": 17827,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "c7fe1b47b098ffe3917cc8c54dd51e94"
+      },
+      "nativeDecodedPcmSha256": "77801ccb085effccbfae0aa9aa1afd856abc76f9c332a1cd0bf949775ca33d4c"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "77801ccb085effccbfae0aa9aa1afd856abc76f9c332a1cd0bf949775ca33d4c",
+      "encodedBytes": 4322990,
+      "elapsedMilliseconds": 124.72041700000409,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1089,
+        "maximumFrameSize": 17827,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "c7fe1b47b098ffe3917cc8c54dd51e94"
+      },
+      "nativeDecodedPcmSha256": "77801ccb085effccbfae0aa9aa1afd856abc76f9c332a1cd0bf949775ca33d4c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "09e611be443a7e3e11fbdce77a600971254eac99a84ceb56e22687ffc6b181ee",
+      "encodedBytes": 3348173,
+      "elapsedMilliseconds": 553.2027950000193,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 4639,
+        "maximumFrameSize": 15549,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d34c75f3326ffaa632879bf0c4bcf6e4"
+      },
+      "nativeDecodedPcmSha256": "09e611be443a7e3e11fbdce77a600971254eac99a84ceb56e22687ffc6b181ee"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "09e611be443a7e3e11fbdce77a600971254eac99a84ceb56e22687ffc6b181ee",
+      "encodedBytes": 3348207,
+      "elapsedMilliseconds": 135.75811900000554,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 4639,
+        "maximumFrameSize": 15549,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d34c75f3326ffaa632879bf0c4bcf6e4"
+      },
+      "nativeDecodedPcmSha256": "09e611be443a7e3e11fbdce77a600971254eac99a84ceb56e22687ffc6b181ee"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 5,
+      "frames": 787999,
+      "expectedPcmSha256": "df5cc90e42602310ecdc1aa55a4daf101fc4601d9583db1f84b12c121b25217b",
+      "encodedBytes": 1533261,
+      "elapsedMilliseconds": 277.8442449999857,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1273,
+        "maximumFrameSize": 10344,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "787999",
+        "md5Hex": "79380b4778c85cd98c9c12b0f00ace39"
+      },
+      "nativeDecodedPcmSha256": "df5cc90e42602310ecdc1aa55a4daf101fc4601d9583db1f84b12c121b25217b"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:d2a9ac32d38219a1dbe387f10ae417abb86101f4366683d2e68270ca1b8b5224",
+      "chunkIndex": 5,
+      "frames": 787999,
+      "expectedPcmSha256": "df5cc90e42602310ecdc1aa55a4daf101fc4601d9583db1f84b12c121b25217b",
+      "encodedBytes": 1533304,
+      "elapsedMilliseconds": 74.37821300001815,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1273,
+        "maximumFrameSize": 10344,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "787999",
+        "md5Hex": "79380b4778c85cd98c9c12b0f00ace39"
+      },
+      "nativeDecodedPcmSha256": "df5cc90e42602310ecdc1aa55a4daf101fc4601d9583db1f84b12c121b25217b"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "e4ce6eccdfae581a69ad7d053af770d4dbcd06c793413b03a4ed3fafdd9cc780",
+      "encodedBytes": 1077045,
+      "elapsedMilliseconds": 394.58232300000964,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1098,
+        "maximumFrameSize": 8211,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "4aff88652345da2edbd6a527805f7254"
+      },
+      "nativeDecodedPcmSha256": "e4ce6eccdfae581a69ad7d053af770d4dbcd06c793413b03a4ed3fafdd9cc780"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "e4ce6eccdfae581a69ad7d053af770d4dbcd06c793413b03a4ed3fafdd9cc780",
+      "encodedBytes": 1077045,
+      "elapsedMilliseconds": 111.33035400000517,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1098,
+        "maximumFrameSize": 8211,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "4aff88652345da2edbd6a527805f7254"
+      },
+      "nativeDecodedPcmSha256": "e4ce6eccdfae581a69ad7d053af770d4dbcd06c793413b03a4ed3fafdd9cc780"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "f17804e177224c0871b40263007f2f9197cabb5587de4b02835ae91cbf268f35",
+      "encodedBytes": 2026435,
+      "elapsedMilliseconds": 576.8538100000005,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5105,
+        "maximumFrameSize": 8224,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "36407f1308b1957e1b6144f30aa22a38"
+      },
+      "nativeDecodedPcmSha256": "f17804e177224c0871b40263007f2f9197cabb5587de4b02835ae91cbf268f35"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "f17804e177224c0871b40263007f2f9197cabb5587de4b02835ae91cbf268f35",
+      "encodedBytes": 2026471,
+      "elapsedMilliseconds": 133.59547899998142,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5105,
+        "maximumFrameSize": 8220,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "36407f1308b1957e1b6144f30aa22a38"
+      },
+      "nativeDecodedPcmSha256": "f17804e177224c0871b40263007f2f9197cabb5587de4b02835ae91cbf268f35"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "7d0ff510517cdf903b7d82524b87531c1fa8fb4caab35f49c40715da28eb7fed",
+      "encodedBytes": 2709275,
+      "elapsedMilliseconds": 559.0298480000056,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7303,
+        "maximumFrameSize": 9110,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "86d21455e0c45c41c61c1067efc5e624"
+      },
+      "nativeDecodedPcmSha256": "7d0ff510517cdf903b7d82524b87531c1fa8fb4caab35f49c40715da28eb7fed"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "7d0ff510517cdf903b7d82524b87531c1fa8fb4caab35f49c40715da28eb7fed",
+      "encodedBytes": 2709350,
+      "elapsedMilliseconds": 135.0033809999877,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7303,
+        "maximumFrameSize": 9110,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "86d21455e0c45c41c61c1067efc5e624"
+      },
+      "nativeDecodedPcmSha256": "7d0ff510517cdf903b7d82524b87531c1fa8fb4caab35f49c40715da28eb7fed"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "d030e1b082aca6c48acb78cef0f175a2385cca984a05c4056ed8b06d7cf33e25",
+      "encodedBytes": 3124543,
+      "elapsedMilliseconds": 581.60257800002,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8177,
+        "maximumFrameSize": 11438,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "e924974998afc7ee2ecb97289590446f"
+      },
+      "nativeDecodedPcmSha256": "d030e1b082aca6c48acb78cef0f175a2385cca984a05c4056ed8b06d7cf33e25"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "d030e1b082aca6c48acb78cef0f175a2385cca984a05c4056ed8b06d7cf33e25",
+      "encodedBytes": 3124526,
+      "elapsedMilliseconds": 149.83695500000613,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8177,
+        "maximumFrameSize": 11439,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "e924974998afc7ee2ecb97289590446f"
+      },
+      "nativeDecodedPcmSha256": "d030e1b082aca6c48acb78cef0f175a2385cca984a05c4056ed8b06d7cf33e25"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "af48460f9080df1be76b9ff6f454b28edb83901dccf8f3fdc1c76aa34d19269a",
+      "encodedBytes": 2993865,
+      "elapsedMilliseconds": 592.1257779999869,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8260,
+        "maximumFrameSize": 11365,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b5d1e81a1ee43f3aaedc77d43ef8b663"
+      },
+      "nativeDecodedPcmSha256": "af48460f9080df1be76b9ff6f454b28edb83901dccf8f3fdc1c76aa34d19269a"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "af48460f9080df1be76b9ff6f454b28edb83901dccf8f3fdc1c76aa34d19269a",
+      "encodedBytes": 2993794,
+      "elapsedMilliseconds": 138.7143919999944,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8260,
+        "maximumFrameSize": 11368,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b5d1e81a1ee43f3aaedc77d43ef8b663"
+      },
+      "nativeDecodedPcmSha256": "af48460f9080df1be76b9ff6f454b28edb83901dccf8f3fdc1c76aa34d19269a"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 5,
+      "frames": 129916,
+      "expectedPcmSha256": "0dd7eda91b2ac9d352e47627d1a7b2839dc09516301a9dd6c2bb6173902a186b",
+      "encodedBytes": 261549,
+      "elapsedMilliseconds": 74.68842399999266,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5936,
+        "maximumFrameSize": 8364,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "129916",
+        "md5Hex": "9116c4c4f5077be0f78a40cecf3edc9d"
+      },
+      "nativeDecodedPcmSha256": "0dd7eda91b2ac9d352e47627d1a7b2839dc09516301a9dd6c2bb6173902a186b"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:d60d7992ce0ac81666b6e13b3ae7064ab5c1aad701a026619d78cfb725386d4d",
+      "chunkIndex": 5,
+      "frames": 129916,
+      "expectedPcmSha256": "0dd7eda91b2ac9d352e47627d1a7b2839dc09516301a9dd6c2bb6173902a186b",
+      "encodedBytes": 261549,
+      "elapsedMilliseconds": 15.645530999987386,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5936,
+        "maximumFrameSize": 8364,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "129916",
+        "md5Hex": "9116c4c4f5077be0f78a40cecf3edc9d"
+      },
+      "nativeDecodedPcmSha256": "0dd7eda91b2ac9d352e47627d1a7b2839dc09516301a9dd6c2bb6173902a186b"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:dbb6eda6ecc56c418428f6b41d0b4872948d5be58e6089ecacb538b188dd7a74",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "2e94af2296c79e0acd1352987dad1c0105dcaab2fa5ec62a110a8f3f44a04e24",
+      "encodedBytes": 5150623,
+      "elapsedMilliseconds": 502.6269139999931,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 19736,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "26053a4513b282f554697b99442d10d4"
+      },
+      "nativeDecodedPcmSha256": "2e94af2296c79e0acd1352987dad1c0105dcaab2fa5ec62a110a8f3f44a04e24"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:dbb6eda6ecc56c418428f6b41d0b4872948d5be58e6089ecacb538b188dd7a74",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "2e94af2296c79e0acd1352987dad1c0105dcaab2fa5ec62a110a8f3f44a04e24",
+      "encodedBytes": 5150623,
+      "elapsedMilliseconds": 131.0990210000018,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 17,
+        "maximumFrameSize": 19736,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "26053a4513b282f554697b99442d10d4"
+      },
+      "nativeDecodedPcmSha256": "2e94af2296c79e0acd1352987dad1c0105dcaab2fa5ec62a110a8f3f44a04e24"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:dbb6eda6ecc56c418428f6b41d0b4872948d5be58e6089ecacb538b188dd7a74",
+      "chunkIndex": 1,
+      "frames": 659918,
+      "expectedPcmSha256": "ba7987b2aeec2b9383b890edb42d2615c9e33220a8a9473f83e5eabd3f81681f",
+      "encodedBytes": 1981971,
+      "elapsedMilliseconds": 250.98428499998408,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 79,
+        "maximumFrameSize": 19765,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "659918",
+        "md5Hex": "bcd7209885a540ae40a0fed23f840025"
+      },
+      "nativeDecodedPcmSha256": "ba7987b2aeec2b9383b890edb42d2615c9e33220a8a9473f83e5eabd3f81681f"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:dbb6eda6ecc56c418428f6b41d0b4872948d5be58e6089ecacb538b188dd7a74",
+      "chunkIndex": 1,
+      "frames": 659918,
+      "expectedPcmSha256": "ba7987b2aeec2b9383b890edb42d2615c9e33220a8a9473f83e5eabd3f81681f",
+      "encodedBytes": 1981954,
+      "elapsedMilliseconds": 63.95825799999875,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 79,
+        "maximumFrameSize": 19765,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "659918",
+        "md5Hex": "bcd7209885a540ae40a0fed23f840025"
+      },
+      "nativeDecodedPcmSha256": "ba7987b2aeec2b9383b890edb42d2615c9e33220a8a9473f83e5eabd3f81681f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "4930de75afb2d6609f801fa1a01c6015b397e3936b098e014e5960411a62bb8c",
+      "encodedBytes": 1873787,
+      "elapsedMilliseconds": 518.6617369999876,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5172,
+        "maximumFrameSize": 10592,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "1df6349a9a1200e5db6488580cfe5609"
+      },
+      "nativeDecodedPcmSha256": "4930de75afb2d6609f801fa1a01c6015b397e3936b098e014e5960411a62bb8c"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "4930de75afb2d6609f801fa1a01c6015b397e3936b098e014e5960411a62bb8c",
+      "encodedBytes": 1873831,
+      "elapsedMilliseconds": 127.71691600000486,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5172,
+        "maximumFrameSize": 10597,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "1df6349a9a1200e5db6488580cfe5609"
+      },
+      "nativeDecodedPcmSha256": "4930de75afb2d6609f801fa1a01c6015b397e3936b098e014e5960411a62bb8c"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "70ea23b1a824512f353489e240fd927f4bd0f8118269c48ac88cf4163f01d227",
+      "encodedBytes": 2060276,
+      "elapsedMilliseconds": 534.253315000009,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5164,
+        "maximumFrameSize": 12080,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "02c109983d30694eeccf693591d4814c"
+      },
+      "nativeDecodedPcmSha256": "70ea23b1a824512f353489e240fd927f4bd0f8118269c48ac88cf4163f01d227"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "70ea23b1a824512f353489e240fd927f4bd0f8118269c48ac88cf4163f01d227",
+      "encodedBytes": 2060264,
+      "elapsedMilliseconds": 127.8587969999935,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5164,
+        "maximumFrameSize": 12080,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "02c109983d30694eeccf693591d4814c"
+      },
+      "nativeDecodedPcmSha256": "70ea23b1a824512f353489e240fd927f4bd0f8118269c48ac88cf4163f01d227"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "bf440567e988c71551be148276316309a1257b2f11b2d1a4bcaea301f1055446",
+      "encodedBytes": 1688615,
+      "elapsedMilliseconds": 534.1880599999859,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5156,
+        "maximumFrameSize": 5282,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "e4ff153fefd0b5983adecdf954619e16"
+      },
+      "nativeDecodedPcmSha256": "bf440567e988c71551be148276316309a1257b2f11b2d1a4bcaea301f1055446"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "bf440567e988c71551be148276316309a1257b2f11b2d1a4bcaea301f1055446",
+      "encodedBytes": 1688615,
+      "elapsedMilliseconds": 125.89968399997451,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5156,
+        "maximumFrameSize": 5282,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "e4ff153fefd0b5983adecdf954619e16"
+      },
+      "nativeDecodedPcmSha256": "bf440567e988c71551be148276316309a1257b2f11b2d1a4bcaea301f1055446"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "097716d93dcac0324bbb6e2110b67088938dff5e489c5e6b06d45918b07e8dcf",
+      "encodedBytes": 1687882,
+      "elapsedMilliseconds": 556.6426360000041,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5164,
+        "maximumFrameSize": 5273,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5f23f612eae3ff947a33c28f917fb0c3"
+      },
+      "nativeDecodedPcmSha256": "097716d93dcac0324bbb6e2110b67088938dff5e489c5e6b06d45918b07e8dcf"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "097716d93dcac0324bbb6e2110b67088938dff5e489c5e6b06d45918b07e8dcf",
+      "encodedBytes": 1687882,
+      "elapsedMilliseconds": 125.59609500001534,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5164,
+        "maximumFrameSize": 5273,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "5f23f612eae3ff947a33c28f917fb0c3"
+      },
+      "nativeDecodedPcmSha256": "097716d93dcac0324bbb6e2110b67088938dff5e489c5e6b06d45918b07e8dcf"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 4,
+      "frames": 915923,
+      "expectedPcmSha256": "af8937f992feb00ab5bb6c0d5a28f80ad75d34e9a9a53439183830e458d8faab",
+      "encodedBytes": 1168887,
+      "elapsedMilliseconds": 384.79651499999454,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 3248,
+        "maximumFrameSize": 5320,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "915923",
+        "md5Hex": "7605d09ff6c2b92d6c7ec2cad106a44a"
+      },
+      "nativeDecodedPcmSha256": "af8937f992feb00ab5bb6c0d5a28f80ad75d34e9a9a53439183830e458d8faab"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:e5c44270be4bd0862850977ef3d8a06f1b3803d75c276bb243139bae1f56db62",
+      "chunkIndex": 4,
+      "frames": 915923,
+      "expectedPcmSha256": "af8937f992feb00ab5bb6c0d5a28f80ad75d34e9a9a53439183830e458d8faab",
+      "encodedBytes": 1168887,
+      "elapsedMilliseconds": 87.53988100000424,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 3248,
+        "maximumFrameSize": 5320,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "915923",
+        "md5Hex": "7605d09ff6c2b92d6c7ec2cad106a44a"
+      },
+      "nativeDecodedPcmSha256": "af8937f992feb00ab5bb6c0d5a28f80ad75d34e9a9a53439183830e458d8faab"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "c153cdd02ee613aa4d856af7b7499256d9a797b85d7f1bf72697b8ebe699572b",
+      "encodedBytes": 3007114,
+      "elapsedMilliseconds": 477.4919189999928,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7681,
+        "maximumFrameSize": 12705,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "251ca0665436123f9e152c2958ab9922"
+      },
+      "nativeDecodedPcmSha256": "c153cdd02ee613aa4d856af7b7499256d9a797b85d7f1bf72697b8ebe699572b"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "c153cdd02ee613aa4d856af7b7499256d9a797b85d7f1bf72697b8ebe699572b",
+      "encodedBytes": 3007108,
+      "elapsedMilliseconds": 121.22079900000244,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7681,
+        "maximumFrameSize": 12705,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "251ca0665436123f9e152c2958ab9922"
+      },
+      "nativeDecodedPcmSha256": "c153cdd02ee613aa4d856af7b7499256d9a797b85d7f1bf72697b8ebe699572b"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "1968944d10881b63a6477b9621071f7f8a56e969b4c0730c2da2b6e27aac62db",
+      "encodedBytes": 3132254,
+      "elapsedMilliseconds": 520.1147029999993,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 2289,
+        "maximumFrameSize": 12504,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f3d43a6b0fbccd05351d16c9ed6a2593"
+      },
+      "nativeDecodedPcmSha256": "1968944d10881b63a6477b9621071f7f8a56e969b4c0730c2da2b6e27aac62db"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "1968944d10881b63a6477b9621071f7f8a56e969b4c0730c2da2b6e27aac62db",
+      "encodedBytes": 3132254,
+      "elapsedMilliseconds": 127.1478519999946,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 2289,
+        "maximumFrameSize": 12504,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f3d43a6b0fbccd05351d16c9ed6a2593"
+      },
+      "nativeDecodedPcmSha256": "1968944d10881b63a6477b9621071f7f8a56e969b4c0730c2da2b6e27aac62db"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "1213ccf392162807582019bde04d3ad714481247b76d1d5f8009a5fc0eb3e069",
+      "encodedBytes": 3096303,
+      "elapsedMilliseconds": 489.8033970000106,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7951,
+        "maximumFrameSize": 12269,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b7de8fa8b924474bd9231a3e5800598b"
+      },
+      "nativeDecodedPcmSha256": "1213ccf392162807582019bde04d3ad714481247b76d1d5f8009a5fc0eb3e069"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "1213ccf392162807582019bde04d3ad714481247b76d1d5f8009a5fc0eb3e069",
+      "encodedBytes": 3096300,
+      "elapsedMilliseconds": 122.74814899999183,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7951,
+        "maximumFrameSize": 12269,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b7de8fa8b924474bd9231a3e5800598b"
+      },
+      "nativeDecodedPcmSha256": "1213ccf392162807582019bde04d3ad714481247b76d1d5f8009a5fc0eb3e069"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "dfe83b8d2c67fefec02a01eef4018f786a03ca52e14aff50e9e395301b4fdbbb",
+      "encodedBytes": 2799241,
+      "elapsedMilliseconds": 433.7698280000186,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7928,
+        "maximumFrameSize": 11232,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f2bb2279e28a8a66a0ce46987a9ff1c7"
+      },
+      "nativeDecodedPcmSha256": "dfe83b8d2c67fefec02a01eef4018f786a03ca52e14aff50e9e395301b4fdbbb"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "dfe83b8d2c67fefec02a01eef4018f786a03ca52e14aff50e9e395301b4fdbbb",
+      "encodedBytes": 2799236,
+      "elapsedMilliseconds": 117.25208599999314,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7928,
+        "maximumFrameSize": 11232,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f2bb2279e28a8a66a0ce46987a9ff1c7"
+      },
+      "nativeDecodedPcmSha256": "dfe83b8d2c67fefec02a01eef4018f786a03ca52e14aff50e9e395301b4fdbbb"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "0f55c1534bb29b9fb8258c13985e13aa3d25fd02a6afe6128aaca72caa8cf731",
+      "encodedBytes": 3407791,
+      "elapsedMilliseconds": 450.7415369999944,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 3152,
+        "maximumFrameSize": 12897,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "22a374fce66170497a8c490eb83cacb3"
+      },
+      "nativeDecodedPcmSha256": "0f55c1534bb29b9fb8258c13985e13aa3d25fd02a6afe6128aaca72caa8cf731"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "0f55c1534bb29b9fb8258c13985e13aa3d25fd02a6afe6128aaca72caa8cf731",
+      "encodedBytes": 3407792,
+      "elapsedMilliseconds": 120.57620899996255,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 3152,
+        "maximumFrameSize": 12897,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "22a374fce66170497a8c490eb83cacb3"
+      },
+      "nativeDecodedPcmSha256": "0f55c1534bb29b9fb8258c13985e13aa3d25fd02a6afe6128aaca72caa8cf731"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "026e9d73a7ff3851959956aaa58f413a73aae7116da4d14652682b7f14d7c382",
+      "encodedBytes": 2657514,
+      "elapsedMilliseconds": 381.5272630000254,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7957,
+        "maximumFrameSize": 8424,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "50c204d2c3ca112cb6d2dfc4574a6b7b"
+      },
+      "nativeDecodedPcmSha256": "026e9d73a7ff3851959956aaa58f413a73aae7116da4d14652682b7f14d7c382"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "026e9d73a7ff3851959956aaa58f413a73aae7116da4d14652682b7f14d7c382",
+      "encodedBytes": 2657514,
+      "elapsedMilliseconds": 110.17599299998255,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7957,
+        "maximumFrameSize": 8424,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "50c204d2c3ca112cb6d2dfc4574a6b7b"
+      },
+      "nativeDecodedPcmSha256": "026e9d73a7ff3851959956aaa58f413a73aae7116da4d14652682b7f14d7c382"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "7669dc7fe143e844e6d85fcaf155e41c6b66faada5383275c8f038938422eedf",
+      "encodedBytes": 1127015,
+      "elapsedMilliseconds": 156.27423999999883,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7943,
+        "maximumFrameSize": 8396,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "61212883dedb8671dfaf0c6b3a48cf26"
+      },
+      "nativeDecodedPcmSha256": "7669dc7fe143e844e6d85fcaf155e41c6b66faada5383275c8f038938422eedf"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:f797073413ecf7782ec9e767bb4645034e8293b52c86cd888c920b33427c0d59",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "7669dc7fe143e844e6d85fcaf155e41c6b66faada5383275c8f038938422eedf",
+      "encodedBytes": 1127015,
+      "elapsedMilliseconds": 47.25385899998946,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7943,
+        "maximumFrameSize": 8396,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "61212883dedb8671dfaf0c6b3a48cf26"
+      },
+      "nativeDecodedPcmSha256": "7669dc7fe143e844e6d85fcaf155e41c6b66faada5383275c8f038938422eedf"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "907c161b6a6b3fc6be1ac83b0514aa8fbe4b72804d7ff1b2912429cf86c4fa12",
+      "encodedBytes": 4714618,
+      "elapsedMilliseconds": 551.9854589999886,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7910,
+        "maximumFrameSize": 18654,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f4eae4970a525ffe360ec2518db524da"
+      },
+      "nativeDecodedPcmSha256": "907c161b6a6b3fc6be1ac83b0514aa8fbe4b72804d7ff1b2912429cf86c4fa12"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "907c161b6a6b3fc6be1ac83b0514aa8fbe4b72804d7ff1b2912429cf86c4fa12",
+      "encodedBytes": 4714618,
+      "elapsedMilliseconds": 134.2187050000066,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7910,
+        "maximumFrameSize": 18654,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "f4eae4970a525ffe360ec2518db524da"
+      },
+      "nativeDecodedPcmSha256": "907c161b6a6b3fc6be1ac83b0514aa8fbe4b72804d7ff1b2912429cf86c4fa12"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "23668afc815608ca7873919d5db8586258717824df6dba0ac7ba65cd56cde2f9",
+      "encodedBytes": 4655200,
+      "elapsedMilliseconds": 575.4978199999896,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5540,
+        "maximumFrameSize": 19005,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "25825cf8c20414d3ce15b75e73bd0da0"
+      },
+      "nativeDecodedPcmSha256": "23668afc815608ca7873919d5db8586258717824df6dba0ac7ba65cd56cde2f9"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "23668afc815608ca7873919d5db8586258717824df6dba0ac7ba65cd56cde2f9",
+      "encodedBytes": 4655199,
+      "elapsedMilliseconds": 135.58698099997127,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 5540,
+        "maximumFrameSize": 19005,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "25825cf8c20414d3ce15b75e73bd0da0"
+      },
+      "nativeDecodedPcmSha256": "23668afc815608ca7873919d5db8586258717824df6dba0ac7ba65cd56cde2f9"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "146a29ebce44459aa8a15c198999ee449e8c6b04c2a8931ac5e9ad86c3920157",
+      "encodedBytes": 4262536,
+      "elapsedMilliseconds": 547.6896730000153,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7955,
+        "maximumFrameSize": 18639,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "eab602a474d9616842a1c3a10793eab8"
+      },
+      "nativeDecodedPcmSha256": "146a29ebce44459aa8a15c198999ee449e8c6b04c2a8931ac5e9ad86c3920157"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "146a29ebce44459aa8a15c198999ee449e8c6b04c2a8931ac5e9ad86c3920157",
+      "encodedBytes": 4262535,
+      "elapsedMilliseconds": 130.9346970000188,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7955,
+        "maximumFrameSize": 18639,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "eab602a474d9616842a1c3a10793eab8"
+      },
+      "nativeDecodedPcmSha256": "146a29ebce44459aa8a15c198999ee449e8c6b04c2a8931ac5e9ad86c3920157"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "c7fdfc4d8c871b684f0d5a3b0208f2f4d51b66450257b74b6b064b74c789c903",
+      "encodedBytes": 5170292,
+      "elapsedMilliseconds": 607.7575269999797,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 10522,
+        "maximumFrameSize": 18823,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fcdccbdef2ee2c7ee8b74f8bd64abb7f"
+      },
+      "nativeDecodedPcmSha256": "c7fdfc4d8c871b684f0d5a3b0208f2f4d51b66450257b74b6b064b74c789c903"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "c7fdfc4d8c871b684f0d5a3b0208f2f4d51b66450257b74b6b064b74c789c903",
+      "encodedBytes": 5170291,
+      "elapsedMilliseconds": 140.20640300004743,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 10522,
+        "maximumFrameSize": 18823,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fcdccbdef2ee2c7ee8b74f8bd64abb7f"
+      },
+      "nativeDecodedPcmSha256": "c7fdfc4d8c871b684f0d5a3b0208f2f4d51b66450257b74b6b064b74c789c903"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "6f35e69c56cae81692bae02df2074b5aa0d1afc8ca25bdcac9d6c4b3e0133a31",
+      "encodedBytes": 4202886,
+      "elapsedMilliseconds": 552.8002099999576,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8425,
+        "maximumFrameSize": 17842,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b4aa781a52d5d7b5f47f9852b0121c46"
+      },
+      "nativeDecodedPcmSha256": "6f35e69c56cae81692bae02df2074b5aa0d1afc8ca25bdcac9d6c4b3e0133a31"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "6f35e69c56cae81692bae02df2074b5aa0d1afc8ca25bdcac9d6c4b3e0133a31",
+      "encodedBytes": 4202884,
+      "elapsedMilliseconds": 132.94711100001587,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 8425,
+        "maximumFrameSize": 17842,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "b4aa781a52d5d7b5f47f9852b0121c46"
+      },
+      "nativeDecodedPcmSha256": "6f35e69c56cae81692bae02df2074b5aa0d1afc8ca25bdcac9d6c4b3e0133a31"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "7663bc6e076e7abf6e495e6f10fe5e511293290188bd2ea42ca8f11dca59c151",
+      "encodedBytes": 2584878,
+      "elapsedMilliseconds": 411.08471199998166,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7955,
+        "maximumFrameSize": 8561,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fc08cdf3e808dc6e0745ddfece913484"
+      },
+      "nativeDecodedPcmSha256": "7663bc6e076e7abf6e495e6f10fe5e511293290188bd2ea42ca8f11dca59c151"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 5,
+      "frames": 1323000,
+      "expectedPcmSha256": "7663bc6e076e7abf6e495e6f10fe5e511293290188bd2ea42ca8f11dca59c151",
+      "encodedBytes": 2584878,
+      "elapsedMilliseconds": 114.23541800002567,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7955,
+        "maximumFrameSize": 8561,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "fc08cdf3e808dc6e0745ddfece913484"
+      },
+      "nativeDecodedPcmSha256": "7663bc6e076e7abf6e495e6f10fe5e511293290188bd2ea42ca8f11dca59c151"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "3849a44bffe57ab48954fd37640c9292db6fba2278a1448464f1748d5dc5745e",
+      "encodedBytes": 1094741,
+      "elapsedMilliseconds": 184.10764300002484,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7864,
+        "maximumFrameSize": 8021,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "e40441b3fc17e9aeaf045157bcb09627"
+      },
+      "nativeDecodedPcmSha256": "3849a44bffe57ab48954fd37640c9292db6fba2278a1448464f1748d5dc5745e"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:fc78916013c03b9827b97fe5d422b260b2926d7bd7159c9b8c967e2a49edeef3",
+      "chunkIndex": 6,
+      "frames": 561092,
+      "expectedPcmSha256": "3849a44bffe57ab48954fd37640c9292db6fba2278a1448464f1748d5dc5745e",
+      "encodedBytes": 1094741,
+      "elapsedMilliseconds": 50.58653899998171,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 7864,
+        "maximumFrameSize": 8021,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "561092",
+        "md5Hex": "e40441b3fc17e9aeaf045157bcb09627"
+      },
+      "nativeDecodedPcmSha256": "3849a44bffe57ab48954fd37640c9292db6fba2278a1448464f1748d5dc5745e"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "1cb3c348a7d541b66309eea6f1aefefb0b02fb421d91b898fadae0733775d780",
+      "encodedBytes": 5144195,
+      "elapsedMilliseconds": 560.7174949999899,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1048,
+        "maximumFrameSize": 19125,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "3f301ecc694f663741a2b783c29dc8f1"
+      },
+      "nativeDecodedPcmSha256": "1cb3c348a7d541b66309eea6f1aefefb0b02fb421d91b898fadae0733775d780"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 0,
+      "frames": 1323000,
+      "expectedPcmSha256": "1cb3c348a7d541b66309eea6f1aefefb0b02fb421d91b898fadae0733775d780",
+      "encodedBytes": 5144195,
+      "elapsedMilliseconds": 134.86247000005096,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1048,
+        "maximumFrameSize": 19125,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "3f301ecc694f663741a2b783c29dc8f1"
+      },
+      "nativeDecodedPcmSha256": "1cb3c348a7d541b66309eea6f1aefefb0b02fb421d91b898fadae0733775d780"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "ed3b2c8a228e50e3b1a11aafa9f1aae51fa304e559661959c63e10a20c1f48da",
+      "encodedBytes": 5172912,
+      "elapsedMilliseconds": 567.3917820000206,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1115,
+        "maximumFrameSize": 19757,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d520abf87f30a1be09fc659b464ce855"
+      },
+      "nativeDecodedPcmSha256": "ed3b2c8a228e50e3b1a11aafa9f1aae51fa304e559661959c63e10a20c1f48da"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 1,
+      "frames": 1323000,
+      "expectedPcmSha256": "ed3b2c8a228e50e3b1a11aafa9f1aae51fa304e559661959c63e10a20c1f48da",
+      "encodedBytes": 5172912,
+      "elapsedMilliseconds": 138.25247900001705,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1115,
+        "maximumFrameSize": 19757,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "d520abf87f30a1be09fc659b464ce855"
+      },
+      "nativeDecodedPcmSha256": "ed3b2c8a228e50e3b1a11aafa9f1aae51fa304e559661959c63e10a20c1f48da"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "034db1186c1eb61b137691797fea0b93a3aca44c2167924d2d7ac4809ba9ad9f",
+      "encodedBytes": 5252207,
+      "elapsedMilliseconds": 595.046325000003,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6915,
+        "maximumFrameSize": 18956,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "36e9ce530e6f5228f07bcf0b1c6dfb95"
+      },
+      "nativeDecodedPcmSha256": "034db1186c1eb61b137691797fea0b93a3aca44c2167924d2d7ac4809ba9ad9f"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 2,
+      "frames": 1323000,
+      "expectedPcmSha256": "034db1186c1eb61b137691797fea0b93a3aca44c2167924d2d7ac4809ba9ad9f",
+      "encodedBytes": 5252207,
+      "elapsedMilliseconds": 134.72385599999689,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 6915,
+        "maximumFrameSize": 18956,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "36e9ce530e6f5228f07bcf0b1c6dfb95"
+      },
+      "nativeDecodedPcmSha256": "034db1186c1eb61b137691797fea0b93a3aca44c2167924d2d7ac4809ba9ad9f"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "85d909ec0f5745a6c02a9b87cf11ab8f35546990395eeecd4059a923084fc6af",
+      "encodedBytes": 5088811,
+      "elapsedMilliseconds": 581.3554679999943,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1068,
+        "maximumFrameSize": 19622,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "a5db113db1af2e6a236797876d040bcc"
+      },
+      "nativeDecodedPcmSha256": "85d909ec0f5745a6c02a9b87cf11ab8f35546990395eeecd4059a923084fc6af"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 3,
+      "frames": 1323000,
+      "expectedPcmSha256": "85d909ec0f5745a6c02a9b87cf11ab8f35546990395eeecd4059a923084fc6af",
+      "encodedBytes": 5088810,
+      "elapsedMilliseconds": 140.57045699999435,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1068,
+        "maximumFrameSize": 19622,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "a5db113db1af2e6a236797876d040bcc"
+      },
+      "nativeDecodedPcmSha256": "85d909ec0f5745a6c02a9b87cf11ab8f35546990395eeecd4059a923084fc6af"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "52739fe2188b8ff3f49b0b6a55444205c91fd05023bfc377d24e7354ad09c665",
+      "encodedBytes": 3443937,
+      "elapsedMilliseconds": 524.1445269999676,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1167,
+        "maximumFrameSize": 19515,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "98aafbd3bbe5b47e9b3591cc435b11e2"
+      },
+      "nativeDecodedPcmSha256": "52739fe2188b8ff3f49b0b6a55444205c91fd05023bfc377d24e7354ad09c665"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 4,
+      "frames": 1323000,
+      "expectedPcmSha256": "52739fe2188b8ff3f49b0b6a55444205c91fd05023bfc377d24e7354ad09c665",
+      "encodedBytes": 3443938,
+      "elapsedMilliseconds": 136.16539300000295,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 1167,
+        "maximumFrameSize": 19515,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "1323000",
+        "md5Hex": "98aafbd3bbe5b47e9b3591cc435b11e2"
+      },
+      "nativeDecodedPcmSha256": "52739fe2188b8ff3f49b0b6a55444205c91fd05023bfc377d24e7354ad09c665"
+    },
+    {
+      "implementation": "wasm",
+      "round": 3,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 5,
+      "frames": 91456,
+      "expectedPcmSha256": "30f490035cb2caaf0b63f57c817211708107df2bb2622eb80a8ca7cf56d41d2d",
+      "encodedBytes": 20011,
+      "elapsedMilliseconds": 26.762933999998495,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 189,
+        "maximumFrameSize": 1171,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "91456",
+        "md5Hex": "4f1a221fa641e39e32e602a5a4648686"
+      },
+      "nativeDecodedPcmSha256": "30f490035cb2caaf0b63f57c817211708107df2bb2622eb80a8ca7cf56d41d2d"
+    },
+    {
+      "implementation": "native",
+      "round": 3,
+      "stemIdentity": "sha256:fdae0da08b49b80492caad638119441bd2a0f2a2330642ff84e3baaafbb03cda",
+      "chunkIndex": 5,
+      "frames": 91456,
+      "expectedPcmSha256": "30f490035cb2caaf0b63f57c817211708107df2bb2622eb80a8ca7cf56d41d2d",
+      "encodedBytes": 20011,
+      "elapsedMilliseconds": 7.879213000007439,
+      "streamInfo": {
+        "minimumBlockSize": 4096,
+        "maximumBlockSize": 4096,
+        "minimumFrameSize": 189,
+        "maximumFrameSize": 1171,
+        "sampleRate": 44100,
+        "channels": 2,
+        "bitsPerSample": 24,
+        "totalFrames": "91456",
+        "md5Hex": "4f1a221fa641e39e32e602a5a4648686"
+      },
+      "nativeDecodedPcmSha256": "30f490035cb2caaf0b63f57c817211708107df2bb2622eb80a8ca7cf56d41d2d"
+    }
+  ],
+  "timingCaveats": [
+    {
+      "affectedRound": 1,
+      "workload": "packed fresh-consumer validation",
+      "detail": "A brief packed-consumer validation overlapped warm round 1 after timing began and completed before rounds 2 and 3. No measurements were excluded or adjusted; round 1 was faster than the reported median for both implementations."
+    }
+  ]
+}
diff --git a/benchmark/tsconfig.json b/benchmark/tsconfig.json
new file mode 100644
index 0000000..7407610
--- /dev/null
+++ b/benchmark/tsconfig.json
@@ -0,0 +1,7 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": ["./corpus.ts", "../src/**/*.ts"]
+}
diff --git a/bun.lock b/bun.lock
new file mode 100644
index 0000000..0926a2d
--- /dev/null
+++ b/bun.lock
@@ -0,0 +1,41 @@
+{
+  "lockfileVersion": 2,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "@misofm/codec",
+      "devDependencies": {
+        "@types/bun": "1.3.9",
+        "@types/node": "22.20.2",
+        "effect": "4.0.0-rc.115",
+        "playwright": "1.62.1",
+        "prettier": "3.6.2",
+        "typescript": "5.9.3",
+      },
+      "peerDependencies": {
+        "effect": "4.0.0-rc.112 || 4.0.0-rc.115",
+      },
+    },
+  },
+  "packages": {
+    "@types/bun": ["@types/bun@1.3.9", "", { "dependencies": { "bun-types": "1.3.9" } }, "sha512-KQ571yULOdWJiMH+RIWIOZ7B2RXQGpL1YQrBtLIV3FqDcCu6FsbFUBwhdKUlCKUpS3PJDsHlJ1QKlpxoVR+xtw=="],
+
+    "@types/node": ["@types/node@22.20.2", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-xlvWf4Vs9n1PEVYwP1n4vvG07M6y8WgvJ2t0vbrWTmijsIHp1cS+uJ2kMIRdY3nHZK0nCYKrPeD171+SzF4/zw=="],
+
+    "bun-types": ["bun-types@1.3.9", "", { "dependencies": { "@types/node": "*" } }, "sha512-+UBWWOakIP4Tswh0Bt0QD0alpTY8cb5hvgiYeWCMet9YukHbzuruIEeXC2D7nMJPB12kbh8C7XJykSexEqGKJg=="],
+
+    "effect": ["effect@4.0.0-rc.115", "", {}, "sha512-ogYulZ5ffeOzrJqQrG0XOkDO5lKn2s9KNHhoxJy/6wKUkF0i12dlVXWA9TgsgQ+zV/JzizyG0+XMPepZEQX6vw=="],
+
+    "fsevents": ["fsevents@2.3.2", "", { "os": "darwin" }, "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA=="],
+
+    "playwright": ["playwright@1.62.1", "", { "dependencies": { "playwright-core": "1.62.1" }, "optionalDependencies": { "fsevents": "2.3.2" }, "bin": { "playwright": "cli.js" } }, "sha512-0M+L3LAD8/nm554LOla9Ayx0j0tmFZ0FBcoQ7F1VuVHpM/XpiC8RcDzBQB8W5+hA8L22THxELzeF+2WcUzvcLg=="],
+
+    "playwright-core": ["playwright-core@1.62.1", "", { "bin": { "playwright-core": "cli.js" } }, "sha512-wPYSwEBJY9GHraISXqyqtx0na0LpO3XEX7jNDhntbex7tzUS7kLnZsOlFruFJB4Hi/rhDMjXGqHewDZ68nYZVw=="],
+
+    "prettier": ["prettier@3.6.2", "", { "bin": { "prettier": "bin/prettier.cjs" } }, "sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],
+  }
+}
diff --git a/consumer/browser.ts b/consumer/browser.ts
new file mode 100644
index 0000000..3e7ec92
--- /dev/null
+++ b/consumer/browser.ts
@@ -0,0 +1,28 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import {
+  makeFlacEncoderLayer,
+  makeFlacDecoderLayer,
+  FLAC_ENCODER_WASM_URL,
+  FLAC_DECODER_WASM_URL,
+} from "@misofm/codec";
+import { scenarios } from "./scenarios.js";
+
+try {
+  const [encoder, decoder] = await Promise.all(
+    [FLAC_ENCODER_WASM_URL, FLAC_DECODER_WASM_URL].map(async (url) => {
+      const response = await fetch(url);
+      if (!response.ok)
+        throw new Error(`Wasm fetch failed: ${response.status}`);
+      return new Uint8Array(await response.arrayBuffer());
+    }),
+  );
+  const layer = Layer.merge(
+    makeFlacEncoderLayer(encoder!),
+    makeFlacDecoderLayer(decoder!),
+  );
+  const result = await Effect.runPromise(scenarios.pipe(Effect.provide(layer)));
+  postMessage(result);
+} catch (error) {
+  postMessage({ error: error instanceof Error ? error.stack : String(error) });
+}
diff --git a/consumer/scenarios.ts b/consumer/scenarios.ts
new file mode 100644
index 0000000..2ff5e09
--- /dev/null
+++ b/consumer/scenarios.ts
@@ -0,0 +1,186 @@
+import * as Cause from "effect/Cause";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import * as Stream from "effect/Stream";
+import {
+  decodeFlac,
+  encodeFlac,
+  PcmFormat,
+  type RandomAccessByteSink,
+} from "@misofm/codec";
+
+const assert: (condition: unknown, message: string) => asserts condition = (
+  condition,
+  message,
+) => {
+  if (!condition) throw new Error(message);
+};
+
+export const scenarios = Effect.gen(function* () {
+  let verifiedFrames = 0;
+  let verifiedBytes = 0;
+  let lastFlac = new Uint8Array();
+  for (const bitsPerSample of [16, 24] as const) {
+    for (const channels of [1, 2] as const) {
+      const frames = 8193;
+      const pcm = new Int32Array(frames * channels);
+      const expected = new Uint8Array(pcm.length * (bitsPerSample / 8));
+      let state = 0x12345678;
+      for (let i = 0; i < pcm.length; i++) {
+        state ^= state << 13;
+        state ^= state >>> 17;
+        state ^= state << 5;
+        const value = state >> (32 - bitsPerSample);
+        pcm[i] = value;
+        for (let byte = 0; byte < bitsPerSample / 8; byte++)
+          expected[i * (bitsPerSample / 8) + byte] = value >> (8 * byte);
+      }
+      // Deliberately bounded test artifact; production consumers supply a file sink.
+      const storage = new Uint8Array(expected.length + 65536);
+      let resized = -1;
+      let resizeCalls = 0;
+      const sink: RandomAccessByteSink<never, never> = {
+        writeAt: (offset, bytes) =>
+          Effect.sync(() => storage.set(bytes, Number(offset))),
+        resize: (length) =>
+          Effect.sync(() => {
+            resized = Number(length);
+            resizeCalls++;
+          }),
+      };
+      const pcmBlocks: Int32Array[] = [];
+      for (let start = 0; start < frames; start += 997)
+        pcmBlocks.push(
+          pcm.slice(start * channels, Math.min(frames, start + 997) * channels),
+        );
+      const format = new PcmFormat({
+        sampleRate: 44100,
+        channels,
+        bitsPerSample,
+      });
+      const result = yield* encodeFlac(Stream.fromIterable(pcmBlocks), sink, {
+        format,
+        expectedFrames: BigInt(frames),
+      });
+      assert(result.frames === BigInt(frames), "encoded frame count");
+      assert(
+        result.streamInfo.totalFrames === BigInt(frames),
+        "final STREAMINFO sample count",
+      );
+      assert(
+        resizeCalls === 1 && resized === Number(result.bytes),
+        "sink final resize",
+      );
+      const encoded = storage.slice(0, resized);
+      lastFlac = encoded;
+      const fragments: Uint8Array[] = [];
+      for (let cursor = 0; cursor < encoded.length; ) {
+        const size = cursor < 42 ? 1 : 509;
+        fragments.push(encoded.slice(cursor, cursor + size));
+        cursor += size;
+      }
+      let cursor = 0;
+      let metadata = 0;
+      let complete = 0;
+      yield* Stream.runForEach(
+        decodeFlac(Stream.fromIterable(fragments)),
+        (event) =>
+          Effect.sync(() => {
+            if (event._tag === "Metadata") {
+              assert(cursor === 0 && metadata === 0, "metadata ordering");
+              assert(
+                event.format.sampleRate === 44100 &&
+                  event.format.channels === channels &&
+                  event.format.bitsPerSample === bitsPerSample,
+                "decoded format",
+              );
+              metadata++;
+            } else if (event._tag === "Pcm") {
+              assert(metadata === 1 && complete === 0, "PCM event ordering");
+              assert(
+                event.frameOffset ===
+                  BigInt(cursor / ((channels * bitsPerSample) / 8)),
+                "PCM frame position",
+              );
+              assert(
+                event.bytes.length ===
+                  (event.frames * channels * bitsPerSample) / 8,
+                "PCM block shape",
+              );
+              for (const byte of event.bytes)
+                assert(
+                  byte === expected[cursor++],
+                  `PCM mismatch at byte ${cursor - 1}`,
+                );
+            } else {
+              assert(
+                event._tag === "Complete" &&
+                  event.md5Checked &&
+                  event.md5Verified,
+                "embedded PCM MD5 verified",
+              );
+              assert(
+                event.frames === BigInt(frames) &&
+                  event.bytes === BigInt(expected.length),
+                "verified completion counts",
+              );
+              complete++;
+            }
+          }),
+      );
+      assert(
+        metadata === 1 && complete === 1,
+        "one metadata and verified completion event",
+      );
+      assert(cursor === expected.length, "all canonical PCM bytes decoded");
+      verifiedFrames += frames;
+      verifiedBytes += expected.length;
+    }
+  }
+
+  let finalized = 0;
+  const waiting = yield* Deferred.make<void>();
+  const pendingSource = Stream.concat(
+    Stream.make(lastFlac.slice(0, 42)),
+    Stream.fromEffect(
+      Effect.andThen(Deferred.succeed(waiting, undefined), Effect.never),
+    ),
+  ).pipe(
+    Stream.ensuring(
+      Effect.sync(() => {
+        finalized++;
+      }),
+    ),
+  );
+  const pending = yield* Effect.forkChild(
+    Stream.runDrain(decodeFlac(pendingSource)),
+  );
+  yield* Deferred.await(waiting);
+  yield* Fiber.interrupt(pending);
+  const interrupted = yield* Fiber.await(pending);
+  assert(
+    Exit.isFailure(interrupted) && Cause.hasInterrupts(interrupted.cause),
+    "decode wait interruption preserved",
+  );
+  assert(finalized === 1, "interrupted source released exactly once");
+
+  const truncated = yield* Effect.exit(
+    Stream.runDrain(decodeFlac(Stream.make(lastFlac.slice(0, -1)))),
+  );
+  assert(
+    Exit.isFailure(truncated) &&
+      Cause.hasFails(truncated.cause) &&
+      !Cause.hasDies(truncated.cause),
+    "truncation must be a typed failure",
+  );
+
+  return {
+    formats: 4,
+    verifiedFrames,
+    verifiedBytes,
+    cancellation: true,
+    truncation: true,
+  };
+});
diff --git a/consumer/server.ts b/consumer/server.ts
new file mode 100644
index 0000000..e6e86e5
--- /dev/null
+++ b/consumer/server.ts
@@ -0,0 +1,16 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { FlacEncoderLive, FlacDecoderLive } from "@misofm/codec/node";
+import { scenarios } from "./scenarios.js";
+
+const result = await Effect.runPromise(
+  scenarios.pipe(Effect.provide(Layer.merge(FlacEncoderLive, FlacDecoderLive))),
+);
+console.log(
+  JSON.stringify({
+    runtime: process.versions.bun
+      ? `Bun ${process.versions.bun}`
+      : `Node ${process.version}`,
+    ...result,
+  }),
+);
diff --git a/consumer/types.ts b/consumer/types.ts
new file mode 100644
index 0000000..19b8cd6
--- /dev/null
+++ b/consumer/types.ts
@@ -0,0 +1,74 @@
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import type * as Stream from "effect/Stream";
+import {
+  encodeFlac,
+  decodeFlac,
+  type FlacEncoder,
+  type FlacDecoder,
+  type FlacEncodeResult,
+  type FlacDecodeEvent,
+  type FlacEncodeError,
+  type FlacDecodeError,
+  type PcmInputError,
+  type FlacEncodeOptions,
+  type RandomAccessByteSink,
+} from "@misofm/codec";
+
+class InputService extends Context.Service<
+  InputService,
+  { readonly input: true }
+>()("consumer/Input") {}
+class OutputService extends Context.Service<
+  OutputService,
+  { readonly output: true }
+>()("consumer/Output") {}
+interface InputFailure {
+  readonly _tag: "InputFailure";
+}
+interface OutputFailure {
+  readonly _tag: "OutputFailure";
+}
+type Equal<A, B> =
+  (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2
+    ? true
+    : false;
+type Assert<T extends true> = T;
+
+declare const input: Stream.Stream<Int32Array, InputFailure, InputService>;
+declare const compressed: Stream.Stream<Uint8Array, InputFailure, InputService>;
+declare const sink: RandomAccessByteSink<OutputFailure, OutputService>;
+declare const options: FlacEncodeOptions;
+const encoded = encodeFlac(input, sink, options);
+const decoded = decodeFlac(compressed);
+
+export type EncodeValue = Assert<
+  Equal<Effect.Success<typeof encoded>, FlacEncodeResult>
+>;
+export type EncodeErrors = Assert<
+  Equal<
+    Effect.Error<typeof encoded>,
+    InputFailure | OutputFailure | PcmInputError | FlacEncodeError
+  >
+>;
+export type EncodeServices = Assert<
+  Equal<
+    Effect.Services<typeof encoded>,
+    InputService | OutputService | FlacEncoder
+  >
+>;
+export type DecodeValue = Assert<
+  Equal<Stream.Success<typeof decoded>, FlacDecodeEvent>
+>;
+export type DecodeErrors = Assert<
+  Equal<Stream.Error<typeof decoded>, InputFailure | FlacDecodeError>
+>;
+export type DecodeServices = Assert<
+  Equal<Stream.Services<typeof decoded>, InputService | FlacDecoder>
+>;
+
+// @ts-expect-error PCM byte streams cannot be passed as integer sample streams.
+encodeFlac(compressed, sink, options);
+// @ts-expect-error Source and sink errors and services cannot disappear.
+const falselyInfallible: Effect.Effect<FlacEncodeResult> = encoded;
+void falselyInfallible;
diff --git a/docs/adapter-integration.md b/docs/adapter-integration.md
new file mode 100644
index 0000000..d056b2f
--- /dev/null
+++ b/docs/adapter-integration.md
@@ -0,0 +1,48 @@
+# Engine web adapter integration
+
+The codec boundary is designed to replace the adapter's package-private libFLAC
+implementation. Integrating it into the adapter is a separate change; this
+repository does not change playback or delivery behavior.
+
+The compatibility reference is `misofm/engine-web-adapter` revision
+`73e891df62375d1ee45d8228029796ef9597cb43`, specifically
+`src/stems/native-flac-decoder.ts`, `src/stems/native-flac-metadata.ts`,
+`src/stems/flac-input-slot.ts`, and `decoder/flac_decoder.c`. No engine or app
+source was inspected or copied for this implementation.
+
+| Responsibility                                          | Owner after integration |
+| ------------------------------------------------------- | ----------------------- |
+| libFLAC version, Wasm build and asset                   | `@misofm/codec`         |
+| FLAC metadata, frame decoding, CRC/count/MD5 checks     | `@misofm/codec`         |
+| HTTP range/auth mapping, retries and delivery admission | Adapter/caller          |
+| Worker scheduling and output credits                    | Adapter                 |
+| Canonical byte count and SHA-256, OPFS promotion        | Adapter                 |
+| AudioWorklet and engine delivery                        | Adapter                 |
+
+The existing adapter accepts mono/stereo signed 16/24-bit PCM at 44.1, 48, 88.2,
+or 96 kHz; variable FLAC blocks up to 65,535 frames; and a header sample count of
+zero when the caller supplies the expected count. Its input slot is 256 KiB and
+its packed PCM output limit is 384 KiB. These are compatibility targets for this
+library's decoder tests.
+
+Its current metadata scanner may skip non-audio metadata using HTTP ranges and
+feed a synthesized 42-byte FLAC STREAMINFO prefix followed by audio frames. The
+same sequence can be represented as an Effect byte stream for `decodeFlac`.
+Applications that already supply a complete FLAC stream can pass that directly.
+
+Use the package's portable compiled-module Layer in the adapter worker. The
+adapter can adapt its current input transport to an Effect stream and await each
+PCM block's output credit. The decoder does not require SharedArrayBuffer or
+cross-origin isolation; the adapter may retain shared transport for its own
+requirements.
+
+A final decoder completion validates FLAC's stream-level checks. It does not
+replace the adapter's canonical SHA-256 or full byte-count verification. An
+absent FLAC MD5 must remain visibly absent, and no source becomes ready before
+all adapter verification and storage promotion finish.
+
+Before replacing the adapter implementation, run its full packed browser suite,
+measure its worker memory and cancellation behavior, and update its asset
+packaging to resolve the codec package's Wasm export. This package's standalone
+packed worker test establishes host compatibility, not completed adapter
+integration.
diff --git a/docs/architecture.md b/docs/architecture.md
new file mode 100644
index 0000000..d6e42ad
--- /dev/null
+++ b/docs/architecture.md
@@ -0,0 +1,35 @@
+# Package boundaries
+
+`@misofm/codec` owns the pinned codec implementation, WebAssembly assets, typed
+format boundaries, and bounded conversion between PCM and encoded audio.
+Version 0.1 implements FLAC encoding and asynchronous streaming decoding. The public API composes with Effect;
+applications choose when and how to run it.
+
+`@misofm/transcoder` owns higher-level media pipelines such as AAC renditions,
+HLS layouts, and verified artifacts. The CLI owns orchestration, delivery chunk
+policy, manifests, uploads, and publication. Creating this package does not
+migrate either consumer automatically.
+
+The first encoding profile uses libFLAC 1.5.0 compression level 8. Prior server
+research found that exhaustive model search saved only 353,391 additional bytes
+across the measured corpus while increasing summed native encoding time from
+15.434 to 60.814 seconds. The underlying
+[research and evidence](https://github.com/misofm/engine-web-adapter/blob/73e891df62375d1ee45d8228029796ef9597cb43/research/077-lossless-delivery/REPORT.md)
+are native measurements. This repository measures the actual Wasm implementation
+separately.
+
+Wasm is the selected backend because current encoding demand does not justify
+native-addon installation and platform distribution work. Applications can
+scale jobs horizontally. Synchronous Wasm calls still occupy the host thread;
+offloading jobs belongs to the application.
+
+A seekable output capability lets libFLAC finalize STREAMINFO without retaining
+the complete output. Effect owns source consumption, sink backpressure, errors,
+and resource lifetime. Callers own durable staging and removal of partial output
+after failure or interruption.
+
+The streaming decoder bridges libFLAC's synchronous read callback to Effect
+input pulls. Each decode owns bounded memory and produces bounded PCM blocks.
+The browser adapter can consume this capability while retaining HTTP ranges,
+worker scheduling, OPFS, canonical SHA-256 verification, and engine delivery.
+Independent native libFLAC remains an oracle for verifying encoded output.
diff --git a/docs/evidence/final-review.md b/docs/evidence/final-review.md
new file mode 100644
index 0000000..3b7bc54
--- /dev/null
+++ b/docs/evidence/final-review.md
@@ -0,0 +1,65 @@
+# Final independent review — `@misofm/codec` issue 1
+
+## Decision
+
+**Signed off with no remaining blocker** at immutable commit `07189c3c709f77fb5218420896b76b152ae2b01a` (`feat: add bounded FLAC Wasm encoding and async decoding`). The worktree was clean, and `git diff --check` passed.
+
+This review covered the bounded Effect APIs, generic source/sink error and requirement ownership, encoder backpressure, asynchronous decoder streaming and chunk boundaries, metadata/frame/truncation handling, normal cancellation and finalization, malformed ABI typed failures, fixed-memory and asset guards, strict linker inputs, reproducible provenance, package imports, native-oracle tests, packed consumers, and the committed corpus receipt.
+
+## Resolved review findings
+
+The initial frozen decoder had release blockers in runtime option totality, unresolved `stdin` hidden by permissive linking, optional metadata validation/order, malformed ABI scalar/range handling, and unbounded zero-progress calls, plus inaccurate post-metadata input phases and incomplete provenance/endpoint evidence. The final commit resolves each:
+
+- decoder options fail lazily through typed `FlacDecodeError`;
+- the linker allows only `codec.read`, with inert `stdin` explicitly defined;
+- libFLAC responds to and validates supported metadata, enforces STREAMINFO order/uniqueness and optional-block legality, and maps fixed-memory refusal to typed `allocation-failed`;
+- metadata flags/scalars and PCM pointer/length/frame/offset values are checked before object/view creation;
+- 64 progressless calls produce a typed frame failure;
+- input errors use the active metadata/frame phase;
+- source/runtime hashes, units, flags, exact imports/exports, memory, and strict linker policy are recorded.
+
+The encoder review found malformed allocation values, incomplete declared metadata-chain success, discarded successful-path cleanup traps, and a missing build-time 256 KiB guard. The final commit validates state/input pointers, captures and validates the complete pinned STREAMINFO + terminal VORBIS_COMMENT profile, checks STREAMINFO block/frame scalars, performs typed idempotent cleanup before returning success, and enforces the asset ceiling in the build script. The missing musl `log_data`/`exp_data` units are restored; the level-8 native compression regression now passes.
+
+Committed ABI tests prove cleanup traps prevent encoder success and decoder `Complete`, earlier source failures remain primary, malformed encoder allocation/metadata and decoder metadata/output/stall cases fail without `Die`, and readable WAT sources correspond to embedded ordinary-test fixtures. The actual decoder allocator test demonstrates a steady live/peak/heap plateau over 96 × 4,096-frame blocks, fixed 2 MiB memory, baseline after delete, zero after dispose, and cleanup after truncation/interruption.
+
+## Independent validation
+
+- `bun run check`: **40 pass, 5 intentional native-only skips, 0 fail, 832 assertions**; Prettier and both strict TypeScript projects passed.
+- Native libFLAC 1.5.0 oracle (`989d591e2c859a921bc6ef35da2fd849fbb0ecc7a1eaf37262100cb18fd33a69`): **5 pass, 0 fail, 657 assertions**. This covers PCM16/24 native decode, level-8 LPC compression, a 65,535-frame compressed block larger than the input slot, every native 8 kHz FLAC split, and every strict prefix.
+- `bun run build`: passed.
+- Pinned offline rebuild: encoder and decoder reproduced byte-for-byte.
+- Fresh `bun run pack:check`: both Effect peers passed on Bun, Node, Chromium, Firefox, and WebKit, reproducing the recorded tarball hash.
+- GitHub Actions run `34737906581`: both the package/browser/native job and Wasm rebuild job were reported green on the reviewed commit.
+
+## Final hashes and receipts
+
+```text
+90da75c73784e7184ea6c27d3ea9509f74df2eda405d8ddc8f964d78a16a273e  wasm/flac-encoder.wasm (133,885 bytes)
+ded738b5deed37bdf277c90d6c7aec9c26779ce2f4c4852ae03804ad92ebc50f  wasm/flac-encoder.manifest.json
+5e282f9874ecb3f49b8ee8437efc318ec14ef5cff5b7580da9d875f94e5c5925  wasm/flac-decoder.wasm (74,338 bytes)
+9d29a97f4e9df858a124b524cb487aac25f0ed5e2855853050492b50778bd718  wasm/flac-decoder.manifest.json
+3a1d684e378028054eced616aa593f38f914ee6bce8a35476651f4b44080fe20  src/encode.ts
+b7c58f091a24a43b47b1369fcc8be23eec53476f263ce3c5701a8facccb8a97a  src/decode.ts
+715916727af8c6a41fe0cc2c5bf117e8b29276bab9fd89bebbcf9e567fc43645  src/internal/encoder-abi.ts
+dbd46bbbe563e0a58979ad10efde295ec44d30c55f179b81896579b1076e6f57  src/internal/decoder-abi.ts
+51468fc2376a9cf70c5b95ee8d6596b12c2ec3806e8036db3617f089a298c5b5  native/encoder.c
+9063ad212a83f506ada7caaefdf47ebad4d34d2744f8a0628c722bf3ffec8743  native/decoder.c
+13fdff77ed97c94a84f9a2f28433c694aa82184c147a2acf7eb6e4f019675e22  native/decoder-runtime.c
+36a66b7f90904c0efa29869e90e6620f4f219ff3a3771e6420b3c6aefe1131fa  scripts/build-wasm.ts
+f080c39e32ec2733737aa4e9bb8da8a3264c7ae71436b74a59d6a88f79c3f036  scripts/build-decoder-wasm.ts
+fa4bf315bc4394145c136b07b92c94058ea183725aa6f606c5171b03f154e33b  test/abi-cleanup.test.ts
+7e11a08bfca5ba5c5e57b8ae084f996d095277e8267adbdd33bbd65d1bef026d  test/resource-lifecycle.test.ts
+847848097dd1a506f9b6b380d08a608ca9a10e0a13a51fc4cfc2655be6a3b7c7  test/partition.test.ts
+c18e86ef6e9898e9c2fa41ff90b2d6bfcb7ac3adb2b70db4ff4e84d5d28fa60f  docs/evidence/packed-consumers.json
+c3670d75efb6273a132d232964e14aa1859cb6ca3d2c1bfe85479f3e6a21ae25  benchmark/evidence/corpus-benchmark.json
+```
+
+The packed receipt contains 10 successful runtime/peer combinations and tarball SHA-256 `19045d0bd1524d07b2d31e07d64fb06832a50dc968904faa5ba328601a52e7a5`. The corpus receipt is complete: 137 decoder qualifications, 822 timed rows, and 971,988,594 verified canonical PCM bytes. It records a brief packed-consumer overlap with warm round 1; all measurements remain present, and round 1 was faster than the median for both implementations.
+
+## Limits
+
+This signoff covers the package slice. Adapter migration and its HTTP/worker/OPFS pipeline were not authorized here. Caller-owned canonical SHA-256, output promotion/rollback, concurrency, and publication remain outside the codec. Mobile measurement, npm publication, merge, and release were not performed.
+
+The decoder's configurable metadata value is a read cap. It does not enlarge fixed 2 MiB memory; a legal retained block that cannot fit fails with typed `allocation-failed`, as documented. The packed browser evidence is for standalone workers and does not claim the later adapter migration.
+
+One unused older base64 test constant remains in `test/abi-cleanup.test.ts`; it is excluded from the package and has no functional effect. Root plans to remove it in a test-only follow-up.
diff --git a/docs/evidence/packed-consumers.json b/docs/evidence/packed-consumers.json
new file mode 100644
index 0000000..c4bcb82
--- /dev/null
+++ b/docs/evidence/packed-consumers.json
@@ -0,0 +1,175 @@
+{
+  "tarballSha256": "19045d0bd1524d07b2d31e07d64fb06832a50dc968904faa5ba328601a52e7a5",
+  "packedBytes": 139215,
+  "unpackedBytes": 418391,
+  "files": [
+    "LICENSE",
+    "README.md",
+    "THIRD_PARTY_NOTICES.md",
+    "dist/decode.d.ts",
+    "dist/decode.d.ts.map",
+    "dist/decode.js",
+    "dist/decode.js.map",
+    "dist/decoder-errors.d.ts",
+    "dist/decoder-errors.d.ts.map",
+    "dist/decoder-errors.js",
+    "dist/decoder-errors.js.map",
+    "dist/decoder-wasm.d.ts",
+    "dist/decoder-wasm.d.ts.map",
+    "dist/decoder-wasm.js",
+    "dist/decoder-wasm.js.map",
+    "dist/encode.d.ts",
+    "dist/encode.d.ts.map",
+    "dist/encode.js",
+    "dist/encode.js.map",
+    "dist/errors.d.ts",
+    "dist/errors.d.ts.map",
+    "dist/errors.js",
+    "dist/errors.js.map",
+    "dist/format.d.ts",
+    "dist/format.d.ts.map",
+    "dist/format.js",
+    "dist/format.js.map",
+    "dist/index.d.ts",
+    "dist/index.d.ts.map",
+    "dist/index.js",
+    "dist/index.js.map",
+    "dist/internal/decoder-abi.d.ts",
+    "dist/internal/decoder-abi.d.ts.map",
+    "dist/internal/decoder-abi.js",
+    "dist/internal/decoder-abi.js.map",
+    "dist/internal/encoder-abi.d.ts",
+    "dist/internal/encoder-abi.d.ts.map",
+    "dist/internal/encoder-abi.js",
+    "dist/internal/encoder-abi.js.map",
+    "dist/node.d.ts",
+    "dist/node.d.ts.map",
+    "dist/node.js",
+    "dist/node.js.map",
+    "dist/wasm.d.ts",
+    "dist/wasm.d.ts.map",
+    "dist/wasm.js",
+    "dist/wasm.js.map",
+    "docs/adapter-integration.md",
+    "docs/architecture.md",
+    "package.json",
+    "vendor/licenses/compiler-rt.txt",
+    "vendor/licenses/emscripten.txt",
+    "vendor/licenses/libFLAC.txt",
+    "vendor/licenses/musl.txt",
+    "wasm/flac-decoder.manifest.json",
+    "wasm/flac-decoder.wasm",
+    "wasm/flac-encoder.manifest.json",
+    "wasm/flac-encoder.wasm"
+  ],
+  "consumers": [
+    {
+      "effect": "4.0.0-rc.112",
+      "bun": {
+        "runtime": "Bun 1.4.2",
+        "formats": 4,
+        "verifiedFrames": 32772,
+        "verifiedBytes": 122895,
+        "cancellation": true,
+        "truncation": true
+      },
+      "node": {
+        "runtime": "Node v22.23.2",
+        "formats": 4,
+        "verifiedFrames": 32772,
+        "verifiedBytes": 122895,
+        "cancellation": true,
+        "truncation": true
+      },
+      "browser": [
+        {
+          "browser": "chromium",
+          "version": "151.0.7922.34",
+          "worker": {
+            "formats": 4,
+            "verifiedFrames": 32772,
+            "verifiedBytes": 122895,
+            "cancellation": true,
+            "truncation": true
+          }
+        },
+        {
+          "browser": "firefox",
+          "version": "153.0",
+          "worker": {
+            "formats": 4,
+            "verifiedFrames": 32772,
+            "verifiedBytes": 122895,
+            "cancellation": true,
+            "truncation": true
+          }
+        },
+        {
+          "browser": "webkit",
+          "version": "26.5",
+          "worker": {
+            "formats": 4,
+            "verifiedFrames": 32772,
+            "verifiedBytes": 122895,
+            "cancellation": true,
+            "truncation": true
+          }
+        }
+      ]
+    },
+    {
+      "effect": "4.0.0-rc.115",
+      "bun": {
+        "runtime": "Bun 1.4.2",
+        "formats": 4,
+        "verifiedFrames": 32772,
+        "verifiedBytes": 122895,
+        "cancellation": true,
+        "truncation": true
+      },
+      "node": {
+        "runtime": "Node v22.23.2",
+        "formats": 4,
+        "verifiedFrames": 32772,
+        "verifiedBytes": 122895,
+        "cancellation": true,
+        "truncation": true
+      },
+      "browser": [
+        {
+          "browser": "chromium",
+          "version": "151.0.7922.34",
+          "worker": {
+            "formats": 4,
+            "verifiedFrames": 32772,
+            "verifiedBytes": 122895,
+            "cancellation": true,
+            "truncation": true
+          }
+        },
+        {
+          "browser": "firefox",
+          "version": "153.0",
+          "worker": {
+            "formats": 4,
+            "verifiedFrames": 32772,
+            "verifiedBytes": 122895,
+            "cancellation": true,
+            "truncation": true
+          }
+        },
+        {
+          "browser": "webkit",
+          "version": "26.5",
+          "worker": {
+            "formats": 4,
+            "verifiedFrames": 32772,
+            "verifiedBytes": 122895,
+            "cancellation": true,
+            "truncation": true
+          }
+        }
+      ]
+    }
+  ]
+}
diff --git a/native/decoder-runtime.c b/native/decoder-runtime.c
new file mode 100644
index 0000000..e260394
--- /dev/null
+++ b/native/decoder-runtime.c
@@ -0,0 +1,241 @@
+/*
+ * Fixed-memory allocator/runtime derived from engine-web-adapter's
+ * decoder/freestanding.c at commit
+ * 73e891df62375d1ee45d8228029796ef9597cb43. The package-local copy keeps the
+ * decoder module free of WASI, filesystem, and Emscripten JavaScript runtime
+ * imports. Changes here add no product or engine behavior.
+ */
+#include <stddef.h>
+#include <stdint.h>
+
+#define HEAP_LIMIT (2u * 1024u * 1024u)
+#define ALIGNMENT 16u
+#define BLOCK_MAGIC 0x434f4443u
+
+/* libFLAC's decoder finish path compares its FILE handle with stdin. */
+void *const stdin = NULL;
+
+typedef struct Block Block;
+struct Block {
+  size_t size;
+  Block *next;
+  uint32_t magic;
+  uint32_t free;
+};
+
+extern unsigned char __heap_base;
+static uintptr_t heap_next;
+static Block *free_list;
+static size_t live_bytes;
+static size_t peak_live_bytes;
+static uintptr_t peak_heap_end;
+static uint32_t free_calls;
+static uint32_t realloc_calls;
+
+static size_t aligned(size_t bytes) {
+  return (bytes + (ALIGNMENT - 1u)) & ~(size_t)(ALIGNMENT - 1u);
+}
+
+static uintptr_t heap_start(void) {
+  return aligned((uintptr_t)&__heap_base);
+}
+
+static void record_allocation(size_t bytes) {
+  live_bytes += bytes;
+  if (live_bytes > peak_live_bytes) peak_live_bytes = live_bytes;
+  if (heap_next > peak_heap_end) peak_heap_end = heap_next;
+}
+
+static void trim_frontier(void) {
+  for (;;) {
+    Block **link = &free_list;
+    Block *block = free_list;
+    while (block != NULL &&
+           (uintptr_t)block + sizeof(Block) + block->size != heap_next) {
+      link = &block->next;
+      block = block->next;
+    }
+    if (block == NULL) return;
+    *link = block->next;
+    heap_next = (uintptr_t)block;
+  }
+}
+
+void *malloc(size_t bytes) {
+  Block **link;
+  Block *block;
+  size_t wanted;
+  uintptr_t start;
+  if (bytes == 0) bytes = 1;
+  if (bytes > HEAP_LIMIT - ALIGNMENT) return NULL;
+  wanted = aligned(bytes);
+  link = &free_list;
+  block = free_list;
+  while (block != NULL && block->size < wanted) {
+    link = &block->next;
+    block = block->next;
+  }
+  if (block != NULL) {
+    *link = block->next;
+    if (block->size >= wanted + sizeof(Block) + ALIGNMENT) {
+      Block *rest = (Block *)((uintptr_t)block + sizeof(Block) + wanted);
+      rest->size = block->size - wanted - sizeof(Block);
+      rest->magic = BLOCK_MAGIC;
+      rest->free = 1;
+      rest->next = *link;
+      *link = rest;
+      block->size = wanted;
+    }
+    block->free = 0;
+    block->next = NULL;
+    record_allocation(block->size);
+    return (void *)(block + 1);
+  }
+  if (heap_next == 0) heap_next = heap_start();
+  start = heap_next;
+  if (start > HEAP_LIMIT - sizeof(Block) ||
+      wanted > HEAP_LIMIT - start - sizeof(Block)) return NULL;
+  block = (Block *)start;
+  block->size = wanted;
+  block->next = NULL;
+  block->magic = BLOCK_MAGIC;
+  block->free = 0;
+  heap_next = start + sizeof(Block) + wanted;
+  record_allocation(wanted);
+  return (void *)(block + 1);
+}
+
+void free(void *pointer) {
+  Block *block;
+  Block **link;
+  Block *previous;
+  if (pointer == NULL) return;
+  block = ((Block *)pointer) - 1;
+  if (block->magic != BLOCK_MAGIC || block->free != 0) return;
+  free_calls += 1;
+  live_bytes -= block->size;
+  block->free = 1;
+  link = &free_list;
+  previous = NULL;
+  while (*link != NULL && (uintptr_t)*link < (uintptr_t)block) {
+    previous = *link;
+    link = &(*link)->next;
+  }
+  block->next = *link;
+  *link = block;
+  if (block->next != NULL &&
+      (uintptr_t)block + sizeof(Block) + block->size ==
+          (uintptr_t)block->next) {
+    block->size += sizeof(Block) + block->next->size;
+    block->next = block->next->next;
+  }
+  if (previous != NULL &&
+      (uintptr_t)previous + sizeof(Block) + previous->size ==
+          (uintptr_t)block) {
+    previous->size += sizeof(Block) + block->size;
+    previous->next = block->next;
+  }
+  trim_frontier();
+}
+
+void *realloc(void *pointer, size_t bytes) {
+  Block *block;
+  unsigned char *result;
+  size_t copied;
+  size_t index;
+  if (pointer == NULL) return malloc(bytes);
+  realloc_calls += 1;
+  if (bytes == 0) {
+    free(pointer);
+    return NULL;
+  }
+  block = ((Block *)pointer) - 1;
+  if (block->magic != BLOCK_MAGIC || block->free != 0) return NULL;
+  if (bytes > HEAP_LIMIT - ALIGNMENT) return NULL;
+  if (aligned(bytes) <= block->size) return pointer;
+  result = malloc(bytes);
+  if (result == NULL) return NULL;
+  copied = block->size < bytes ? block->size : bytes;
+  for (index = 0; index < copied; index++)
+    result[index] = ((unsigned char *)pointer)[index];
+  free(pointer);
+  return result;
+}
+
+void *calloc(size_t count, size_t bytes) {
+  size_t total;
+  unsigned char *result;
+  size_t index;
+  if (count != 0 && bytes > (size_t)-1 / count) return NULL;
+  total = count * bytes;
+  result = malloc(total);
+  if (result == NULL) return NULL;
+  for (index = 0; index < total; index++) result[index] = 0;
+  return result;
+}
+
+void *memcpy(void *destination, const void *source, size_t bytes) {
+  unsigned char *out = destination;
+  const unsigned char *in = source;
+  size_t index;
+  for (index = 0; index < bytes; index++) out[index] = in[index];
+  return destination;
+}
+
+void *memset(void *destination, int value, size_t bytes) {
+  unsigned char *out = destination;
+  size_t index;
+  for (index = 0; index < bytes; index++) out[index] = (unsigned char)value;
+  return destination;
+}
+
+void *memmove(void *destination, const void *source, size_t bytes) {
+  unsigned char *out = destination;
+  const unsigned char *in = source;
+  size_t index;
+  if (out < in) {
+    for (index = 0; index < bytes; index++) out[index] = in[index];
+  } else {
+    for (index = bytes; index != 0; index--) out[index - 1] = in[index - 1];
+  }
+  return destination;
+}
+
+int memcmp(const void *left, const void *right, size_t bytes) {
+  const unsigned char *a = left;
+  const unsigned char *b = right;
+  size_t index;
+  for (index = 0; index < bytes; index++) {
+    if (a[index] != b[index]) return (int)a[index] - (int)b[index];
+  }
+  return 0;
+}
+
+int abs(int value) { return value < 0 ? -value : value; }
+
+int fclose(void *stream) {
+  (void)stream;
+  return -1;
+}
+
+uint32_t codec_decoder_allocator_live_bytes(void) {
+  return (uint32_t)live_bytes;
+}
+
+uint32_t codec_decoder_allocator_peak_live_bytes(void) {
+  return (uint32_t)peak_live_bytes;
+}
+
+uint32_t codec_decoder_allocator_peak_heap_bytes(void) {
+  return peak_heap_end == 0
+      ? 0u
+      : (uint32_t)(peak_heap_end - heap_start());
+}
+
+uint32_t codec_decoder_allocator_free_calls(void) {
+  return free_calls;
+}
+
+uint32_t codec_decoder_allocator_realloc_calls(void) {
+  return realloc_calls;
+}
diff --git a/native/decoder.c b/native/decoder.c
new file mode 100644
index 0000000..e18ff71
--- /dev/null
+++ b/native/decoder.c
@@ -0,0 +1,563 @@
+#include <FLAC/stream_decoder.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(__wasm__)
+#define CODEC_IMPORT(module, name) \
+  __attribute__((import_module(module), import_name(name)))
+#define CODEC_EXPORT(name) __attribute__((export_name(name)))
+#else
+#define CODEC_IMPORT(module, name)
+#define CODEC_EXPORT(name)
+#endif
+
+#define CODEC_DECODER_ABI 1u
+#define CODEC_OUTPUT_CAPACITY (384u * 1024u)
+
+/*
+ * Asyncify suspends the synchronous libFLAC call when the host has no bytes in
+ * its single input slot. Positive values are bytes copied, zero is true EOF,
+ * and a negative value aborts decoding.
+ */
+CODEC_IMPORT("codec", "read")
+extern int32_t codec_read(uint8_t *target, uint32_t maximum_bytes);
+
+typedef struct codec_decoder {
+  FLAC__StreamDecoder *decoder;
+  uint8_t output[CODEC_OUTPUT_CAPACITY];
+  uint32_t output_length;
+  uint32_t output_frames;
+  uint64_t output_frame_offset;
+  uint64_t decoded_frames;
+  uint64_t decoded_bytes;
+  uint64_t input_bytes;
+  uint64_t expected_frames;
+  uint64_t streaminfo_frames;
+  uint32_t expected_sample_rate;
+  uint32_t expected_channels;
+  uint32_t expected_bits_per_sample;
+  uint32_t sample_rate;
+  uint32_t channels;
+  uint32_t bits_per_sample;
+  uint32_t minimum_block_frames;
+  uint32_t maximum_block_frames;
+  uint32_t previous_block_frames;
+  uint32_t frame_number;
+  uint32_t maximum_metadata_bytes;
+  uint32_t singleton_metadata;
+  int32_t callback_error;
+  int initialized;
+  int metadata_ready;
+  int md5_present;
+  int expected_format_present;
+  int expected_frames_present;
+  int standard_icon_seen;
+  int file_icon_seen;
+} codec_decoder;
+
+#define CODEC_METADATA_SEEKTABLE (1u << FLAC__METADATA_TYPE_SEEKTABLE)
+#define CODEC_METADATA_VORBIS_COMMENT \
+  (1u << FLAC__METADATA_TYPE_VORBIS_COMMENT)
+#define CODEC_METADATA_CUESHEET (1u << FLAC__METADATA_TYPE_CUESHEET)
+
+static int is_all_zero(const uint8_t *bytes, size_t length) {
+  size_t index;
+  for (index = 0; index < length; index++) {
+    if (bytes[index] != 0) return 0;
+  }
+  return 1;
+}
+
+static int string_equals(const char *left, const char *right) {
+  size_t index = 0;
+  while (left[index] != '\0' && right[index] != '\0') {
+    if (left[index] != right[index]) return 0;
+    index++;
+  }
+  return left[index] == right[index];
+}
+
+static FLAC__StreamDecoderReadStatus read_callback(
+    const FLAC__StreamDecoder *decoder,
+    FLAC__byte buffer[],
+    size_t *bytes,
+    void *client_data) {
+  codec_decoder *self = (codec_decoder *)client_data;
+  size_t maximum = *bytes;
+  int32_t result;
+
+  if (maximum == 0 || maximum > UINT32_MAX) {
+    self->callback_error = 1;
+    *bytes = 0;
+    return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
+  }
+
+  if (FLAC__stream_decoder_get_state(decoder) ==
+          FLAC__STREAM_DECODER_SEARCH_FOR_METADATA ||
+      FLAC__stream_decoder_get_state(decoder) ==
+          FLAC__STREAM_DECODER_READ_METADATA) {
+    uint64_t remaining;
+    if (self->input_bytes >= self->maximum_metadata_bytes) {
+      self->callback_error = 2;
+      *bytes = 0;
+      return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
+    }
+    remaining = (uint64_t)self->maximum_metadata_bytes - self->input_bytes;
+    if (remaining < maximum) maximum = (size_t)remaining;
+  }
+
+  result = codec_read(buffer, (uint32_t)maximum);
+  if (result > 0 && (uint32_t)result <= (uint32_t)maximum) {
+    *bytes = (size_t)result;
+    self->input_bytes += (uint32_t)result;
+    return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
+  }
+  *bytes = 0;
+  if (result == 0) return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
+  self->callback_error = 3;
+  return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
+}
+
+static FLAC__StreamDecoderWriteStatus write_callback(
+    const FLAC__StreamDecoder *decoder,
+    const FLAC__Frame *frame,
+    const FLAC__int32 *const channels[],
+    void *client_data) {
+  codec_decoder *self = (codec_decoder *)client_data;
+  uint32_t block = frame->header.blocksize;
+  uint32_t width;
+  uint32_t sample;
+  uint32_t channel;
+  uint64_t output_bytes;
+  uint64_t position;
+  (void)decoder;
+
+  if (!self->metadata_ready || self->output_length != 0 || block == 0 ||
+      block > self->maximum_block_frames ||
+      (self->previous_block_frames != 0 &&
+       self->previous_block_frames < self->minimum_block_frames) ||
+      frame->header.sample_rate != self->sample_rate ||
+      frame->header.channels != self->channels ||
+      frame->header.bits_per_sample != self->bits_per_sample) {
+    self->callback_error = 10;
+    return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
+  }
+
+  if (frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER) {
+    position = frame->header.number.sample_number;
+  } else if (frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER) {
+    if (frame->header.number.frame_number != self->frame_number ||
+        (self->previous_block_frames != 0 &&
+         self->previous_block_frames != self->maximum_block_frames)) {
+      self->callback_error = 11;
+      return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
+    }
+    position = self->decoded_frames;
+  } else {
+    self->callback_error = 11;
+    return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
+  }
+
+  if (position != self->decoded_frames) {
+    self->callback_error = 11;
+    return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
+  }
+
+  width = self->bits_per_sample / 8u;
+  output_bytes = (uint64_t)block * self->channels * width;
+  if (output_bytes > CODEC_OUTPUT_CAPACITY ||
+      (self->expected_frames_present &&
+       self->decoded_frames + block > self->expected_frames)) {
+    self->callback_error = 12;
+    return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
+  }
+
+  for (sample = 0; sample < block; sample++) {
+    for (channel = 0; channel < self->channels; channel++) {
+      uint32_t offset = (sample * self->channels + channel) * width;
+      uint32_t value = (uint32_t)channels[channel][sample];
+      self->output[offset] = (uint8_t)value;
+      self->output[offset + 1] = (uint8_t)(value >> 8);
+      if (width == 3u) self->output[offset + 2] = (uint8_t)(value >> 16);
+    }
+  }
+
+  self->output_frame_offset = self->decoded_frames;
+  self->output_length = (uint32_t)output_bytes;
+  self->output_frames = block;
+  self->decoded_frames += block;
+  self->decoded_bytes += output_bytes;
+  self->previous_block_frames = block;
+  self->frame_number += 1;
+  return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
+}
+
+static void metadata_callback(
+    const FLAC__StreamDecoder *decoder,
+    const FLAC__StreamMetadata *metadata,
+    void *client_data) {
+  codec_decoder *self = (codec_decoder *)client_data;
+  const FLAC__StreamMetadata_StreamInfo *info;
+  const char *violation = NULL;
+  uint32_t index;
+  uint32_t singleton;
+  (void)decoder;
+
+  if (self->callback_error != 0) return;
+  if (metadata->type == FLAC__METADATA_TYPE_STREAMINFO) {
+    if (self->metadata_ready) {
+      self->callback_error = 20;
+      return;
+    }
+    info = &metadata->data.stream_info;
+    if (info->sample_rate < 8000u || info->sample_rate > 192000u ||
+        (info->channels != 1u && info->channels != 2u) ||
+        (info->bits_per_sample != 16u && info->bits_per_sample != 24u) ||
+        info->min_blocksize < 16u ||
+        info->max_blocksize < info->min_blocksize ||
+        info->max_blocksize > 65535u ||
+        (info->min_framesize != 0u && info->max_framesize != 0u &&
+         info->max_framesize < info->min_framesize)) {
+      self->callback_error = 21;
+      return;
+    }
+    if (self->expected_format_present &&
+        (info->sample_rate != self->expected_sample_rate ||
+         info->channels != self->expected_channels ||
+         info->bits_per_sample != self->expected_bits_per_sample)) {
+      self->callback_error = 22;
+      return;
+    }
+    if (self->expected_frames_present && info->total_samples != 0 &&
+        info->total_samples != self->expected_frames) {
+      self->callback_error = 23;
+      return;
+    }
+
+    self->sample_rate = info->sample_rate;
+    self->channels = info->channels;
+    self->bits_per_sample = info->bits_per_sample;
+    self->minimum_block_frames = info->min_blocksize;
+    self->maximum_block_frames = info->max_blocksize;
+    self->streaminfo_frames = info->total_samples;
+    self->expected_frames = self->expected_frames_present
+                                ? self->expected_frames
+                                : info->total_samples;
+    self->expected_frames_present =
+        self->expected_frames_present || info->total_samples != 0;
+    self->md5_present =
+        !is_all_zero(info->md5sum, sizeof(info->md5sum));
+    self->metadata_ready = 1;
+    return;
+  }
+
+  if (!self->metadata_ready || metadata->type >= FLAC__METADATA_TYPE_UNDEFINED) {
+    self->callback_error = 20;
+    return;
+  }
+
+  singleton = 0;
+  if (metadata->type == FLAC__METADATA_TYPE_SEEKTABLE)
+    singleton = CODEC_METADATA_SEEKTABLE;
+  else if (metadata->type == FLAC__METADATA_TYPE_VORBIS_COMMENT)
+    singleton = CODEC_METADATA_VORBIS_COMMENT;
+  else if (metadata->type == FLAC__METADATA_TYPE_CUESHEET)
+    singleton = CODEC_METADATA_CUESHEET;
+  if (singleton != 0) {
+    if ((self->singleton_metadata & singleton) != 0) {
+      self->callback_error = 20;
+      return;
+    }
+    self->singleton_metadata |= singleton;
+  }
+
+  switch (metadata->type) {
+    case FLAC__METADATA_TYPE_PADDING:
+      return;
+    case FLAC__METADATA_TYPE_APPLICATION:
+      if (metadata->length >= 4u) return;
+      break;
+    case FLAC__METADATA_TYPE_SEEKTABLE:
+      if (FLAC__format_seektable_is_legal(&metadata->data.seek_table)) return;
+      break;
+    case FLAC__METADATA_TYPE_VORBIS_COMMENT:
+      if (!FLAC__format_vorbiscomment_entry_value_is_legal(
+              metadata->data.vorbis_comment.vendor_string.entry,
+              metadata->data.vorbis_comment.vendor_string.length))
+        break;
+      for (index = 0;
+           index < metadata->data.vorbis_comment.num_comments;
+           index++) {
+        if (!FLAC__format_vorbiscomment_entry_is_legal(
+                metadata->data.vorbis_comment.comments[index].entry,
+                metadata->data.vorbis_comment.comments[index].length))
+          break;
+      }
+      if (index == metadata->data.vorbis_comment.num_comments) return;
+      break;
+    case FLAC__METADATA_TYPE_CUESHEET:
+      if (FLAC__format_cuesheet_is_legal(&metadata->data.cue_sheet, false,
+                                         &violation))
+        return;
+      break;
+    case FLAC__METADATA_TYPE_PICTURE:
+      if (!FLAC__format_picture_is_legal(&metadata->data.picture, &violation))
+        break;
+      if (metadata->data.picture.type ==
+          FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD) {
+        if (self->standard_icon_seen ||
+            !string_equals(metadata->data.picture.mime_type, "image/png") ||
+            metadata->data.picture.width != 32u ||
+            metadata->data.picture.height != 32u)
+          break;
+        self->standard_icon_seen = 1;
+      } else if (metadata->data.picture.type ==
+                 FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON) {
+        if (self->file_icon_seen) break;
+        self->file_icon_seen = 1;
+      }
+      return;
+    default:
+      self->callback_error = 20;
+      return;
+  }
+  self->callback_error = 21;
+}
+
+static void error_callback(
+    const FLAC__StreamDecoder *decoder,
+    FLAC__StreamDecoderErrorStatus status,
+    void *client_data) {
+  codec_decoder *self = (codec_decoder *)client_data;
+  (void)decoder;
+  if (self->callback_error == 0)
+    self->callback_error = 100 + (int32_t)status;
+}
+
+CODEC_EXPORT("codec_decoder_abi_version")
+uint32_t codec_decoder_abi_version(void) { return CODEC_DECODER_ABI; }
+
+CODEC_EXPORT("codec_decoder_new")
+codec_decoder *codec_decoder_new(
+    uint32_t maximum_metadata_bytes,
+    uint32_t expected_sample_rate,
+    uint32_t expected_channels,
+    uint32_t expected_bits_per_sample,
+    uint32_t expected_frames_low,
+    uint32_t expected_frames_high,
+    uint32_t expected_format_present,
+    uint32_t expected_frames_present) {
+  codec_decoder *self;
+  if (maximum_metadata_bytes < 42u) return NULL;
+  self = (codec_decoder *)calloc(1, sizeof(codec_decoder));
+  if (self == NULL) return NULL;
+  self->decoder = FLAC__stream_decoder_new();
+  if (self->decoder == NULL) {
+    free(self);
+    return NULL;
+  }
+  self->maximum_metadata_bytes = maximum_metadata_bytes;
+  self->expected_sample_rate = expected_sample_rate;
+  self->expected_channels = expected_channels;
+  self->expected_bits_per_sample = expected_bits_per_sample;
+  self->expected_frames =
+      ((uint64_t)expected_frames_high << 32) | expected_frames_low;
+  self->expected_format_present = expected_format_present != 0;
+  self->expected_frames_present = expected_frames_present != 0;
+  if (!FLAC__stream_decoder_set_md5_checking(self->decoder, true) ||
+      !FLAC__stream_decoder_set_metadata_respond_all(self->decoder)) {
+    FLAC__stream_decoder_delete(self->decoder);
+    free(self);
+    return NULL;
+  }
+  return self;
+}
+
+CODEC_EXPORT("codec_decoder_init")
+int32_t codec_decoder_init(codec_decoder *self) {
+  FLAC__StreamDecoderInitStatus status;
+  if (self == NULL || self->decoder == NULL || self->initialized) return -1;
+  status = FLAC__stream_decoder_init_stream(
+      self->decoder,
+      read_callback,
+      NULL,
+      NULL,
+      NULL,
+      NULL,
+      write_callback,
+      metadata_callback,
+      error_callback,
+      self);
+  if (status != FLAC__STREAM_DECODER_INIT_STATUS_OK)
+    return -10 - (int32_t)status;
+  self->initialized = 1;
+  if (!FLAC__stream_decoder_process_until_end_of_metadata(self->decoder) ||
+      self->callback_error != 0 || !self->metadata_ready)
+    return -20;
+  return 0;
+}
+
+/* 1: output block, 2: true EOF, 0: progress, negative: terminal failure. */
+CODEC_EXPORT("codec_decoder_process_single")
+int32_t codec_decoder_process_single(codec_decoder *self) {
+  FLAC__StreamDecoderState state;
+  if (self == NULL || !self->initialized || self->decoder == NULL ||
+      self->output_length != 0)
+    return -1;
+  if (!FLAC__stream_decoder_process_single(self->decoder) ||
+      self->callback_error != 0)
+    return -2;
+  if (self->output_length != 0) return 1;
+  state = FLAC__stream_decoder_get_state(self->decoder);
+  return state == FLAC__STREAM_DECODER_END_OF_STREAM ? 2 : 0;
+}
+
+CODEC_EXPORT("codec_decoder_finish")
+int32_t codec_decoder_finish(codec_decoder *self) {
+  FLAC__bool valid;
+  if (self == NULL || !self->initialized || self->decoder == NULL ||
+      FLAC__stream_decoder_get_state(self->decoder) !=
+          FLAC__STREAM_DECODER_END_OF_STREAM ||
+      self->output_length != 0)
+    return -1;
+  if ((self->expected_frames_present &&
+       self->decoded_frames != self->expected_frames) ||
+      self->callback_error != 0)
+    return -2;
+  valid = FLAC__stream_decoder_finish(self->decoder);
+  self->initialized = 0;
+  return valid && self->callback_error == 0 ? 0 : -3;
+}
+
+CODEC_EXPORT("codec_decoder_delete")
+void codec_decoder_delete(codec_decoder *self) {
+  if (self == NULL) return;
+  if (self->decoder != NULL) FLAC__stream_decoder_delete(self->decoder);
+  memset(self, 0, sizeof(codec_decoder));
+  free(self);
+}
+
+CODEC_EXPORT("codec_decoder_output_ptr")
+uint32_t codec_decoder_output_ptr(codec_decoder *self) {
+  return self == NULL ? 0u : (uint32_t)(uintptr_t)self->output;
+}
+
+CODEC_EXPORT("codec_decoder_output_length")
+uint32_t codec_decoder_output_length(codec_decoder *self) {
+  return self == NULL ? 0u : self->output_length;
+}
+
+CODEC_EXPORT("codec_decoder_output_frames")
+uint32_t codec_decoder_output_frames(codec_decoder *self) {
+  return self == NULL ? 0u : self->output_frames;
+}
+
+CODEC_EXPORT("codec_decoder_output_frame_offset_low")
+uint32_t codec_decoder_output_frame_offset_low(codec_decoder *self) {
+  return self == NULL ? 0u : (uint32_t)self->output_frame_offset;
+}
+
+CODEC_EXPORT("codec_decoder_output_frame_offset_high")
+uint32_t codec_decoder_output_frame_offset_high(codec_decoder *self) {
+  return self == NULL ? 0u : (uint32_t)(self->output_frame_offset >> 32);
+}
+
+CODEC_EXPORT("codec_decoder_release_output")
+void codec_decoder_release_output(codec_decoder *self) {
+  if (self == NULL) return;
+  self->output_length = 0;
+  self->output_frames = 0;
+}
+
+CODEC_EXPORT("codec_decoder_sample_rate")
+uint32_t codec_decoder_sample_rate(codec_decoder *self) {
+  return self == NULL ? 0u : self->sample_rate;
+}
+
+CODEC_EXPORT("codec_decoder_channels")
+uint32_t codec_decoder_channels(codec_decoder *self) {
+  return self == NULL ? 0u : self->channels;
+}
+
+CODEC_EXPORT("codec_decoder_bits_per_sample")
+uint32_t codec_decoder_bits_per_sample(codec_decoder *self) {
+  return self == NULL ? 0u : self->bits_per_sample;
+}
+
+CODEC_EXPORT("codec_decoder_minimum_block_frames")
+uint32_t codec_decoder_minimum_block_frames(codec_decoder *self) {
+  return self == NULL ? 0u : self->minimum_block_frames;
+}
+
+CODEC_EXPORT("codec_decoder_maximum_block_frames")
+uint32_t codec_decoder_maximum_block_frames(codec_decoder *self) {
+  return self == NULL ? 0u : self->maximum_block_frames;
+}
+
+CODEC_EXPORT("codec_decoder_total_frames_low")
+uint32_t codec_decoder_total_frames_low(codec_decoder *self) {
+  return self == NULL ? 0u : (uint32_t)self->expected_frames;
+}
+
+CODEC_EXPORT("codec_decoder_total_frames_high")
+uint32_t codec_decoder_total_frames_high(codec_decoder *self) {
+  return self == NULL ? 0u : (uint32_t)(self->expected_frames >> 32);
+}
+
+CODEC_EXPORT("codec_decoder_total_frames_known")
+uint32_t codec_decoder_total_frames_known(codec_decoder *self) {
+  return self == NULL ? 0u : (uint32_t)self->expected_frames_present;
+}
+
+CODEC_EXPORT("codec_decoder_streaminfo_frames_low")
+uint32_t codec_decoder_streaminfo_frames_low(codec_decoder *self) {
+  return self == NULL ? 0u : (uint32_t)self->streaminfo_frames;
+}
+
+CODEC_EXPORT("codec_decoder_streaminfo_frames_high")
+uint32_t codec_decoder_streaminfo_frames_high(codec_decoder *self) {
+  return self == NULL ? 0u : (uint32_t)(self->streaminfo_frames >> 32);
+}
+
+CODEC_EXPORT("codec_decoder_streaminfo_frames_known")
+uint32_t codec_decoder_streaminfo_frames_known(codec_decoder *self) {
+  return self == NULL ? 0u : (uint32_t)(self->streaminfo_frames != 0);
+}
+
+CODEC_EXPORT("codec_decoder_md5_present")
+uint32_t codec_decoder_md5_present(codec_decoder *self) {
+  return self == NULL ? 0u : (uint32_t)self->md5_present;
+}
+
+CODEC_EXPORT("codec_decoder_decoded_frames_low")
+uint32_t codec_decoder_decoded_frames_low(codec_decoder *self) {
+  return self == NULL ? 0u : (uint32_t)self->decoded_frames;
+}
+
+CODEC_EXPORT("codec_decoder_decoded_frames_high")
+uint32_t codec_decoder_decoded_frames_high(codec_decoder *self) {
+  return self == NULL ? 0u : (uint32_t)(self->decoded_frames >> 32);
+}
+
+CODEC_EXPORT("codec_decoder_decoded_bytes_low")
+uint32_t codec_decoder_decoded_bytes_low(codec_decoder *self) {
+  return self == NULL ? 0u : (uint32_t)self->decoded_bytes;
+}
+
+CODEC_EXPORT("codec_decoder_decoded_bytes_high")
+uint32_t codec_decoder_decoded_bytes_high(codec_decoder *self) {
+  return self == NULL ? 0u : (uint32_t)(self->decoded_bytes >> 32);
+}
+
+CODEC_EXPORT("codec_decoder_callback_error")
+int32_t codec_decoder_callback_error(codec_decoder *self) {
+  return self == NULL ? -1 : self->callback_error;
+}
+
+CODEC_EXPORT("codec_decoder_state")
+int32_t codec_decoder_state(codec_decoder *self) {
+  return self == NULL || self->decoder == NULL
+      ? -1
+      : (int32_t)FLAC__stream_decoder_get_state(self->decoder);
+}
diff --git a/native/encoder.c b/native/encoder.c
new file mode 100644
index 0000000..1f37e47
--- /dev/null
+++ b/native/encoder.c
@@ -0,0 +1,202 @@
+#include <FLAC/stream_encoder.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#if defined(__wasm__)
+#define CODEC_IMPORT(module, name) \
+  __attribute__((import_module(module), import_name(name)))
+#define CODEC_EXPORT(name) __attribute__((export_name(name)))
+#else
+#define CODEC_IMPORT(module, name)
+#define CODEC_EXPORT(name)
+#endif
+
+/*
+ * Callbacks stay synchronous. The host copies each write into a bounded staging
+ * area, then drains that area through the caller's Effect sink after the Wasm
+ * call returns.
+ */
+CODEC_IMPORT("codec", "write")
+extern int codec_write(uint64_t offset, const uint8_t *bytes, uint32_t length);
+
+CODEC_IMPORT("codec", "seek")
+extern int codec_seek(uint64_t offset);
+
+#if defined(__wasm__)
+/* emmalloc asks before growing; this package promises fixed memory. */
+FILE *const stdin = NULL;
+FILE *const stdout = NULL;
+int emscripten_resize_heap(size_t requested_size) {
+  (void)requested_size;
+  return 0;
+}
+size_t emscripten_get_heap_size(void) { return 16u * 1024u * 1024u; }
+int *__errno_location(void) {
+  static int codec_errno;
+  return &codec_errno;
+}
+int fclose(FILE *stream) {
+  (void)stream;
+  return EOF;
+}
+size_t fread(void *buffer, size_t size, size_t count, FILE *stream) {
+  (void)buffer;
+  (void)size;
+  (void)count;
+  (void)stream;
+  return 0;
+}
+size_t fwrite(const void *buffer, size_t size, size_t count, FILE *stream) {
+  (void)buffer;
+  (void)size;
+  (void)count;
+  (void)stream;
+  return 0;
+}
+int fseeko(FILE *stream, off_t offset, int whence) {
+  (void)stream;
+  (void)offset;
+  (void)whence;
+  return -1;
+}
+off_t ftello(FILE *stream) {
+  (void)stream;
+  return (off_t)-1;
+}
+#endif
+
+typedef struct codec_encoder {
+  FLAC__StreamEncoder *encoder;
+  uint64_t cursor;
+  int initialized;
+} codec_encoder;
+
+static FLAC__StreamEncoderWriteStatus write_callback(
+    const FLAC__StreamEncoder *encoder,
+    const FLAC__byte buffer[],
+    size_t bytes,
+    unsigned samples,
+    unsigned current_frame,
+    void *client_data) {
+  codec_encoder *self = (codec_encoder *)client_data;
+  (void)encoder;
+  (void)samples;
+  (void)current_frame;
+
+  if (bytes > UINT32_MAX || codec_write(self->cursor, buffer, (uint32_t)bytes) != 0)
+    return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
+
+  self->cursor += (uint64_t)bytes;
+  return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
+}
+
+static FLAC__StreamEncoderSeekStatus seek_callback(
+    const FLAC__StreamEncoder *encoder,
+    FLAC__uint64 absolute_byte_offset,
+    void *client_data) {
+  codec_encoder *self = (codec_encoder *)client_data;
+  (void)encoder;
+
+  if (codec_seek((uint64_t)absolute_byte_offset) != 0)
+    return FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR;
+
+  self->cursor = (uint64_t)absolute_byte_offset;
+  return FLAC__STREAM_ENCODER_SEEK_STATUS_OK;
+}
+
+static FLAC__StreamEncoderTellStatus tell_callback(
+    const FLAC__StreamEncoder *encoder,
+    FLAC__uint64 *absolute_byte_offset,
+    void *client_data) {
+  codec_encoder *self = (codec_encoder *)client_data;
+  (void)encoder;
+  *absolute_byte_offset = (FLAC__uint64)self->cursor;
+  return FLAC__STREAM_ENCODER_TELL_STATUS_OK;
+}
+
+CODEC_EXPORT("codec_encoder_new")
+codec_encoder *codec_encoder_new(
+    uint32_t sample_rate,
+    uint32_t channels,
+    uint32_t bits_per_sample,
+    uint32_t compression_level,
+    uint32_t block_size) {
+  codec_encoder *self = (codec_encoder *)calloc(1, sizeof(codec_encoder));
+  if (self == NULL)
+    return NULL;
+
+  self->encoder = FLAC__stream_encoder_new();
+  if (self->encoder == NULL) {
+    free(self);
+    return NULL;
+  }
+
+  if (!FLAC__stream_encoder_set_channels(self->encoder, channels) ||
+      !FLAC__stream_encoder_set_bits_per_sample(self->encoder, bits_per_sample) ||
+      !FLAC__stream_encoder_set_sample_rate(self->encoder, sample_rate) ||
+      !FLAC__stream_encoder_set_compression_level(self->encoder, compression_level) ||
+      !FLAC__stream_encoder_set_blocksize(self->encoder, block_size) ||
+      !FLAC__stream_encoder_set_verify(self->encoder, false)) {
+    FLAC__stream_encoder_delete(self->encoder);
+    free(self);
+    return NULL;
+  }
+
+  return self;
+}
+
+CODEC_EXPORT("codec_encoder_init")
+uint32_t codec_encoder_init(codec_encoder *self) {
+  FLAC__StreamEncoderInitStatus status;
+  if (self == NULL || self->encoder == NULL || self->initialized)
+    return (uint32_t)FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
+
+  status = FLAC__stream_encoder_init_stream(
+      self->encoder,
+      write_callback,
+      seek_callback,
+      tell_callback,
+      NULL,
+      self);
+  if (status == FLAC__STREAM_ENCODER_INIT_STATUS_OK)
+    self->initialized = 1;
+  return (uint32_t)status;
+}
+
+CODEC_EXPORT("codec_encoder_process_interleaved")
+uint32_t codec_encoder_process_interleaved(
+    codec_encoder *self,
+    const FLAC__int32 pcm[],
+    uint32_t frames) {
+  if (self == NULL || self->encoder == NULL || !self->initialized)
+    return 0;
+  return FLAC__stream_encoder_process_interleaved(self->encoder, pcm, frames) ? 1 : 0;
+}
+
+CODEC_EXPORT("codec_encoder_finish")
+uint32_t codec_encoder_finish(codec_encoder *self) {
+  FLAC__bool ok;
+  if (self == NULL || self->encoder == NULL || !self->initialized)
+    return 0;
+  ok = FLAC__stream_encoder_finish(self->encoder);
+  self->initialized = 0;
+  return ok ? 1 : 0;
+}
+
+CODEC_EXPORT("codec_encoder_state")
+uint32_t codec_encoder_state(codec_encoder *self) {
+  if (self == NULL || self->encoder == NULL)
+    return UINT32_MAX;
+  return (uint32_t)FLAC__stream_encoder_get_state(self->encoder);
+}
+
+/* Deliberately does not finish: failed/interrupted calls must not emit output. */
+CODEC_EXPORT("codec_encoder_delete")
+void codec_encoder_delete(codec_encoder *self) {
+  if (self == NULL)
+    return;
+  if (self->encoder != NULL)
+    FLAC__stream_encoder_delete(self->encoder);
+  free(self);
+}
diff --git a/native/libflac-stream-only.patch b/native/libflac-stream-only.patch
new file mode 100644
index 0000000..24c71fa
--- /dev/null
+++ b/native/libflac-stream-only.patch
@@ -0,0 +1,30 @@
+--- a/src/libFLAC/stream_encoder.c
++++ b/src/libFLAC/stream_encoder.c
+@@ -1883,6 +1883,19 @@
+ 	ok &= FLAC__stream_encoder_set_do_mid_side_stereo          (encoder, compression_levels_[value].do_mid_side_stereo);
+ 	ok &= FLAC__stream_encoder_set_loose_mid_side_stereo       (encoder, compression_levels_[value].loose_mid_side_stereo);
+ #ifndef FLAC__INTEGER_ONLY_LIBRARY
++#if defined(CODEC_STREAM_ONLY)
++	encoder->protected_->num_apodizations = 1;
++	if(value >= 6) {
++		const uint32_t parts = value >= 8 ? 3 : 2;
++		encoder->protected_->apodizations[0].type = FLAC__APODIZATION_SUBDIVIDE_TUKEY;
++		encoder->protected_->apodizations[0].parameters.subdivide_tukey.parts = parts;
++		encoder->protected_->apodizations[0].parameters.subdivide_tukey.p = 0.5 / parts;
++	}
++	else {
++		encoder->protected_->apodizations[0].type = FLAC__APODIZATION_TUKEY;
++		encoder->protected_->apodizations[0].parameters.tukey.p = 0.5;
++	}
++#else
+ #if 1
+ 	ok &= FLAC__stream_encoder_set_apodization                 (encoder, compression_levels_[value].apodization);
+ #else
+@@ -1892,6 +1905,7 @@
+ 	encoder->protected_->apodizations[0].parameters.tukey.p = 0.5;
+ #endif
+ #endif
++#endif
+ 	ok &= FLAC__stream_encoder_set_max_lpc_order               (encoder, compression_levels_[value].max_lpc_order);
+ 	ok &= FLAC__stream_encoder_set_qlp_coeff_precision         (encoder, compression_levels_[value].qlp_coeff_precision);
+ 	ok &= FLAC__stream_encoder_set_do_qlp_coeff_prec_search    (encoder, compression_levels_[value].do_qlp_coeff_prec_search);
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..6936f3a
--- /dev/null
+++ b/package.json
@@ -0,0 +1,67 @@
+{
+  "name": "@misofm/codec",
+  "version": "0.1.0",
+  "description": "Effect-based audio codec primitives backed by pinned libFLAC WebAssembly",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/misofm/codec.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "bun": ">=1.4.2 <1.5",
+    "node": ">=22.23.2 <23"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.js"
+    },
+    "./wasm/flac-encoder.wasm": "./wasm/flac-encoder.wasm",
+    "./wasm/flac-decoder.wasm": "./wasm/flac-decoder.wasm",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "wasm/*.wasm",
+    "wasm/*.manifest.json",
+    "README.md",
+    "docs/*.md",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md",
+    "vendor/licenses"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "build:wasm": "bun run scripts/build-wasm.ts --verify && bun run scripts/build-decoder-wasm.ts --verify",
+    "build:wasm:update": "bun run scripts/build-wasm.ts --update && bun run scripts/build-decoder-wasm.ts --update",
+    "build:wasm:verify": "bun run scripts/build-wasm.ts --verify && bun run scripts/build-decoder-wasm.ts --verify",
+    "check": "bun run format:check && bun run typecheck && bun test",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\" \"scripts/*.{ts,mjs}\" \"consumer/**/*.ts\" \"benchmark/*.ts\" \"benchmark/*.md\" \"benchmark/tsconfig.json\" \"docs/*.md\" \"*.md\" \".github/**/*.md\" \".github/**/*.yml\" \"*.json\"",
+    "format:check": "prettier --check \"src/**/*.ts\" \"test/**/*.ts\" \"scripts/*.{ts,mjs}\" \"consumer/**/*.ts\" \"benchmark/*.ts\" \"benchmark/*.md\" \"benchmark/tsconfig.json\" \"docs/*.md\" \"*.md\" \".github/**/*.md\" \".github/**/*.yml\" \"*.json\"",
+    "pack:check": "node scripts/pack-check.mjs",
+    "test": "bun test",
+    "test:integration": "if [ -z \"$CODEC_NATIVE_FLAC\" ]; then echo 'CODEC_NATIVE_FLAC must name the pinned native flac binary' >&2; exit 1; fi; bun test test/*-native-integration.test.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p benchmark/tsconfig.json --noEmit"
+  },
+  "peerDependencies": {
+    "effect": "4.0.0-rc.112 || 4.0.0-rc.115"
+  },
+  "devDependencies": {
+    "@types/bun": "1.3.9",
+    "@types/node": "22.20.2",
+    "effect": "4.0.0-rc.115",
+    "playwright": "1.62.1",
+    "prettier": "3.6.2",
+    "typescript": "5.9.3"
+  }
+}
diff --git a/scripts/browser-consumer.mjs b/scripts/browser-consumer.mjs
new file mode 100644
index 0000000..8401403
--- /dev/null
+++ b/scripts/browser-consumer.mjs
@@ -0,0 +1,102 @@
+import { createServer } from "node:http";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { chromium, firefox, webkit } from "playwright";
+
+const directory = process.argv[2];
+if (!directory)
+  throw new Error(
+    "usage: node scripts/browser-consumer.mjs CONSUMER_DIRECTORY",
+  );
+const routes = new Map([
+  ["/browser.js", [join(directory, "browser.js"), "text/javascript"]],
+  [
+    "/wasm/flac-encoder.wasm",
+    [
+      join(directory, "node_modules/@misofm/codec/wasm/flac-encoder.wasm"),
+      "application/wasm",
+    ],
+  ],
+  [
+    "/wasm/flac-decoder.wasm",
+    [
+      join(directory, "node_modules/@misofm/codec/wasm/flac-decoder.wasm"),
+      "application/wasm",
+    ],
+  ],
+]);
+const server = createServer(async (request, response) => {
+  try {
+    if (request.url === "/") {
+      response.writeHead(200, { "content-type": "text/html" });
+      response.end("<!doctype html><title>Packed codec consumer</title>");
+      return;
+    }
+    const route = routes.get(request.url);
+    if (!route) {
+      response.writeHead(404);
+      response.end();
+      return;
+    }
+    response.writeHead(200, { "content-type": route[1] });
+    response.end(await readFile(route[0]));
+  } catch (error) {
+    response.writeHead(500);
+    response.end(String(error));
+  }
+});
+await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+const address = server.address();
+const results = [];
+try {
+  for (const [name, browserType] of [
+    ["chromium", chromium],
+    ["firefox", firefox],
+    ["webkit", webkit],
+  ]) {
+    const browser = await browserType.launch({
+      headless: true,
+      ...(name === "chromium" && process.env.CODEC_CHROMIUM_PATH
+        ? { executablePath: process.env.CODEC_CHROMIUM_PATH }
+        : {}),
+    });
+    try {
+      const page = await browser.newPage();
+      await page.goto(`http://127.0.0.1:${address.port}/`);
+      const result = await page.evaluate(async () => {
+        const worker = new Worker("/browser.js", { type: "module" });
+        try {
+          return await new Promise((resolve, reject) => {
+            const timeout = setTimeout(
+              () => reject(new Error("codec worker timed out")),
+              30000,
+            );
+            worker.onerror = (event) => {
+              clearTimeout(timeout);
+              reject(new Error(event.message));
+            };
+            worker.onmessage = ({ data }) => {
+              clearTimeout(timeout);
+              if (data.error) reject(new Error(data.error));
+              else resolve(data);
+            };
+          });
+        } finally {
+          worker.terminate();
+        }
+      });
+      results.push({
+        browser: name,
+        version: browser.version(),
+        worker: result,
+      });
+    } finally {
+      await browser.close();
+    }
+  }
+  process.stdout.write(`${JSON.stringify(results)}\n`);
+} finally {
+  await new Promise((resolve, reject) =>
+    server.close((error) => (error ? reject(error) : resolve())),
+  );
+}
diff --git a/scripts/build-decoder-wasm.ts b/scripts/build-decoder-wasm.ts
new file mode 100644
index 0000000..1fef7e8
--- /dev/null
+++ b/scripts/build-decoder-wasm.ts
@@ -0,0 +1,385 @@
+import { createHash } from "node:crypto";
+import {
+  chmod,
+  copyFile,
+  mkdir,
+  readFile,
+  rm,
+  writeFile,
+} from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+
+const repository = resolve(import.meta.dirname, "..");
+const sourceArchive = resolve(
+  repository,
+  "vendor/libflac-1.5.0/flac-1.5.0.tar.xz",
+);
+const wrapperSource = resolve(repository, "native/decoder.c");
+const asset = resolve(repository, "wasm/flac-decoder.wasm");
+const manifestPath = resolve(repository, "wasm/flac-decoder.manifest.json");
+const buildRoot = resolve(repository, ".cache/flac-decoder-build");
+const sourceRoot = resolve(buildRoot, "flac-1.5.0");
+const runtimeSource = resolve(repository, "native/decoder-runtime.c");
+const emscriptenRoot =
+  process.env.CODEC_EMSCRIPTEN_ROOT ??
+  "/data/codec-tooling/emsdk/upstream/emscripten";
+const emsdkRoot = resolve(emscriptenRoot, "../..");
+const emcc = resolve(emscriptenRoot, "emcc");
+const emconfigure = resolve(emscriptenRoot, "emconfigure");
+const wasmLd = resolve(emscriptenRoot, "../bin/wasm-ld");
+const wasmOpt = resolve(emscriptenRoot, "../bin/wasm-opt");
+
+const SOURCE_SHA256 =
+  "f2c1c76592a82ffff8413ba3c4a1299b6c7ab06c734dee03fd88630485c2b920";
+const EMCC_VERSION = "6.0.9";
+const EMCC_COMMIT = "4e4223852a0835923411059a3929907d7df1232e";
+const SDK_TAG_COMMIT = "5eb0bde7585670252e8ba05e9d361627bffd08b5";
+const SDK_RELEASES_COMMIT = "f04ea239d533260dd1db760dd2d668d5f9a88d6b";
+const WASM_OPT_VERSION = "wasm-opt version 132 (version_132-49-gd03c25ea4)";
+const MEMORY_BYTES = 2 * 1024 * 1024;
+const STACK_BYTES = 64 * 1024;
+const ASYNCIFY_STACK_BYTES = 64 * 1024;
+
+const sha256 = (bytes: Uint8Array): string =>
+  createHash("sha256").update(bytes).digest("hex");
+
+const run = async (
+  command: string,
+  args: ReadonlyArray<string>,
+  cwd = repository,
+  env: Record<string, string> = {},
+): Promise<string> => {
+  const proc = Bun.spawn([command, ...args], {
+    cwd,
+    env: { ...process.env, ...env },
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, status] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+  if (status !== 0)
+    throw new Error(`${command} exited ${status}\n${stdout}${stderr}`);
+  if (stderr.length > 0) process.stderr.write(stderr);
+  return stdout;
+};
+
+const main = async (): Promise<void> => {
+  const mode = process.argv[2];
+  if (mode !== "--verify" && mode !== "--update") {
+    throw new Error(
+      "usage: bun run scripts/build-decoder-wasm.ts --verify|--update",
+    );
+  }
+
+  const archiveHash = sha256(new Uint8Array(await readFile(sourceArchive)));
+  if (archiveHash !== SOURCE_SHA256) {
+    throw new Error(`libFLAC source SHA-256 mismatch: ${archiveHash}`);
+  }
+  const version = await run(emcc, ["--version"]);
+  if (
+    !version.includes(
+      `emcc (Emscripten gcc/clang-like replacement + linker emulating GNU ld) ${EMCC_VERSION}`,
+    ) ||
+    !version.includes(EMCC_COMMIT)
+  ) {
+    throw new Error(`unexpected compiler version:\n${version}`);
+  }
+  const sdkCommit = (
+    await run("git", ["-C", emsdkRoot, "rev-parse", "HEAD"])
+  ).trim();
+  if (sdkCommit !== SDK_TAG_COMMIT) {
+    throw new Error(`unexpected emsdk checkout commit: ${sdkCommit}`);
+  }
+  const releaseTags = JSON.parse(
+    await readFile(resolve(emsdkRoot, "emscripten-releases-tags.json"), "utf8"),
+  ) as {
+    readonly releases?: Readonly<Record<string, string>>;
+  };
+  if (releaseTags.releases?.[EMCC_VERSION] !== SDK_RELEASES_COMMIT) {
+    throw new Error(`emsdk release mapping for ${EMCC_VERSION} is not pinned`);
+  }
+  const wasmOptVersion = (await run(wasmOpt, ["--version"])).trim();
+  if (wasmOptVersion !== WASM_OPT_VERSION) {
+    throw new Error(`unexpected wasm-opt version: ${wasmOptVersion}`);
+  }
+
+  await rm(buildRoot, { recursive: true, force: true });
+  await mkdir(buildRoot, { recursive: true });
+  await run("tar", ["-xJf", sourceArchive, "-C", buildRoot]);
+  await chmod(resolve(sourceRoot, "configure"), 0o755);
+  const reproducibleEnv = {
+    SOURCE_DATE_EPOCH: "1735689600",
+    ZERO_AR_DATE: "1",
+    CFLAGS: "-O3 -DNDEBUG",
+  };
+  await run(
+    emconfigure,
+    [
+      "./configure",
+      "--host=wasm32-unknown-emscripten",
+      "--disable-shared",
+      "--enable-static",
+      "--disable-asm-optimizations",
+      "--disable-avx",
+      "--disable-cpplibs",
+      "--disable-ogg",
+      "--disable-oggtest",
+      "--disable-programs",
+      "--disable-examples",
+      "--disable-multithreading",
+      "--disable-doxygen-docs",
+      "--disable-dependency-tracking",
+      "--disable-version-from-git",
+    ],
+    sourceRoot,
+    reproducibleEnv,
+  );
+  const commonCompile = [
+    "-O3",
+    "-ffreestanding",
+    "-fno-builtin",
+    "-DFLAC__NO_DLL",
+    "-DHAVE_CONFIG_H",
+    `-I${sourceRoot}`,
+    `-I${resolve(sourceRoot, "include")}`,
+    `-I${resolve(sourceRoot, "src/libFLAC/include")}`,
+  ];
+  const units = [
+    "bitmath",
+    "bitreader",
+    "cpu",
+    "crc",
+    "fixed",
+    "format",
+    "lpc",
+    "md5",
+    "memory",
+    "stream_decoder",
+  ];
+  const objects: Array<string> = [];
+  for (const unit of units) {
+    const object = resolve(buildRoot, `${unit}.o`);
+    await run(
+      emcc,
+      [
+        ...commonCompile,
+        "-c",
+        resolve(sourceRoot, `src/libFLAC/${unit}.c`),
+        "-o",
+        object,
+      ],
+      repository,
+      reproducibleEnv,
+    );
+    objects.push(object);
+  }
+  const wrapperObject = resolve(buildRoot, "decoder.o");
+  const runtimeObject = resolve(buildRoot, "decoder-runtime.o");
+  await run(
+    emcc,
+    [...commonCompile, "-c", wrapperSource, "-o", wrapperObject],
+    repository,
+    reproducibleEnv,
+  );
+  await run(
+    emcc,
+    [...commonCompile, "-c", runtimeSource, "-o", runtimeObject],
+    repository,
+    reproducibleEnv,
+  );
+
+  const rawOutput = resolve(buildRoot, "flac-decoder.raw.wasm");
+  const output = resolve(buildRoot, "flac-decoder.wasm");
+  const allowedUndefined = resolve(buildRoot, "allowed-undefined.txt");
+  await writeFile(allowedUndefined, "codec_read\n");
+  const exports = [
+    "malloc",
+    "free",
+    "codec_decoder_abi_version",
+    "codec_decoder_new",
+    "codec_decoder_init",
+    "codec_decoder_process_single",
+    "codec_decoder_finish",
+    "codec_decoder_delete",
+    "codec_decoder_output_ptr",
+    "codec_decoder_output_length",
+    "codec_decoder_output_frames",
+    "codec_decoder_output_frame_offset_low",
+    "codec_decoder_output_frame_offset_high",
+    "codec_decoder_release_output",
+    "codec_decoder_sample_rate",
+    "codec_decoder_channels",
+    "codec_decoder_bits_per_sample",
+    "codec_decoder_minimum_block_frames",
+    "codec_decoder_maximum_block_frames",
+    "codec_decoder_total_frames_low",
+    "codec_decoder_total_frames_high",
+    "codec_decoder_total_frames_known",
+    "codec_decoder_md5_present",
+    "codec_decoder_streaminfo_frames_low",
+    "codec_decoder_streaminfo_frames_high",
+    "codec_decoder_streaminfo_frames_known",
+    "codec_decoder_decoded_frames_low",
+    "codec_decoder_decoded_frames_high",
+    "codec_decoder_decoded_bytes_low",
+    "codec_decoder_decoded_bytes_high",
+    "codec_decoder_callback_error",
+    "codec_decoder_state",
+    "codec_decoder_allocator_live_bytes",
+    "codec_decoder_allocator_peak_live_bytes",
+    "codec_decoder_allocator_peak_heap_bytes",
+    "codec_decoder_allocator_free_calls",
+    "codec_decoder_allocator_realloc_calls",
+  ];
+  await run(
+    wasmLd,
+    [
+      "--no-entry",
+      `--allow-undefined-file=${allowedUndefined}`,
+      "--import-undefined",
+      "--export-memory",
+      `--initial-memory=${MEMORY_BYTES}`,
+      `--max-memory=${MEMORY_BYTES}`,
+      "--stack-first",
+      "-z",
+      `stack-size=${STACK_BYTES}`,
+      "--strip-all",
+      ...exports.map((name) => `--export=${name}`),
+      "-o",
+      rawOutput,
+      wrapperObject,
+      ...objects,
+      runtimeObject,
+    ],
+    repository,
+    reproducibleEnv,
+  );
+  await run(
+    wasmOpt,
+    [
+      rawOutput,
+      "--asyncify",
+      "--pass-arg=asyncify-imports@codec.read",
+      "--enable-bulk-memory",
+      "-O3",
+      "--strip-debug",
+      "-o",
+      output,
+    ],
+    repository,
+    reproducibleEnv,
+  );
+
+  const outputBytes = new Uint8Array(await readFile(output));
+  const outputHash = sha256(outputBytes);
+  const module = await WebAssembly.compile(outputBytes);
+  const imports = WebAssembly.Module.imports(module)
+    .map(({ module, name, kind }) => `${module}.${name}:${kind}`)
+    .sort();
+  const expectedImports = ["codec.read:function"];
+  if (JSON.stringify(imports) !== JSON.stringify(expectedImports)) {
+    throw new Error(`unexpected Wasm imports: ${imports.join(", ")}`);
+  }
+  const exported = WebAssembly.Module.exports(module)
+    .map(({ name, kind }) => `${name}:${kind}`)
+    .sort();
+  const expectedExports = [
+    "memory:memory",
+    "asyncify_get_state:function",
+    "asyncify_start_unwind:function",
+    "asyncify_stop_unwind:function",
+    "asyncify_start_rewind:function",
+    "asyncify_stop_rewind:function",
+    ...exports.map((name) => `${name}:function`),
+  ].sort();
+  if (JSON.stringify(exported) !== JSON.stringify(expectedExports)) {
+    throw new Error(`unexpected Wasm exports: ${exported.join(", ")}`);
+  }
+  if (outputBytes.byteLength > 256 * 1024) {
+    throw new Error(
+      `decoder Wasm exceeds 256 KiB objective: ${outputBytes.byteLength}`,
+    );
+  }
+
+  const [wrapperSha256, runtimeSha256] = await Promise.all([
+    readFile(wrapperSource).then((bytes) => sha256(new Uint8Array(bytes))),
+    readFile(runtimeSource).then((bytes) => sha256(new Uint8Array(bytes))),
+  ]);
+
+  const manifest = {
+    asset: "flac-decoder.wasm",
+    assetSha256: outputHash,
+    libflac: {
+      version: "1.5.0",
+      archive: "vendor/libflac-1.5.0/flac-1.5.0.tar.xz",
+      archiveSha256: SOURCE_SHA256,
+    },
+    sources: {
+      wrapper: "native/decoder.c",
+      wrapperSha256,
+      runtime: "native/decoder-runtime.c",
+      runtimeSha256,
+    },
+    emscripten: {
+      version: EMCC_VERSION,
+      compilerCommit: EMCC_COMMIT,
+      sdkTagCommit: SDK_TAG_COMMIT,
+      sdkReleasesCommit: SDK_RELEASES_COMMIT,
+      wasmOptVersion: WASM_OPT_VERSION,
+    },
+    build: {
+      initialMemoryBytes: MEMORY_BYTES,
+      maximumMemoryBytes: MEMORY_BYTES,
+      stackBytes: STACK_BYTES,
+      asyncifyStackBytes: ASYNCIFY_STACK_BYTES,
+      filesystem: false,
+      memoryGrowth: false,
+      imports: expectedImports,
+      exports: expectedExports,
+      libflacUnits: units,
+      compilerFlags: [
+        "-O3",
+        "-ffreestanding",
+        "-fno-builtin",
+        "-DFLAC__NO_DLL",
+        "-DHAVE_CONFIG_H",
+      ],
+      linkerPolicy: {
+        allowedUndefinedSymbols: ["codec_read"],
+        noEntry: true,
+        stripAll: true,
+      },
+      asyncifyImports: ["codec.read"],
+    },
+  } as const;
+  const serializedManifest = `${JSON.stringify(manifest, null, 2)}\n`;
+
+  if (mode === "--update") {
+    await mkdir(dirname(asset), { recursive: true });
+    await copyFile(output, asset);
+    await writeFile(manifestPath, serializedManifest);
+    process.stdout.write(`updated wasm/flac-decoder.wasm (${outputHash})\n`);
+    return;
+  }
+
+  const [checkedAsset, checkedManifest] = await Promise.all([
+    readFile(asset),
+    readFile(manifestPath, "utf8"),
+  ]);
+  if (
+    sha256(checkedAsset) !== outputHash ||
+    checkedManifest !== serializedManifest
+  ) {
+    throw new Error(
+      "rebuilt decoder Wasm does not match the checked-in asset/manifest; run build-decoder-wasm.ts --update intentionally",
+    );
+  }
+  process.stdout.write(
+    `verified reproducible wasm/flac-decoder.wasm (${outputHash})\n`,
+  );
+};
+
+await main();
diff --git a/scripts/build-native-flac.sh b/scripts/build-native-flac.sh
new file mode 100755
index 0000000..db57231
--- /dev/null
+++ b/scripts/build-native-flac.sh
@@ -0,0 +1,23 @@
+#!/bin/sh
+set -eu
+root=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
+archive="$root/vendor/libflac-1.5.0/flac-1.5.0.tar.xz"
+expected=f2c1c76592a82ffff8413ba3c4a1299b6c7ab06c734dee03fd88630485c2b920
+actual=$(sha256sum "$archive" | cut -d ' ' -f 1)
+test "$actual" = "$expected"
+work=$(mktemp -d "${TMPDIR:-/tmp}/codec-native-flac.XXXXXX")
+# Leave successful builds available to the caller; failed builds retain logs.
+tar -xf "$archive" -C "$work"
+mkdir "$work/build"
+cd "$work/build"
+if ! "$work/flac-1.5.0/configure" --disable-shared --enable-static \
+  --disable-ogg --disable-cpplibs --disable-examples --disable-doxygen-docs \
+  --disable-multithreading > configure.log 2>&1; then
+  cat configure.log >&2
+  exit 1
+fi
+if ! make -j2 > build.log 2>&1; then
+  cat build.log >&2
+  exit 1
+fi
+printf '%s\n' "$work/build/src/flac/flac"
diff --git a/scripts/build-wasm.ts b/scripts/build-wasm.ts
new file mode 100644
index 0000000..f0839ba
--- /dev/null
+++ b/scripts/build-wasm.ts
@@ -0,0 +1,423 @@
+import { createHash } from "node:crypto";
+import {
+  chmod,
+  copyFile,
+  mkdir,
+  readFile,
+  rm,
+  writeFile,
+} from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+
+const repository = resolve(import.meta.dirname, "..");
+const sourceArchive = resolve(
+  repository,
+  "vendor/libflac-1.5.0/flac-1.5.0.tar.xz",
+);
+const wrapperSource = resolve(repository, "native/encoder.c");
+const asset = resolve(repository, "wasm/flac-encoder.wasm");
+const manifestPath = resolve(repository, "wasm/flac-encoder.manifest.json");
+const buildRoot = resolve(repository, ".cache/flac-encoder-build");
+const sourceRoot = resolve(buildRoot, "flac-1.5.0");
+const emscriptenRoot =
+  process.env.CODEC_EMSCRIPTEN_ROOT ??
+  "/data/codec-tooling/emsdk/upstream/emscripten";
+const emcc = resolve(emscriptenRoot, "emcc");
+const emconfigure = resolve(emscriptenRoot, "emconfigure");
+const wasmLd = resolve(emscriptenRoot, "../bin/wasm-ld");
+const wasmOpt = resolve(emscriptenRoot, "../bin/wasm-opt");
+const sysroot = resolve(emscriptenRoot, "cache/sysroot");
+const musl = resolve(emscriptenRoot, "system/lib/libc/musl");
+const emsdkRoot = resolve(emscriptenRoot, "../..");
+
+const SOURCE_SHA256 =
+  "f2c1c76592a82ffff8413ba3c4a1299b6c7ab06c734dee03fd88630485c2b920";
+const EMCC_VERSION = "6.0.9";
+const EMCC_COMMIT = "4e4223852a0835923411059a3929907d7df1232e";
+const SDK_TAG_COMMIT = "5eb0bde7585670252e8ba05e9d361627bffd08b5";
+const SDK_RELEASES_COMMIT = "f04ea239d533260dd1db760dd2d668d5f9a88d6b";
+const WASM_OPT_VERSION = "wasm-opt version 132 (version_132-49-gd03c25ea4)";
+const MEMORY_BYTES = 16 * 1024 * 1024;
+const STACK_BYTES = 256 * 1024;
+
+const sha256 = (bytes: Uint8Array): string =>
+  createHash("sha256").update(bytes).digest("hex");
+
+const run = async (
+  command: string,
+  args: ReadonlyArray<string>,
+  cwd = repository,
+  env: Record<string, string> = {},
+): Promise<string> => {
+  const proc = Bun.spawn([command, ...args], {
+    cwd,
+    env: { ...process.env, ...env },
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, status] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+  if (status !== 0) {
+    throw new Error(`${command} exited ${status}\n${stdout}${stderr}`);
+  }
+  if (stderr.length > 0) process.stderr.write(stderr);
+  return stdout;
+};
+
+const main = async (): Promise<void> => {
+  const mode = process.argv[2];
+  if (mode !== "--verify" && mode !== "--update") {
+    throw new Error("usage: bun run scripts/build-wasm.ts --verify|--update");
+  }
+
+  const archiveBytes = new Uint8Array(await readFile(sourceArchive));
+  const archiveHash = sha256(archiveBytes);
+  if (archiveHash !== SOURCE_SHA256) {
+    throw new Error(`libFLAC source SHA-256 mismatch: ${archiveHash}`);
+  }
+
+  const version = await run(emcc, ["--version"]);
+  if (
+    !version.includes(
+      `emcc (Emscripten gcc/clang-like replacement + linker emulating GNU ld) ${EMCC_VERSION}`,
+    ) ||
+    !version.includes(EMCC_COMMIT)
+  ) {
+    throw new Error(`unexpected compiler version:\n${version}`);
+  }
+  const sdkCommit = (await run("git", ["rev-parse", "HEAD"], emsdkRoot)).trim();
+  if (sdkCommit !== SDK_TAG_COMMIT) {
+    throw new Error(`unexpected emsdk revision: ${sdkCommit}`);
+  }
+  const releaseTags = JSON.parse(
+    await readFile(resolve(emsdkRoot, "emscripten-releases-tags.json"), "utf8"),
+  ) as {
+    readonly releases?: Readonly<Record<string, unknown>>;
+  };
+  if (releaseTags.releases?.[EMCC_VERSION] !== SDK_RELEASES_COMMIT) {
+    throw new Error(
+      `emsdk release map does not pin ${EMCC_VERSION} to ${SDK_RELEASES_COMMIT}`,
+    );
+  }
+  const wasmOptVersion = (await run(wasmOpt, ["--version"])).trim();
+  if (wasmOptVersion !== WASM_OPT_VERSION) {
+    throw new Error(`unexpected wasm-opt version: ${wasmOptVersion}`);
+  }
+
+  await rm(buildRoot, { recursive: true, force: true });
+  await mkdir(buildRoot, { recursive: true });
+  await run("tar", ["-xJf", sourceArchive, "-C", buildRoot]);
+  await chmod(resolve(sourceRoot, "configure"), 0o755);
+  await run(
+    "patch",
+    ["-p1", "-i", resolve(repository, "native/libflac-stream-only.patch")],
+    sourceRoot,
+  );
+
+  const reproducibleEnv = {
+    SOURCE_DATE_EPOCH: "1735689600",
+    ZERO_AR_DATE: "1",
+    CFLAGS: "-O3 -DCODEC_STREAM_ONLY=1",
+  };
+  await run(
+    emconfigure,
+    [
+      "./configure",
+      "--host=wasm32-unknown-emscripten",
+      "--disable-shared",
+      "--enable-static",
+      "--disable-asm-optimizations",
+      "--disable-avx",
+      "--disable-cpplibs",
+      "--disable-ogg",
+      "--disable-oggtest",
+      "--disable-programs",
+      "--disable-examples",
+      "--disable-multithreading",
+      "--disable-doxygen-docs",
+      "--disable-dependency-tracking",
+      "--disable-version-from-git",
+    ],
+    sourceRoot,
+    reproducibleEnv,
+  );
+  const objectRoot = resolve(buildRoot, "objects");
+  await mkdir(objectRoot, { recursive: true });
+  const includeFlags = [
+    `-I${sourceRoot}`,
+    `-I${resolve(sourceRoot, "include")}`,
+    `-I${resolve(sourceRoot, "src/libFLAC/include")}`,
+  ];
+  const commonCompileFlags = [
+    "-O3",
+    "-ffreestanding",
+    "-fno-builtin",
+    "-DFLAC__NO_DLL",
+    "-DHAVE_CONFIG_H",
+    "-DCODEC_STREAM_ONLY=1",
+    ...includeFlags,
+  ];
+  const flacUnits = [
+    "bitmath",
+    "bitreader",
+    "bitwriter",
+    "cpu",
+    "crc",
+    "fixed",
+    "float",
+    "format",
+    "lpc",
+    "md5",
+    "memory",
+    "stream_decoder",
+    "stream_encoder",
+    "stream_encoder_framing",
+    "window",
+  ] as const;
+  const objects: Array<string> = [];
+  for (const unit of flacUnits) {
+    const object = resolve(objectRoot, `flac-${unit}.o`);
+    await run(
+      emcc,
+      [
+        ...commonCompileFlags,
+        "-c",
+        resolve(sourceRoot, `src/libFLAC/${unit}.c`),
+        "-o",
+        object,
+      ],
+      repository,
+      reproducibleEnv,
+    );
+    objects.push(object);
+  }
+  const wrapperObject = resolve(objectRoot, "encoder.o");
+  await run(
+    emcc,
+    [...commonCompileFlags, "-c", wrapperSource, "-o", wrapperObject],
+    repository,
+    reproducibleEnv,
+  );
+  objects.unshift(wrapperObject);
+
+  const muslUnits = [
+    "string/memcpy",
+    "string/memmove",
+    "string/memset",
+    "string/memcmp",
+    "string/strcmp",
+    "string/strlen",
+    "stdlib/abs",
+    "stdlib/qsort",
+    "stdlib/qsort_nr",
+    "math/log",
+    "math/log_data",
+    "math/exp",
+    "math/exp_data",
+    "math/frexp",
+    "math/lround",
+    "math/round",
+    "math/floor",
+    "math/cosf",
+    "math/fabs",
+    "math/fabsf",
+    "math/scalbn",
+    "math/__cosdf",
+    "math/__sindf",
+    "math/__rem_pio2f",
+    "math/__rem_pio2_large",
+    "math/__math_uflow",
+    "math/__math_oflow",
+    "math/__math_divzero",
+    "math/__math_invalid",
+    "math/__math_xflow",
+  ] as const;
+  const muslIncludeFlags = [
+    `-I${resolve(musl, "src/include")}`,
+    `-I${resolve(musl, "src/internal")}`,
+    `-I${resolve(musl, "arch/emscripten")}`,
+    `-I${resolve(musl, "arch/generic")}`,
+  ];
+  for (const unit of muslUnits) {
+    const object = resolve(objectRoot, `musl-${unit.replaceAll("/", "-")}.o`);
+    await run(
+      emcc,
+      [
+        "-O3",
+        "-ffreestanding",
+        "-fno-builtin",
+        ...muslIncludeFlags,
+        "-c",
+        resolve(musl, `src/${unit}.c`),
+        "-o",
+        object,
+      ],
+      repository,
+      reproducibleEnv,
+    );
+    objects.push(object);
+  }
+
+  const rawOutput = resolve(buildRoot, "flac-encoder.raw.wasm");
+  const output = resolve(buildRoot, "flac-encoder.wasm");
+  const allowedUndefined = resolve(buildRoot, "allowed-undefined.txt");
+  await writeFile(allowedUndefined, "codec_seek\ncodec_write\n");
+  await run(
+    wasmLd,
+    [
+      "--no-entry",
+      `--allow-undefined-file=${allowedUndefined}`,
+      "--import-undefined",
+      "--export-memory",
+      `--initial-memory=${MEMORY_BYTES}`,
+      `--max-memory=${MEMORY_BYTES}`,
+      "--stack-first",
+      `-zstack-size=${STACK_BYTES}`,
+      "--strip-all",
+      "--export=malloc",
+      "--export=free",
+      "--export=codec_encoder_new",
+      "--export=codec_encoder_init",
+      "--export=codec_encoder_process_interleaved",
+      "--export=codec_encoder_finish",
+      "--export=codec_encoder_state",
+      "--export=codec_encoder_delete",
+      "-o",
+      rawOutput,
+      ...objects,
+      resolve(sysroot, "lib/wasm32-emscripten/libemmalloc.a"),
+      resolve(sysroot, "lib/wasm32-emscripten/libclang_rt.builtins.a"),
+    ],
+    repository,
+    reproducibleEnv,
+  );
+  await run(wasmOpt, [
+    rawOutput,
+    "--enable-bulk-memory",
+    "--enable-nontrapping-float-to-int",
+    "-O3",
+    "--strip-debug",
+    "-o",
+    output,
+  ]);
+
+  const outputBytes = new Uint8Array(await readFile(output));
+  if (outputBytes.byteLength > 256 * 1024) {
+    throw new Error(
+      `encoder Wasm exceeds 256 KiB objective: ${outputBytes.byteLength}`,
+    );
+  }
+  const outputHash = sha256(outputBytes);
+  const imports = WebAssembly.Module.imports(
+    await WebAssembly.compile(outputBytes),
+  )
+    .map(({ module, name, kind }) => `${module}.${name}:${kind}`)
+    .sort();
+  const expectedImports = ["codec.seek:function", "codec.write:function"];
+  if (JSON.stringify(imports) !== JSON.stringify(expectedImports)) {
+    throw new Error(`unexpected Wasm imports: ${imports.join(", ")}`);
+  }
+  const exports = WebAssembly.Module.exports(
+    await WebAssembly.compile(outputBytes),
+  )
+    .map(({ name, kind }) => `${name}:${kind}`)
+    .sort();
+  const expectedExports = [
+    "__em_lib_deps__em_malloc_deps:global",
+    "codec_encoder_delete:function",
+    "codec_encoder_finish:function",
+    "codec_encoder_init:function",
+    "codec_encoder_new:function",
+    "codec_encoder_process_interleaved:function",
+    "codec_encoder_state:function",
+    "free:function",
+    "malloc:function",
+    "memory:memory",
+  ];
+  if (JSON.stringify(exports) !== JSON.stringify(expectedExports)) {
+    throw new Error(`unexpected Wasm exports: ${exports.join(", ")}`);
+  }
+
+  const patchHash = sha256(
+    new Uint8Array(
+      await readFile(resolve(repository, "native/libflac-stream-only.patch")),
+    ),
+  );
+  const wrapperSha256 = sha256(new Uint8Array(await readFile(wrapperSource)));
+  const manifest = {
+    asset: "flac-encoder.wasm",
+    assetSha256: outputHash,
+    libflac: {
+      version: "1.5.0",
+      archive: "vendor/libflac-1.5.0/flac-1.5.0.tar.xz",
+      archiveSha256: SOURCE_SHA256,
+      patch: "native/libflac-stream-only.patch",
+      patchSha256: patchHash,
+    },
+    sources: {
+      wrapper: "native/encoder.c",
+      wrapperSha256,
+    },
+    emscripten: {
+      version: EMCC_VERSION,
+      compilerCommit: EMCC_COMMIT,
+      sdkTagCommit: SDK_TAG_COMMIT,
+      sdkReleasesCommit: SDK_RELEASES_COMMIT,
+      wasmOptVersion: WASM_OPT_VERSION,
+    },
+    build: {
+      initialMemoryBytes: MEMORY_BYTES,
+      maximumMemoryBytes: MEMORY_BYTES,
+      stackBytes: STACK_BYTES,
+      filesystem: false,
+      memoryGrowth: false,
+      imports: expectedImports,
+      exports: expectedExports,
+      libflacUnits: flacUnits,
+      muslUnits,
+      compilerFlags: [
+        "-O3",
+        "-ffreestanding",
+        "-fno-builtin",
+        "-DFLAC__NO_DLL",
+        "-DHAVE_CONFIG_H",
+        "-DCODEC_STREAM_ONLY=1",
+      ],
+      linkerPolicy: {
+        allowedUndefinedSymbols: ["codec_seek", "codec_write"],
+        noEntry: true,
+        stripAll: true,
+      },
+    },
+  } as const;
+  const serializedManifest = `${JSON.stringify(manifest, null, 2)}\n`;
+
+  if (mode === "--update") {
+    await mkdir(dirname(asset), { recursive: true });
+    await copyFile(output, asset);
+    await writeFile(manifestPath, serializedManifest);
+    process.stdout.write(`updated wasm/flac-encoder.wasm (${outputHash})\n`);
+    return;
+  }
+
+  const [checkedAsset, checkedManifest] = await Promise.all([
+    readFile(asset),
+    readFile(manifestPath, "utf8"),
+  ]);
+  if (
+    sha256(checkedAsset) !== outputHash ||
+    checkedManifest !== serializedManifest
+  ) {
+    throw new Error(
+      "rebuilt encoder Wasm does not match the checked-in asset/manifest; run build:wasm:update intentionally",
+    );
+  }
+  process.stdout.write(
+    `verified reproducible wasm/flac-encoder.wasm (${outputHash})\n`,
+  );
+};
+
+await main();
diff --git a/scripts/pack-check.mjs b/scripts/pack-check.mjs
new file mode 100644
index 0000000..66e2522
--- /dev/null
+++ b/scripts/pack-check.mjs
@@ -0,0 +1,155 @@
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdtemp, readFile, writeFile, cp, mkdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const scratch = await mkdtemp(join(tmpdir(), "misofm-codec-packed-"));
+const peers = ["4.0.0-rc.112", "4.0.0-rc.115"];
+const receipts = [];
+const run = (command, args, cwd) => {
+  const result = spawnSync(command, args, {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: 16 * 1024 * 1024,
+  });
+  if (result.error || result.status !== 0) {
+    throw new Error(
+      `${command} ${args.join(" ")} failed\n${result.error ?? ""}\n${result.stdout}\n${result.stderr}`,
+    );
+  }
+  return result.stdout;
+};
+
+try {
+  run("bun", ["run", "build"], root);
+  const [packed] = JSON.parse(
+    run("npm", ["pack", "--json", "--pack-destination", scratch], root),
+  );
+  const names = packed.files.map((file) => file.path);
+  for (const required of [
+    "dist/index.js",
+    "dist/index.d.ts",
+    "dist/node.js",
+    "wasm/flac-encoder.wasm",
+    "wasm/flac-decoder.wasm",
+    "THIRD_PARTY_NOTICES.md",
+    "docs/architecture.md",
+    "docs/adapter-integration.md",
+    "vendor/licenses/libFLAC.txt",
+  ]) {
+    if (!names.includes(required))
+      throw new Error(`packed package lacks ${required}`);
+  }
+  for (const name of names) {
+    if (
+      /^(node_modules|\.cache|native|test|consumer)\//.test(name) ||
+      name.endsWith(".tar.xz")
+    ) {
+      throw new Error(`unexpected packed file: ${name}`);
+    }
+  }
+  const tarball = join(scratch, packed.filename);
+  const hash = createHash("sha256")
+    .update(await readFile(tarball))
+    .digest("hex");
+  for (const peer of peers) {
+    const directory = join(scratch, peer);
+    await mkdir(directory);
+    await writeFile(
+      join(directory, "package.json"),
+      JSON.stringify(
+        {
+          name: "isolated-codec-consumer",
+          private: true,
+          type: "module",
+          dependencies: { "@misofm/codec": `file:${tarball}`, effect: peer },
+          devDependencies: { typescript: "5.9.3", "@types/node": "22.20.2" },
+        },
+        null,
+        2,
+      ),
+    );
+    await cp(join(root, "consumer"), join(directory, "consumer"), {
+      recursive: true,
+    });
+    run("bun", ["install", "--ignore-scripts"], directory);
+    await writeFile(
+      join(directory, "tsconfig.json"),
+      JSON.stringify(
+        {
+          compilerOptions: {
+            target: "ES2022",
+            module: "NodeNext",
+            moduleResolution: "NodeNext",
+            lib: ["ES2022", "DOM"],
+            strict: true,
+            exactOptionalPropertyTypes: true,
+            noUncheckedIndexedAccess: true,
+            skipLibCheck: true,
+            outDir: "compiled",
+            types: ["node"],
+          },
+          include: ["consumer/**/*.ts"],
+        },
+        null,
+        2,
+      ),
+    );
+    run(
+      "node",
+      ["node_modules/typescript/bin/tsc", "-p", "tsconfig.json"],
+      directory,
+    );
+    const bun = JSON.parse(
+      run("bun", ["compiled/server.js"], directory).trim(),
+    );
+    const node = JSON.parse(
+      run("node", ["compiled/server.js"], directory).trim(),
+    );
+    // Bun bundles the installed tarball's portable entrypoint; no repository alias.
+    run(
+      "bun",
+      [
+        "build",
+        "./consumer/browser.ts",
+        "--target=browser",
+        "--outfile=browser.js",
+      ],
+      directory,
+    );
+    const bundle = await readFile(join(directory, "browser.js"), "utf8");
+    if (/node:(?:fs|crypto|path)|require\(["'](?:fs|path)["']\)/.test(bundle)) {
+      throw new Error("portable browser bundle contains a server dependency");
+    }
+    const browser = JSON.parse(
+      run(
+        "node",
+        [join(root, "scripts/browser-consumer.mjs"), directory],
+        root,
+      ).trim(),
+    );
+    receipts.push({ effect: peer, bun, node, browser });
+    process.stdout.write(
+      `packed consumer passed: Effect ${peer}, Bun, Node, Chromium/Firefox/WebKit\n`,
+    );
+  }
+  const report = {
+    tarballSha256: hash,
+    packedBytes: packed.size,
+    unpackedBytes: packed.unpackedSize,
+    files: names,
+    consumers: receipts,
+  };
+  if (process.env.CODEC_PACK_RECEIPT) {
+    await writeFile(
+      resolve(process.env.CODEC_PACK_RECEIPT),
+      `${JSON.stringify(report, null, 2)}\n`,
+    );
+  }
+  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+} finally {
+  await rm(scratch, { recursive: true, force: true });
+}
diff --git a/src/decode.ts b/src/decode.ts
new file mode 100644
index 0000000..0fdcae2
--- /dev/null
+++ b/src/decode.ts
@@ -0,0 +1,596 @@
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Pull from "effect/Pull";
+import * as Schema from "effect/Schema";
+import * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+
+import { FlacDecodeError } from "./decoder-errors.js";
+import { PcmFormat } from "./format.js";
+import {
+  instantiateDecoder,
+  type DecoderAbi,
+  type DecoderPhase,
+} from "./internal/decoder-abi.js";
+import { FlacDecoder, FLAC_DECODER_LIMITS } from "./decoder-wasm.js";
+
+export interface FlacDecodeOptions {
+  readonly expectedFormat?: PcmFormat;
+  readonly expectedFrames?: bigint;
+  /** Maximum size of each source element. Defaults to the fixed 256 KiB input-slot limit. */
+  readonly maxInputChunkBytes?: number;
+  /** Maximum bytes libFLAC may read while parsing metadata. Defaults to 1 MiB. */
+  readonly maxMetadataBytes?: number;
+}
+
+export interface FlacMetadata {
+  readonly _tag: "Metadata";
+  readonly format: PcmFormat;
+  readonly minimumBlockFrames: number;
+  readonly maximumBlockFrames: number;
+  /** STREAMINFO total samples, absent when the encoded value is zero (unknown). */
+  readonly totalFrames?: bigint;
+  readonly md5Present: boolean;
+}
+
+export interface FlacPcm {
+  readonly _tag: "Pcm";
+  readonly format: PcmFormat;
+  readonly frameOffset: bigint;
+  readonly frames: number;
+  /** Canonical interleaved signed PCM, packed little-endian at `format.bitsPerSample`. */
+  readonly bytes: Uint8Array;
+}
+
+export interface FlacDecodeComplete {
+  readonly _tag: "Complete";
+  readonly format: PcmFormat;
+  readonly frames: bigint;
+  readonly bytes: bigint;
+  readonly md5Checked: boolean;
+  readonly md5Verified: boolean;
+}
+
+export type FlacDecodeEvent = FlacMetadata | FlacPcm | FlacDecodeComplete;
+
+interface CheckedOptions {
+  readonly expectedFormat: PcmFormat | undefined;
+  readonly expectedFrames: bigint | undefined;
+  readonly maxInputChunkBytes: number;
+  readonly maxMetadataBytes: number;
+}
+
+interface DecoderResource {
+  readonly abi: DecoderAbi;
+  readonly decoder: number;
+}
+
+const invalidOptions = (detail: string): FlacDecodeError =>
+  new FlacDecodeError({
+    reason: "invalid-options",
+    phase: "metadata",
+    detail,
+  });
+
+const checkOptions = (
+  options: unknown,
+): Effect.Effect<CheckedOptions, FlacDecodeError> =>
+  Effect.gen(function* () {
+    if (
+      typeof options !== "object" ||
+      options === null ||
+      Array.isArray(options)
+    ) {
+      return yield* invalidOptions("decoder options must be an object");
+    }
+    const values = options as Readonly<Record<string, unknown>>;
+    const maxInputChunkBytes =
+      values.maxInputChunkBytes ?? FLAC_DECODER_LIMITS.maxInputChunkBytes;
+    const maxMetadataBytes =
+      values.maxMetadataBytes ?? FLAC_DECODER_LIMITS.defaultMaxMetadataBytes;
+    const expectedFrames = values.expectedFrames;
+    if (
+      typeof maxInputChunkBytes !== "number" ||
+      !Number.isSafeInteger(maxInputChunkBytes) ||
+      maxInputChunkBytes < 1 ||
+      maxInputChunkBytes > FLAC_DECODER_LIMITS.maxInputChunkBytes
+    ) {
+      return yield* invalidOptions(
+        `maxInputChunkBytes must be an integer from 1 through ${FLAC_DECODER_LIMITS.maxInputChunkBytes}`,
+      );
+    }
+    if (
+      typeof maxMetadataBytes !== "number" ||
+      !Number.isSafeInteger(maxMetadataBytes) ||
+      maxMetadataBytes < 42 ||
+      maxMetadataBytes > FLAC_DECODER_LIMITS.maxMetadataBytes
+    ) {
+      return yield* invalidOptions(
+        `maxMetadataBytes must be an integer from 42 through ${FLAC_DECODER_LIMITS.maxMetadataBytes}`,
+      );
+    }
+    if (
+      expectedFrames !== undefined &&
+      (typeof expectedFrames !== "bigint" ||
+        expectedFrames < 0n ||
+        expectedFrames > FLAC_DECODER_LIMITS.maxTotalFrames)
+    ) {
+      return yield* invalidOptions(
+        `expectedFrames must be from 0 through ${FLAC_DECODER_LIMITS.maxTotalFrames}`,
+      );
+    }
+    const expectedFormat =
+      values.expectedFormat === undefined
+        ? undefined
+        : yield* Schema.decodeUnknownEffect(PcmFormat)(
+            values.expectedFormat,
+          ).pipe(
+            Effect.mapError(() =>
+              invalidOptions(
+                "expectedFormat is outside the supported PCM format",
+              ),
+            ),
+          );
+    return {
+      expectedFormat,
+      expectedFrames,
+      maxInputChunkBytes,
+      maxMetadataBytes,
+    };
+  });
+
+const uint64 = (low: number, high: number): bigint =>
+  (BigInt(high >>> 0) << 32n) | BigInt(low >>> 0);
+
+const low32 = (value: bigint): number => Number(value & 0xffff_ffffn);
+const high32 = (value: bigint): number => Number((value >> 32n) & 0xffff_ffffn);
+
+const abiOperation = <A>(
+  phase: DecoderPhase,
+  detail: string,
+  operation: () => A,
+): Effect.Effect<A, FlacDecodeError> =>
+  Effect.try({
+    try: operation,
+    catch: (cause) =>
+      new FlacDecodeError({
+        reason: "wasm-trap",
+        phase,
+        detail,
+        cause,
+      }),
+  });
+
+const decoderFailure = (
+  resource: DecoderResource,
+  phase: DecoderPhase,
+  detail: string,
+  result: number,
+): FlacDecodeError => {
+  const { exports } = resource.abi;
+  let callbackError: number;
+  let nativeState: number;
+  try {
+    callbackError = exports.codec_decoder_callback_error(resource.decoder);
+    nativeState = exports.codec_decoder_state(resource.decoder);
+  } catch (cause) {
+    return new FlacDecodeError({
+      reason: "wasm-trap",
+      phase,
+      detail: "decoder diagnostics trapped after a failed operation",
+      cause,
+    });
+  }
+  let reason: FlacDecodeError["reason"] = "invalid-stream";
+  if (nativeState === 8) reason = "allocation-failed";
+  else if (callbackError === 2) reason = "metadata-limit";
+  else if (
+    callbackError === 20 ||
+    callbackError === 21 ||
+    callbackError === 104
+  )
+    reason = "invalid-metadata";
+  else if (callbackError === 22 || callbackError === 23)
+    reason = "expected-metadata-mismatch";
+  else if (callbackError === 11) reason = "frame-position-mismatch";
+  else if (callbackError === 12 || (phase === "finish" && result === -2))
+    reason = "frame-count-mismatch";
+  else if (callbackError === 102) reason = "crc-mismatch";
+  else if (phase === "finish" && result === -3 && callbackError === 0)
+    reason = "md5-mismatch";
+  return new FlacDecodeError({
+    reason,
+    phase,
+    detail: `${detail} (native result ${result})`,
+    nativeState,
+    callbackError,
+  });
+};
+
+const makeDecodeStream = <E, R>(
+  input: Stream.Stream<Uint8Array, E, R>,
+  options: CheckedOptions,
+): Stream.Stream<FlacDecodeEvent, E | FlacDecodeError, R | FlacDecoder> =>
+  Stream.transformPullBracket(
+    input.pipe(Stream.rechunk(1)),
+    (inputPull, _scope, resourceScope) =>
+      Effect.gen(function* () {
+        const service = yield* FlacDecoder;
+        const abi = yield* instantiateDecoder(service.module);
+        let decoder = 0;
+        let released = false;
+        const releaseDecoder = (): void => {
+          if (released) return;
+          released = true;
+          let trapped = false;
+          let firstCause: unknown;
+          const attempt = (operation: () => void): void => {
+            try {
+              operation();
+            } catch (cause) {
+              if (!trapped) firstCause = cause;
+              trapped = true;
+            }
+          };
+          attempt(() => abi.normalize());
+          const ownedDecoder = decoder;
+          decoder = 0;
+          if (ownedDecoder !== 0)
+            attempt(() => abi.exports.codec_decoder_delete(ownedDecoder));
+          attempt(() => abi.dispose());
+          if (trapped) throw firstCause;
+        };
+        yield* Scope.addFinalizer(
+          resourceScope,
+          Effect.sync(() => {
+            try {
+              releaseDecoder();
+            } catch {
+              // The decode result already carries any primary Wasm failure.
+            }
+          }),
+        );
+
+        const expectedFrames = options.expectedFrames ?? 0n;
+        const expectedFormat = options.expectedFormat;
+        decoder = yield* abiOperation(
+          "instantiate",
+          "decoder Wasm trapped while allocating libFLAC state",
+          () =>
+            abi.exports.codec_decoder_new(
+              options.maxMetadataBytes,
+              expectedFormat?.sampleRate ?? 0,
+              expectedFormat?.channels ?? 0,
+              expectedFormat?.bitsPerSample ?? 0,
+              low32(expectedFrames),
+              high32(expectedFrames),
+              expectedFormat === undefined ? 0 : 1,
+              options.expectedFrames === undefined ? 0 : 1,
+            ),
+        );
+        if (
+          !Number.isSafeInteger(decoder) ||
+          decoder <= 0 ||
+          decoder >= abi.exports.memory.buffer.byteLength
+        ) {
+          return yield* new FlacDecodeError({
+            reason: "allocation-failed",
+            phase: "instantiate",
+            detail: "could not allocate the fixed-memory libFLAC decoder",
+          });
+        }
+
+        let state: "metadata" | "frames" | "done" = "metadata";
+        let format: PcmFormat | undefined;
+        let minimumBlockFrames = 0;
+        let maximumBlockFrames = 0;
+        let md5Present = false;
+        let emittedFrames = 0n;
+        let emittedBytes = 0n;
+        let progresslessCalls = 0;
+        const pullInput: Effect.Effect<Uint8Array | null, E, R> =
+          inputPull.pipe(
+            Pull.matchEffect({
+              onSuccess: (chunks) => Effect.succeed(chunks[0]!),
+              onFailure: (cause) => Effect.failCause(cause),
+              onDone: () => Effect.succeed(null),
+            }),
+          );
+        const nextInput: Effect.Effect<
+          Uint8Array | null,
+          E | FlacDecodeError,
+          R
+        > = Effect.gen(function* () {
+          for (;;) {
+            const bytes = yield* pullInput;
+            if (bytes === null) return null;
+            const phase = state === "metadata" ? "metadata" : "frame";
+            if (!(bytes instanceof Uint8Array)) {
+              return yield* new FlacDecodeError({
+                reason: "invalid-stream",
+                phase,
+                detail: "FLAC input elements must be Uint8Array values",
+              });
+            }
+            if (bytes.byteLength > options.maxInputChunkBytes) {
+              return yield* new FlacDecodeError({
+                reason: "input-chunk-too-large",
+                phase,
+                detail: `input chunk is ${bytes.byteLength} bytes; maximum is ${options.maxInputChunkBytes}`,
+              });
+            }
+            if (bytes.byteLength !== 0) return bytes;
+          }
+        });
+
+        const outputPull = Effect.gen(function* () {
+          if (state === "done") return yield* Cause.done();
+          if (state === "metadata") {
+            const result = yield* abi.invoke(
+              "metadata",
+              () => abi.exports.codec_decoder_init(decoder),
+              nextInput,
+            );
+            if (result !== 0) {
+              return yield* decoderFailure(
+                { abi, decoder },
+                "metadata",
+                "libFLAC rejected FLAC metadata",
+                result,
+              );
+            }
+            const metadataValues = yield* abiOperation(
+              "metadata",
+              "decoder Wasm trapped while reporting STREAMINFO",
+              () => ({
+                sampleRate: abi.exports.codec_decoder_sample_rate(decoder),
+                channels: abi.exports.codec_decoder_channels(decoder),
+                bitsPerSample:
+                  abi.exports.codec_decoder_bits_per_sample(decoder),
+                minimumBlockFrames:
+                  abi.exports.codec_decoder_minimum_block_frames(decoder),
+                maximumBlockFrames:
+                  abi.exports.codec_decoder_maximum_block_frames(decoder),
+                md5Present: abi.exports.codec_decoder_md5_present(decoder),
+                totalFramesKnown:
+                  abi.exports.codec_decoder_streaminfo_frames_known(decoder),
+                totalFramesLow:
+                  abi.exports.codec_decoder_streaminfo_frames_low(decoder),
+                totalFramesHigh:
+                  abi.exports.codec_decoder_streaminfo_frames_high(decoder),
+              }),
+            );
+            minimumBlockFrames = metadataValues.minimumBlockFrames;
+            maximumBlockFrames = metadataValues.maximumBlockFrames;
+            if (
+              !Number.isSafeInteger(minimumBlockFrames) ||
+              !Number.isSafeInteger(maximumBlockFrames) ||
+              minimumBlockFrames < 16 ||
+              maximumBlockFrames < minimumBlockFrames ||
+              maximumBlockFrames > 65_535 ||
+              (metadataValues.md5Present !== 0 &&
+                metadataValues.md5Present !== 1) ||
+              (metadataValues.totalFramesKnown !== 0 &&
+                metadataValues.totalFramesKnown !== 1)
+            ) {
+              return yield* new FlacDecodeError({
+                reason: "wasm-abi",
+                phase: "metadata",
+                detail: "decoder returned invalid STREAMINFO scalars or flags",
+              });
+            }
+            format = yield* Schema.decodeUnknownEffect(PcmFormat)({
+              sampleRate: metadataValues.sampleRate,
+              channels: metadataValues.channels,
+              bitsPerSample: metadataValues.bitsPerSample,
+            }).pipe(
+              Effect.mapError(
+                (cause) =>
+                  new FlacDecodeError({
+                    reason: "wasm-abi",
+                    phase: "metadata",
+                    detail: "decoder returned an unsupported PCM format",
+                    cause,
+                  }),
+              ),
+            );
+            md5Present = metadataValues.md5Present === 1;
+            const totalFramesKnown = metadataValues.totalFramesKnown === 1;
+            const totalFrames = uint64(
+              metadataValues.totalFramesLow,
+              metadataValues.totalFramesHigh,
+            );
+            if (
+              totalFramesKnown &&
+              totalFrames > FLAC_DECODER_LIMITS.maxTotalFrames
+            ) {
+              return yield* new FlacDecodeError({
+                reason: "wasm-abi",
+                phase: "metadata",
+                detail:
+                  "decoder returned an out-of-range STREAMINFO frame count",
+              });
+            }
+            const metadata: FlacMetadata = {
+              _tag: "Metadata",
+              format,
+              minimumBlockFrames,
+              maximumBlockFrames,
+              ...(totalFramesKnown ? { totalFrames } : {}),
+              md5Present,
+            };
+            state = "frames";
+            return [metadata] as readonly [FlacDecodeEvent];
+          }
+
+          for (;;) {
+            const result = yield* abi.invoke(
+              "frame",
+              () => abi.exports.codec_decoder_process_single(decoder),
+              nextInput,
+            );
+            if (result === 1) {
+              progresslessCalls = 0;
+              const output = yield* abiOperation(
+                "frame",
+                "decoder Wasm trapped while reporting PCM output",
+                () => ({
+                  length: abi.exports.codec_decoder_output_length(decoder),
+                  frames: abi.exports.codec_decoder_output_frames(decoder),
+                  pointer: abi.exports.codec_decoder_output_ptr(decoder),
+                  offset: uint64(
+                    abi.exports.codec_decoder_output_frame_offset_low(decoder),
+                    abi.exports.codec_decoder_output_frame_offset_high(decoder),
+                  ),
+                }),
+              );
+              const expectedLength =
+                output.frames * format!.channels * (format!.bitsPerSample / 8);
+              if (
+                !Number.isSafeInteger(output.length) ||
+                !Number.isSafeInteger(output.frames) ||
+                !Number.isSafeInteger(output.pointer) ||
+                output.length <= 0 ||
+                output.frames <= 0 ||
+                output.frames > maximumBlockFrames ||
+                output.offset !== emittedFrames ||
+                output.length !== expectedLength ||
+                output.length > FLAC_DECODER_LIMITS.maxOutputBlockBytes ||
+                output.pointer <= 0 ||
+                output.pointer >
+                  abi.exports.memory.buffer.byteLength - output.length
+              ) {
+                return yield* new FlacDecodeError({
+                  reason: "wasm-abi",
+                  phase: "frame",
+                  detail:
+                    "decoder returned an invalid bounded PCM output range",
+                });
+              }
+              const bytes = yield* abiOperation(
+                "frame",
+                "decoder Wasm trapped while copying PCM output",
+                () =>
+                  Uint8Array.from(
+                    new Uint8Array(
+                      abi.exports.memory.buffer,
+                      output.pointer,
+                      output.length,
+                    ),
+                  ),
+              );
+              const event: FlacPcm = {
+                _tag: "Pcm",
+                format: format!,
+                frameOffset: output.offset,
+                frames: output.frames,
+                bytes,
+              };
+              yield* abiOperation(
+                "frame",
+                "decoder Wasm trapped while releasing PCM output",
+                () => abi.exports.codec_decoder_release_output(decoder),
+              );
+              emittedFrames += BigInt(output.frames);
+              emittedBytes += BigInt(output.length);
+              return [event] as readonly [FlacDecodeEvent];
+            }
+            if (result === 0) {
+              progresslessCalls += 1;
+              if (
+                progresslessCalls > FLAC_DECODER_LIMITS.maxProgresslessCalls
+              ) {
+                return yield* new FlacDecodeError({
+                  reason: "invalid-stream",
+                  phase: "frame",
+                  detail: `decoder made no observable progress for ${progresslessCalls} bounded calls`,
+                });
+              }
+              yield* Effect.yieldNow;
+              continue;
+            }
+            if (result !== 2) {
+              return yield* decoderFailure(
+                { abi, decoder },
+                "frame",
+                "libFLAC rejected an audio frame",
+                result,
+              );
+            }
+
+            const finish = yield* abi.invoke(
+              "finish",
+              () => abi.exports.codec_decoder_finish(decoder),
+              nextInput,
+            );
+            if (finish !== 0) {
+              return yield* decoderFailure(
+                { abi, decoder },
+                "finish",
+                "libFLAC could not verify the completed stream",
+                finish,
+              );
+            }
+            const completed = yield* abiOperation(
+              "finish",
+              "decoder Wasm trapped while reporting completion",
+              () => ({
+                frames: uint64(
+                  abi.exports.codec_decoder_decoded_frames_low(decoder),
+                  abi.exports.codec_decoder_decoded_frames_high(decoder),
+                ),
+                bytes: uint64(
+                  abi.exports.codec_decoder_decoded_bytes_low(decoder),
+                  abi.exports.codec_decoder_decoded_bytes_high(decoder),
+                ),
+              }),
+            );
+            if (
+              completed.frames > FLAC_DECODER_LIMITS.maxTotalFrames ||
+              completed.frames !== emittedFrames ||
+              completed.bytes !== emittedBytes
+            ) {
+              return yield* new FlacDecodeError({
+                reason: "wasm-abi",
+                phase: "finish",
+                detail: "decoder completion counters do not match emitted PCM",
+              });
+            }
+            const complete: FlacDecodeComplete = {
+              _tag: "Complete",
+              format: format!,
+              frames: completed.frames,
+              bytes: completed.bytes,
+              md5Checked: md5Present,
+              md5Verified: md5Present,
+            };
+            yield* abiOperation(
+              "finish",
+              "decoder cleanup trapped after successful verification",
+              releaseDecoder,
+            );
+            state = "done";
+            return [complete] as readonly [FlacDecodeEvent];
+          }
+        });
+        return outputPull;
+      }),
+  );
+
+/**
+ * Incrementally decode an ordinary native-FLAC byte stream. The returned Stream
+ * pulls at most one bounded input element at each Asyncify suspension and emits
+ * one bounded PCM block at a time. A `Complete` event is the only verified
+ * success signal; early stream cancellation emits none and releases the Wasm
+ * decoder through the stream scope.
+ */
+export const decodeFlac = <E, R>(
+  input: Stream.Stream<Uint8Array, E, R>,
+  options: FlacDecodeOptions = {},
+): Stream.Stream<FlacDecodeEvent, E | FlacDecodeError, R | FlacDecoder> => {
+  return Stream.unwrap(
+    checkOptions(options).pipe(
+      Effect.map((checked) => makeDecodeStream(input, checked)),
+    ),
+  );
+};
diff --git a/src/decoder-errors.ts b/src/decoder-errors.ts
new file mode 100644
index 0000000..8836cce
--- /dev/null
+++ b/src/decoder-errors.ts
@@ -0,0 +1,38 @@
+import * as Schema from "effect/Schema";
+
+export const FlacDecodeErrorReason = Schema.Literals([
+  "invalid-options",
+  "input-chunk-too-large",
+  "wasm-compile",
+  "wasm-abi",
+  "wasm-instantiate",
+  "wasm-trap",
+  "allocation-failed",
+  "invalid-metadata",
+  "metadata-limit",
+  "expected-metadata-mismatch",
+  "invalid-stream",
+  "frame-position-mismatch",
+  "frame-count-mismatch",
+  "crc-mismatch",
+  "md5-mismatch",
+]);
+
+/** A checked failure while loading or incrementally decoding a FLAC stream. */
+export class FlacDecodeError extends Schema.TaggedError<FlacDecodeError>()(
+  "FlacDecodeError",
+  {
+    reason: FlacDecodeErrorReason,
+    phase: Schema.Literals([
+      "load",
+      "instantiate",
+      "metadata",
+      "frame",
+      "finish",
+    ]),
+    detail: Schema.String,
+    nativeState: Schema.optionalKey(Schema.Int),
+    callbackError: Schema.optionalKey(Schema.Int),
+    cause: Schema.optionalKey(Schema.Defect()),
+  },
+) {}
diff --git a/src/decoder-wasm.ts b/src/decoder-wasm.ts
new file mode 100644
index 0000000..815fdfd
--- /dev/null
+++ b/src/decoder-wasm.ts
@@ -0,0 +1,155 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import { FlacDecodeError } from "./decoder-errors.js";
+
+export const FLAC_DECODER_WASM_URL = new URL(
+  "../wasm/flac-decoder.wasm",
+  import.meta.url,
+);
+
+// Updated only by the explicit reproducible Wasm build command.
+export const FLAC_DECODER_WASM_SHA256 =
+  "5e282f9874ecb3f49b8ee8437efc318ec14ef5cff5b7580da9d875f94e5c5925";
+
+export const FLAC_DECODER_LIMITS = {
+  maxInputChunkBytes: 256 * 1024,
+  maxOutputBlockBytes: 384 * 1024,
+  maxMetadataBytes: 16 * 1024 * 1024,
+  defaultMaxMetadataBytes: 1024 * 1024,
+  wasmMemoryBytes: 2 * 1024 * 1024,
+  wasmStackBytes: 64 * 1024,
+  asyncifyStackBytes: 64 * 1024,
+  maxProgresslessCalls: 64,
+  maxAssetBytes: 256 * 1024,
+  maxTotalFrames: (1n << 36n) - 1n,
+} as const;
+
+export interface FlacDecoderService {
+  readonly module: WebAssembly.Module;
+}
+
+/** A Layer-scoped, compiled decoder module shared by independent decode calls. */
+export class FlacDecoder extends Context.Service<
+  FlacDecoder,
+  FlacDecoderService
+>()("@misofm/codec/FlacDecoder") {}
+
+const EXPECTED_IMPORTS = ["codec.read:function"] as const;
+const EXPECTED_EXPORTS = [
+  "asyncify_get_state:function",
+  "asyncify_start_rewind:function",
+  "asyncify_start_unwind:function",
+  "asyncify_stop_rewind:function",
+  "asyncify_stop_unwind:function",
+  "codec_decoder_abi_version:function",
+  "codec_decoder_allocator_free_calls:function",
+  "codec_decoder_allocator_live_bytes:function",
+  "codec_decoder_allocator_peak_heap_bytes:function",
+  "codec_decoder_allocator_peak_live_bytes:function",
+  "codec_decoder_allocator_realloc_calls:function",
+  "codec_decoder_bits_per_sample:function",
+  "codec_decoder_callback_error:function",
+  "codec_decoder_channels:function",
+  "codec_decoder_decoded_bytes_high:function",
+  "codec_decoder_decoded_bytes_low:function",
+  "codec_decoder_decoded_frames_high:function",
+  "codec_decoder_decoded_frames_low:function",
+  "codec_decoder_delete:function",
+  "codec_decoder_finish:function",
+  "codec_decoder_init:function",
+  "codec_decoder_maximum_block_frames:function",
+  "codec_decoder_md5_present:function",
+  "codec_decoder_minimum_block_frames:function",
+  "codec_decoder_new:function",
+  "codec_decoder_output_frame_offset_high:function",
+  "codec_decoder_output_frame_offset_low:function",
+  "codec_decoder_output_frames:function",
+  "codec_decoder_output_length:function",
+  "codec_decoder_output_ptr:function",
+  "codec_decoder_process_single:function",
+  "codec_decoder_release_output:function",
+  "codec_decoder_sample_rate:function",
+  "codec_decoder_state:function",
+  "codec_decoder_streaminfo_frames_high:function",
+  "codec_decoder_streaminfo_frames_known:function",
+  "codec_decoder_streaminfo_frames_low:function",
+  "codec_decoder_total_frames_high:function",
+  "codec_decoder_total_frames_known:function",
+  "codec_decoder_total_frames_low:function",
+  "free:function",
+  "malloc:function",
+  "memory:memory",
+] as const;
+
+const digestHex = (bytes: ArrayBuffer): Promise<string> =>
+  globalThis.crypto.subtle
+    .digest("SHA-256", bytes)
+    .then((digest) =>
+      Array.from(new Uint8Array(digest), (byte) =>
+        byte.toString(16).padStart(2, "0"),
+      ).join(""),
+    );
+
+export const loadFlacDecoderFromBytes = (
+  bytes: Uint8Array,
+): Effect.Effect<FlacDecoderService, FlacDecodeError> =>
+  Effect.tryPromise({
+    try: async () => {
+      if (bytes.byteLength > FLAC_DECODER_LIMITS.maxAssetBytes) {
+        throw new Error(
+          `decoder asset is ${bytes.byteLength} bytes; maximum is ${FLAC_DECODER_LIMITS.maxAssetBytes}`,
+        );
+      }
+      const owned = Uint8Array.from(bytes);
+      const hash = await digestHex(owned.buffer);
+      if (hash !== FLAC_DECODER_WASM_SHA256) {
+        throw new Error(
+          `decoder asset SHA-256 ${hash} does not match pinned ${FLAC_DECODER_WASM_SHA256}`,
+        );
+      }
+      return WebAssembly.compile(owned.buffer);
+    },
+    catch: (cause) =>
+      new FlacDecodeError({
+        reason: "wasm-compile",
+        phase: "load",
+        detail: "WebAssembly.compile rejected the decoder asset",
+        cause,
+      }),
+  }).pipe(
+    Effect.flatMap((module) => {
+      const imports = WebAssembly.Module.imports(module)
+        .map(({ module, name, kind }) => `${module}.${name}:${kind}`)
+        .sort();
+      if (JSON.stringify(imports) !== JSON.stringify(EXPECTED_IMPORTS)) {
+        return Effect.fail(
+          new FlacDecodeError({
+            reason: "wasm-abi",
+            phase: "load",
+            detail: `unexpected decoder imports: ${imports.join(", ")}`,
+          }),
+        );
+      }
+      const exports = WebAssembly.Module.exports(module)
+        .map(({ name, kind }) => `${name}:${kind}`)
+        .sort();
+      if (JSON.stringify(exports) !== JSON.stringify(EXPECTED_EXPORTS)) {
+        return Effect.fail(
+          new FlacDecodeError({
+            reason: "wasm-abi",
+            phase: "load",
+            detail: `unexpected decoder exports: ${exports.join(", ")}`,
+          }),
+        );
+      }
+      return Effect.succeed({ module });
+    }),
+  );
+
+/** Compile and validate trusted decoder Wasm bytes once for a Layer lifetime. */
+export const makeFlacDecoderLayer = (
+  bytes: Uint8Array,
+): Layer.Layer<FlacDecoder, FlacDecodeError> =>
+  Layer.effect(FlacDecoder, loadFlacDecoderFromBytes(bytes));
diff --git a/src/encode.ts b/src/encode.ts
new file mode 100644
index 0000000..6d363f6
--- /dev/null
+++ b/src/encode.ts
@@ -0,0 +1,667 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+
+import { FlacEncodeError, PcmInputError } from "./errors.js";
+import { PcmFormat } from "./format.js";
+import {
+  instantiateEncoder,
+  type EncoderAbi,
+  type StagedWrite,
+} from "./internal/encoder-abi.js";
+import { FlacEncoder, FLAC_ENCODER_LIMITS } from "./wasm.js";
+
+export interface RandomAccessByteSink<E, R> {
+  readonly writeAt: (
+    offset: bigint,
+    bytes: Uint8Array,
+  ) => Effect.Effect<void, E, R>;
+  readonly resize: (length: bigint) => Effect.Effect<void, E, R>;
+}
+
+export interface FlacEncodeOptions {
+  readonly format: PcmFormat;
+  readonly expectedFrames?: bigint;
+}
+
+export interface FlacStreamInfo {
+  readonly minimumBlockFrames: number;
+  readonly maximumBlockFrames: number;
+  readonly minimumFrameBytes: number;
+  readonly maximumFrameBytes: number;
+  readonly totalFrames: bigint;
+  readonly md5Hex: string;
+}
+
+export interface FlacEncodeResult {
+  readonly format: PcmFormat;
+  readonly frames: bigint;
+  readonly bytes: bigint;
+  readonly streamInfo: FlacStreamInfo;
+}
+
+interface EncoderResource {
+  readonly abi: EncoderAbi;
+  readonly encoder: number;
+  readonly input: number;
+  released: boolean;
+}
+
+interface CheckedEncodeOptions {
+  readonly format: PcmFormat;
+  readonly expectedFrames: bigint | undefined;
+}
+
+const readUint16 = (bytes: Uint8Array, offset: number): number =>
+  ((bytes[offset] ?? 0) << 8) | (bytes[offset + 1] ?? 0);
+
+const readUint24 = (bytes: Uint8Array, offset: number): number =>
+  ((bytes[offset] ?? 0) << 16) |
+  ((bytes[offset + 1] ?? 0) << 8) |
+  (bytes[offset + 2] ?? 0);
+
+const readUint32LittleEndian = (bytes: Uint8Array, offset: number): number =>
+  ((bytes[offset] ?? 0) |
+    ((bytes[offset + 1] ?? 0) << 8) |
+    ((bytes[offset + 2] ?? 0) << 16) |
+    ((bytes[offset + 3] ?? 0) << 24)) >>>
+  0;
+
+const invalidStreamInfo = (detail: string): FlacEncodeError =>
+  new FlacEncodeError({
+    reason: "invalid-streaminfo",
+    phase: "validate",
+    detail,
+  });
+
+const parseStreamInfo = (
+  prefix: Uint8Array,
+  prefixPresent: Uint8Array,
+  format: PcmFormat,
+  frames: bigint,
+): Effect.Effect<FlacStreamInfo, FlacEncodeError> => {
+  for (let index = 0; index < 42; index++)
+    if (prefixPresent[index] !== 1)
+      return Effect.fail(
+        invalidStreamInfo(
+          "final output did not contain a complete 42-byte FLAC STREAMINFO prefix",
+        ),
+      );
+  if (
+    prefix[0] !== 0x66 ||
+    prefix[1] !== 0x4c ||
+    prefix[2] !== 0x61 ||
+    prefix[3] !== 0x43 ||
+    (prefix[4]! & 0x7f) !== 0 ||
+    readUint24(prefix, 5) !== 34
+  ) {
+    return Effect.fail(
+      invalidStreamInfo(
+        "final output has an invalid native-FLAC STREAMINFO header",
+      ),
+    );
+  }
+
+  // This pinned profile emits STREAMINFO followed by one terminal, empty-comment
+  // VORBIS_COMMENT block. Walk the declared metadata chain and require all bytes
+  // to have arrived so a malformed backend cannot return a truncated FLAC as a
+  // successful encode.
+  if ((prefix[4]! & 0x80) !== 0)
+    return Effect.fail(
+      invalidStreamInfo(
+        "STREAMINFO unexpectedly terminated the metadata chain",
+      ),
+    );
+  for (let index = 42; index < 46; index++)
+    if (prefixPresent[index] !== 1)
+      return Effect.fail(
+        invalidStreamInfo("final output omitted the VORBIS_COMMENT header"),
+      );
+  if (prefix[42] !== 0x84)
+    return Effect.fail(
+      invalidStreamInfo(
+        "metadata after STREAMINFO is not the terminal VORBIS_COMMENT block",
+      ),
+    );
+  const commentLength = readUint24(prefix, 43);
+  const metadataEnd = 46 + commentLength;
+  if (commentLength < 8 || metadataEnd > prefix.length)
+    return Effect.fail(
+      invalidStreamInfo(
+        `VORBIS_COMMENT length ${commentLength} exceeds the bounded metadata profile`,
+      ),
+    );
+  for (let index = 46; index < metadataEnd; index++)
+    if (prefixPresent[index] !== 1)
+      return Effect.fail(
+        invalidStreamInfo("final output contained a truncated VORBIS_COMMENT"),
+      );
+  const vendorLength = readUint32LittleEndian(prefix, 46);
+  if (
+    vendorLength > commentLength - 8 ||
+    50 + vendorLength + 4 !== metadataEnd ||
+    readUint32LittleEndian(prefix, 50 + vendorLength) !== 0
+  )
+    return Effect.fail(
+      invalidStreamInfo(
+        "VORBIS_COMMENT does not match the pinned zero-user-comment profile",
+      ),
+    );
+
+  let packed = 0n;
+  for (let index = 18; index < 26; index++)
+    packed = (packed << 8n) | BigInt(prefix[index]!);
+  const streamSampleRate = Number(packed >> 44n);
+  const streamChannels = Number((packed >> 41n) & 0x7n) + 1;
+  const streamBits = Number((packed >> 36n) & 0x1fn) + 1;
+  const totalFrames = packed & FLAC_ENCODER_LIMITS.maxTotalFrames;
+  if (
+    streamSampleRate !== format.sampleRate ||
+    streamChannels !== format.channels ||
+    streamBits !== format.bitsPerSample ||
+    totalFrames !== frames
+  ) {
+    return Effect.fail(
+      new FlacEncodeError({
+        reason: "streaminfo-mismatch",
+        phase: "validate",
+        detail: `STREAMINFO reported ${streamSampleRate} Hz/${streamChannels} ch/${streamBits} bit/${totalFrames} frames; encoded ${format.sampleRate} Hz/${format.channels} ch/${format.bitsPerSample} bit/${frames} frames`,
+      }),
+    );
+  }
+
+  const minimumBlockFrames = readUint16(prefix, 8);
+  const maximumBlockFrames = readUint16(prefix, 10);
+  const minimumFrameBytes = readUint24(prefix, 12);
+  const maximumFrameBytes = readUint24(prefix, 15);
+  if (
+    minimumBlockFrames !== FLAC_ENCODER_LIMITS.encoderBlockFrames ||
+    maximumBlockFrames !== FLAC_ENCODER_LIMITS.encoderBlockFrames
+  )
+    return Effect.fail(
+      invalidStreamInfo(
+        `STREAMINFO block sizes ${minimumBlockFrames}/${maximumBlockFrames} do not match the ${FLAC_ENCODER_LIMITS.encoderBlockFrames}-frame profile`,
+      ),
+    );
+  if (
+    frames > 0n &&
+    (minimumFrameBytes === 0 ||
+      maximumFrameBytes < minimumFrameBytes ||
+      maximumFrameBytes > FLAC_ENCODER_LIMITS.maxStagedBytesPerCall)
+  )
+    return Effect.fail(
+      invalidStreamInfo(
+        `STREAMINFO frame sizes ${minimumFrameBytes}/${maximumFrameBytes} are incoherent`,
+      ),
+    );
+
+  return Effect.succeed({
+    minimumBlockFrames,
+    maximumBlockFrames,
+    minimumFrameBytes,
+    maximumFrameBytes,
+    totalFrames,
+    md5Hex: Array.from(prefix.subarray(26, 42), (byte) =>
+      byte.toString(16).padStart(2, "0"),
+    ).join(""),
+  });
+};
+
+const validateOptions = (
+  options: unknown,
+): Effect.Effect<CheckedEncodeOptions, PcmInputError> => {
+  if (
+    typeof options !== "object" ||
+    options === null ||
+    Array.isArray(options)
+  ) {
+    return Effect.fail(
+      new PcmInputError({
+        reason: "invalid-format",
+        detail: "encoder options must be an object",
+      }),
+    );
+  }
+  const values = options as Readonly<Record<string, unknown>>;
+  const expectedFrames = values.expectedFrames;
+  if (
+    expectedFrames !== undefined &&
+    (typeof expectedFrames !== "bigint" ||
+      expectedFrames < 0n ||
+      expectedFrames > FLAC_ENCODER_LIMITS.maxTotalFrames)
+  ) {
+    return Effect.fail(
+      new PcmInputError({
+        reason: "invalid-format",
+        detail: `expectedFrames must be between 0 and ${FLAC_ENCODER_LIMITS.maxTotalFrames}`,
+      }),
+    );
+  }
+  return Schema.decodeUnknownEffect(PcmFormat)(values.format).pipe(
+    Effect.map((format) => ({ format, expectedFrames })),
+    Effect.mapError(
+      (error) =>
+        new PcmInputError({
+          reason: "invalid-format",
+          detail: error.message,
+        }),
+    ),
+  );
+};
+
+const validateBlock = (
+  block: Int32Array,
+  format: PcmFormat,
+  blockIndex: number,
+  framesSoFar: bigint,
+  expectedFrames: bigint | undefined,
+): Effect.Effect<number, PcmInputError> => {
+  if (!(block instanceof Int32Array)) {
+    return Effect.fail(
+      new PcmInputError({
+        reason: "invalid-format",
+        detail: "PCM blocks must be Int32Array values",
+        blockIndex,
+      }),
+    );
+  }
+  if (block.length === 0) {
+    return Effect.fail(
+      new PcmInputError({
+        reason: "empty-block",
+        detail: "PCM blocks must be non-empty",
+        blockIndex,
+      }),
+    );
+  }
+  if (block.length % format.channels !== 0) {
+    return Effect.fail(
+      new PcmInputError({
+        reason: "misaligned-block",
+        detail: `PCM block length ${block.length} is not aligned to ${format.channels} channels`,
+        blockIndex,
+      }),
+    );
+  }
+  const blockFrames = block.length / format.channels;
+  if (blockFrames > FLAC_ENCODER_LIMITS.maxInputBlockFrames) {
+    return Effect.fail(
+      new PcmInputError({
+        reason: "block-too-large",
+        detail: `PCM block has ${blockFrames} frames; maximum is ${FLAC_ENCODER_LIMITS.maxInputBlockFrames}`,
+        blockIndex,
+      }),
+    );
+  }
+  if (framesSoFar + BigInt(blockFrames) > FLAC_ENCODER_LIMITS.maxTotalFrames) {
+    return Effect.fail(
+      new PcmInputError({
+        reason: "too-many-frames",
+        detail: `native FLAC STREAMINFO can represent at most ${FLAC_ENCODER_LIMITS.maxTotalFrames} frames`,
+        blockIndex,
+      }),
+    );
+  }
+  if (
+    expectedFrames !== undefined &&
+    framesSoFar + BigInt(blockFrames) > expectedFrames
+  ) {
+    return Effect.fail(
+      new PcmInputError({
+        reason: "frame-count-mismatch",
+        detail: `block ${blockIndex} would exceed expected frame count ${expectedFrames}`,
+        blockIndex,
+        expectedFrames,
+        actualFrames: framesSoFar + BigInt(blockFrames),
+      }),
+    );
+  }
+  const minimum = -(2 ** (format.bitsPerSample - 1));
+  const maximum = 2 ** (format.bitsPerSample - 1) - 1;
+  for (let sampleIndex = 0; sampleIndex < block.length; sampleIndex++) {
+    const value = block[sampleIndex]!;
+    if (value < minimum || value > maximum) {
+      return Effect.fail(
+        new PcmInputError({
+          reason: "sample-out-of-range",
+          detail: `sample ${value} is outside signed PCM${format.bitsPerSample} range ${minimum}…${maximum}`,
+          blockIndex,
+          sampleIndex,
+          value,
+        }),
+      );
+    }
+  }
+  return Effect.succeed(blockFrames);
+};
+
+const nativeFailure = (
+  abi: EncoderAbi,
+  encoder: number,
+  reason: "encoder-init" | "encoder-process" | "encoder-finish",
+  phase: "init" | "process" | "finish",
+): FlacEncodeError => {
+  let nativeState: number | undefined;
+  try {
+    nativeState = abi.exports.codec_encoder_state(encoder);
+  } catch {
+    // The primary operation already failed; state is diagnostic only.
+  }
+  return new FlacEncodeError({
+    reason,
+    phase,
+    detail: `libFLAC ${phase} returned failure`,
+    ...(nativeState === undefined ? {} : { nativeState }),
+  });
+};
+
+const releaseEncoder = (
+  resource: EncoderResource,
+): Effect.Effect<void, FlacEncodeError> =>
+  Effect.try({
+    try: () => {
+      if (resource.released) return;
+      resource.released = true;
+      let trapped = false;
+      let firstCause: unknown;
+      try {
+        resource.abi.exports.free(resource.input);
+      } catch (cause) {
+        trapped = true;
+        firstCause = cause;
+      }
+      try {
+        resource.abi.exports.codec_encoder_delete(resource.encoder);
+      } catch (cause) {
+        if (!trapped) firstCause = cause;
+        trapped = true;
+      }
+      if (trapped) throw firstCause;
+    },
+    catch: (cause) =>
+      new FlacEncodeError({
+        reason: "wasm-trap",
+        phase: "finish",
+        detail: "encoder cleanup trapped after successful finalization",
+        cause,
+      }),
+  });
+
+/**
+ * Incrementally encode bounded right-justified interleaved PCM to native FLAC.
+ *
+ * The Effect is lazy. It awaits every staged random-access write before pulling
+ * another PCM block. Synchronous Wasm calls are bounded but cannot be interrupted
+ * mid-call; interruption is observed before the next call/pull/write. A failed or
+ * interrupted operation may leave partial sink bytes, and the caller owns cleanup.
+ */
+export const encodeFlac = <EI, RI, EO, RO>(
+  source: Stream.Stream<Int32Array, EI, RI>,
+  sink: RandomAccessByteSink<EO, RO>,
+  options: FlacEncodeOptions,
+): Effect.Effect<
+  FlacEncodeResult,
+  EI | EO | PcmInputError | FlacEncodeError,
+  RI | RO | FlacEncoder
+> =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const checkedOptions = yield* validateOptions(options);
+      const { format, expectedFrames } = checkedOptions;
+      const service = yield* FlacEncoder;
+      const abi = yield* instantiateEncoder(service.module);
+      const metadataPrefix = new Uint8Array(
+        FLAC_ENCODER_LIMITS.maxMetadataPrefixBytes,
+      );
+      const metadataPrefixPresent = new Uint8Array(
+        FLAC_ENCODER_LIMITS.maxMetadataPrefixBytes,
+      );
+      let highWaterMark = 0n;
+
+      const drainWrites = (
+        writes: ReadonlyArray<StagedWrite>,
+      ): Effect.Effect<void, EO, RO> =>
+        Effect.forEach(
+          writes,
+          (write) =>
+            sink.writeAt(write.offset, write.bytes).pipe(
+              Effect.tap(() =>
+                Effect.sync(() => {
+                  const end = write.offset + BigInt(write.bytes.length);
+                  if (end > highWaterMark) highWaterMark = end;
+                  if (
+                    write.offset <
+                      BigInt(FLAC_ENCODER_LIMITS.maxMetadataPrefixBytes) &&
+                    end > 0n
+                  ) {
+                    const sourceStart =
+                      write.offset < 0n ? Number(-write.offset) : 0;
+                    const targetStart = Number(
+                      write.offset < 0n ? 0n : write.offset,
+                    );
+                    const count = Math.min(
+                      write.bytes.length - sourceStart,
+                      FLAC_ENCODER_LIMITS.maxMetadataPrefixBytes - targetStart,
+                    );
+                    if (count > 0) {
+                      metadataPrefix.set(
+                        write.bytes.subarray(sourceStart, sourceStart + count),
+                        targetStart,
+                      );
+                      metadataPrefixPresent.fill(
+                        1,
+                        targetStart,
+                        targetStart + count,
+                      );
+                    }
+                  }
+                }),
+              ),
+            ),
+          { discard: true },
+        );
+
+      const resource = yield* Effect.acquireRelease(
+        Effect.try({
+          try: (): EncoderResource => {
+            abi.beginCall();
+            const memoryBytes = abi.exports.memory.buffer.byteLength;
+            const encoder = abi.exports.codec_encoder_new(
+              format.sampleRate,
+              format.channels,
+              format.bitsPerSample,
+              FLAC_ENCODER_LIMITS.compressionLevel,
+              FLAC_ENCODER_LIMITS.encoderBlockFrames,
+            );
+            if (
+              !Number.isSafeInteger(encoder) ||
+              encoder <= 0 ||
+              encoder % 4 !== 0 ||
+              encoder >= memoryBytes
+            )
+              throw new FlacEncodeError({
+                reason: encoder === 0 ? "encoder-create" : "wasm-abi",
+                phase: "init",
+                detail:
+                  encoder === 0
+                    ? "libFLAC could not allocate/configure an encoder"
+                    : "encoder returned an invalid state pointer",
+              });
+            const inputBytes =
+              FLAC_ENCODER_LIMITS.maxInputBlockFrames *
+              format.channels *
+              Int32Array.BYTES_PER_ELEMENT;
+            const input = abi.exports.malloc(inputBytes);
+            if (
+              !Number.isSafeInteger(input) ||
+              input <= 0 ||
+              input % Int32Array.BYTES_PER_ELEMENT !== 0 ||
+              input > memoryBytes - inputBytes
+            ) {
+              try {
+                abi.exports.codec_encoder_delete(encoder);
+              } catch {
+                // The invalid allocation is the primary typed failure.
+              }
+              throw new FlacEncodeError({
+                reason: input === 0 ? "allocation-failed" : "wasm-abi",
+                phase: "init",
+                detail:
+                  input === 0
+                    ? "Wasm could not allocate the bounded PCM input buffer"
+                    : "encoder returned an invalid PCM input pointer",
+              });
+            }
+            return { abi, encoder, input, released: false };
+          },
+          catch: (cause) =>
+            cause instanceof FlacEncodeError
+              ? cause
+              : new FlacEncodeError({
+                  reason: "wasm-trap",
+                  phase: "init",
+                  detail: "encoder allocation trapped",
+                  cause,
+                }),
+        }),
+        (owned) =>
+          Effect.sync(() => {
+            if (owned.released) return;
+            owned.released = true;
+            try {
+              owned.abi.exports.free(owned.input);
+            } catch {
+              // Finalization is best-effort for a caller-supplied malformed ABI.
+            }
+            try {
+              owned.abi.exports.codec_encoder_delete(owned.encoder);
+            } catch {
+              // Finalization is best-effort for a caller-supplied malformed ABI.
+            }
+          }),
+      );
+
+      resource.abi.beginCall();
+      const initStatus = yield* Effect.try({
+        try: () => resource.abi.exports.codec_encoder_init(resource.encoder),
+        catch: (cause) =>
+          new FlacEncodeError({
+            reason: "wasm-trap",
+            phase: "init",
+            detail: "encoder initialization trapped",
+            cause,
+          }),
+      });
+      const initBatch = resource.abi.endCall();
+      if (initBatch.error !== undefined) return yield* initBatch.error;
+      if (initStatus !== 0)
+        return yield* nativeFailure(
+          resource.abi,
+          resource.encoder,
+          "encoder-init",
+          "init",
+        );
+      yield* drainWrites(initBatch.writes);
+
+      let frames = 0n;
+      let blockIndex = 0;
+      yield* Stream.runForEach(source, (block) =>
+        Effect.gen(function* () {
+          const blockFrames = yield* validateBlock(
+            block,
+            format,
+            blockIndex,
+            frames,
+            expectedFrames,
+          );
+          yield* Effect.try({
+            try: () =>
+              new Int32Array(
+                resource.abi.exports.memory.buffer,
+                resource.input,
+                block.length,
+              ).set(block),
+            catch: (cause) =>
+              new FlacEncodeError({
+                reason: "wasm-abi",
+                phase: "process",
+                detail: `could not copy PCM block ${blockIndex} into encoder memory`,
+                cause,
+              }),
+          });
+          resource.abi.beginCall();
+          const processStatus = yield* Effect.try({
+            try: () =>
+              resource.abi.exports.codec_encoder_process_interleaved(
+                resource.encoder,
+                resource.input,
+                blockFrames,
+              ),
+            catch: (cause) =>
+              new FlacEncodeError({
+                reason: "wasm-trap",
+                phase: "process",
+                detail: `encoder process call ${blockIndex} trapped`,
+                cause,
+              }),
+          });
+          const batch = resource.abi.endCall();
+          if (batch.error !== undefined) return yield* batch.error;
+          if (processStatus !== 1) {
+            return yield* nativeFailure(
+              resource.abi,
+              resource.encoder,
+              "encoder-process",
+              "process",
+            );
+          }
+          yield* drainWrites(batch.writes);
+          frames += BigInt(blockFrames);
+          blockIndex += 1;
+          yield* Effect.yieldNow;
+        }),
+      );
+
+      if (expectedFrames !== undefined && frames !== expectedFrames) {
+        return yield* new PcmInputError({
+          reason: "frame-count-mismatch",
+          detail: `source produced ${frames} frames; expected ${expectedFrames}`,
+          expectedFrames,
+          actualFrames: frames,
+        });
+      }
+
+      resource.abi.beginCall();
+      const finishStatus = yield* Effect.try({
+        try: () => resource.abi.exports.codec_encoder_finish(resource.encoder),
+        catch: (cause) =>
+          new FlacEncodeError({
+            reason: "wasm-trap",
+            phase: "finish",
+            detail: "encoder finish trapped",
+            cause,
+          }),
+      });
+      const finishBatch = resource.abi.endCall();
+      if (finishBatch.error !== undefined) return yield* finishBatch.error;
+      if (finishStatus !== 1) {
+        return yield* nativeFailure(
+          resource.abi,
+          resource.encoder,
+          "encoder-finish",
+          "finish",
+        );
+      }
+      yield* drainWrites(finishBatch.writes);
+      const streamInfo = yield* parseStreamInfo(
+        metadataPrefix,
+        metadataPrefixPresent,
+        format,
+        frames,
+      );
+      yield* sink.resize(highWaterMark);
+      yield* releaseEncoder(resource);
+
+      return { format, frames, bytes: highWaterMark, streamInfo };
+    }),
+  );
diff --git a/src/errors.ts b/src/errors.ts
new file mode 100644
index 0000000..b3fb54e
--- /dev/null
+++ b/src/errors.ts
@@ -0,0 +1,59 @@
+import * as Schema from "effect/Schema";
+
+export const PcmInputErrorReason = Schema.Literals([
+  "invalid-format",
+  "empty-block",
+  "misaligned-block",
+  "block-too-large",
+  "sample-out-of-range",
+  "too-many-frames",
+  "frame-count-mismatch",
+]);
+
+/** A checked PCM contract violation. No samples from the failing block are used. */
+export class PcmInputError extends Schema.TaggedError<PcmInputError>()(
+  "PcmInputError",
+  {
+    reason: PcmInputErrorReason,
+    detail: Schema.String,
+    blockIndex: Schema.optionalKey(Schema.Natural),
+    sampleIndex: Schema.optionalKey(Schema.Natural),
+    value: Schema.optionalKey(Schema.Int),
+    expectedFrames: Schema.optionalKey(Schema.BigInt),
+    actualFrames: Schema.optionalKey(Schema.BigInt),
+  },
+) {}
+
+export const FlacEncodeErrorReason = Schema.Literals([
+  "wasm-compile",
+  "wasm-abi",
+  "wasm-instantiate",
+  "wasm-trap",
+  "allocation-failed",
+  "encoder-create",
+  "encoder-init",
+  "encoder-process",
+  "encoder-finish",
+  "staged-output-limit",
+  "invalid-streaminfo",
+  "streaminfo-mismatch",
+]);
+
+/** A failure in the Wasm/libFLAC encoder boundary. */
+export class FlacEncodeError extends Schema.TaggedError<FlacEncodeError>()(
+  "FlacEncodeError",
+  {
+    reason: FlacEncodeErrorReason,
+    phase: Schema.Literals([
+      "load",
+      "instantiate",
+      "init",
+      "process",
+      "finish",
+      "validate",
+    ]),
+    detail: Schema.String,
+    nativeState: Schema.optionalKey(Schema.Int),
+    cause: Schema.optionalKey(Schema.Defect()),
+  },
+) {}
diff --git a/src/format.ts b/src/format.ts
new file mode 100644
index 0000000..969698e
--- /dev/null
+++ b/src/format.ts
@@ -0,0 +1,27 @@
+import * as Schema from "effect/Schema";
+
+export const PcmSampleRate = Schema.Int.pipe(
+  Schema.check(Schema.isBetween({ minimum: 8_000, maximum: 192_000 })),
+).annotate({
+  identifier: "PcmSampleRate",
+  description: "Integer PCM sample rate from 8,000 through 192,000 Hz",
+});
+
+export const PcmChannels = Schema.Literals([1, 2]).annotate({
+  identifier: "PcmChannels",
+  description: "Interleaved mono or stereo PCM channel count",
+});
+
+export const PcmBitsPerSample = Schema.Literals([16, 24]).annotate({
+  identifier: "PcmBitsPerSample",
+  description: "Signed, right-justified integer PCM sample depth",
+});
+
+/** The validated PCM format accepted and returned by this package. */
+export class PcmFormat extends Schema.Class<PcmFormat>(
+  "@misofm/codec/PcmFormat",
+)({
+  sampleRate: PcmSampleRate,
+  channels: PcmChannels,
+  bitsPerSample: PcmBitsPerSample,
+}) {}
diff --git a/src/index.ts b/src/index.ts
new file mode 100644
index 0000000..dd5584b
--- /dev/null
+++ b/src/index.ts
@@ -0,0 +1,42 @@
+export {
+  FlacEncodeError,
+  FlacEncodeErrorReason,
+  PcmInputError,
+  PcmInputErrorReason,
+} from "./errors.js";
+export {
+  PcmBitsPerSample,
+  PcmChannels,
+  PcmFormat,
+  PcmSampleRate,
+} from "./format.js";
+export {
+  encodeFlac,
+  type FlacEncodeOptions,
+  type FlacEncodeResult,
+  type FlacStreamInfo,
+  type RandomAccessByteSink,
+} from "./encode.js";
+export {
+  FlacEncoder,
+  FLAC_ENCODER_LIMITS,
+  FLAC_ENCODER_WASM_SHA256,
+  FLAC_ENCODER_WASM_URL,
+  makeFlacEncoderLayer,
+} from "./wasm.js";
+export { FlacDecodeError, FlacDecodeErrorReason } from "./decoder-errors.js";
+export {
+  decodeFlac,
+  type FlacDecodeComplete,
+  type FlacDecodeEvent,
+  type FlacDecodeOptions,
+  type FlacMetadata,
+  type FlacPcm,
+} from "./decode.js";
+export {
+  FlacDecoder,
+  FLAC_DECODER_LIMITS,
+  FLAC_DECODER_WASM_SHA256,
+  FLAC_DECODER_WASM_URL,
+  makeFlacDecoderLayer,
+} from "./decoder-wasm.js";
diff --git a/src/internal/decoder-abi.ts b/src/internal/decoder-abi.ts
new file mode 100644
index 0000000..c168c93
--- /dev/null
+++ b/src/internal/decoder-abi.ts
@@ -0,0 +1,321 @@
+import * as Effect from "effect/Effect";
+
+import { FlacDecodeError } from "../decoder-errors.js";
+import { FLAC_DECODER_LIMITS } from "../decoder-wasm.js";
+
+export type DecoderPhase = "instantiate" | "metadata" | "frame" | "finish";
+
+export interface DecoderExports extends WebAssembly.Exports {
+  readonly memory: WebAssembly.Memory;
+  readonly malloc: (size: number) => number;
+  readonly free: (pointer: number) => void;
+  readonly asyncify_start_unwind: (data: number) => void;
+  readonly asyncify_stop_unwind: () => void;
+  readonly asyncify_start_rewind: (data: number) => void;
+  readonly asyncify_stop_rewind: () => void;
+  readonly asyncify_get_state: () => number;
+  readonly codec_decoder_abi_version: () => number;
+  readonly codec_decoder_new: (...arguments_: ReadonlyArray<number>) => number;
+  readonly codec_decoder_init: (decoder: number) => number;
+  readonly codec_decoder_process_single: (decoder: number) => number;
+  readonly codec_decoder_finish: (decoder: number) => number;
+  readonly codec_decoder_delete: (decoder: number) => void;
+  readonly codec_decoder_output_ptr: (decoder: number) => number;
+  readonly codec_decoder_output_length: (decoder: number) => number;
+  readonly codec_decoder_output_frames: (decoder: number) => number;
+  readonly codec_decoder_output_frame_offset_low: (decoder: number) => number;
+  readonly codec_decoder_output_frame_offset_high: (decoder: number) => number;
+  readonly codec_decoder_release_output: (decoder: number) => void;
+  readonly codec_decoder_sample_rate: (decoder: number) => number;
+  readonly codec_decoder_channels: (decoder: number) => number;
+  readonly codec_decoder_bits_per_sample: (decoder: number) => number;
+  readonly codec_decoder_minimum_block_frames: (decoder: number) => number;
+  readonly codec_decoder_maximum_block_frames: (decoder: number) => number;
+  readonly codec_decoder_total_frames_low: (decoder: number) => number;
+  readonly codec_decoder_total_frames_high: (decoder: number) => number;
+  readonly codec_decoder_total_frames_known: (decoder: number) => number;
+  readonly codec_decoder_streaminfo_frames_low: (decoder: number) => number;
+  readonly codec_decoder_streaminfo_frames_high: (decoder: number) => number;
+  readonly codec_decoder_streaminfo_frames_known: (decoder: number) => number;
+  readonly codec_decoder_md5_present: (decoder: number) => number;
+  readonly codec_decoder_decoded_frames_low: (decoder: number) => number;
+  readonly codec_decoder_decoded_frames_high: (decoder: number) => number;
+  readonly codec_decoder_decoded_bytes_low: (decoder: number) => number;
+  readonly codec_decoder_decoded_bytes_high: (decoder: number) => number;
+  readonly codec_decoder_callback_error: (decoder: number) => number;
+  readonly codec_decoder_state: (decoder: number) => number;
+  readonly codec_decoder_allocator_live_bytes: () => number;
+  readonly codec_decoder_allocator_peak_live_bytes: () => number;
+  readonly codec_decoder_allocator_peak_heap_bytes: () => number;
+  readonly codec_decoder_allocator_free_calls: () => number;
+  readonly codec_decoder_allocator_realloc_calls: () => number;
+}
+
+const REQUIRED_EXPORTS = [
+  "memory",
+  "malloc",
+  "free",
+  "asyncify_start_unwind",
+  "asyncify_stop_unwind",
+  "asyncify_start_rewind",
+  "asyncify_stop_rewind",
+  "asyncify_get_state",
+  "codec_decoder_abi_version",
+  "codec_decoder_new",
+  "codec_decoder_init",
+  "codec_decoder_process_single",
+  "codec_decoder_finish",
+  "codec_decoder_delete",
+  "codec_decoder_output_ptr",
+  "codec_decoder_output_length",
+  "codec_decoder_output_frames",
+  "codec_decoder_output_frame_offset_low",
+  "codec_decoder_output_frame_offset_high",
+  "codec_decoder_release_output",
+  "codec_decoder_sample_rate",
+  "codec_decoder_channels",
+  "codec_decoder_bits_per_sample",
+  "codec_decoder_minimum_block_frames",
+  "codec_decoder_maximum_block_frames",
+  "codec_decoder_total_frames_low",
+  "codec_decoder_total_frames_high",
+  "codec_decoder_total_frames_known",
+  "codec_decoder_streaminfo_frames_low",
+  "codec_decoder_streaminfo_frames_high",
+  "codec_decoder_streaminfo_frames_known",
+  "codec_decoder_md5_present",
+  "codec_decoder_decoded_frames_low",
+  "codec_decoder_decoded_frames_high",
+  "codec_decoder_decoded_bytes_low",
+  "codec_decoder_decoded_bytes_high",
+  "codec_decoder_callback_error",
+  "codec_decoder_state",
+  "codec_decoder_allocator_live_bytes",
+  "codec_decoder_allocator_peak_live_bytes",
+  "codec_decoder_allocator_peak_heap_bytes",
+  "codec_decoder_allocator_free_calls",
+  "codec_decoder_allocator_realloc_calls",
+] as const;
+
+const ASYNCIFY_NORMAL = 0;
+const ASYNCIFY_UNWINDING = 1;
+const ASYNCIFY_REWINDING = 2;
+const ASYNCIFY_DATA_BYTES = 8;
+
+const wasmError = (
+  reason: "wasm-abi" | "wasm-instantiate" | "wasm-trap" | "allocation-failed",
+  phase: DecoderPhase,
+  detail: string,
+  cause?: unknown,
+): FlacDecodeError =>
+  new FlacDecodeError({
+    reason,
+    phase,
+    detail,
+    ...(cause === undefined ? {} : { cause }),
+  });
+
+export interface DecoderAbi {
+  readonly exports: DecoderExports;
+  readonly invoke: <E, R>(
+    phase: DecoderPhase,
+    call: () => number,
+    nextInput: Effect.Effect<Uint8Array | null, E, R>,
+  ) => Effect.Effect<number, E | FlacDecodeError, R>;
+  readonly normalize: () => void;
+  readonly dispose: () => void;
+}
+
+/**
+ * Instantiate one fixed-memory decoder. The only suspension point is the
+ * imported synchronous read callback; `invoke` moves that suspension into the
+ * caller's Effect pull without owning or nesting a runtime.
+ */
+export const instantiateDecoder = (
+  module: WebAssembly.Module,
+): Effect.Effect<DecoderAbi, FlacDecodeError> =>
+  Effect.tryPromise({
+    try: async () => {
+      let decoderExports: DecoderExports | undefined;
+      let slot: Uint8Array | undefined;
+      let slotOffset = 0;
+      let eof = false;
+      let asyncifyData = 0;
+      let disposed = false;
+
+      const read = (pointer: number, maximumBytes: number): number => {
+        const exports = decoderExports;
+        if (exports === undefined)
+          throw new Error("decoder read before instantiation");
+        const state = exports.asyncify_get_state();
+        if (state === ASYNCIFY_REWINDING) exports.asyncify_stop_rewind();
+        if (state !== ASYNCIFY_NORMAL && state !== ASYNCIFY_REWINDING) {
+          throw new Error(`decoder read in invalid Asyncify state ${state}`);
+        }
+        if (slot !== undefined) {
+          if (
+            !Number.isSafeInteger(pointer) ||
+            !Number.isSafeInteger(maximumBytes) ||
+            pointer < 0 ||
+            maximumBytes <= 0 ||
+            pointer + maximumBytes > exports.memory.buffer.byteLength
+          ) {
+            throw new Error("libFLAC supplied an invalid read callback range");
+          }
+          const length = Math.min(maximumBytes, slot.byteLength - slotOffset);
+          new Uint8Array(exports.memory.buffer, pointer, length).set(
+            slot.subarray(slotOffset, slotOffset + length),
+          );
+          slotOffset += length;
+          if (slotOffset === slot.byteLength) {
+            slot = undefined;
+            slotOffset = 0;
+          }
+          return length;
+        }
+        if (eof) return 0;
+        if (state === ASYNCIFY_REWINDING) {
+          throw new Error("decoder resumed without an input slot or EOF");
+        }
+        exports.asyncify_start_unwind(asyncifyData);
+        return -1;
+      };
+
+      const instance = await WebAssembly.instantiate(module, {
+        codec: { read },
+      });
+      const raw = instance.exports;
+      for (const name of REQUIRED_EXPORTS) {
+        if (!(name in raw))
+          throw new Error(`missing decoder Wasm export: ${name}`);
+        if (name !== "memory" && typeof raw[name] !== "function") {
+          throw new Error(`decoder Wasm export is not a function: ${name}`);
+        }
+      }
+      decoderExports = raw as DecoderExports;
+      if (!(decoderExports.memory instanceof WebAssembly.Memory)) {
+        throw new Error("decoder memory export is not WebAssembly.Memory");
+      }
+      if (decoderExports.codec_decoder_abi_version() !== 1) {
+        throw new Error(
+          `unsupported decoder ABI ${decoderExports.codec_decoder_abi_version()}`,
+        );
+      }
+      if (
+        decoderExports.memory.buffer.byteLength !==
+        FLAC_DECODER_LIMITS.wasmMemoryBytes
+      ) {
+        throw new Error(
+          `decoder memory is ${decoderExports.memory.buffer.byteLength} bytes`,
+        );
+      }
+      if (
+        typeof SharedArrayBuffer !== "undefined" &&
+        decoderExports.memory.buffer instanceof SharedArrayBuffer
+      ) {
+        throw new Error("decoder memory must be non-shared");
+      }
+      try {
+        decoderExports.memory.grow(1);
+        throw new Error("decoder memory is growable");
+      } catch (cause) {
+        if (
+          cause instanceof Error &&
+          cause.message === "decoder memory is growable"
+        )
+          throw cause;
+      }
+
+      const allocationBytes =
+        ASYNCIFY_DATA_BYTES + FLAC_DECODER_LIMITS.asyncifyStackBytes;
+      asyncifyData = decoderExports.malloc(allocationBytes);
+      if (asyncifyData === 0)
+        throw new Error("could not allocate the Asyncify stack");
+      const stackStart = asyncifyData + ASYNCIFY_DATA_BYTES;
+      const data = new DataView(decoderExports.memory.buffer);
+      data.setUint32(asyncifyData, stackStart, true);
+      data.setUint32(
+        asyncifyData + 4,
+        stackStart + FLAC_DECODER_LIMITS.asyncifyStackBytes,
+        true,
+      );
+
+      const normalize = (): void => {
+        const state = decoderExports!.asyncify_get_state();
+        if (state === ASYNCIFY_UNWINDING)
+          decoderExports!.asyncify_stop_unwind();
+        else if (state === ASYNCIFY_REWINDING)
+          decoderExports!.asyncify_stop_rewind();
+      };
+
+      const invoke = <E, R>(
+        phase: DecoderPhase,
+        call: () => number,
+        nextInput: Effect.Effect<Uint8Array | null, E, R>,
+      ): Effect.Effect<number, E | FlacDecodeError, R> =>
+        Effect.gen(function* () {
+          let rewind = false;
+          for (;;) {
+            const outcome = yield* Effect.try({
+              try: () => {
+                try {
+                  if (rewind)
+                    decoderExports!.asyncify_start_rewind(asyncifyData);
+                  const result = call();
+                  const state = decoderExports!.asyncify_get_state();
+                  if (state === ASYNCIFY_UNWINDING) {
+                    decoderExports!.asyncify_stop_unwind();
+                    return { result, suspended: true } as const;
+                  }
+                  if (state !== ASYNCIFY_NORMAL) {
+                    normalize();
+                    throw new Error(
+                      `decoder stopped in Asyncify state ${state}`,
+                    );
+                  }
+                  return { result, suspended: false } as const;
+                } catch (cause) {
+                  normalize();
+                  throw cause;
+                }
+              },
+              catch: (cause) =>
+                wasmError(
+                  "wasm-trap",
+                  phase,
+                  `decoder Wasm trapped during ${phase}`,
+                  cause,
+                ),
+            });
+            if (!outcome.suspended) return outcome.result;
+            const input = yield* nextInput;
+            if (input === null) {
+              eof = true;
+            } else {
+              slot = input;
+              slotOffset = 0;
+            }
+            rewind = true;
+          }
+        });
+
+      const dispose = (): void => {
+        if (disposed) return;
+        disposed = true;
+        normalize();
+        if (asyncifyData !== 0) decoderExports!.free(asyncifyData);
+        asyncifyData = 0;
+        slot = undefined;
+      };
+      return { exports: decoderExports, invoke, normalize, dispose };
+    },
+    catch: (cause) =>
+      cause instanceof FlacDecodeError
+        ? cause
+        : wasmError(
+            "wasm-instantiate",
+            "instantiate",
+            "could not instantiate the decoder Wasm module",
+            cause,
+          ),
+  });
diff --git a/src/internal/encoder-abi.ts b/src/internal/encoder-abi.ts
new file mode 100644
index 0000000..b3dfe09
--- /dev/null
+++ b/src/internal/encoder-abi.ts
@@ -0,0 +1,195 @@
+import * as Effect from "effect/Effect";
+
+import { FlacEncodeError } from "../errors.js";
+import { FLAC_ENCODER_LIMITS } from "../wasm.js";
+
+export interface StagedWrite {
+  readonly offset: bigint;
+  readonly bytes: Uint8Array;
+}
+
+interface EncoderExports extends WebAssembly.Exports {
+  readonly memory: WebAssembly.Memory;
+  readonly malloc: (size: number) => number;
+  readonly free: (pointer: number) => void;
+  readonly codec_encoder_new: (
+    sampleRate: number,
+    channels: number,
+    bitsPerSample: number,
+    compressionLevel: number,
+    blockFrames: number,
+  ) => number;
+  readonly codec_encoder_init: (encoder: number) => number;
+  readonly codec_encoder_process_interleaved: (
+    encoder: number,
+    pcm: number,
+    frames: number,
+  ) => number;
+  readonly codec_encoder_finish: (encoder: number) => number;
+  readonly codec_encoder_state: (encoder: number) => number;
+  readonly codec_encoder_delete: (encoder: number) => void;
+}
+
+const REQUIRED_EXPORTS = [
+  "memory",
+  "malloc",
+  "free",
+  "codec_encoder_new",
+  "codec_encoder_init",
+  "codec_encoder_process_interleaved",
+  "codec_encoder_finish",
+  "codec_encoder_state",
+  "codec_encoder_delete",
+] as const;
+
+export interface EncoderCallBatch {
+  readonly writes: ReadonlyArray<StagedWrite>;
+  readonly error: FlacEncodeError | undefined;
+}
+
+export interface EncoderAbi {
+  readonly exports: EncoderExports;
+  beginCall(): void;
+  endCall(): EncoderCallBatch;
+}
+
+const abiError = (detail: string, cause?: unknown): FlacEncodeError =>
+  new FlacEncodeError({
+    reason: "wasm-abi",
+    phase: "instantiate",
+    detail,
+    ...(cause === undefined ? {} : { cause }),
+  });
+
+export const instantiateEncoder = (
+  module: WebAssembly.Module,
+): Effect.Effect<EncoderAbi, FlacEncodeError> =>
+  Effect.try({
+    try: () => {
+      let memory: WebAssembly.Memory | undefined;
+      let writes: Array<StagedWrite> = [];
+      let stagedBytes = 0;
+      let error: FlacEncodeError | undefined;
+
+      const imports = {
+        codec: {
+          write: (offset: bigint, pointer: number, length: number): number => {
+            if (error !== undefined) return 1;
+            if (
+              memory === undefined ||
+              offset < 0n ||
+              !Number.isSafeInteger(pointer) ||
+              !Number.isSafeInteger(length) ||
+              pointer < 0 ||
+              length < 0 ||
+              pointer + length > memory.buffer.byteLength
+            ) {
+              error = abiError(
+                "libFLAC supplied an invalid write callback range",
+              );
+              return 1;
+            }
+            if (
+              stagedBytes + length >
+              FLAC_ENCODER_LIMITS.maxStagedBytesPerCall
+            ) {
+              error = new FlacEncodeError({
+                reason: "staged-output-limit",
+                phase: "process",
+                detail: `one Wasm call exceeded ${FLAC_ENCODER_LIMITS.maxStagedBytesPerCall} staged bytes`,
+              });
+              return 1;
+            }
+            if (writes.length >= FLAC_ENCODER_LIMITS.maxStagedWritesPerCall) {
+              error = new FlacEncodeError({
+                reason: "staged-output-limit",
+                phase: "process",
+                detail: `one Wasm call exceeded ${FLAC_ENCODER_LIMITS.maxStagedWritesPerCall} staged writes`,
+              });
+              return 1;
+            }
+            const bytes = new Uint8Array(length);
+            bytes.set(new Uint8Array(memory.buffer, pointer, length));
+            writes.push({ offset, bytes });
+            stagedBytes += length;
+            return 0;
+          },
+          seek: (offset: bigint): number => {
+            if (error !== undefined) return 1;
+            if (offset < 0n) {
+              error = abiError(
+                "libFLAC supplied a negative seek callback offset",
+              );
+              return 1;
+            }
+            return 0;
+          },
+        },
+      };
+
+      const instance = new WebAssembly.Instance(module, imports);
+      const raw = instance.exports;
+      for (const name of REQUIRED_EXPORTS) {
+        if (!(name in raw))
+          throw abiError(`encoder Wasm is missing export ${name}`);
+      }
+      if (!(raw.memory instanceof WebAssembly.Memory)) {
+        throw abiError("encoder memory export is not WebAssembly.Memory");
+      }
+      for (const name of REQUIRED_EXPORTS) {
+        if (name !== "memory" && typeof raw[name] !== "function") {
+          throw abiError(`encoder Wasm export ${name} is not a function`);
+        }
+      }
+      memory = raw.memory;
+      if (memory.buffer.byteLength !== FLAC_ENCODER_LIMITS.wasmMemoryBytes) {
+        throw abiError(
+          `encoder memory is ${memory.buffer.byteLength} bytes; expected ${FLAC_ENCODER_LIMITS.wasmMemoryBytes}`,
+        );
+      }
+      if (
+        typeof SharedArrayBuffer !== "undefined" &&
+        memory.buffer instanceof SharedArrayBuffer
+      ) {
+        throw abiError("encoder memory must not be shared");
+      }
+      try {
+        memory.grow(1);
+        throw abiError("encoder memory unexpectedly permits growth");
+      } catch (cause) {
+        if (cause instanceof FlacEncodeError) throw cause;
+        if (!(cause instanceof RangeError))
+          throw abiError("could not establish fixed encoder memory", cause);
+      }
+
+      // Every required function is checked before this structural narrowing.
+      const exports = raw as EncoderExports;
+      return {
+        exports,
+        beginCall(): void {
+          writes = [];
+          stagedBytes = 0;
+          error = undefined;
+        },
+        endCall(): EncoderCallBatch {
+          const batch = { writes, error };
+          writes = [];
+          stagedBytes = 0;
+          error = undefined;
+          return batch;
+        },
+      };
+    },
+    catch: (cause) =>
+      cause instanceof FlacEncodeError
+        ? cause
+        : new FlacEncodeError({
+            reason:
+              cause instanceof WebAssembly.RuntimeError
+                ? "wasm-trap"
+                : "wasm-instantiate",
+            phase: "instantiate",
+            detail: "failed to instantiate or validate encoder Wasm",
+            cause,
+          }),
+  });
diff --git a/src/node.ts b/src/node.ts
new file mode 100644
index 0000000..86fd996
--- /dev/null
+++ b/src/node.ts
@@ -0,0 +1,49 @@
+import { readFile } from "node:fs/promises";
+
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import { FlacEncodeError } from "./errors.js";
+import { FlacDecodeError } from "./decoder-errors.js";
+import {
+  FlacDecoder,
+  FLAC_DECODER_WASM_URL,
+  loadFlacDecoderFromBytes,
+} from "./decoder-wasm.js";
+import {
+  FlacEncoder,
+  FLAC_ENCODER_WASM_URL,
+  loadFlacEncoderFromBytes,
+} from "./wasm.js";
+
+/** Load, compile, and validate the package encoder asset using Node/Bun file I/O. */
+export const loadFlacEncoder = Effect.tryPromise({
+  try: (signal) => readFile(FLAC_ENCODER_WASM_URL, { signal }),
+  catch: (cause) =>
+    new FlacEncodeError({
+      reason: "wasm-compile",
+      phase: "load",
+      detail: `could not read encoder Wasm asset at ${FLAC_ENCODER_WASM_URL.href}`,
+      cause,
+    }),
+}).pipe(Effect.flatMap(loadFlacEncoderFromBytes));
+
+/** Node/Bun Layer that loads the packaged encoder Wasm asset once. */
+export const FlacEncoderLive: Layer.Layer<FlacEncoder, FlacEncodeError> =
+  Layer.effect(FlacEncoder, loadFlacEncoder);
+
+/** Load, compile, and validate the package decoder asset using Node/Bun file I/O. */
+export const loadFlacDecoder = Effect.tryPromise({
+  try: (signal) => readFile(FLAC_DECODER_WASM_URL, { signal }),
+  catch: (cause) =>
+    new FlacDecodeError({
+      reason: "wasm-compile",
+      phase: "load",
+      detail: `could not read decoder Wasm asset at ${FLAC_DECODER_WASM_URL.href}`,
+      cause,
+    }),
+}).pipe(Effect.flatMap(loadFlacDecoderFromBytes));
+
+/** Node/Bun Layer that loads the packaged decoder Wasm asset once. */
+export const FlacDecoderLive: Layer.Layer<FlacDecoder, FlacDecodeError> =
+  Layer.effect(FlacDecoder, loadFlacDecoder);
diff --git a/src/wasm.ts b/src/wasm.ts
new file mode 100644
index 0000000..c8b934f
--- /dev/null
+++ b/src/wasm.ts
@@ -0,0 +1,128 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import { FlacEncodeError } from "./errors.js";
+
+export const FLAC_ENCODER_WASM_URL = new URL(
+  "../wasm/flac-encoder.wasm",
+  import.meta.url,
+);
+
+// Updated only by the explicit reproducible Wasm build command.
+export const FLAC_ENCODER_WASM_SHA256 =
+  "90da75c73784e7184ea6c27d3ea9509f74df2eda405d8ddc8f964d78a16a273e";
+
+export const FLAC_ENCODER_LIMITS = {
+  maxInputBlockFrames: 4_096,
+  maxStagedBytesPerCall: 256 * 1_024,
+  maxStagedWritesPerCall: 64,
+  maxMetadataPrefixBytes: 4 * 1_024,
+  maxAssetBytes: 256 * 1_024,
+  wasmMemoryBytes: 16 * 1_024 * 1_024,
+  wasmStackBytes: 256 * 1_024,
+  compressionLevel: 8,
+  encoderBlockFrames: 4_096,
+  maxTotalFrames: (1n << 36n) - 1n,
+} as const;
+
+export interface FlacEncoderService {
+  readonly module: WebAssembly.Module;
+}
+
+/** A Layer-scoped, compiled encoder module shared by independent encode calls. */
+export class FlacEncoder extends Context.Service<
+  FlacEncoder,
+  FlacEncoderService
+>()("@misofm/codec/FlacEncoder") {}
+
+const EXPECTED_IMPORTS = [
+  "codec.seek:function",
+  "codec.write:function",
+] as const;
+const EXPECTED_EXPORTS = [
+  "__em_lib_deps__em_malloc_deps:global",
+  "codec_encoder_delete:function",
+  "codec_encoder_finish:function",
+  "codec_encoder_init:function",
+  "codec_encoder_new:function",
+  "codec_encoder_process_interleaved:function",
+  "codec_encoder_state:function",
+  "free:function",
+  "malloc:function",
+  "memory:memory",
+] as const;
+
+const digestHex = (bytes: ArrayBuffer): Promise<string> =>
+  globalThis.crypto.subtle
+    .digest("SHA-256", bytes)
+    .then((digest) =>
+      Array.from(new Uint8Array(digest), (byte) =>
+        byte.toString(16).padStart(2, "0"),
+      ).join(""),
+    );
+
+const compileEncoder = (
+  bytes: Uint8Array,
+): Effect.Effect<FlacEncoderService, FlacEncodeError> =>
+  Effect.tryPromise({
+    try: async () => {
+      if (bytes.byteLength > FLAC_ENCODER_LIMITS.maxAssetBytes) {
+        throw new Error(
+          `encoder asset is ${bytes.byteLength} bytes; maximum is ${FLAC_ENCODER_LIMITS.maxAssetBytes}`,
+        );
+      }
+      const owned = new Uint8Array(bytes.byteLength);
+      owned.set(bytes);
+      const hash = await digestHex(owned.buffer);
+      if (hash !== FLAC_ENCODER_WASM_SHA256) {
+        throw new Error(
+          `encoder asset SHA-256 ${hash} does not match pinned ${FLAC_ENCODER_WASM_SHA256}`,
+        );
+      }
+      return WebAssembly.compile(owned.buffer);
+    },
+    catch: (cause) =>
+      new FlacEncodeError({
+        reason: "wasm-compile",
+        phase: "load",
+        detail: "WebAssembly.compile rejected the encoder asset",
+        cause,
+      }),
+  }).pipe(
+    Effect.flatMap((module) => {
+      const imports = WebAssembly.Module.imports(module)
+        .map(({ module, name, kind }) => `${module}.${name}:${kind}`)
+        .sort();
+      if (JSON.stringify(imports) !== JSON.stringify(EXPECTED_IMPORTS)) {
+        return Effect.fail(
+          new FlacEncodeError({
+            reason: "wasm-abi",
+            phase: "load",
+            detail: `unexpected encoder imports: ${imports.join(", ")}`,
+          }),
+        );
+      }
+      const exports = WebAssembly.Module.exports(module)
+        .map(({ name, kind }) => `${name}:${kind}`)
+        .sort();
+      if (JSON.stringify(exports) !== JSON.stringify(EXPECTED_EXPORTS)) {
+        return Effect.fail(
+          new FlacEncodeError({
+            reason: "wasm-abi",
+            phase: "load",
+            detail: `unexpected encoder exports: ${exports.join(", ")}`,
+          }),
+        );
+      }
+      return Effect.succeed({ module });
+    }),
+  );
+
+/** Compile and validate trusted encoder Wasm bytes once for a Layer lifetime. */
+export const makeFlacEncoderLayer = (
+  bytes: Uint8Array,
+): Layer.Layer<FlacEncoder, FlacEncodeError> =>
+  Layer.effect(FlacEncoder, compileEncoder(bytes));
+
+export const loadFlacEncoderFromBytes = compileEncoder;
diff --git a/test/abi-cleanup.test.ts b/test/abi-cleanup.test.ts
new file mode 100644
index 0000000..1d6490e
--- /dev/null
+++ b/test/abi-cleanup.test.ts
@@ -0,0 +1,223 @@
+import { expect, test } from "bun:test";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Stream from "effect/Stream";
+
+import {
+  decodeFlac,
+  encodeFlac,
+  FlacDecodeError,
+  FlacDecoder,
+  FlacEncodeError,
+  FlacEncoder,
+  PcmFormat,
+  type RandomAccessByteSink,
+} from "../src/index.js";
+
+// Auditable WAT sources live in test/fixtures/*.wat. The embedded compiled bytes
+// keep ordinary tests independent of an external WABT installation.
+const ENCODER_DELETE_TRAP =
+  "AGFzbQEAAAABJgZgA35/fwF/YAF+AX9gAX8Bf2ABfwBgBX9/f39/AX9gA39/fwF/AhwCBWNvZGVjBXdyaXRlAAAFY29kZWMEc2VlawABAwkIAgMEAgUCAgMFBgEBgAKAAgerAQkGbWVtb3J5AgAGbWFsbG9jAAIEZnJlZQADEWNvZGVjX2VuY29kZXJfbmV3AAQSY29kZWNfZW5jb2Rlcl9pbml0AAUhY29kZWNfZW5jb2Rlcl9wcm9jZXNzX2ludGVybGVhdmVkAAYUY29kZWNfZW5jb2Rlcl9maW5pc2gABxNjb2RlY19lbmNvZGVyX3N0YXRlAAgUY29kZWNfZW5jb2Rlcl9kZWxldGUACQozCAUAQYAQCwIACwUAQYACCw8AQgBBgAhB1gAQABpBAAsEAEEBCwQAQQELBABBAAsDAAALC10BAEGACAtWZkxhQwAAACIQABAA////AAAAAfQA8AAAAADUHYzZjwCyBOmACZjs+EJ+hAAAKCAAAAByZWZlcmVuY2UgbGliRkxBQyAxLjUuMCAyMDI1MDIxMQAAAAA=";
+const DECODER_DELETE_TRAP =
+  "AGFzbQEAAAABDANgAABgAAF/YAF/AAMNDAABAQEBAQEBAQEBAgUEAQEgIAeDCisGbWVtb3J5AgAG" +
+  "bWFsbG9jAAMEZnJlZQAAFWFzeW5jaWZ5X3N0YXJ0X3Vud2luZAAAFGFzeW5jaWZ5X3N0b3BfdW53" +
+  "aW5kAAAVYXN5bmNpZnlfc3RhcnRfcmV3aW5kAAAUYXN5bmNpZnlfc3RvcF9yZXdpbmQAABJhc3lu" +
+  "Y2lmeV9nZXRfc3RhdGUAARljb2RlY19kZWNvZGVyX2FiaV92ZXJzaW9uAAIRY29kZWNfZGVjb2Rl" +
+  "cl9uZXcAAhJjb2RlY19kZWNvZGVyX2luaXQAARxjb2RlY19kZWNvZGVyX3Byb2Nlc3Nfc2luZ2xl" +
+  "AAUUY29kZWNfZGVjb2Rlcl9maW5pc2gAARRjb2RlY19kZWNvZGVyX2RlbGV0ZQALGGNvZGVjX2Rl" +
+  "Y29kZXJfb3V0cHV0X3B0cgADG2NvZGVjX2RlY29kZXJfb3V0cHV0X2xlbmd0aAAKG2NvZGVjX2Rl" +
+  "Y29kZXJfb3V0cHV0X2ZyYW1lcwAJJWNvZGVjX2RlY29kZXJfb3V0cHV0X2ZyYW1lX29mZnNldF9s" +
+  "b3cAASZjb2RlY19kZWNvZGVyX291dHB1dF9mcmFtZV9vZmZzZXRfaGlnaAABHGNvZGVjX2RlY29k" +
+  "ZXJfcmVsZWFzZV9vdXRwdXQAABljb2RlY19kZWNvZGVyX3NhbXBsZV9yYXRlAAQWY29kZWNfZGVj" +
+  "b2Rlcl9jaGFubmVscwAFHWNvZGVjX2RlY29kZXJfYml0c19wZXJfc2FtcGxlAAciY29kZWNfZGVj" +
+  "b2Rlcl9taW5pbXVtX2Jsb2NrX2ZyYW1lcwAGImNvZGVjX2RlY29kZXJfbWF4aW11bV9ibG9ja19m" +
+  "cmFtZXMACB5jb2RlY19kZWNvZGVyX3RvdGFsX2ZyYW1lc19sb3cAAR9jb2RlY19kZWNvZGVyX3Rv" +
+  "dGFsX2ZyYW1lc19oaWdoAAEgY29kZWNfZGVjb2Rlcl90b3RhbF9mcmFtZXNfa25vd24AASNjb2Rl" +
+  "Y19kZWNvZGVyX3N0cmVhbWluZm9fZnJhbWVzX2xvdwABJGNvZGVjX2RlY29kZXJfc3RyZWFtaW5m" +
+  "b19mcmFtZXNfaGlnaAABJWNvZGVjX2RlY29kZXJfc3RyZWFtaW5mb19mcmFtZXNfa25vd24AARlj" +
+  "b2RlY19kZWNvZGVyX21kNV9wcmVzZW50AAEgY29kZWNfZGVjb2Rlcl9kZWNvZGVkX2ZyYW1lc19s" +
+  "b3cAASFjb2RlY19kZWNvZGVyX2RlY29kZWRfZnJhbWVzX2hpZ2gAAR9jb2RlY19kZWNvZGVyX2Rl" +
+  "Y29kZWRfYnl0ZXNfbG93AAEgY29kZWNfZGVjb2Rlcl9kZWNvZGVkX2J5dGVzX2hpZ2gAARxjb2Rl" +
+  "Y19kZWNvZGVyX2NhbGxiYWNrX2Vycm9yAAETY29kZWNfZGVjb2Rlcl9zdGF0ZQABImNvZGVjX2Rl" +
+  "Y29kZXJfYWxsb2NhdG9yX2xpdmVfYnl0ZXMAASdjb2RlY19kZWNvZGVyX2FsbG9jYXRvcl9wZWFr" +
+  "X2xpdmVfYnl0ZXMAASdjb2RlY19kZWNvZGVyX2FsbG9jYXRvcl9wZWFrX2hlYXBfYnl0ZXMAASJj" +
+  "b2RlY19kZWNvZGVyX2FsbG9jYXRvcl9mcmVlX2NhbGxzAAElY29kZWNfZGVjb2Rlcl9hbGxvY2F0" +
+  "b3JfcmVhbGxvY19jYWxscwABCj8MAgALBABBAAsEAEEBCwUAQYAICwYAQcTYAgsEAEECCwQAQRAL" +
+  "BABBGAsGAEH//wMLBABBfwsEAEF6CwMAAAs=";
+const ENCODER_INVALID_ALLOCATION =
+  "AGFzbQEAAAABCAJgAABgAAF/AwYFAAEBAQEFBgEBgAKAAgerAQkGbWVtb3J5AgAGbWFsbG9jAAQEZnJlZQAAEWNvZGVjX2VuY29kZXJfbmV3AAMSY29kZWNfZW5jb2Rlcl9pbml0AAEhY29kZWNfZW5jb2Rlcl9wcm9jZXNzX2ludGVybGVhdmVkAAIUY29kZWNfZW5jb2Rlcl9maW5pc2gAAhNjb2RlY19lbmNvZGVyX3N0YXRlAAEUY29kZWNfZW5jb2Rlcl9kZWxldGUAAAoZBQIACwQAQQALBABBAQsFAEGAAgsEAEF8Cw==";
+const ENCODER_INVALID_METADATA_CHAIN =
+  "AGFzbQEAAAABJgZgA35/fwF/YAF+AX9gAX8Bf2ABfwBgBX9/f39/AX9gA39/fwF/AhwCBWNvZGVjBXdyaXRlAAAFY29kZWMEc2VlawABAwkIAgMEAgUCAgMFBgEBgAKAAgerAQkGbWVtb3J5AgAGbWFsbG9jAAIEZnJlZQADEWNvZGVjX2VuY29kZXJfbmV3AAQSY29kZWNfZW5jb2Rlcl9pbml0AAUhY29kZWNfZW5jb2Rlcl9wcm9jZXNzX2ludGVybGVhdmVkAAYUY29kZWNfZW5jb2Rlcl9maW5pc2gABxNjb2RlY19lbmNvZGVyX3N0YXRlAAgUY29kZWNfZW5jb2Rlcl9kZWxldGUACQoxCAUAQYAQCwIACwUAQYACCw4AQgBBgAhBKhAAGkEACwQAQQELBABBAQsEAEEACwIACwsxAQBBgAgLKmZMYUMAAAAiEAAQAAAAAAAAAAH0APAAAAAA1B2M2Y8AsgTpgAmY7PhCfg==";
+const DECODER_INVALID_OUTPUT =
+  "AGFzbQEAAAABCAJgAAF/YAAAAwwLAQAAAAAAAAAAAAAFBAEBICAHgworBm1lbW9yeQIABm1hbGxvYwADBGZyZWUAABVhc3luY2lmeV9zdGFydF91bndpbmQAABRhc3luY2lmeV9zdG9wX3Vud2luZAAAFWFzeW5jaWZ5X3N0YXJ0X3Jld2luZAAAFGFzeW5jaWZ5X3N0b3BfcmV3aW5kAAASYXN5bmNpZnlfZ2V0X3N0YXRlAAEZY29kZWNfZGVjb2Rlcl9hYmlfdmVyc2lvbgACEWNvZGVjX2RlY29kZXJfbmV3AAISY29kZWNfZGVjb2Rlcl9pbml0AAEcY29kZWNfZGVjb2Rlcl9wcm9jZXNzX3NpbmdsZQACFGNvZGVjX2RlY29kZXJfZmluaXNoAAEUY29kZWNfZGVjb2Rlcl9kZWxldGUAABhjb2RlY19kZWNvZGVyX291dHB1dF9wdHIAAxtjb2RlY19kZWNvZGVyX291dHB1dF9sZW5ndGgAChtjb2RlY19kZWNvZGVyX291dHB1dF9mcmFtZXMACSVjb2RlY19kZWNvZGVyX291dHB1dF9mcmFtZV9vZmZzZXRfbG93AAEmY29kZWNfZGVjb2Rlcl9vdXRwdXRfZnJhbWVfb2Zmc2V0X2hpZ2gAARxjb2RlY19kZWNvZGVyX3JlbGVhc2Vfb3V0cHV0AAAZY29kZWNfZGVjb2Rlcl9zYW1wbGVfcmF0ZQAEFmNvZGVjX2RlY29kZXJfY2hhbm5lbHMABR1jb2RlY19kZWNvZGVyX2JpdHNfcGVyX3NhbXBsZQAHImNvZGVjX2RlY29kZXJfbWluaW11bV9ibG9ja19mcmFtZXMABiJjb2RlY19kZWNvZGVyX21heGltdW1fYmxvY2tfZnJhbWVzAAgeY29kZWNfZGVjb2Rlcl90b3RhbF9mcmFtZXNfbG93AAEfY29kZWNfZGVjb2Rlcl90b3RhbF9mcmFtZXNfaGlnaAABIGNvZGVjX2RlY29kZXJfdG90YWxfZnJhbWVzX2tub3duAAEjY29kZWNfZGVjb2Rlcl9zdHJlYW1pbmZvX2ZyYW1lc19sb3cAASRjb2RlY19kZWNvZGVyX3N0cmVhbWluZm9fZnJhbWVzX2hpZ2gAASVjb2RlY19kZWNvZGVyX3N0cmVhbWluZm9fZnJhbWVzX2tub3duAAEZY29kZWNfZGVjb2Rlcl9tZDVfcHJlc2VudAABIGNvZGVjX2RlY29kZXJfZGVjb2RlZF9mcmFtZXNfbG93AAEhY29kZWNfZGVjb2Rlcl9kZWNvZGVkX2ZyYW1lc19oaWdoAAEfY29kZWNfZGVjb2Rlcl9kZWNvZGVkX2J5dGVzX2xvdwABIGNvZGVjX2RlY29kZXJfZGVjb2RlZF9ieXRlc19oaWdoAAEcY29kZWNfZGVjb2Rlcl9jYWxsYmFja19lcnJvcgABE2NvZGVjX2RlY29kZXJfc3RhdGUAASJjb2RlY19kZWNvZGVyX2FsbG9jYXRvcl9saXZlX2J5dGVzAAEnY29kZWNfZGVjb2Rlcl9hbGxvY2F0b3JfcGVha19saXZlX2J5dGVzAAEnY29kZWNfZGVjb2Rlcl9hbGxvY2F0b3JfcGVha19oZWFwX2J5dGVzAAEiY29kZWNfZGVjb2Rlcl9hbGxvY2F0b3JfZnJlZV9jYWxscwABJWNvZGVjX2RlY29kZXJfYWxsb2NhdG9yX3JlYWxsb2NfY2FsbHMAAQo7CwIACwQAQQALBABBAQsFAEGACAsGAEHE2AILBABBAgsEAEEQCwQAQRgLBgBB//8DCwQAQX8LBABBegs=";
+const DECODER_STALL =
+  "AGFzbQEAAAABCAJgAAF/YAAAAwwLAQAAAAAAAAAAAAAFBAEBICAHgworBm1lbW9yeQIABm1hbGxvYwADBGZyZWUAABVhc3luY2lmeV9zdGFydF91bndpbmQAABRhc3luY2lmeV9zdG9wX3Vud2luZAAAFWFzeW5jaWZ5X3N0YXJ0X3Jld2luZAAAFGFzeW5jaWZ5X3N0b3BfcmV3aW5kAAASYXN5bmNpZnlfZ2V0X3N0YXRlAAEZY29kZWNfZGVjb2Rlcl9hYmlfdmVyc2lvbgACEWNvZGVjX2RlY29kZXJfbmV3AAISY29kZWNfZGVjb2Rlcl9pbml0AAEcY29kZWNfZGVjb2Rlcl9wcm9jZXNzX3NpbmdsZQABFGNvZGVjX2RlY29kZXJfZmluaXNoAAEUY29kZWNfZGVjb2Rlcl9kZWxldGUAABhjb2RlY19kZWNvZGVyX291dHB1dF9wdHIAAxtjb2RlY19kZWNvZGVyX291dHB1dF9sZW5ndGgAChtjb2RlY19kZWNvZGVyX291dHB1dF9mcmFtZXMACSVjb2RlY19kZWNvZGVyX291dHB1dF9mcmFtZV9vZmZzZXRfbG93AAEmY29kZWNfZGVjb2Rlcl9vdXRwdXRfZnJhbWVfb2Zmc2V0X2hpZ2gAARxjb2RlY19kZWNvZGVyX3JlbGVhc2Vfb3V0cHV0AAAZY29kZWNfZGVjb2Rlcl9zYW1wbGVfcmF0ZQAEFmNvZGVjX2RlY29kZXJfY2hhbm5lbHMABR1jb2RlY19kZWNvZGVyX2JpdHNfcGVyX3NhbXBsZQAHImNvZGVjX2RlY29kZXJfbWluaW11bV9ibG9ja19mcmFtZXMABiJjb2RlY19kZWNvZGVyX21heGltdW1fYmxvY2tfZnJhbWVzAAgeY29kZWNfZGVjb2Rlcl90b3RhbF9mcmFtZXNfbG93AAEfY29kZWNfZGVjb2Rlcl90b3RhbF9mcmFtZXNfaGlnaAABIGNvZGVjX2RlY29kZXJfdG90YWxfZnJhbWVzX2tub3duAAEjY29kZWNfZGVjb2Rlcl9zdHJlYW1pbmZvX2ZyYW1lc19sb3cAASRjb2RlY19kZWNvZGVyX3N0cmVhbWluZm9fZnJhbWVzX2hpZ2gAASVjb2RlY19kZWNvZGVyX3N0cmVhbWluZm9fZnJhbWVzX2tub3duAAEZY29kZWNfZGVjb2Rlcl9tZDVfcHJlc2VudAABIGNvZGVjX2RlY29kZXJfZGVjb2RlZF9mcmFtZXNfbG93AAEhY29kZWNfZGVjb2Rlcl9kZWNvZGVkX2ZyYW1lc19oaWdoAAEfY29kZWNfZGVjb2Rlcl9kZWNvZGVkX2J5dGVzX2xvdwABIGNvZGVjX2RlY29kZXJfZGVjb2RlZF9ieXRlc19oaWdoAAEcY29kZWNfZGVjb2Rlcl9jYWxsYmFja19lcnJvcgABE2NvZGVjX2RlY29kZXJfc3RhdGUAASJjb2RlY19kZWNvZGVyX2FsbG9jYXRvcl9saXZlX2J5dGVzAAEnY29kZWNfZGVjb2Rlcl9hbGxvY2F0b3JfcGVha19saXZlX2J5dGVzAAEnY29kZWNfZGVjb2Rlcl9hbGxvY2F0b3JfcGVha19oZWFwX2J5dGVzAAEiY29kZWNfZGVjb2Rlcl9hbGxvY2F0b3JfZnJlZV9jYWxscwABJWNvZGVjX2RlY29kZXJfYWxsb2NhdG9yX3JlYWxsb2NfY2FsbHMAAQo7CwIACwQAQQALBABBAQsFAEGACAsGAEHE2AILBABBAgsEAEEQCwQAQRgLBgBB//8DCwQAQX8LBABBegs=";
+
+const joinBase64 = (...chunks: ReadonlyArray<string>): string =>
+  chunks.join("");
+const DECODER_INVALID_METADATA_AUDITED = joinBase64(
+  "AGFzbQEAAAABCAJgAABgAAF/AwUEAAEBAQUEAQEgIAeDCisGbWVtb3J5AgAGbWFsbG9jAAMEZnJl",
+  "ZQAAFWFzeW5jaWZ5X3N0YXJ0X3Vud2luZAAAFGFzeW5jaWZ5X3N0b3BfdW53aW5kAAAVYXN5bmNp",
+  "Znlfc3RhcnRfcmV3aW5kAAAUYXN5bmNpZnlfc3RvcF9yZXdpbmQAABJhc3luY2lmeV9nZXRfc3Rh",
+  "dGUAARljb2RlY19kZWNvZGVyX2FiaV92ZXJzaW9uAAIRY29kZWNfZGVjb2Rlcl9uZXcAAhJjb2Rl",
+  "Y19kZWNvZGVyX2luaXQAARxjb2RlY19kZWNvZGVyX3Byb2Nlc3Nfc2luZ2xlAAEUY29kZWNfZGVj",
+  "b2Rlcl9maW5pc2gAARRjb2RlY19kZWNvZGVyX2RlbGV0ZQAAGGNvZGVjX2RlY29kZXJfb3V0cHV0",
+  "X3B0cgACG2NvZGVjX2RlY29kZXJfb3V0cHV0X2xlbmd0aAABG2NvZGVjX2RlY29kZXJfb3V0cHV0",
+  "X2ZyYW1lcwABJWNvZGVjX2RlY29kZXJfb3V0cHV0X2ZyYW1lX29mZnNldF9sb3cAASZjb2RlY19k",
+  "ZWNvZGVyX291dHB1dF9mcmFtZV9vZmZzZXRfaGlnaAABHGNvZGVjX2RlY29kZXJfcmVsZWFzZV9v",
+  "dXRwdXQAABljb2RlY19kZWNvZGVyX3NhbXBsZV9yYXRlAAEWY29kZWNfZGVjb2Rlcl9jaGFubmVs",
+  "cwABHWNvZGVjX2RlY29kZXJfYml0c19wZXJfc2FtcGxlAAEiY29kZWNfZGVjb2Rlcl9taW5pbXVt",
+  "X2Jsb2NrX2ZyYW1lcwABImNvZGVjX2RlY29kZXJfbWF4aW11bV9ibG9ja19mcmFtZXMAAR5jb2Rl",
+  "Y19kZWNvZGVyX3RvdGFsX2ZyYW1lc19sb3cAAR9jb2RlY19kZWNvZGVyX3RvdGFsX2ZyYW1lc19o",
+  "aWdoAAEgY29kZWNfZGVjb2Rlcl90b3RhbF9mcmFtZXNfa25vd24AASNjb2RlY19kZWNvZGVyX3N0",
+  "cmVhbWluZm9fZnJhbWVzX2xvdwABJGNvZGVjX2RlY29kZXJfc3RyZWFtaW5mb19mcmFtZXNfaGln",
+  "aAABJWNvZGVjX2RlY29kZXJfc3RyZWFtaW5mb19mcmFtZXNfa25vd24AARljb2RlY19kZWNvZGVy",
+  "X21kNV9wcmVzZW50AAEgY29kZWNfZGVjb2Rlcl9kZWNvZGVkX2ZyYW1lc19sb3cAASFjb2RlY19k",
+  "ZWNvZGVyX2RlY29kZWRfZnJhbWVzX2hpZ2gAAR9jb2RlY19kZWNvZGVyX2RlY29kZWRfYnl0ZXNf",
+  "bG93AAEgY29kZWNfZGVjb2Rlcl9kZWNvZGVkX2J5dGVzX2hpZ2gAARxjb2RlY19kZWNvZGVyX2Nh",
+  "bGxiYWNrX2Vycm9yAAETY29kZWNfZGVjb2Rlcl9zdGF0ZQABImNvZGVjX2RlY29kZXJfYWxsb2Nh",
+  "dG9yX2xpdmVfYnl0ZXMAASdjb2RlY19kZWNvZGVyX2FsbG9jYXRvcl9wZWFrX2xpdmVfYnl0ZXMA",
+  "ASdjb2RlY19kZWNvZGVyX2FsbG9jYXRvcl9wZWFrX2hlYXBfYnl0ZXMAASJjb2RlY19kZWNvZGVy",
+  "X2FsbG9jYXRvcl9mcmVlX2NhbGxzAAElY29kZWNfZGVjb2Rlcl9hbGxvY2F0b3JfcmVhbGxvY19j",
+  "YWxscwABChQEAgALBABBAAsEAEEBCwUAQYAICw==",
+);
+
+const moduleFromBase64 = (base64: string): Promise<WebAssembly.Module> =>
+  WebAssembly.compile(
+    Uint8Array.from(atob(base64), (character) => character.charCodeAt(0)),
+  );
+
+const format = new PcmFormat({
+  sampleRate: 8_000,
+  channels: 1,
+  bitsPerSample: 16,
+});
+
+const memorySink = (): RandomAccessByteSink<never, never> => ({
+  writeAt: () => Effect.void,
+  resize: () => Effect.void,
+});
+
+test("successful encoder cleanup traps are typed failures", async () => {
+  const module = await moduleFromBase64(ENCODER_DELETE_TRAP);
+  const exit = await Effect.runPromise(
+    Effect.exit(
+      encodeFlac(Stream.empty, memorySink(), {
+        format,
+        expectedFrames: 0n,
+      }).pipe(Effect.provideService(FlacEncoder, { module })),
+    ),
+  );
+  expect(Exit.isFailure(exit)).toBe(true);
+  if (Exit.isFailure(exit)) {
+    expect(Cause.hasDies(exit.cause)).toBe(false);
+    const error = Cause.squash(exit.cause);
+    expect(error).toBeInstanceOf(FlacEncodeError);
+    expect(error).toMatchObject({ reason: "wasm-trap", phase: "finish" });
+  }
+});
+
+test("successful decoder cleanup traps before Complete", async () => {
+  const module = await moduleFromBase64(DECODER_DELETE_TRAP);
+  const emitted: Array<string> = [];
+  const exit = await Effect.runPromise(
+    Effect.exit(
+      Stream.runDrain(
+        decodeFlac(Stream.empty).pipe(
+          Stream.tap((event) =>
+            Effect.sync(() => {
+              emitted.push(event._tag);
+            }),
+          ),
+        ),
+      ).pipe(Effect.provideService(FlacDecoder, { module })),
+    ),
+  );
+  expect(emitted).toEqual(["Metadata"]);
+  expect(Exit.isFailure(exit)).toBe(true);
+  if (Exit.isFailure(exit)) {
+    expect(Cause.hasDies(exit.cause)).toBe(false);
+    const error = Cause.squash(exit.cause);
+    expect(error).toBeInstanceOf(FlacDecodeError);
+    expect(error).toMatchObject({ reason: "wasm-trap", phase: "finish" });
+  }
+});
+
+test("cleanup traps preserve a primary source failure", async () => {
+  const module = await moduleFromBase64(ENCODER_DELETE_TRAP);
+  const primary = { _tag: "PrimaryFailure" } as const;
+  const exit = await Effect.runPromise(
+    Effect.exit(
+      encodeFlac(Stream.fail(primary), memorySink(), {
+        format,
+        expectedFrames: 0n,
+      }).pipe(Effect.provideService(FlacEncoder, { module })),
+    ),
+  );
+  expect(Exit.isFailure(exit)).toBe(true);
+  if (Exit.isFailure(exit)) expect(Cause.squash(exit.cause)).toBe(primary);
+});
+
+test("malformed encoder pointers and metadata chains fail without defects", async () => {
+  for (const [bytes, expected] of [
+    [ENCODER_INVALID_ALLOCATION, { reason: "wasm-abi", phase: "init" }],
+    [
+      ENCODER_INVALID_METADATA_CHAIN,
+      { reason: "invalid-streaminfo", phase: "validate" },
+    ],
+  ] as const) {
+    const module = await moduleFromBase64(bytes);
+    const exit = await Effect.runPromise(
+      Effect.exit(
+        encodeFlac(Stream.empty, memorySink(), {
+          format,
+          expectedFrames: 0n,
+        }).pipe(Effect.provideService(FlacEncoder, { module })),
+      ),
+    );
+    expect(Exit.isFailure(exit)).toBe(true);
+    if (Exit.isFailure(exit)) {
+      expect(Cause.hasDies(exit.cause)).toBe(false);
+      expect(Cause.squash(exit.cause)).toMatchObject(expected);
+    }
+  }
+});
+
+test("malformed decoder metadata, output, and stalls fail without defects", async () => {
+  for (const [bytes, expected, expectedEvents] of [
+    [
+      DECODER_INVALID_METADATA_AUDITED,
+      { reason: "wasm-abi", phase: "metadata" },
+      [],
+    ],
+    [
+      DECODER_INVALID_OUTPUT,
+      { reason: "wasm-abi", phase: "frame" },
+      ["Metadata"],
+    ],
+    [DECODER_STALL, { reason: "invalid-stream", phase: "frame" }, ["Metadata"]],
+  ] as const) {
+    const module = await moduleFromBase64(bytes);
+    const emitted: Array<string> = [];
+    const exit = await Effect.runPromise(
+      Effect.exit(
+        Stream.runDrain(
+          decodeFlac(Stream.empty).pipe(
+            Stream.tap((event) =>
+              Effect.sync(() => {
+                emitted.push(event._tag);
+              }),
+            ),
+          ),
+        ).pipe(Effect.provideService(FlacDecoder, { module })),
+      ),
+    );
+    expect(emitted).toEqual([...expectedEvents]);
+    expect(Exit.isFailure(exit)).toBe(true);
+    if (Exit.isFailure(exit)) {
+      expect(Cause.hasDies(exit.cause)).toBe(false);
+      expect(Cause.squash(exit.cause)).toMatchObject(expected);
+    }
+  }
+});
diff --git a/test/decode-native-integration.test.ts b/test/decode-native-integration.test.ts
new file mode 100644
index 0000000..7d55d2c
--- /dev/null
+++ b/test/decode-native-integration.test.ts
@@ -0,0 +1,191 @@
+import { expect, test } from "bun:test";
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import * as Effect from "effect/Effect";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+import * as Stream from "effect/Stream";
+
+import { decodeFlac } from "../src/decode.js";
+import { makeFlacDecoderLayer } from "../src/decoder-wasm.js";
+import { PcmFormat } from "../src/format.js";
+import { FlacDecodeError } from "../src/decoder-errors.js";
+import { FlacDecoderLive } from "../src/node.js";
+
+const nativeFlac = process.env.CODEC_NATIVE_FLAC;
+
+/*
+ * Independent fixture: native libFLAC 1.5.0 `flac -8 --lax
+ * --blocksize=65535` over 65,535 stereo PCM24 frames generated from xorshift
+ * seed 1234567. It proves that an encoded frame larger than the 256 KiB host
+ * input slot resumes across many Asyncify pulls.
+ */
+test.skipIf(nativeFlac === undefined)(
+  "decodes a maximum-size FLAC block across bounded input pulls",
+  async () => {
+    expect(existsSync(nativeFlac!)).toBe(true);
+    const directory = await mkdtemp(join(tmpdir(), "codec-max-block-"));
+    try {
+      const rawPath = join(directory, "max-block.raw");
+      const fixturePath = join(directory, "max-block.flac");
+      const raw = new Uint8Array(65_535 * 2 * 3);
+      let state = 1234567;
+      for (let index = 0; index < raw.length; index++) {
+        state ^= state << 13;
+        state ^= state >>> 17;
+        state ^= state << 5;
+        raw[index] = state & 0xff;
+      }
+      await writeFile(rawPath, raw);
+      const process = Bun.spawn(
+        [
+          nativeFlac!,
+          "--totally-silent",
+          "-8",
+          "--lax",
+          "--blocksize=65535",
+          "--no-padding",
+          "--no-seektable",
+          "--force-raw-format",
+          "--endian=little",
+          "--sign=signed",
+          "--channels=2",
+          "--bps=24",
+          "--sample-rate=44100",
+          `--output-name=${fixturePath}`,
+          rawPath,
+        ],
+        { stdout: "ignore", stderr: "pipe" },
+      );
+      const stderr = new Response(process.stderr).text();
+      expect(await process.exited, await stderr).toBe(0);
+      const [encoded, decoderBytes] = await Promise.all([
+        readFile(fixturePath),
+        readFile(new URL("../wasm/flac-decoder.wasm", import.meta.url)),
+      ]);
+      const fragments: Array<Uint8Array> = [];
+      expect(encoded.byteLength).toBeGreaterThan(256 * 1024);
+      for (let offset = 0; offset < encoded.byteLength; offset += 997) {
+        fragments.push(
+          encoded.subarray(offset, Math.min(offset + 997, encoded.byteLength)),
+        );
+      }
+      const format = new PcmFormat({
+        sampleRate: 44_100,
+        channels: 2,
+        bitsPerSample: 24,
+      });
+      const digest = createHash("sha256");
+      let pcmBytes = 0;
+      let complete = false;
+      await Effect.runPromise(
+        Stream.runForEach(
+          decodeFlac(Stream.fromIterable(fragments), {
+            expectedFormat: format,
+            expectedFrames: 65_535n,
+          }),
+          (event) =>
+            Effect.sync(() => {
+              if (event._tag === "Pcm") {
+                digest.update(event.bytes);
+                pcmBytes += event.bytes.byteLength;
+              } else if (event._tag === "Complete") {
+                complete =
+                  event.md5Checked &&
+                  event.md5Verified &&
+                  event.frames === 65_535n;
+              }
+            }),
+        ).pipe(Effect.provide(makeFlacDecoderLayer(decoderBytes))),
+      );
+      expect(pcmBytes).toBe(393_210);
+      expect(digest.digest("hex")).toBe(
+        "dfe5d44b7eab5437879b3f91a9c4d5443c263ed0e33dab15399dccc38bfe9443",
+      );
+      expect(complete).toBe(true);
+    } finally {
+      await rm(directory, { recursive: true, force: true });
+    }
+  },
+);
+
+test.skipIf(nativeFlac === undefined)(
+  "native 8 kHz audio survives every byte split and rejects every strict prefix",
+  async () => {
+    const raw = new Uint8Array(64);
+    for (let index = 0; index < raw.length; index += 2) {
+      const sample = ((index * 401) ^ (index << 7)) & 0xffff;
+      raw[index] = sample;
+      raw[index + 1] = sample >>> 8;
+    }
+    const process = Bun.spawn(
+      [
+        nativeFlac!,
+        "--silent",
+        "--force-raw-format",
+        "--endian=little",
+        "--sign=signed",
+        "--channels=1",
+        "--bps=16",
+        "--sample-rate=8000",
+        "--blocksize=16",
+        "--no-padding",
+        "--stdout",
+        "-",
+      ],
+      { stdin: "pipe", stdout: "pipe", stderr: "pipe" },
+    );
+    process.stdin.write(raw);
+    process.stdin.end();
+    const [status, output, stderr] = await Promise.all([
+      process.exited,
+      new Response(process.stdout).arrayBuffer(),
+      new Response(process.stderr).text(),
+    ]);
+    expect(status, stderr).toBe(0);
+    const encoded = new Uint8Array(output);
+    expect(encoded.length).toBeLessThan(256);
+    const format = new PcmFormat({
+      sampleRate: 8000,
+      channels: 1,
+      bitsPerSample: 16,
+    });
+    await Effect.runPromise(
+      Effect.gen(function* () {
+        const decode = (parts: ReadonlyArray<Uint8Array>) =>
+          decodeFlac(Stream.fromIterable(parts), {
+            expectedFormat: format,
+            expectedFrames: 32n,
+          }).pipe(Stream.runCollect);
+        const reference = yield* decode([encoded]);
+        const decoded = Uint8Array.from(
+          reference.flatMap((event) =>
+            event._tag === "Pcm" ? Array.from(event.bytes) : [],
+          ),
+        );
+        expect(decoded).toEqual(raw);
+        for (let boundary = 0; boundary <= encoded.length; boundary++) {
+          const actual = yield* decode([
+            encoded.subarray(0, boundary),
+            encoded.subarray(boundary),
+          ]);
+          expect(actual).toEqual(reference);
+        }
+        for (let boundary = 0; boundary < encoded.length; boundary++) {
+          const exit = yield* Effect.exit(
+            decode([encoded.subarray(0, boundary)]),
+          );
+          expect(Exit.isFailure(exit)).toBe(true);
+          if (Exit.isFailure(exit)) {
+            expect(Cause.hasDies(exit.cause)).toBe(false);
+            expect(Cause.squash(exit.cause)).toBeInstanceOf(FlacDecodeError);
+          }
+        }
+      }).pipe(Effect.provide(FlacDecoderLive)),
+    );
+  },
+);
diff --git a/test/decode.test.ts b/test/decode.test.ts
new file mode 100644
index 0000000..513662f
--- /dev/null
+++ b/test/decode.test.ts
@@ -0,0 +1,545 @@
+import { beforeAll, describe, expect, test } from "bun:test";
+import { readFile } from "node:fs/promises";
+
+import * as Cause from "effect/Cause";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import * as Stream from "effect/Stream";
+
+import {
+  decodeFlac,
+  type FlacDecodeEvent,
+  type FlacDecodeOptions,
+} from "../src/decode.js";
+import { FlacDecodeError } from "../src/decoder-errors.js";
+import { makeFlacDecoderLayer } from "../src/decoder-wasm.js";
+import type { FlacDecoder } from "../src/decoder-wasm.js";
+import { encodeFlac, type RandomAccessByteSink } from "../src/encode.js";
+import { PcmFormat } from "../src/format.js";
+import { makeFlacEncoderLayer } from "../src/wasm.js";
+import type { FlacEncoder } from "../src/wasm.js";
+
+interface Fixture {
+  readonly encoded: Uint8Array;
+  readonly pcm: Int32Array;
+  readonly canonical: Uint8Array;
+  readonly format: PcmFormat;
+  readonly frames: number;
+}
+
+let fixture: Fixture;
+let run: <A, E>(effect: Effect.Effect<A, E, FlacDecoder>) => Promise<A>;
+let runEncoder: <A, E>(effect: Effect.Effect<A, E, FlacEncoder>) => Promise<A>;
+
+const makeFixture = (
+  frames: number,
+  format = new PcmFormat({
+    sampleRate: 44_100,
+    channels: 2,
+    bitsPerSample: 24,
+  }),
+): Effect.Effect<Fixture, unknown, import("../src/wasm.js").FlacEncoder> => {
+  const pcm = new Int32Array(frames * format.channels);
+  const width = format.bitsPerSample / 8;
+  const canonical = new Uint8Array(pcm.length * width);
+  let state = 0x1234_5678;
+  for (let index = 0; index < pcm.length; index++) {
+    state ^= state << 13;
+    state ^= state >>> 17;
+    state ^= state << 5;
+    const value = state >> (32 - format.bitsPerSample);
+    pcm[index] = value;
+    for (let byte = 0; byte < width; byte++) {
+      canonical[index * width + byte] = value >> (byte * 8);
+    }
+  }
+  const storage = new Uint8Array(canonical.byteLength + 128 * 1024);
+  let finalLength = 0;
+  const sink: RandomAccessByteSink<never, never> = {
+    writeAt: (offset, bytes) =>
+      Effect.sync(() => storage.set(bytes, Number(offset))),
+    resize: (length) =>
+      Effect.sync(() => {
+        finalLength = Number(length);
+      }),
+  };
+  const blocks: Array<Int32Array> = [];
+  for (let frame = 0; frame < frames; frame += 997) {
+    blocks.push(
+      pcm.slice(
+        frame * format.channels,
+        Math.min(frame + 997, frames) * format.channels,
+      ),
+    );
+  }
+  return encodeFlac(Stream.fromIterable(blocks), sink, {
+    format,
+    expectedFrames: BigInt(frames),
+  }).pipe(
+    Effect.map(() => ({
+      encoded: storage.slice(0, finalLength),
+      pcm,
+      canonical,
+      format,
+      frames,
+    })),
+  );
+};
+
+const fragment = (bytes: Uint8Array): ReadonlyArray<Uint8Array> => {
+  const chunks: Array<Uint8Array> = [];
+  let cursor = 0;
+  let state = 0x5eed_1234;
+  while (cursor < bytes.byteLength) {
+    state ^= state << 13;
+    state ^= state >>> 17;
+    state ^= state << 5;
+    const length = cursor < 42 ? 1 : 1 + ((state >>> 0) % 509);
+    chunks.push(
+      bytes.slice(cursor, Math.min(cursor + length, bytes.byteLength)),
+    );
+    cursor += length;
+  }
+  return chunks;
+};
+
+const optionalMetadataEnd = (encoded: Uint8Array): number =>
+  46 +
+  ((encoded[43] ?? 0) << 16) +
+  ((encoded[44] ?? 0) << 8) +
+  (encoded[45] ?? 0);
+
+const replaceOptionalMetadata = (
+  encoded: Uint8Array,
+  type: number,
+  payload: Uint8Array,
+): Uint8Array => {
+  const audio = encoded.subarray(optionalMetadataEnd(encoded));
+  const result = new Uint8Array(42 + 4 + payload.byteLength + audio.byteLength);
+  result.set(encoded.subarray(0, 42));
+  result[42] = 0x80 | type;
+  result[43] = payload.byteLength >>> 16;
+  result[44] = payload.byteLength >>> 8;
+  result[45] = payload.byteLength;
+  result.set(payload, 46);
+  result.set(audio, 46 + payload.byteLength);
+  return result;
+};
+
+const duplicateOptionalMetadata = (encoded: Uint8Array): Uint8Array => {
+  const end = optionalMetadataEnd(encoded);
+  const block = encoded.slice(42, end);
+  block[0]! &= 0x7f;
+  const result = new Uint8Array(encoded.byteLength + block.byteLength);
+  result.set(encoded.subarray(0, 42));
+  result.set(block, 42);
+  result.set(encoded.subarray(42), 42 + block.byteLength);
+  return result;
+};
+
+const duplicateStreamInfo = (encoded: Uint8Array): Uint8Array => {
+  const block = encoded.slice(4, 42);
+  const result = new Uint8Array(encoded.byteLength + block.byteLength);
+  result.set(encoded.subarray(0, 42));
+  result.set(block, 42);
+  result.set(encoded.subarray(42), 42 + block.byteLength);
+  return result;
+};
+
+const optionalBeforeStreamInfo = (encoded: Uint8Array): Uint8Array => {
+  const application = Uint8Array.of(2, 0, 0, 4, 0x54, 0x45, 0x53, 0x54);
+  const streamInfo = encoded.slice(4, 42);
+  streamInfo[0]! |= 0x80;
+  const audio = encoded.subarray(optionalMetadataEnd(encoded));
+  const result = new Uint8Array(
+    4 + application.byteLength + streamInfo.byteLength + audio.byteLength,
+  );
+  result.set(encoded.subarray(0, 4));
+  result.set(application, 4);
+  result.set(streamInfo, 4 + application.byteLength);
+  result.set(audio, 4 + application.byteLength + streamInfo.byteLength);
+  return result;
+};
+
+const collectPcm = (events: ReadonlyArray<FlacDecodeEvent>): Uint8Array => {
+  const length = events.reduce(
+    (sum, event) => sum + (event._tag === "Pcm" ? event.bytes.byteLength : 0),
+    0,
+  );
+  const bytes = new Uint8Array(length);
+  let offset = 0;
+  for (const event of events) {
+    if (event._tag !== "Pcm") continue;
+    bytes.set(event.bytes, offset);
+    offset += event.bytes.byteLength;
+  }
+  return bytes;
+};
+
+const decodeExit = (chunks: ReadonlyArray<Uint8Array>) =>
+  run(Effect.exit(Stream.runCollect(decodeFlac(Stream.fromIterable(chunks)))));
+
+beforeAll(async () => {
+  const [encoderBytes, decoderBytes] = await Promise.all([
+    readFile(new URL("../wasm/flac-encoder.wasm", import.meta.url)),
+    readFile(new URL("../wasm/flac-decoder.wasm", import.meta.url)),
+  ]);
+  const encoderLayer = makeFlacEncoderLayer(encoderBytes);
+  const decoderLayer = makeFlacDecoderLayer(decoderBytes);
+  run = <A, E>(effect: Effect.Effect<A, E, FlacDecoder>) =>
+    Effect.runPromise(effect.pipe(Effect.provide(decoderLayer)));
+  runEncoder = <A, E>(effect: Effect.Effect<A, E, FlacEncoder>) =>
+    Effect.runPromise(effect.pipe(Effect.provide(encoderLayer)));
+  fixture = await runEncoder(makeFixture(8_193));
+});
+
+describe("decodeFlac", () => {
+  test("accepts the supported 8 kHz and 192 kHz format boundaries", async () => {
+    const formats = [
+      new PcmFormat({
+        sampleRate: 8_000,
+        channels: 1,
+        bitsPerSample: 16,
+      }),
+      new PcmFormat({
+        sampleRate: 192_000,
+        channels: 2,
+        bitsPerSample: 24,
+      }),
+    ];
+    for (const format of formats) {
+      const boundary = await runEncoder(makeFixture(257, format));
+      const events = await run(
+        Stream.runCollect(
+          decodeFlac(Stream.make(boundary.encoded), {
+            expectedFormat: format,
+            expectedFrames: 257n,
+          }),
+        ),
+      );
+      expect(events[0]).toMatchObject({ _tag: "Metadata", format });
+      expect(collectPcm(events)).toEqual(boundary.canonical);
+      expect(events.at(-1)).toMatchObject({ _tag: "Complete", frames: 257n });
+    }
+  });
+
+  test("decodes byte-fragmented input into bounded canonical PCM and verified completion", async () => {
+    const events = await run(
+      Stream.runCollect(
+        decodeFlac(Stream.fromIterable(fragment(fixture.encoded)), {
+          expectedFormat: fixture.format,
+          expectedFrames: BigInt(fixture.frames),
+        }),
+      ),
+    );
+    expect(events[0]?._tag).toBe("Metadata");
+    expect(events.at(-1)).toMatchObject({
+      _tag: "Complete",
+      frames: BigInt(fixture.frames),
+      bytes: BigInt(fixture.canonical.byteLength),
+      md5Checked: true,
+      md5Verified: true,
+    });
+    let expectedOffset = 0n;
+    for (const event of events) {
+      if (event._tag !== "Pcm") continue;
+      expect(event.frameOffset).toBe(expectedOffset);
+      expect(event.bytes.byteLength).toBeLessThanOrEqual(384 * 1024);
+      expectedOffset += BigInt(event.frames);
+    }
+    expect(collectPcm(events)).toEqual(fixture.canonical);
+  });
+
+  test("runs independent repeat and concurrent subscriptions", async () => {
+    const source = Stream.fromIterable(fragment(fixture.encoded));
+    const results = await run(
+      Effect.all(
+        [
+          Stream.runCollect(decodeFlac(source)),
+          Stream.runCollect(decodeFlac(source)),
+          Stream.runCollect(decodeFlac(source)),
+        ],
+        { concurrency: 3 },
+      ),
+    );
+    for (const events of results) {
+      expect(collectPcm(events)).toEqual(fixture.canonical);
+      expect(events.at(-1)?._tag).toBe("Complete");
+    }
+  });
+
+  test("accepts an absent STREAMINFO MD5 without claiming verification", async () => {
+    const encoded = Uint8Array.from(fixture.encoded);
+    encoded.fill(0, 26, 42);
+    const events = await run(
+      Stream.runCollect(decodeFlac(Stream.make(encoded))),
+    );
+    expect(events[0]).toMatchObject({ _tag: "Metadata", md5Present: false });
+    expect(events.at(-1)).toMatchObject({
+      _tag: "Complete",
+      md5Checked: false,
+      md5Verified: false,
+    });
+    expect(collectPcm(events)).toEqual(fixture.canonical);
+  });
+
+  test("accepts validated padding and application metadata without retaining it", async () => {
+    const cases = [
+      replaceOptionalMetadata(fixture.encoded, 1, new Uint8Array()),
+      replaceOptionalMetadata(
+        fixture.encoded,
+        2,
+        Uint8Array.of(0x54, 0x45, 0x53, 0x54),
+      ),
+    ];
+    for (const encoded of cases) {
+      const events = await run(
+        Stream.runCollect(decodeFlac(Stream.make(encoded))),
+      );
+      expect(collectPcm(events)).toEqual(fixture.canonical);
+      expect(events.at(-1)?._tag).toBe("Complete");
+    }
+  });
+
+  test("rejects malformed, reserved, duplicate, and misordered metadata", async () => {
+    const cases = [
+      replaceOptionalMetadata(fixture.encoded, 4, new Uint8Array()),
+      replaceOptionalMetadata(fixture.encoded, 5, new Uint8Array()),
+      replaceOptionalMetadata(fixture.encoded, 6, new Uint8Array()),
+      replaceOptionalMetadata(fixture.encoded, 127, new Uint8Array()),
+      duplicateOptionalMetadata(fixture.encoded),
+      duplicateStreamInfo(fixture.encoded),
+      optionalBeforeStreamInfo(fixture.encoded),
+    ];
+    for (const encoded of cases) {
+      const exit = await decodeExit(fragment(encoded));
+      expect(Exit.isFailure(exit)).toBe(true);
+      if (Exit.isFailure(exit)) {
+        expect(Cause.squash(exit.cause)).toMatchObject({
+          _tag: "FlacDecodeError",
+          reason: "invalid-metadata",
+        });
+      }
+    }
+  });
+
+  test("reports fixed-memory refusal for oversized retained metadata", async () => {
+    const payload = new Uint8Array(1_900_000);
+    payload.set([0x54, 0x45, 0x53, 0x54]);
+    const encoded = replaceOptionalMetadata(fixture.encoded, 2, payload);
+    const chunks: Array<Uint8Array> = [];
+    for (let offset = 0; offset < encoded.byteLength; offset += 128 * 1024) {
+      chunks.push(encoded.subarray(offset, offset + 128 * 1024));
+    }
+    const exit = await run(
+      Effect.exit(
+        Stream.runDrain(
+          decodeFlac(Stream.fromIterable(chunks), {
+            maxMetadataBytes: 2 * 1024 * 1024,
+          }),
+        ),
+      ),
+    );
+    expect(Exit.isFailure(exit)).toBe(true);
+    if (Exit.isFailure(exit)) {
+      expect(Cause.squash(exit.cause)).toMatchObject({
+        _tag: "FlacDecodeError",
+        reason: "allocation-failed",
+      });
+    }
+  });
+
+  test("reports MD5 and frame CRC corruption as distinct typed failures", async () => {
+    const badMd5 = Uint8Array.from(fixture.encoded);
+    badMd5[26]! ^= 1;
+    const md5Exit = await decodeExit([badMd5]);
+    expect(Exit.isFailure(md5Exit)).toBe(true);
+    if (Exit.isFailure(md5Exit)) {
+      expect(Cause.squash(md5Exit.cause)).toMatchObject({
+        _tag: "FlacDecodeError",
+        reason: "md5-mismatch",
+      });
+    }
+
+    const badCrc = Uint8Array.from(fixture.encoded);
+    badCrc[badCrc.byteLength - 1]! ^= 1;
+    const crcExit = await decodeExit([badCrc]);
+    expect(Exit.isFailure(crcExit)).toBe(true);
+    if (Exit.isFailure(crcExit)) {
+      expect(Cause.squash(crcExit.cause)).toMatchObject({
+        _tag: "FlacDecodeError",
+        reason: "crc-mismatch",
+      });
+    }
+  });
+
+  test("rejects truncation, buffered and delayed trailing bytes, and concatenated streams", async () => {
+    const trailing = Uint8Array.from([...fixture.encoded, 0, 1, 2, 3]);
+    const cases: ReadonlyArray<ReadonlyArray<Uint8Array>> = [
+      [fixture.encoded.slice(0, -1)],
+      [trailing],
+      [fixture.encoded, Uint8Array.of(0, 1, 2, 3)],
+      [fixture.encoded, fixture.encoded],
+    ];
+    for (const chunks of cases) {
+      const exit = await decodeExit(chunks);
+      expect(Exit.isFailure(exit)).toBe(true);
+      if (Exit.isFailure(exit))
+        expect(Cause.squash(exit.cause)).toBeInstanceOf(FlacDecodeError);
+    }
+  });
+
+  test("fails mismatched expected metadata and explicit input/metadata bounds", async () => {
+    const mismatch = await run(
+      Effect.exit(
+        Stream.runDrain(
+          decodeFlac(Stream.make(fixture.encoded), {
+            expectedFrames: BigInt(fixture.frames + 1),
+          }),
+        ),
+      ),
+    );
+    expect(Exit.isFailure(mismatch)).toBe(true);
+    if (Exit.isFailure(mismatch)) {
+      expect(Cause.squash(mismatch.cause)).toMatchObject({
+        reason: "expected-metadata-mismatch",
+      });
+    }
+
+    const oversized = await decodeExit([new Uint8Array(256 * 1024 + 1)]);
+    expect(Exit.isFailure(oversized)).toBe(true);
+    if (Exit.isFailure(oversized)) {
+      expect(Cause.squash(oversized.cause)).toMatchObject({
+        reason: "input-chunk-too-large",
+      });
+    }
+
+    const extendedMetadata = new Uint8Array(fixture.encoded.byteLength + 104);
+    extendedMetadata.set(fixture.encoded.subarray(0, 42));
+    extendedMetadata[4]! &= 0x7f;
+    extendedMetadata.set([0x81, 0, 0, 100], 42);
+    extendedMetadata.set(fixture.encoded.subarray(42), 146);
+    const metadataLimit = await run(
+      Effect.exit(
+        Stream.runDrain(
+          decodeFlac(Stream.make(extendedMetadata), { maxMetadataBytes: 80 }),
+        ),
+      ),
+    );
+    expect(Exit.isFailure(metadataLimit)).toBe(true);
+    if (Exit.isFailure(metadataLimit)) {
+      expect(Cause.squash(metadataLimit.cause)).toMatchObject({
+        reason: "metadata-limit",
+      });
+    }
+  });
+
+  test("lazily rejects malformed runtime options with a typed error", async () => {
+    const malformed = [
+      null,
+      { expectedFormat: null },
+      { expectedFrames: 1 },
+      { expectedFrames: 1.5 },
+      { expectedFrames: Number.NaN },
+      { expectedFrames: "1" },
+    ] as const;
+
+    for (const options of malformed) {
+      const make = () =>
+        decodeFlac(Stream.empty, options as unknown as FlacDecodeOptions);
+      expect(make).not.toThrow();
+      const exit = await run(Effect.exit(Stream.runDrain(make())));
+      expect(Exit.isFailure(exit)).toBe(true);
+      if (Exit.isFailure(exit)) {
+        expect(Cause.squash(exit.cause)).toMatchObject({
+          _tag: "FlacDecodeError",
+          reason: "invalid-options",
+        });
+      }
+    }
+  });
+
+  test("preserves interruption while awaiting input and releases the source once", async () => {
+    const result = await run(
+      Effect.gen(function* () {
+        let finalized = 0;
+        let complete = false;
+        const waiting = yield* Deferred.make<void>();
+        const source = Stream.concat(
+          Stream.make(fixture.encoded.slice(0, 42)),
+          Stream.fromEffect(
+            Effect.andThen(Deferred.succeed(waiting, undefined), Effect.never),
+          ),
+        ).pipe(
+          Stream.ensuring(
+            Effect.sync(() => {
+              finalized += 1;
+            }),
+          ),
+        );
+        const fiber = yield* Effect.forkChild(
+          decodeFlac(source).pipe(
+            Stream.tap((event) =>
+              Effect.sync(() => {
+                if (event._tag === "Complete") complete = true;
+              }),
+            ),
+            Stream.runDrain,
+          ),
+        );
+        yield* Deferred.await(waiting);
+        yield* Fiber.interrupt(fiber);
+        const exit = yield* Fiber.await(fiber);
+        return { exit, finalized, complete };
+      }),
+    );
+    expect(
+      Exit.isFailure(result.exit) && Cause.hasInterrupts(result.exit.cause),
+    ).toBe(true);
+    expect(result.finalized).toBe(1);
+    expect(result.complete).toBe(false);
+  });
+
+  test("early take closes the decoder and never emits Complete", async () => {
+    let finalized = 0;
+    const events = await run(
+      decodeFlac(
+        Stream.fromIterable(fragment(fixture.encoded)).pipe(
+          Stream.ensuring(
+            Effect.sync(() => {
+              finalized += 1;
+            }),
+          ),
+        ),
+      ).pipe(Stream.take(1), Stream.runCollect),
+    );
+    expect(events.map((event) => event._tag)).toEqual(["Metadata"]);
+    expect(finalized).toBe(1);
+  });
+
+  test("does not pull the whole encoded source while downstream is stalled", async () => {
+    const fragments = fragment(fixture.encoded);
+    let pulled = 0;
+    const source = Stream.unfold(0, (index) =>
+      Effect.succeed(
+        index < fragments.length
+          ? ([fragments[index]!, index + 1] as const)
+          : undefined,
+      ),
+    ).pipe(
+      Stream.tap(() =>
+        Effect.sync(() => {
+          pulled += 1;
+        }),
+      ),
+    );
+    const events = await run(
+      decodeFlac(source).pipe(Stream.take(2), Stream.runCollect),
+    );
+    expect(events.map((event) => event._tag)).toEqual(["Metadata", "Pcm"]);
+    expect(pulled).toBeGreaterThan(0);
+    expect(pulled).toBeLessThan(fragments.length);
+  });
+});
diff --git a/test/decoder-wasm.test.ts b/test/decoder-wasm.test.ts
new file mode 100644
index 0000000..82bc4ca
--- /dev/null
+++ b/test/decoder-wasm.test.ts
@@ -0,0 +1,49 @@
+import { expect, test } from "bun:test";
+import { readFile } from "node:fs/promises";
+
+import * as Effect from "effect/Effect";
+
+import {
+  FLAC_DECODER_LIMITS,
+  FLAC_DECODER_WASM_SHA256,
+  loadFlacDecoderFromBytes,
+} from "../src/decoder-wasm.js";
+
+test("loads only the pinned bounded decoder module", async () => {
+  const bytes = new Uint8Array(
+    await readFile(new URL("../wasm/flac-decoder.wasm", import.meta.url)),
+  );
+  const service = await Effect.runPromise(loadFlacDecoderFromBytes(bytes));
+  expect(WebAssembly.Module.imports(service.module)).toEqual([
+    { module: "codec", name: "read", kind: "function" },
+  ]);
+  expect(bytes.byteLength).toBeLessThanOrEqual(
+    FLAC_DECODER_LIMITS.maxAssetBytes,
+  );
+  expect(FLAC_DECODER_WASM_SHA256).toHaveLength(64);
+});
+
+test("rejects modified and oversized decoder assets before instantiation", async () => {
+  const bytes = new Uint8Array(
+    await readFile(new URL("../wasm/flac-decoder.wasm", import.meta.url)),
+  );
+  bytes[bytes.byteLength - 1]! ^= 1;
+  const modified = await Effect.runPromise(
+    Effect.flip(loadFlacDecoderFromBytes(bytes)),
+  );
+  expect(modified).toMatchObject({
+    _tag: "FlacDecodeError",
+    reason: "wasm-compile",
+    phase: "load",
+  });
+
+  const oversized = new Uint8Array(FLAC_DECODER_LIMITS.maxAssetBytes + 1);
+  const tooLarge = await Effect.runPromise(
+    Effect.flip(loadFlacDecoderFromBytes(oversized)),
+  );
+  expect(tooLarge).toMatchObject({
+    _tag: "FlacDecodeError",
+    reason: "wasm-compile",
+    phase: "load",
+  });
+});
diff --git a/test/encode-native-integration.test.ts b/test/encode-native-integration.test.ts
new file mode 100644
index 0000000..9f31f61
--- /dev/null
+++ b/test/encode-native-integration.test.ts
@@ -0,0 +1,223 @@
+import { existsSync } from "node:fs";
+import { mkdtemp, readFile, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { expect, test } from "bun:test";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+
+import {
+  encodeFlac,
+  PcmFormat,
+  type RandomAccessByteSink,
+} from "../src/index.js";
+import { FlacEncoderLive } from "../src/node.js";
+
+const nativeFlac = process.env.CODEC_NATIVE_FLAC;
+
+const rawPcm = (pcm: Int32Array, bits: 16 | 24): Uint8Array => {
+  const width = bits / 8;
+  const bytes = new Uint8Array(pcm.length * width);
+  for (let index = 0; index < pcm.length; index++) {
+    const value = pcm[index]! >>> 0;
+    for (let byte = 0; byte < width; byte++)
+      bytes[index * width + byte] = (value >>> (8 * byte)) & 0xff;
+  }
+  return bytes;
+};
+
+for (const bits of [16, 24] as const) {
+  test.skipIf(nativeFlac === undefined)(
+    `native libFLAC decodes PCM${bits} output byte-for-byte`,
+    async () => {
+      const command = nativeFlac!;
+      expect(
+        existsSync(command),
+        `CODEC_NATIVE_FLAC does not exist: ${command}`,
+      ).toBe(true);
+      const format = new PcmFormat({
+        sampleRate: 44_100,
+        channels: 2,
+        bitsPerSample: bits,
+      });
+      const pcm = new Int32Array(2 * 4_097);
+      let random = 0x31415926;
+      for (let index = 0; index < pcm.length; index++) {
+        random = (Math.imul(random, 1_103_515_245) + 12_345) | 0;
+        pcm[index] = random >> (32 - bits);
+      }
+      pcm[0] = -(2 ** (bits - 1));
+      pcm[1] = 2 ** (bits - 1) - 1;
+      let encoded = new Uint8Array();
+      const sink: RandomAccessByteSink<never, never> = {
+        writeAt: (offset, bytes) =>
+          Effect.sync(() => {
+            const end = Number(offset) + bytes.length;
+            if (end > encoded.length) {
+              const grown = new Uint8Array(end);
+              grown.set(encoded);
+              encoded = grown;
+            }
+            encoded.set(bytes, Number(offset));
+          }),
+        resize: (length) =>
+          Effect.sync(() => {
+            encoded = encoded.slice(0, Number(length));
+          }),
+      };
+      await Effect.runPromise(
+        encodeFlac(
+          Stream.make(pcm.subarray(0, 8_192), pcm.subarray(8_192)),
+          sink,
+          { format, expectedFrames: 4_097n },
+        ).pipe(Effect.provide(FlacEncoderLive)),
+      );
+
+      const directory = await mkdtemp(join(tmpdir(), "codec-native-"));
+      const flacPath = join(directory, `fixture-${bits}.flac`);
+      try {
+        await Bun.write(flacPath, encoded);
+        const proc = Bun.spawn(
+          [
+            command,
+            "--silent",
+            "--decode",
+            "--stdout",
+            "--force-raw-format",
+            "--endian=little",
+            "--sign=signed",
+            flacPath,
+          ],
+          { stdout: "pipe", stderr: "pipe" },
+        );
+        const [decoded, stderr, status] = await Promise.all([
+          new Response(proc.stdout).arrayBuffer(),
+          new Response(proc.stderr).text(),
+          proc.exited,
+        ]);
+        expect(status, stderr).toBe(0);
+        expect(Array.from(new Uint8Array(decoded))).toEqual(
+          Array.from(rawPcm(pcm, bits)),
+        );
+      } finally {
+        await rm(directory, { recursive: true, force: true });
+      }
+    },
+  );
+}
+
+test.skipIf(nativeFlac === undefined)(
+  "level-8 LPC analysis stays within two percent of native libFLAC",
+  async () => {
+    const command = nativeFlac!;
+    expect(
+      existsSync(command),
+      `CODEC_NATIVE_FLAC does not exist: ${command}`,
+    ).toBe(true);
+    const format = new PcmFormat({
+      sampleRate: 44_100,
+      channels: 2,
+      bitsPerSample: 24,
+    });
+    const frames = 131_072;
+    const pcm = new Int32Array(frames * format.channels);
+    for (let frame = 0; frame < frames; frame++) {
+      const slow = Math.sin(frame * 0.000_31) * 900_000;
+      pcm[frame * 2] = Math.round(
+        slow +
+          Math.sin(frame * 0.007_1) * 2_700_000 +
+          Math.sin(frame * 0.011_3) * 1_300_000,
+      );
+      pcm[frame * 2 + 1] = Math.round(
+        slow +
+          Math.sin(frame * 0.007_1 + 0.19) * 2_650_000 +
+          Math.sin(frame * 0.011_3 + 0.07) * 1_350_000,
+      );
+    }
+
+    let encoded = new Uint8Array();
+    const sink: RandomAccessByteSink<never, never> = {
+      writeAt: (offset, bytes) =>
+        Effect.sync(() => {
+          const end = Number(offset) + bytes.byteLength;
+          if (end > encoded.byteLength) {
+            const grown = new Uint8Array(end);
+            grown.set(encoded);
+            encoded = grown;
+          }
+          encoded.set(bytes, Number(offset));
+        }),
+      resize: (length) =>
+        Effect.sync(() => {
+          encoded = encoded.slice(0, Number(length));
+        }),
+    };
+    const blocks: Array<Int32Array> = [];
+    for (let frame = 0; frame < frames; frame += 4_096) {
+      blocks.push(pcm.subarray(frame * 2, Math.min(frame + 4_096, frames) * 2));
+    }
+    await Effect.runPromise(
+      encodeFlac(Stream.fromIterable(blocks), sink, {
+        format,
+        expectedFrames: BigInt(frames),
+      }).pipe(Effect.provide(FlacEncoderLive)),
+    );
+
+    const directory = await mkdtemp(join(tmpdir(), "codec-compression-"));
+    const rawPath = join(directory, "predictive.raw");
+    const wasmPath = join(directory, "wasm.flac");
+    const nativePath = join(directory, "native.flac");
+    const analysisPath = join(directory, "wasm.ana");
+    try {
+      await Promise.all([
+        Bun.write(rawPath, rawPcm(pcm, 24)),
+        Bun.write(wasmPath, encoded),
+      ]);
+      const native = Bun.spawn(
+        [
+          command,
+          "--totally-silent",
+          "--force",
+          "-8",
+          "--no-exhaustive-model-search",
+          "--threads=1",
+          "--no-padding",
+          "--no-seektable",
+          "--force-raw-format",
+          "--endian=little",
+          "--sign=signed",
+          "--channels=2",
+          "--bps=24",
+          "--sample-rate=44100",
+          `--output-name=${nativePath}`,
+          rawPath,
+        ],
+        { stdout: "pipe", stderr: "pipe" },
+      );
+      const nativeStderr = new Response(native.stderr).text();
+      expect(await native.exited, await nativeStderr).toBe(0);
+      const nativeBytes = (await stat(nativePath)).size;
+      expect(encoded.byteLength).toBeLessThanOrEqual(
+        Math.ceil(nativeBytes * 1.02),
+      );
+
+      const analyze = Bun.spawn(
+        [
+          command,
+          "--analyze",
+          "--force",
+          `--output-name=${analysisPath}`,
+          wasmPath,
+        ],
+        { stdout: "pipe", stderr: "pipe" },
+      );
+      const analyzeStderr = new Response(analyze.stderr).text();
+      expect(await analyze.exited, await analyzeStderr).toBe(0);
+      const analysis = await readFile(analysisPath, "utf8");
+      expect(analysis).toMatch(/type=LPC\s+order=(?:[2-9]|1[0-2])\b/);
+    } finally {
+      await rm(directory, { recursive: true, force: true });
+    }
+  },
+);
diff --git a/test/encode.test.ts b/test/encode.test.ts
new file mode 100644
index 0000000..b67cab8
--- /dev/null
+++ b/test/encode.test.ts
@@ -0,0 +1,366 @@
+import { createHash } from "node:crypto";
+
+import { describe, expect, test } from "bun:test";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import * as Stream from "effect/Stream";
+
+import {
+  encodeFlac,
+  FlacEncodeError,
+  FLAC_ENCODER_LIMITS,
+  makeFlacEncoderLayer,
+  PcmFormat,
+  PcmInputError,
+  type FlacEncodeOptions,
+  type RandomAccessByteSink,
+} from "../src/index.js";
+import { FlacEncoderLive } from "../src/node.js";
+
+class MemorySink<E = never, R = never> implements RandomAccessByteSink<E, R> {
+  bytes = new Uint8Array();
+  readonly writes: Array<{
+    readonly offset: bigint;
+    readonly bytes: Uint8Array;
+  }> = [];
+  resizeCalls = 0;
+
+  readonly writeAt = (
+    offset: bigint,
+    bytes: Uint8Array,
+  ): Effect.Effect<void, E, R> =>
+    Effect.sync(() => {
+      this.writes.push({ offset, bytes: Uint8Array.from(bytes) });
+      const end = Number(offset) + bytes.length;
+      if (end > this.bytes.length) {
+        const grown = new Uint8Array(end);
+        grown.set(this.bytes);
+        this.bytes = grown;
+      }
+      this.bytes.set(bytes, Number(offset));
+    }) as Effect.Effect<void, E, R>;
+
+  readonly resize = (length: bigint): Effect.Effect<void, E, R> =>
+    Effect.sync(() => {
+      this.resizeCalls += 1;
+      this.bytes = this.bytes.slice(0, Number(length));
+    }) as Effect.Effect<void, E, R>;
+}
+
+const pcmBytes = (pcm: Int32Array, bitsPerSample: 16 | 24): Uint8Array => {
+  const bytesPerSample = bitsPerSample / 8;
+  const bytes = new Uint8Array(pcm.length * bytesPerSample);
+  for (let index = 0; index < pcm.length; index++) {
+    const value = pcm[index]! >>> 0;
+    for (let byte = 0; byte < bytesPerSample; byte++) {
+      bytes[index * bytesPerSample + byte] = (value >>> (byte * 8)) & 0xff;
+    }
+  }
+  return bytes;
+};
+
+const md5 = (bytes: Uint8Array): string =>
+  createHash("md5").update(bytes).digest("hex");
+
+const format16 = new PcmFormat({
+  sampleRate: 44_100,
+  channels: 2,
+  bitsPerSample: 16,
+});
+const format24 = new PcmFormat({
+  sampleRate: 192_000,
+  channels: 1,
+  bitsPerSample: 24,
+});
+
+const run = <A, E>(
+  effect: Effect.Effect<A, E, import("../src/index.js").FlacEncoder>,
+) => Effect.runPromise(effect.pipe(Effect.provide(FlacEncoderLive)));
+
+const deterministicPcm = (samples: number, bits: 16 | 24): Int32Array => {
+  const result = new Int32Array(samples);
+  let state = 0x12345678;
+  const shift = 32 - bits;
+  for (let index = 0; index < samples; index++) {
+    state = (Math.imul(state, 1_664_525) + 1_013_904_223) | 0;
+    result[index] = state >> shift;
+  }
+  return result;
+};
+
+describe("encodeFlac", () => {
+  test("encodes finalized PCM16 STREAMINFO and canonical MD5", async () => {
+    const pcm = deterministicPcm(2 * 4_096, 16);
+    const sink = new MemorySink();
+    const result = await run(
+      encodeFlac(Stream.make(pcm), sink, {
+        format: format16,
+        expectedFrames: 4_096n,
+      }),
+    );
+
+    expect(new TextDecoder().decode(sink.bytes.subarray(0, 4))).toBe("fLaC");
+    expect(result.frames).toBe(4_096n);
+    expect(result.bytes).toBe(BigInt(sink.bytes.length));
+    expect(result.streamInfo.totalFrames).toBe(4_096n);
+    expect(result.streamInfo.md5Hex).toBe(md5(pcmBytes(pcm, 16)));
+    expect(result.streamInfo.minimumBlockFrames).toBe(4_096);
+    expect(result.streamInfo.maximumBlockFrames).toBe(4_096);
+    expect(sink.resizeCalls).toBe(1);
+    expect(sink.writes.some((write) => write.offset === 4n)).toBe(true);
+  });
+
+  test("encodes PCM24 extrema and a partial final block", async () => {
+    const random = deterministicPcm(4_097, 24);
+    random[0] = -8_388_608;
+    random[1] = 8_388_607;
+    const sink = new MemorySink();
+    const result = await run(
+      encodeFlac(
+        Stream.make(random.subarray(0, 4_096), random.subarray(4_096)),
+        sink,
+        { format: format24, expectedFrames: 4_097n },
+      ),
+    );
+
+    expect(result.frames).toBe(4_097n);
+    expect(result.streamInfo.md5Hex).toBe(md5(pcmBytes(random, 24)));
+    expect(result.streamInfo.minimumBlockFrames).toBe(4_096);
+    expect(result.streamInfo.maximumBlockFrames).toBe(4_096);
+    expect(sink.resizeCalls).toBe(1);
+  });
+
+  test("defines an empty source as a valid zero-frame FLAC", async () => {
+    const sink = new MemorySink();
+    const result = await run(
+      encodeFlac(Stream.empty, sink, {
+        format: format16,
+        expectedFrames: 0n,
+      }),
+    );
+
+    expect(result.frames).toBe(0n);
+    expect(result.streamInfo.totalFrames).toBe(0n);
+    expect(result.streamInfo.md5Hex).toBe("d41d8cd98f00b204e9800998ecf8427e");
+    expect(sink.resizeCalls).toBe(1);
+  });
+
+  test("rejects oversized and out-of-depth blocks before processing them", async () => {
+    const cases = [
+      {
+        pcm: new Int32Array((FLAC_ENCODER_LIMITS.maxInputBlockFrames + 1) * 2),
+        reason: "block-too-large",
+      },
+      { pcm: Int32Array.of(0, 32_768), reason: "sample-out-of-range" },
+      { pcm: Int32Array.of(0), reason: "misaligned-block" },
+      { pcm: new Int32Array(), reason: "empty-block" },
+    ] as const;
+
+    for (const fixture of cases) {
+      const sink = new MemorySink();
+      const error = await run(
+        Effect.flip(
+          encodeFlac(Stream.make(fixture.pcm), sink, {
+            format: format16,
+          }),
+        ),
+      );
+      expect(error).toBeInstanceOf(PcmInputError);
+      expect((error as PcmInputError).reason).toBe(fixture.reason);
+      expect(sink.resizeCalls).toBe(0);
+      expect(sink.writes.filter((write) => write.offset === 4n)).toHaveLength(
+        1,
+      );
+    }
+  });
+
+  test("lazily rejects malformed runtime options with a typed error", async () => {
+    const malformed = [
+      null,
+      { format: null },
+      { format: format16, expectedFrames: 1 },
+      { format: format16, expectedFrames: Number.NaN },
+      { format: format16, expectedFrames: "1" },
+    ] as const;
+
+    for (const options of malformed) {
+      const make = () =>
+        encodeFlac(
+          Stream.empty,
+          new MemorySink(),
+          options as unknown as FlacEncodeOptions,
+        );
+      expect(make).not.toThrow();
+      const exit = await Effect.runPromiseExit(
+        make().pipe(Effect.provide(FlacEncoderLive)),
+      );
+      expect(Exit.isFailure(exit)).toBe(true);
+      if (Exit.isFailure(exit)) {
+        expect(Cause.squash(exit.cause)).toBeInstanceOf(PcmInputError);
+      }
+    }
+  });
+
+  test("stops before processing a block that overshoots expectedFrames", async () => {
+    let pulled = 0;
+    const source = Stream.fromIterable([
+      Int32Array.of(1, 2, 3, 4),
+      Int32Array.of(5, 6),
+      Int32Array.of(7, 8),
+    ]).pipe(
+      Stream.tap(() =>
+        Effect.sync(() => {
+          pulled += 1;
+        }),
+      ),
+    );
+    const sink = new MemorySink();
+    const error = await run(
+      Effect.flip(
+        encodeFlac(source, sink, {
+          format: format16,
+          expectedFrames: 2n,
+        }),
+      ),
+    );
+
+    expect(error).toBeInstanceOf(PcmInputError);
+    expect((error as PcmInputError).reason).toBe("frame-count-mismatch");
+    expect(pulled).toBe(2);
+    expect(sink.resizeCalls).toBe(0);
+    expect(sink.writes.filter((write) => write.offset === 4n)).toHaveLength(1);
+  });
+
+  test("preserves source and sink failures by identity", async () => {
+    const sourceFailure = { _tag: "SourceFailure" as const };
+    const sinkFailure = { _tag: "SinkFailure" as const };
+
+    const sourceError = await run(
+      Effect.flip(
+        encodeFlac(Stream.fail(sourceFailure), new MemorySink(), {
+          format: format16,
+        }),
+      ),
+    );
+    expect(sourceError).toBe(sourceFailure);
+
+    const failingSink: RandomAccessByteSink<typeof sinkFailure, never> = {
+      writeAt: () => Effect.fail(sinkFailure),
+      resize: () => Effect.void,
+    };
+    const sinkError = await run(
+      Effect.flip(
+        encodeFlac(Stream.empty, failingSink, {
+          format: format16,
+        }),
+      ),
+    );
+    expect(sinkError).toBe(sinkFailure);
+  });
+
+  test("awaits sink backpressure before pulling PCM", async () => {
+    let release!: () => void;
+    let reportBlocked!: () => void;
+    const gate = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+    const blocked = new Promise<void>((resolve) => {
+      reportBlocked = resolve;
+    });
+    let first = true;
+    let pulled = 0;
+    const memory = new MemorySink();
+    const sink: RandomAccessByteSink<never, never> = {
+      writeAt: (offset, bytes) => {
+        if (first) {
+          first = false;
+          reportBlocked();
+          return Effect.promise(() => gate).pipe(
+            Effect.andThen(memory.writeAt(offset, bytes)),
+          );
+        }
+        return memory.writeAt(offset, bytes);
+      },
+      resize: memory.resize,
+    };
+    const source = Stream.fromEffect(
+      Effect.sync(() => {
+        pulled += 1;
+        return Int32Array.of(0, 0);
+      }),
+    );
+
+    const running = run(
+      encodeFlac(source, sink, { format: format16, expectedFrames: 1n }),
+    );
+    await blocked;
+    expect(pulled).toBe(0);
+    release();
+    await running;
+    expect(pulled).toBe(1);
+  });
+
+  test("interruption stops a pending source without final resize or late writes", async () => {
+    const sink = new MemorySink();
+    const program = encodeFlac(Stream.never, sink, { format: format16 }).pipe(
+      Effect.provide(FlacEncoderLive),
+    );
+    const fiber = Effect.runFork(program);
+    await Bun.sleep(10);
+    const before = sink.writes.length;
+    await Effect.runPromise(Fiber.interrupt(fiber));
+    const exit = await Effect.runPromise(Fiber.await(fiber));
+    expect(Exit.isFailure(exit)).toBe(true);
+    if (Exit.isFailure(exit))
+      expect(Cause.hasInterrupts(exit.cause)).toBe(true);
+    await Bun.sleep(10);
+    expect(sink.writes.length).toBe(before);
+    expect(sink.resizeCalls).toBe(0);
+  });
+
+  test("isolates concurrent encoder instances", async () => {
+    const a = deterministicPcm(2 * 257, 16);
+    const b = deterministicPcm(2 * 4_096, 16);
+    b.reverse();
+    const sinkA = new MemorySink();
+    const sinkB = new MemorySink();
+    const [resultA, resultB] = await Promise.all([
+      run(
+        encodeFlac(Stream.make(a), sinkA, {
+          format: format16,
+          expectedFrames: 257n,
+        }),
+      ),
+      run(
+        encodeFlac(Stream.make(b), sinkB, {
+          format: format16,
+          expectedFrames: 4_096n,
+        }),
+      ),
+    ]);
+
+    expect(resultA.streamInfo.md5Hex).toBe(md5(pcmBytes(a, 16)));
+    expect(resultB.streamInfo.md5Hex).toBe(md5(pcmBytes(b, 16)));
+    expect(resultA.streamInfo.md5Hex).not.toBe(resultB.streamInfo.md5Hex);
+  });
+
+  test("rejects corrupt or unpinned Wasm bytes through FlacEncodeError", async () => {
+    const sink = new MemorySink();
+    const exit = await Effect.runPromiseExit(
+      encodeFlac(Stream.empty, sink, {
+        format: format16,
+      }).pipe(
+        Effect.provide(makeFlacEncoderLayer(Uint8Array.of(0, 97, 115, 109))),
+      ),
+    );
+
+    expect(Exit.isFailure(exit)).toBe(true);
+    if (Exit.isFailure(exit)) {
+      const error = Cause.squash(exit.cause);
+      expect(error).toBeInstanceOf(FlacEncodeError);
+      expect((error as FlacEncodeError).reason).toBe("wasm-compile");
+    }
+  });
+});
diff --git a/test/fixtures/decoder-delete-trap.wat b/test/fixtures/decoder-delete-trap.wat
new file mode 100644
index 0000000..a2314e3
--- /dev/null
+++ b/test/fixtures/decoder-delete-trap.wat
@@ -0,0 +1,56 @@
+(module
+  (memory (export "memory") 32 32)
+  (func $void)
+  (func $zero (result i32) (i32.const 0))
+  (func $one (result i32) (i32.const 1))
+  (func $allocation (result i32) (i32.const 1024))
+  (func $rate (result i32) (i32.const 44100))
+  (func $two (result i32) (i32.const 2))
+  (func $sixteen (result i32) (i32.const 16))
+  (func $twentyFour (result i32) (i32.const 24))
+  (func $maxBlock (result i32) (i32.const 65535))
+  (func $unusedNegativeFrames (result i32) (i32.const -1))
+  (func $unusedNegativeLength (result i32) (i32.const -6))
+  (func $trap (param i32) unreachable)
+  (export "malloc" (func $allocation))
+  (export "free" (func $void))
+  (export "asyncify_start_unwind" (func $void))
+  (export "asyncify_stop_unwind" (func $void))
+  (export "asyncify_start_rewind" (func $void))
+  (export "asyncify_stop_rewind" (func $void))
+  (export "asyncify_get_state" (func $zero))
+  (export "codec_decoder_abi_version" (func $one))
+  (export "codec_decoder_new" (func $one))
+  (export "codec_decoder_init" (func $zero))
+  (export "codec_decoder_process_single" (func $two))
+  (export "codec_decoder_finish" (func $zero))
+  (export "codec_decoder_delete" (func $trap))
+  (export "codec_decoder_output_ptr" (func $allocation))
+  (export "codec_decoder_output_length" (func $unusedNegativeLength))
+  (export "codec_decoder_output_frames" (func $unusedNegativeFrames))
+  (export "codec_decoder_output_frame_offset_low" (func $zero))
+  (export "codec_decoder_output_frame_offset_high" (func $zero))
+  (export "codec_decoder_release_output" (func $void))
+  (export "codec_decoder_sample_rate" (func $rate))
+  (export "codec_decoder_channels" (func $two))
+  (export "codec_decoder_bits_per_sample" (func $twentyFour))
+  (export "codec_decoder_minimum_block_frames" (func $sixteen))
+  (export "codec_decoder_maximum_block_frames" (func $maxBlock))
+  (export "codec_decoder_total_frames_low" (func $zero))
+  (export "codec_decoder_total_frames_high" (func $zero))
+  (export "codec_decoder_total_frames_known" (func $zero))
+  (export "codec_decoder_streaminfo_frames_low" (func $zero))
+  (export "codec_decoder_streaminfo_frames_high" (func $zero))
+  (export "codec_decoder_streaminfo_frames_known" (func $zero))
+  (export "codec_decoder_md5_present" (func $zero))
+  (export "codec_decoder_decoded_frames_low" (func $zero))
+  (export "codec_decoder_decoded_frames_high" (func $zero))
+  (export "codec_decoder_decoded_bytes_low" (func $zero))
+  (export "codec_decoder_decoded_bytes_high" (func $zero))
+  (export "codec_decoder_callback_error" (func $zero))
+  (export "codec_decoder_state" (func $zero))
+  (export "codec_decoder_allocator_live_bytes" (func $zero))
+  (export "codec_decoder_allocator_peak_live_bytes" (func $zero))
+  (export "codec_decoder_allocator_peak_heap_bytes" (func $zero))
+  (export "codec_decoder_allocator_free_calls" (func $zero))
+  (export "codec_decoder_allocator_realloc_calls" (func $zero)))
diff --git a/test/fixtures/decoder-invalid-metadata.wat b/test/fixtures/decoder-invalid-metadata.wat
new file mode 100644
index 0000000..6671159
--- /dev/null
+++ b/test/fixtures/decoder-invalid-metadata.wat
@@ -0,0 +1,48 @@
+(module
+  (memory (export "memory") 32 32)
+  (func $void)
+  (func $zero (result i32) (i32.const 0))
+  (func $one (result i32) (i32.const 1))
+  (func $allocation (result i32) (i32.const 1024))
+  (export "malloc" (func $allocation))
+  (export "free" (func $void))
+  (export "asyncify_start_unwind" (func $void))
+  (export "asyncify_stop_unwind" (func $void))
+  (export "asyncify_start_rewind" (func $void))
+  (export "asyncify_stop_rewind" (func $void))
+  (export "asyncify_get_state" (func $zero))
+  (export "codec_decoder_abi_version" (func $one))
+  (export "codec_decoder_new" (func $one))
+  (export "codec_decoder_init" (func $zero))
+  (export "codec_decoder_process_single" (func $zero))
+  (export "codec_decoder_finish" (func $zero))
+  (export "codec_decoder_delete" (func $void))
+  (export "codec_decoder_output_ptr" (func $one))
+  (export "codec_decoder_output_length" (func $zero))
+  (export "codec_decoder_output_frames" (func $zero))
+  (export "codec_decoder_output_frame_offset_low" (func $zero))
+  (export "codec_decoder_output_frame_offset_high" (func $zero))
+  (export "codec_decoder_release_output" (func $void))
+  (export "codec_decoder_sample_rate" (func $zero))
+  (export "codec_decoder_channels" (func $zero))
+  (export "codec_decoder_bits_per_sample" (func $zero))
+  (export "codec_decoder_minimum_block_frames" (func $zero))
+  (export "codec_decoder_maximum_block_frames" (func $zero))
+  (export "codec_decoder_total_frames_low" (func $zero))
+  (export "codec_decoder_total_frames_high" (func $zero))
+  (export "codec_decoder_total_frames_known" (func $zero))
+  (export "codec_decoder_streaminfo_frames_low" (func $zero))
+  (export "codec_decoder_streaminfo_frames_high" (func $zero))
+  (export "codec_decoder_streaminfo_frames_known" (func $zero))
+  (export "codec_decoder_md5_present" (func $zero))
+  (export "codec_decoder_decoded_frames_low" (func $zero))
+  (export "codec_decoder_decoded_frames_high" (func $zero))
+  (export "codec_decoder_decoded_bytes_low" (func $zero))
+  (export "codec_decoder_decoded_bytes_high" (func $zero))
+  (export "codec_decoder_callback_error" (func $zero))
+  (export "codec_decoder_state" (func $zero))
+  (export "codec_decoder_allocator_live_bytes" (func $zero))
+  (export "codec_decoder_allocator_peak_live_bytes" (func $zero))
+  (export "codec_decoder_allocator_peak_heap_bytes" (func $zero))
+  (export "codec_decoder_allocator_free_calls" (func $zero))
+  (export "codec_decoder_allocator_realloc_calls" (func $zero)))
diff --git a/test/fixtures/decoder-invalid-output.wat b/test/fixtures/decoder-invalid-output.wat
new file mode 100644
index 0000000..0f1b374
--- /dev/null
+++ b/test/fixtures/decoder-invalid-output.wat
@@ -0,0 +1,55 @@
+(module
+  (memory (export "memory") 32 32)
+  (func $void)
+  (func $zero (result i32) (i32.const 0))
+  (func $one (result i32) (i32.const 1))
+  (func $allocation (result i32) (i32.const 1024))
+  (func $rate (result i32) (i32.const 44100))
+  (func $two (result i32) (i32.const 2))
+  (func $sixteen (result i32) (i32.const 16))
+  (func $twentyFour (result i32) (i32.const 24))
+  (func $maxBlock (result i32) (i32.const 65535))
+  (func $negativeFrames (result i32) (i32.const -1))
+  (func $negativeLength (result i32) (i32.const -6))
+  (export "malloc" (func $allocation))
+  (export "free" (func $void))
+  (export "asyncify_start_unwind" (func $void))
+  (export "asyncify_stop_unwind" (func $void))
+  (export "asyncify_start_rewind" (func $void))
+  (export "asyncify_stop_rewind" (func $void))
+  (export "asyncify_get_state" (func $zero))
+  (export "codec_decoder_abi_version" (func $one))
+  (export "codec_decoder_new" (func $one))
+  (export "codec_decoder_init" (func $zero))
+  (export "codec_decoder_process_single" (func $one))
+  (export "codec_decoder_finish" (func $zero))
+  (export "codec_decoder_delete" (func $void))
+  (export "codec_decoder_output_ptr" (func $allocation))
+  (export "codec_decoder_output_length" (func $negativeLength))
+  (export "codec_decoder_output_frames" (func $negativeFrames))
+  (export "codec_decoder_output_frame_offset_low" (func $zero))
+  (export "codec_decoder_output_frame_offset_high" (func $zero))
+  (export "codec_decoder_release_output" (func $void))
+  (export "codec_decoder_sample_rate" (func $rate))
+  (export "codec_decoder_channels" (func $two))
+  (export "codec_decoder_bits_per_sample" (func $twentyFour))
+  (export "codec_decoder_minimum_block_frames" (func $sixteen))
+  (export "codec_decoder_maximum_block_frames" (func $maxBlock))
+  (export "codec_decoder_total_frames_low" (func $zero))
+  (export "codec_decoder_total_frames_high" (func $zero))
+  (export "codec_decoder_total_frames_known" (func $zero))
+  (export "codec_decoder_streaminfo_frames_low" (func $zero))
+  (export "codec_decoder_streaminfo_frames_high" (func $zero))
+  (export "codec_decoder_streaminfo_frames_known" (func $zero))
+  (export "codec_decoder_md5_present" (func $zero))
+  (export "codec_decoder_decoded_frames_low" (func $zero))
+  (export "codec_decoder_decoded_frames_high" (func $zero))
+  (export "codec_decoder_decoded_bytes_low" (func $zero))
+  (export "codec_decoder_decoded_bytes_high" (func $zero))
+  (export "codec_decoder_callback_error" (func $zero))
+  (export "codec_decoder_state" (func $zero))
+  (export "codec_decoder_allocator_live_bytes" (func $zero))
+  (export "codec_decoder_allocator_peak_live_bytes" (func $zero))
+  (export "codec_decoder_allocator_peak_heap_bytes" (func $zero))
+  (export "codec_decoder_allocator_free_calls" (func $zero))
+  (export "codec_decoder_allocator_realloc_calls" (func $zero)))
diff --git a/test/fixtures/decoder-stall.wat b/test/fixtures/decoder-stall.wat
new file mode 100644
index 0000000..10aa681
--- /dev/null
+++ b/test/fixtures/decoder-stall.wat
@@ -0,0 +1,55 @@
+(module
+  (memory (export "memory") 32 32)
+  (func $void)
+  (func $zero (result i32) (i32.const 0))
+  (func $one (result i32) (i32.const 1))
+  (func $allocation (result i32) (i32.const 1024))
+  (func $rate (result i32) (i32.const 44100))
+  (func $two (result i32) (i32.const 2))
+  (func $sixteen (result i32) (i32.const 16))
+  (func $twentyFour (result i32) (i32.const 24))
+  (func $maxBlock (result i32) (i32.const 65535))
+  (func $unusedNegativeFrames (result i32) (i32.const -1))
+  (func $unusedNegativeLength (result i32) (i32.const -6))
+  (export "malloc" (func $allocation))
+  (export "free" (func $void))
+  (export "asyncify_start_unwind" (func $void))
+  (export "asyncify_stop_unwind" (func $void))
+  (export "asyncify_start_rewind" (func $void))
+  (export "asyncify_stop_rewind" (func $void))
+  (export "asyncify_get_state" (func $zero))
+  (export "codec_decoder_abi_version" (func $one))
+  (export "codec_decoder_new" (func $one))
+  (export "codec_decoder_init" (func $zero))
+  (export "codec_decoder_process_single" (func $zero))
+  (export "codec_decoder_finish" (func $zero))
+  (export "codec_decoder_delete" (func $void))
+  (export "codec_decoder_output_ptr" (func $allocation))
+  (export "codec_decoder_output_length" (func $unusedNegativeLength))
+  (export "codec_decoder_output_frames" (func $unusedNegativeFrames))
+  (export "codec_decoder_output_frame_offset_low" (func $zero))
+  (export "codec_decoder_output_frame_offset_high" (func $zero))
+  (export "codec_decoder_release_output" (func $void))
+  (export "codec_decoder_sample_rate" (func $rate))
+  (export "codec_decoder_channels" (func $two))
+  (export "codec_decoder_bits_per_sample" (func $twentyFour))
+  (export "codec_decoder_minimum_block_frames" (func $sixteen))
+  (export "codec_decoder_maximum_block_frames" (func $maxBlock))
+  (export "codec_decoder_total_frames_low" (func $zero))
+  (export "codec_decoder_total_frames_high" (func $zero))
+  (export "codec_decoder_total_frames_known" (func $zero))
+  (export "codec_decoder_streaminfo_frames_low" (func $zero))
+  (export "codec_decoder_streaminfo_frames_high" (func $zero))
+  (export "codec_decoder_streaminfo_frames_known" (func $zero))
+  (export "codec_decoder_md5_present" (func $zero))
+  (export "codec_decoder_decoded_frames_low" (func $zero))
+  (export "codec_decoder_decoded_frames_high" (func $zero))
+  (export "codec_decoder_decoded_bytes_low" (func $zero))
+  (export "codec_decoder_decoded_bytes_high" (func $zero))
+  (export "codec_decoder_callback_error" (func $zero))
+  (export "codec_decoder_state" (func $zero))
+  (export "codec_decoder_allocator_live_bytes" (func $zero))
+  (export "codec_decoder_allocator_peak_live_bytes" (func $zero))
+  (export "codec_decoder_allocator_peak_heap_bytes" (func $zero))
+  (export "codec_decoder_allocator_free_calls" (func $zero))
+  (export "codec_decoder_allocator_realloc_calls" (func $zero)))
diff --git a/test/fixtures/encoder-delete-trap.wat b/test/fixtures/encoder-delete-trap.wat
new file mode 100644
index 0000000..ca59cd6
--- /dev/null
+++ b/test/fixtures/encoder-delete-trap.wat
@@ -0,0 +1,25 @@
+(module
+  (import "codec" "write" (func $write (param i64 i32 i32) (result i32)))
+  (import "codec" "seek" (func $seek (param i64) (result i32)))
+  (memory (export "memory") 256 256)
+  ;; Exact 86-byte empty output emitted by the pinned encoder for 8k mono PCM16.
+  (data (i32.const 1024)
+    "\66\4c\61\43\00\00\00\22\10\00\10\00\ff\ff\ff\00\00\00\01\f4\00\f0\00\00\00\00\d4\1d\8c\d9\8f\00\b2\04\e9\80\09\98\ec\f8\42\7e\84\00\00\28\20\00\00\00\72\65\66\65\72\65\6e\63\65\20\6c\69\62\46\4c\41\43\20\31\2e\35\2e\30\20\32\30\32\35\30\32\31\31\00\00\00\00")
+  (func $malloc (param i32) (result i32) (i32.const 2048))
+  (func $free (param i32))
+  (func $new (param i32 i32 i32 i32 i32) (result i32) (i32.const 256))
+  (func $init (param i32) (result i32)
+    (drop (call $write (i64.const 0) (i32.const 1024) (i32.const 86)))
+    (i32.const 0))
+  (func $process (param i32 i32 i32) (result i32) (i32.const 1))
+  (func $finish (param i32) (result i32) (i32.const 1))
+  (func $state (param i32) (result i32) (i32.const 0))
+  (func $delete (param i32) unreachable)
+  (export "malloc" (func $malloc))
+  (export "free" (func $free))
+  (export "codec_encoder_new" (func $new))
+  (export "codec_encoder_init" (func $init))
+  (export "codec_encoder_process_interleaved" (func $process))
+  (export "codec_encoder_finish" (func $finish))
+  (export "codec_encoder_state" (func $state))
+  (export "codec_encoder_delete" (func $delete)))
diff --git a/test/fixtures/encoder-invalid-allocation.wat b/test/fixtures/encoder-invalid-allocation.wat
new file mode 100644
index 0000000..58928a5
--- /dev/null
+++ b/test/fixtures/encoder-invalid-allocation.wat
@@ -0,0 +1,15 @@
+(module
+  (memory (export "memory") 256 256)
+  (func $void)
+  (func $zero (result i32) (i32.const 0))
+  (func $one (result i32) (i32.const 1))
+  (func $encoder (result i32) (i32.const 256))
+  (func $negative (result i32) (i32.const -4))
+  (export "malloc" (func $negative))
+  (export "free" (func $void))
+  (export "codec_encoder_new" (func $encoder))
+  (export "codec_encoder_init" (func $zero))
+  (export "codec_encoder_process_interleaved" (func $one))
+  (export "codec_encoder_finish" (func $one))
+  (export "codec_encoder_state" (func $zero))
+  (export "codec_encoder_delete" (func $void)))
diff --git a/test/fixtures/encoder-invalid-metadata-chain.wat b/test/fixtures/encoder-invalid-metadata-chain.wat
new file mode 100644
index 0000000..7dd4e95
--- /dev/null
+++ b/test/fixtures/encoder-invalid-metadata-chain.wat
@@ -0,0 +1,26 @@
+(module
+  (import "codec" "write" (func $write (param i64 i32 i32) (result i32)))
+  (import "codec" "seek" (func $seek (param i64) (result i32)))
+  (memory (export "memory") 256 256)
+  ;; A valid empty 8 kHz/mono/PCM16 STREAMINFO that declares another metadata
+  ;; block, but the backend never emits that block.
+  (data (i32.const 1024)
+    "\66\4c\61\43\00\00\00\22\10\00\10\00\00\00\00\00\00\00\01\f4\00\f0\00\00\00\00\d4\1d\8c\d9\8f\00\b2\04\e9\80\09\98\ec\f8\42\7e")
+  (func $malloc (param i32) (result i32) (i32.const 2048))
+  (func $free (param i32))
+  (func $new (param i32 i32 i32 i32 i32) (result i32) (i32.const 256))
+  (func $init (param i32) (result i32)
+    (drop (call $write (i64.const 0) (i32.const 1024) (i32.const 42)))
+    (i32.const 0))
+  (func $process (param i32 i32 i32) (result i32) (i32.const 1))
+  (func $finish (param i32) (result i32) (i32.const 1))
+  (func $state (param i32) (result i32) (i32.const 0))
+  (func $delete (param i32))
+  (export "malloc" (func $malloc))
+  (export "free" (func $free))
+  (export "codec_encoder_new" (func $new))
+  (export "codec_encoder_init" (func $init))
+  (export "codec_encoder_process_interleaved" (func $process))
+  (export "codec_encoder_finish" (func $finish))
+  (export "codec_encoder_state" (func $state))
+  (export "codec_encoder_delete" (func $delete)))
diff --git a/test/partition.test.ts b/test/partition.test.ts
new file mode 100644
index 0000000..41a3073
--- /dev/null
+++ b/test/partition.test.ts
@@ -0,0 +1,184 @@
+import { expect, test } from "bun:test";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+
+import {
+  decodeFlac,
+  encodeFlac,
+  PcmFormat,
+  type RandomAccessByteSink,
+} from "../src/index.js";
+import { FlacDecoderLive, FlacEncoderLive } from "../src/node.js";
+
+const format = new PcmFormat({
+  sampleRate: 44_100,
+  channels: 2,
+  bitsPerSample: 24,
+});
+
+// Small deterministic fixtures may be collected in tests; the codec itself streams.
+const encode = (
+  blocks: ReadonlyArray<Int32Array>,
+  frames: number,
+  pcmFormat = format,
+) => {
+  let output = new Uint8Array();
+  const sink: RandomAccessByteSink<never, never> = {
+    writeAt: (offset, bytes) =>
+      Effect.sync(() => {
+        const end = Number(offset) + bytes.byteLength;
+        if (end > output.byteLength) {
+          const grown = new Uint8Array(end);
+          grown.set(output);
+          output = grown;
+        }
+        output.set(bytes, Number(offset));
+      }),
+    resize: (size) =>
+      Effect.sync(() => {
+        output = output.slice(0, Number(size));
+      }),
+  };
+  return encodeFlac(Stream.fromIterable(blocks), sink, {
+    format: pcmFormat,
+    expectedFrames: BigInt(frames),
+  }).pipe(Effect.map((result) => ({ output, result })));
+};
+
+const canonical = (pcm: Int32Array, bits: 16 | 24 = 24) => {
+  const width = bits / 8;
+  const output = new Uint8Array(pcm.length * width);
+  for (let index = 0; index < pcm.length; index++) {
+    const value = pcm[index]!;
+    for (let byte = 0; byte < width; byte++)
+      output[index * width + byte] = (value >>> (byte * 8)) & 255;
+  }
+  return output;
+};
+
+test("silence, impulse, extrema, random, partial and empty vectors round-trip in every PCM shape", async () => {
+  await Effect.runPromise(
+    Effect.gen(function* () {
+      for (const channels of [1, 2] as const) {
+        for (const bitsPerSample of [16, 24] as const) {
+          const pcmFormat = new PcmFormat({
+            sampleRate: 44_100,
+            channels,
+            bitsPerSample,
+          });
+          const frames = 8193;
+          const pcm = new Int32Array(frames * channels);
+          const maximum = 2 ** (bitsPerSample - 1) - 1;
+          let state = 0x13579bdf;
+          // One constant-silence frame, a sparse impulse frame, and a partial tail.
+          for (let channel = 0; channel < channels; channel++) {
+            pcm[(4096 + channel * 17) * channels + channel] = maximum;
+            pcm[(4097 + channel * 17) * channels + channel] = -maximum - 1;
+          }
+          for (let index = 8176 * channels; index < pcm.length; index++) {
+            state = (Math.imul(state, 1664525) + 1013904223) | 0;
+            pcm[index] = state >> (32 - bitsPerSample);
+          }
+          const { output } = yield* encode(
+            [
+              pcm.subarray(0, 4096 * channels),
+              pcm.subarray(4096 * channels, 8192 * channels),
+              pcm.subarray(8192 * channels),
+            ],
+            frames,
+            pcmFormat,
+          );
+          const events = yield* decodeFlac(Stream.make(output), {
+            expectedFormat: pcmFormat,
+            expectedFrames: BigInt(frames),
+          }).pipe(Stream.runCollect);
+          const actual = Uint8Array.from(
+            events.flatMap((event) =>
+              event._tag === "Pcm" ? Array.from(event.bytes) : [],
+            ),
+          );
+          expect(actual).toEqual(canonical(pcm, bitsPerSample));
+          expect(events.at(-1)).toMatchObject({
+            _tag: "Complete",
+            frames: BigInt(frames),
+            md5Checked: true,
+            md5Verified: true,
+          });
+
+          const empty = yield* encode([], 0, pcmFormat);
+          const emptyEvents = yield* decodeFlac(Stream.make(empty.output), {
+            expectedFormat: pcmFormat,
+            expectedFrames: 0n,
+          }).pipe(Stream.runCollect);
+          expect(emptyEvents.map((event) => event._tag)).toEqual([
+            "Metadata",
+            "Complete",
+          ]);
+          expect(emptyEvents.at(-1)).toMatchObject({
+            _tag: "Complete",
+            frames: 0n,
+            bytes: 0n,
+            md5Checked: true,
+            md5Verified: true,
+          });
+        }
+      }
+    }).pipe(Effect.provide(FlacEncoderLive), Effect.provide(FlacDecoderLive)),
+  );
+});
+
+test("every legal two-part PCM boundary produces the same finalized FLAC", async () => {
+  const pcm = Int32Array.from({ length: 34 }, (_, index) =>
+    index % 2 === 0 ? index * 71_321 - 1_000_000 : 8_388_607 - index * 213_877,
+  );
+  await Effect.runPromise(
+    Effect.gen(function* () {
+      const reference = yield* encode([pcm], 17);
+      for (let boundary = 1; boundary < 17; boundary++) {
+        const actual = yield* encode(
+          [pcm.subarray(0, boundary * 2), pcm.subarray(boundary * 2)],
+          17,
+        );
+        expect(actual.output).toEqual(reference.output);
+        expect(actual.result).toEqual(reference.result);
+      }
+    }).pipe(Effect.provide(FlacEncoderLive)),
+  );
+});
+
+test("every encoded byte boundary preserves metadata, exact PCM, and completion", async () => {
+  const pcm = Int32Array.from({ length: 34 }, (_, index) =>
+    index % 3 === 0
+      ? -8_388_608
+      : index % 3 === 1
+        ? 8_388_607
+        : index * 471_239 - 8_000_000,
+  );
+  const expected = canonical(pcm);
+  await Effect.runPromise(
+    Effect.gen(function* () {
+      const { output } = yield* encode([pcm], 17);
+      const decode = (parts: ReadonlyArray<Uint8Array>) =>
+        decodeFlac(Stream.fromIterable(parts), {
+          expectedFormat: format,
+          expectedFrames: 17n,
+        }).pipe(Stream.runCollect);
+      const reference = yield* decode([output]);
+      expect(reference.map((event) => event._tag)).toEqual([
+        "Metadata",
+        "Pcm",
+        "Complete",
+      ]);
+      const event = reference[1]!;
+      expect(event._tag).toBe("Pcm");
+      if (event._tag === "Pcm") expect(event.bytes).toEqual(expected);
+      for (let boundary = 1; boundary < output.byteLength; boundary++) {
+        const actual = yield* decode([
+          output.subarray(0, boundary),
+          output.subarray(boundary),
+        ]);
+        expect(actual).toEqual(reference);
+      }
+    }).pipe(Effect.provide(FlacEncoderLive), Effect.provide(FlacDecoderLive)),
+  );
+});
diff --git a/test/resource-lifecycle.test.ts b/test/resource-lifecycle.test.ts
new file mode 100644
index 0000000..5f13d8e
--- /dev/null
+++ b/test/resource-lifecycle.test.ts
@@ -0,0 +1,509 @@
+import { beforeAll, describe, expect, test } from "bun:test";
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+
+import * as Cause from "effect/Cause";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import * as Stream from "effect/Stream";
+
+import { decodeFlac } from "../src/decode.js";
+import { FlacDecodeError } from "../src/decoder-errors.js";
+import {
+  FlacDecoder,
+  FLAC_DECODER_LIMITS,
+  loadFlacDecoderFromBytes,
+  type FlacDecoderService,
+} from "../src/decoder-wasm.js";
+import { encodeFlac, type RandomAccessByteSink } from "../src/encode.js";
+import { PcmFormat } from "../src/format.js";
+import {
+  instantiateDecoder,
+  type DecoderAbi,
+  type DecoderPhase,
+} from "../src/internal/decoder-abi.js";
+import {
+  FlacEncoder,
+  loadFlacEncoderFromBytes,
+  type FlacEncoderService,
+} from "../src/wasm.js";
+
+const BLOCK_FRAMES = 4_096;
+const BLOCK_COUNT = 96;
+const INPUT_FRAGMENT_PATTERN = [1, 31, 4_093, 65_521] as const;
+
+interface LongFixture {
+  readonly encoded: Uint8Array;
+  readonly format: PcmFormat;
+  readonly frames: number;
+  readonly pcmBytes: number;
+  readonly pcmSha256: string;
+}
+
+interface TrackedDecoder {
+  readonly abi: DecoderAbi;
+  readonly baselineLiveBytes: number;
+  decoder: number;
+  deleted: boolean;
+}
+
+interface AllocatorSample {
+  readonly liveBytes: number;
+  readonly peakLiveBytes: number;
+  readonly peakHeapBytes: number;
+  readonly memoryBytes: number;
+}
+
+let decoderService: FlacDecoderService;
+let fixture: LongFixture;
+
+const canonicalPcm24 = (samples: Int32Array): Uint8Array => {
+  const bytes = new Uint8Array(samples.length * 3);
+  for (let index = 0; index < samples.length; index += 1) {
+    const value = samples[index]!;
+    bytes[index * 3] = value;
+    bytes[index * 3 + 1] = value >> 8;
+    bytes[index * 3 + 2] = value >> 16;
+  }
+  return bytes;
+};
+
+const makeLongFixture = (
+  encoder: FlacEncoderService,
+): Effect.Effect<LongFixture, unknown> => {
+  const format = new PcmFormat({
+    sampleRate: 44_100,
+    channels: 2,
+    bitsPerSample: 24,
+  });
+  const block = new Int32Array(BLOCK_FRAMES * format.channels);
+  let random = 0x1234_5678;
+  for (let index = 0; index < block.length; index += 1) {
+    random ^= random << 13;
+    random ^= random >>> 17;
+    random ^= random << 5;
+    block[index] = random >> 8;
+  }
+  const canonicalBlock = canonicalPcm24(block);
+  const digest = createHash("sha256");
+  for (let index = 0; index < BLOCK_COUNT; index += 1)
+    digest.update(canonicalBlock);
+
+  const frames = BLOCK_FRAMES * BLOCK_COUNT;
+  const storage = new Uint8Array(frames * format.channels * 3 + 128 * 1_024);
+  let finalLength = 0;
+  const sink: RandomAccessByteSink<never, never> = {
+    writeAt: (offset, bytes) =>
+      Effect.sync(() => storage.set(bytes, Number(offset))),
+    resize: (length) =>
+      Effect.sync(() => {
+        finalLength = Number(length);
+      }),
+  };
+  const source = Stream.unfold(0, (index) =>
+    Effect.succeed(
+      index < BLOCK_COUNT ? ([block, index + 1] as const) : undefined,
+    ),
+  );
+  return encodeFlac(source, sink, {
+    format,
+    expectedFrames: BigInt(frames),
+  }).pipe(
+    Effect.provideService(FlacEncoder, encoder),
+    Effect.map(() => ({
+      encoded: storage.slice(0, finalLength),
+      format,
+      frames,
+      pcmBytes: canonicalBlock.byteLength * BLOCK_COUNT,
+      pcmSha256: digest.digest("hex"),
+    })),
+  );
+};
+
+const nextFragment = (
+  encoded: Uint8Array,
+): Effect.Effect<Uint8Array | null> => {
+  let offset = 0;
+  let fragment = 0;
+  return Effect.sync(() => {
+    if (offset === encoded.byteLength) return null;
+    const requested =
+      INPUT_FRAGMENT_PATTERN[fragment % INPUT_FRAGMENT_PATTERN.length]!;
+    const end = Math.min(offset + requested, encoded.byteLength);
+    const bytes = encoded.subarray(offset, end);
+    offset = end;
+    fragment += 1;
+    return bytes;
+  });
+};
+
+const fragmentedSource = (encoded: Uint8Array): Stream.Stream<Uint8Array> =>
+  Stream.unfold({ offset: 0, fragment: 0 }, ({ offset, fragment }) => {
+    if (offset === encoded.byteLength) return Effect.succeed(undefined);
+    const requested =
+      INPUT_FRAGMENT_PATTERN[fragment % INPUT_FRAGMENT_PATTERN.length]!;
+    const end = Math.min(offset + requested, encoded.byteLength);
+    return Effect.succeed([
+      encoded.subarray(offset, end),
+      { offset: end, fragment: fragment + 1 },
+    ] as const);
+  });
+
+const directFailure = (phase: DecoderPhase, result: number): FlacDecodeError =>
+  new FlacDecodeError({
+    reason: "invalid-stream",
+    phase,
+    detail: `direct pinned decoder returned ${result} during ${phase}`,
+  });
+
+const withTrackedDecoder = <A, E, R>(
+  use: (resource: TrackedDecoder) => Effect.Effect<A, E, R>,
+): Effect.Effect<A, E | FlacDecodeError, R> =>
+  Effect.acquireUseRelease(
+    instantiateDecoder(decoderService.module).pipe(
+      Effect.map((abi) => ({
+        abi,
+        baselineLiveBytes: abi.exports.codec_decoder_allocator_live_bytes(),
+        decoder: 0,
+        deleted: false,
+      })),
+    ),
+    use,
+    (resource) =>
+      Effect.sync(() => {
+        try {
+          resource.abi.normalize();
+          if (!resource.deleted && resource.decoder !== 0)
+            resource.abi.exports.codec_decoder_delete(resource.decoder);
+        } finally {
+          resource.deleted = true;
+          resource.decoder = 0;
+          resource.abi.dispose();
+        }
+      }),
+  );
+
+const createDecoder = (
+  resource: TrackedDecoder,
+  expectedFrames: number,
+): Effect.Effect<void, FlacDecodeError> =>
+  Effect.gen(function* () {
+    const decoder = resource.abi.exports.codec_decoder_new(
+      FLAC_DECODER_LIMITS.defaultMaxMetadataBytes,
+      fixture.format.sampleRate,
+      fixture.format.channels,
+      fixture.format.bitsPerSample,
+      expectedFrames >>> 0,
+      Math.floor(expectedFrames / 0x1_0000_0000),
+      1,
+      1,
+    );
+    if (
+      !Number.isSafeInteger(decoder) ||
+      decoder <= 0 ||
+      decoder >= resource.abi.exports.memory.buffer.byteLength
+    ) {
+      return yield* new FlacDecodeError({
+        reason: "allocation-failed",
+        phase: "instantiate",
+        detail: "direct pinned decoder allocation failed",
+      });
+    }
+    resource.decoder = decoder;
+  });
+
+const driveDecoder = (
+  resource: TrackedDecoder,
+  input: Effect.Effect<Uint8Array | null>,
+): Effect.Effect<
+  {
+    readonly frames: number;
+    readonly bytes: number;
+    readonly sha256: string;
+    readonly allocator: ReadonlyArray<AllocatorSample>;
+    readonly liveAfterDelete: number;
+    readonly freeCallsAfterDelete: number;
+  },
+  FlacDecodeError
+> =>
+  Effect.gen(function* () {
+    const { abi, decoder } = resource;
+    const initialized = yield* abi.invoke(
+      "metadata",
+      () => abi.exports.codec_decoder_init(decoder),
+      input,
+    );
+    if (initialized !== 0) return yield* directFailure("metadata", initialized);
+
+    const digest = createHash("sha256");
+    const allocator: Array<AllocatorSample> = [];
+    let frames = 0;
+    let bytes = 0;
+    let progressless = 0;
+    for (;;) {
+      const result = yield* abi.invoke(
+        "frame",
+        () => abi.exports.codec_decoder_process_single(decoder),
+        input,
+      );
+      if (result === 0) {
+        progressless += 1;
+        if (progressless > FLAC_DECODER_LIMITS.maxProgresslessCalls)
+          return yield* directFailure("frame", result);
+        continue;
+      }
+      progressless = 0;
+      if (result === 2) break;
+      if (result !== 1) return yield* directFailure("frame", result);
+
+      const outputLength = abi.exports.codec_decoder_output_length(decoder);
+      const outputFrames = abi.exports.codec_decoder_output_frames(decoder);
+      const outputPointer = abi.exports.codec_decoder_output_ptr(decoder);
+      if (
+        outputLength <= 0 ||
+        outputFrames <= 0 ||
+        outputPointer <= 0 ||
+        outputPointer > abi.exports.memory.buffer.byteLength - outputLength
+      ) {
+        return yield* directFailure("frame", -1);
+      }
+      digest.update(
+        new Uint8Array(abi.exports.memory.buffer, outputPointer, outputLength),
+      );
+      frames += outputFrames;
+      bytes += outputLength;
+      abi.exports.codec_decoder_release_output(decoder);
+      allocator.push({
+        liveBytes: abi.exports.codec_decoder_allocator_live_bytes(),
+        peakLiveBytes: abi.exports.codec_decoder_allocator_peak_live_bytes(),
+        peakHeapBytes: abi.exports.codec_decoder_allocator_peak_heap_bytes(),
+        memoryBytes: abi.exports.memory.buffer.byteLength,
+      });
+    }
+
+    const finished = yield* abi.invoke(
+      "finish",
+      () => abi.exports.codec_decoder_finish(decoder),
+      input,
+    );
+    if (finished !== 0) return yield* directFailure("finish", finished);
+    abi.exports.codec_decoder_delete(decoder);
+    resource.deleted = true;
+    resource.decoder = 0;
+    return {
+      frames,
+      bytes,
+      sha256: digest.digest("hex"),
+      allocator,
+      liveAfterDelete: abi.exports.codec_decoder_allocator_live_bytes(),
+      freeCallsAfterDelete: abi.exports.codec_decoder_allocator_free_calls(),
+    };
+  });
+
+beforeAll(async () => {
+  const [encoderBytes, decoderBytes] = await Promise.all([
+    readFile(new URL("../wasm/flac-encoder.wasm", import.meta.url)),
+    readFile(new URL("../wasm/flac-decoder.wasm", import.meta.url)),
+  ]);
+  const [encoder, decoder] = await Promise.all([
+    Effect.runPromise(loadFlacEncoderFromBytes(encoderBytes)),
+    Effect.runPromise(loadFlacDecoderFromBytes(decoderBytes)),
+  ]);
+  decoderService = decoder;
+  fixture = await Effect.runPromise(makeLongFixture(encoder));
+});
+
+describe("decoder resource lifecycle", () => {
+  test("keeps the actual pinned allocator steady during a long hash-only decode", async () => {
+    const result = await Effect.runPromise(
+      withTrackedDecoder((resource) =>
+        Effect.gen(function* () {
+          yield* createDecoder(resource, fixture.frames);
+          const decoded = yield* driveDecoder(
+            resource,
+            nextFragment(fixture.encoded),
+          );
+          return { resource, decoded };
+        }),
+      ),
+    );
+
+    expect(result.decoded.frames).toBe(fixture.frames);
+    expect(result.decoded.bytes).toBe(fixture.pcmBytes);
+    expect(result.decoded.sha256).toBe(fixture.pcmSha256);
+    expect(result.decoded.allocator.length).toBe(BLOCK_COUNT);
+    const warm = result.decoded.allocator[2]!;
+    for (const sample of result.decoded.allocator.slice(3)) {
+      expect(sample.liveBytes).toBeLessThanOrEqual(warm.liveBytes);
+      expect(sample.peakLiveBytes).toBe(warm.peakLiveBytes);
+      expect(sample.peakHeapBytes).toBe(warm.peakHeapBytes);
+      expect(sample.memoryBytes).toBe(FLAC_DECODER_LIMITS.wasmMemoryBytes);
+    }
+    expect(warm.peakLiveBytes).toBeLessThan(
+      FLAC_DECODER_LIMITS.wasmMemoryBytes,
+    );
+    expect(warm.peakHeapBytes).toBeLessThan(
+      FLAC_DECODER_LIMITS.wasmMemoryBytes,
+    );
+    expect(result.decoded.liveAfterDelete).toBe(
+      result.resource.baselineLiveBytes,
+    );
+    expect(
+      result.resource.abi.exports.codec_decoder_allocator_live_bytes(),
+    ).toBe(0);
+    expect(
+      result.resource.abi.exports.codec_decoder_allocator_free_calls(),
+    ).toBe(result.decoded.freeCallsAfterDelete + 1);
+  });
+
+  test("returns the actual pinned allocator to zero after truncated failure", async () => {
+    let observed: DecoderAbi | undefined;
+    const exit = await Effect.runPromise(
+      Effect.exit(
+        withTrackedDecoder((resource) =>
+          Effect.gen(function* () {
+            observed = resource.abi;
+            yield* createDecoder(resource, fixture.frames);
+            yield* driveDecoder(
+              resource,
+              nextFragment(
+                fixture.encoded.subarray(0, fixture.encoded.length - 1),
+              ),
+            );
+          }),
+        ),
+      ),
+    );
+    expect(Exit.isFailure(exit)).toBe(true);
+    if (Exit.isFailure(exit))
+      expect(Cause.squash(exit.cause)).toBeInstanceOf(FlacDecodeError);
+    expect(observed?.exports.codec_decoder_allocator_live_bytes()).toBe(0);
+  });
+
+  test("returns the actual pinned allocator to zero when input waiting is interrupted", async () => {
+    let observed: DecoderAbi | undefined;
+    const result = await Effect.runPromise(
+      Effect.gen(function* () {
+        const waiting = yield* Deferred.make<void>();
+        const exit = yield* Effect.exit(
+          withTrackedDecoder((resource) =>
+            Effect.gen(function* () {
+              observed = resource.abi;
+              yield* createDecoder(resource, fixture.frames);
+              let pulls = 0;
+              const input = Effect.suspend(() => {
+                pulls += 1;
+                return pulls === 1
+                  ? Effect.succeed(fixture.encoded.subarray(0, 42))
+                  : Effect.andThen(
+                      Deferred.succeed(waiting, undefined),
+                      Effect.never,
+                    );
+              });
+              const fiber = yield* Effect.forkChild(
+                resource.abi.invoke(
+                  "metadata",
+                  () =>
+                    resource.abi.exports.codec_decoder_init(resource.decoder),
+                  input,
+                ),
+              );
+              yield* Deferred.await(waiting);
+              yield* Fiber.interrupt(fiber);
+              return yield* Fiber.join(fiber);
+            }),
+          ),
+        );
+        return exit;
+      }),
+    );
+    expect(Exit.isFailure(result) && Cause.hasInterrupts(result.cause)).toBe(
+      true,
+    );
+    expect(observed?.exports.codec_decoder_allocator_live_bytes()).toBe(0);
+  });
+
+  test("finalizes public sources once after success, failure, and cancellation", async () => {
+    const finalizers = { success: 0, failure: 0, cancellation: 0 };
+    const successDigest = createHash("sha256");
+    let complete = false;
+    await Effect.runPromise(
+      decodeFlac(
+        fragmentedSource(fixture.encoded).pipe(
+          Stream.ensuring(
+            Effect.sync(() => {
+              finalizers.success += 1;
+            }),
+          ),
+        ),
+      ).pipe(
+        Stream.runForEach((event) =>
+          Effect.sync(() => {
+            if (event._tag === "Pcm") successDigest.update(event.bytes);
+            if (event._tag === "Complete") complete = true;
+          }),
+        ),
+        Effect.provideService(FlacDecoder, decoderService),
+      ),
+    );
+    expect(successDigest.digest("hex")).toBe(fixture.pcmSha256);
+    expect(complete).toBe(true);
+
+    const sourceFailure = new Error("lifecycle source failure");
+    const failed = await Effect.runPromise(
+      Effect.exit(
+        decodeFlac(
+          Stream.concat(
+            Stream.make(fixture.encoded.subarray(0, 42)),
+            Stream.fail(sourceFailure),
+          ).pipe(
+            Stream.ensuring(
+              Effect.sync(() => {
+                finalizers.failure += 1;
+              }),
+            ),
+          ),
+        ).pipe(
+          Stream.runDrain,
+          Effect.provideService(FlacDecoder, decoderService),
+        ),
+      ),
+    );
+    expect(Exit.isFailure(failed)).toBe(true);
+    if (Exit.isFailure(failed))
+      expect(Cause.squash(failed.cause)).toBe(sourceFailure);
+
+    const cancelled = await Effect.runPromise(
+      Effect.gen(function* () {
+        const waiting = yield* Deferred.make<void>();
+        const source = Stream.concat(
+          Stream.make(fixture.encoded.subarray(0, 42)),
+          Stream.fromEffect(
+            Effect.andThen(Deferred.succeed(waiting, undefined), Effect.never),
+          ),
+        ).pipe(
+          Stream.ensuring(
+            Effect.sync(() => {
+              finalizers.cancellation += 1;
+            }),
+          ),
+        );
+        const fiber = yield* Effect.forkChild(
+          decodeFlac(source).pipe(
+            Stream.runDrain,
+            Effect.provideService(FlacDecoder, decoderService),
+          ),
+        );
+        yield* Deferred.await(waiting);
+        yield* Fiber.interrupt(fiber);
+        return yield* Fiber.await(fiber);
+      }),
+    );
+    expect(
+      Exit.isFailure(cancelled) && Cause.hasInterrupts(cancelled.cause),
+    ).toBe(true);
+    expect(finalizers).toEqual({ success: 1, failure: 1, cancellation: 1 });
+  });
+});
diff --git a/test/types.test.ts b/test/types.test.ts
new file mode 100644
index 0000000..d083f7b
--- /dev/null
+++ b/test/types.test.ts
@@ -0,0 +1,92 @@
+import { expect, test } from "bun:test";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+
+import {
+  encodeFlac,
+  FlacEncodeError,
+  FlacEncoder,
+  PcmFormat,
+  PcmInputError,
+  type FlacEncodeResult,
+  type RandomAccessByteSink,
+} from "../src/index.js";
+
+class SourceError extends Data.TaggedError("SourceError") {}
+class SinkError extends Data.TaggedError("SinkError") {}
+class SourceRequirement extends Context.Service<
+  SourceRequirement,
+  { readonly pcm: Int32Array }
+>()("test/SourceRequirement") {}
+class SinkRequirement extends Context.Service<
+  SinkRequirement,
+  { readonly write: true }
+>()("test/SinkRequirement") {}
+
+const source = Stream.concat(
+  Stream.fromEffect(SourceRequirement.pipe(Effect.map(({ pcm }) => pcm))),
+  Stream.fail(new SourceError()),
+);
+const sink: RandomAccessByteSink<SinkError, SinkRequirement> = {
+  writeAt: () =>
+    SinkRequirement.pipe(Effect.flatMap(() => Effect.fail(new SinkError()))),
+  resize: () =>
+    SinkRequirement.pipe(Effect.flatMap(() => Effect.fail(new SinkError()))),
+};
+const operation = encodeFlac(source, sink, {
+  format: new PcmFormat({ sampleRate: 44_100, channels: 2, bitsPerSample: 24 }),
+});
+
+type Success<T> =
+  T extends Effect.Effect<infer A, unknown, unknown> ? A : never;
+type Failure<T> =
+  T extends Effect.Effect<unknown, infer E, unknown> ? E : never;
+type Requirements<T> =
+  T extends Effect.Effect<unknown, unknown, infer R> ? R : never;
+type Equal<A, B> =
+  (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2
+    ? (<T>() => T extends B ? 1 : 2) extends <T>() => T extends A ? 1 : 2
+      ? true
+      : false
+    : false;
+type Assert<T extends true> = T;
+
+type _Success = Assert<Equal<Success<typeof operation>, FlacEncodeResult>>;
+type _Failure = Assert<
+  Equal<
+    Failure<typeof operation>,
+    SourceError | SinkError | PcmInputError | FlacEncodeError
+  >
+>;
+type _Requirements = Assert<
+  Equal<
+    Requirements<typeof operation>,
+    SourceRequirement | SinkRequirement | FlacEncoder
+  >
+>;
+
+if (false) {
+  // @ts-expect-error channel count is constrained by the PcmFormat Schema
+  new PcmFormat({ sampleRate: 44_100, channels: 3, bitsPerSample: 24 });
+
+  // @ts-expect-error PCM input must use signed Int32Array blocks
+  encodeFlac(Stream.make(new Uint16Array()), sink, {
+    format: new PcmFormat({
+      sampleRate: 44_100,
+      channels: 2,
+      bitsPerSample: 16,
+    }),
+  });
+
+  // @ts-expect-error a random-access sink must implement final resize
+  const incompleteSink: RandomAccessByteSink<never, never> = {
+    writeAt: () => Effect.void,
+  };
+  void incompleteSink;
+}
+
+test("public encoder types retain caller failures and requirements", () => {
+  expect(operation).toBeDefined();
+});
diff --git a/tsconfig.build.json b/tsconfig.build.json
new file mode 100644
index 0000000..3ce2b0d
--- /dev/null
+++ b/tsconfig.build.json
@@ -0,0 +1,13 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "sourceMap": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["test", "scripts"]
+}
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 0000000..44609da
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022", "DOM"],
+    "strict": true,
+    "exactOptionalPropertyTypes": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noFallthroughCasesInSwitch": true,
+    "verbatimModuleSyntax": true,
+    "skipLibCheck": true,
+    "types": ["bun"]
+  },
+  "include": ["src/**/*.ts", "test/**/*.ts", "scripts/**/*.ts"]
+}
diff --git a/vendor/libflac-1.5.0/flac-1.5.0.tar.xz b/vendor/libflac-1.5.0/flac-1.5.0.tar.xz
new file mode 100644
index 0000000..78961a6
Binary files /dev/null and b/vendor/libflac-1.5.0/flac-1.5.0.tar.xz differ
diff --git a/vendor/licenses/compiler-rt.txt b/vendor/licenses/compiler-rt.txt
new file mode 100644
index 0000000..5a79a1b
--- /dev/null
+++ b/vendor/licenses/compiler-rt.txt
@@ -0,0 +1,311 @@
+==============================================================================
+The LLVM Project is under the Apache License v2.0 with LLVM Exceptions:
+==============================================================================
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+    1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+    2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+    3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+    4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+    5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+    6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+    7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+    8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+    9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+    END OF TERMS AND CONDITIONS
+
+    APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+    Copyright [yyyy] [name of copyright owner]
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+
+---- LLVM Exceptions to the Apache 2.0 License ----
+
+As an exception, if, as a result of your compiling your source code, portions
+of this Software are embedded into an Object form of such source code, you
+may redistribute such embedded portions in such Object form without complying
+with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
+
+In addition, if you combine or link compiled forms of this Software with
+software that is licensed under the GPLv2 ("Combined Software") and if a
+court of competent jurisdiction determines that the patent provision (Section
+3), the indemnity provision (Section 9) or other Section of the License
+conflicts with the conditions of the GPLv2, you may retroactively and
+prospectively choose to deem waived or otherwise exclude such Section(s) of
+the License, but only in their entirety and only with respect to the Combined
+Software.
+
+==============================================================================
+Software from third parties included in the LLVM Project:
+==============================================================================
+The LLVM Project contains third party software which is under different license
+terms. All such code will be identified clearly using at least one of two
+mechanisms:
+1) It will be in a separate directory tree with its own `LICENSE.txt` or
+   `LICENSE` file at the top containing the specific license and restrictions
+   which apply to that software, or
+2) It will contain specific license and restriction terms at the top of every
+   file.
+
+==============================================================================
+Legacy LLVM License (https://llvm.org/docs/DeveloperPolicy.html#legacy):
+==============================================================================
+
+The compiler_rt library is dual licensed under both the University of Illinois
+"BSD-Like" license and the MIT license.  As a user of this code you may choose
+to use it under either license.  As a contributor, you agree to allow your code
+to be used under both.
+
+Full text of the relevant licenses is included below.
+
+==============================================================================
+
+University of Illinois/NCSA
+Open Source License
+
+Copyright (c) 2009-2019 by the contributors listed in CREDITS.TXT
+
+All rights reserved.
+
+Developed by:
+
+    LLVM Team
+
+    University of Illinois at Urbana-Champaign
+
+    http://llvm.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal with
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimers.
+
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimers in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the names of the LLVM Team, University of Illinois at
+      Urbana-Champaign, nor the names of its contributors may be used to
+      endorse or promote products derived from this Software without specific
+      prior written permission.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
+SOFTWARE.
+
+==============================================================================
+
+Copyright (c) 2009-2015 by the contributors listed in CREDITS.TXT
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/licenses/emscripten.txt b/vendor/licenses/emscripten.txt
new file mode 100644
index 0000000..3a9b104
--- /dev/null
+++ b/vendor/licenses/emscripten.txt
@@ -0,0 +1,101 @@
+Emscripten is available under 2 licenses, the MIT license and the
+University of Illinois/NCSA Open Source License.
+
+Both are permissive open source licenses, with little if any
+practical difference between them.
+
+The reason for offering both is that (1) the MIT license is
+well-known, while (2) the University of Illinois/NCSA Open Source
+License allows Emscripten's code to be integrated upstream into
+LLVM, which uses that license, should the opportunity arise.
+
+The full text of both licenses follows.
+
+==============================================================================
+
+Copyright (c) 2010-2014 Emscripten authors, see AUTHORS file.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+==============================================================================
+
+Copyright (c) 2010-2014 Emscripten authors, see AUTHORS file.
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal with the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+    Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimers.
+
+    Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimers
+    in the documentation and/or other materials provided with the
+    distribution.
+
+    Neither the names of Mozilla,
+    nor the names of its contributors may be used to endorse
+    or promote products derived from this Software without specific prior
+    written permission.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE SOFTWARE.
+
+==============================================================================
+
+This program uses portions of Node.js source code located in src/library_path.js,
+in accordance with the terms of the MIT license. Node's license follows:
+
+    """
+        Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to
+        deal in the Software without restriction, including without limitation the
+        rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+        sell copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+
+        The above copyright notice and this permission notice shall be included in
+        all copies or substantial portions of the Software.
+
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+        FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+        IN THE SOFTWARE.
+    """
+
+The musl libc project is bundled in this repo, and it has the MIT license, see
+system/lib/libc/musl/COPYRIGHT
+
+The third_party/ subdirectory contains code with other licenses. None of it is
+used by default, but certain options use it (e.g., the optional closure compiler
+flag will run closure compiler from third_party/).
diff --git a/vendor/licenses/libFLAC.txt b/vendor/licenses/libFLAC.txt
new file mode 100644
index 0000000..f42f48b
--- /dev/null
+++ b/vendor/licenses/libFLAC.txt
@@ -0,0 +1,29 @@
+Copyright (C) 2000-2009  Josh Coalson
+Copyright (C) 2011-2025  Xiph.Org Foundation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+- Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+- Neither the name of the Xiph.Org Foundation nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/licenses/musl.txt b/vendor/licenses/musl.txt
new file mode 100644
index 0000000..2f15edc
--- /dev/null
+++ b/vendor/licenses/musl.txt
@@ -0,0 +1,193 @@
+musl as a whole is licensed under the following standard MIT license:
+
+----------------------------------------------------------------------
+Copyright © 2005-2020 Rich Felker, et al.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+----------------------------------------------------------------------
+
+Authors/contributors include:
+
+A. Wilcox
+Ada Worcester
+Alex Dowad
+Alex Suykov
+Alexander Monakov
+Andre McCurdy
+Andrew Kelley
+Anthony G. Basile
+Aric Belsito
+Arvid Picciani
+Bartosz Brachaczek
+Benjamin Peterson
+Bobby Bingham
+Boris Brezillon
+Brent Cook
+Chris Spiegel
+Clément Vasseur
+Daniel Micay
+Daniel Sabogal
+Daurnimator
+David Carlier
+David Edelsohn
+Denys Vlasenko
+Dmitry Ivanov
+Dmitry V. Levin
+Drew DeVault
+Emil Renner Berthing
+Fangrui Song
+Felix Fietkau
+Felix Janda
+Gianluca Anzolin
+Hauke Mehrtens
+He X
+Hiltjo Posthuma
+Isaac Dunham
+Jaydeep Patil
+Jens Gustedt
+Jeremy Huntwork
+Jo-Philipp Wich
+Joakim Sindholt
+John Spencer
+Julien Ramseier
+Justin Cormack
+Kaarle Ritvanen
+Khem Raj
+Kylie McClain
+Leah Neukirchen
+Luca Barbato
+Luka Perkov
+Lynn Ochs
+M Farkas-Dyck (Strake)
+Mahesh Bodapati
+Markus Wichmann
+Masanori Ogino
+Michael Clark
+Michael Forney
+Mikhail Kremnyov
+Natanael Copa
+Nicholas J. Kain
+orc
+Pascal Cuoq
+Patrick Oppenlander
+Petr Hosek
+Petr Skocik
+Pierre Carrier
+Reini Urban
+Rich Felker
+Richard Pennington
+Ryan Fairfax
+Samuel Holland
+Segev Finer
+Shiz
+sin
+Solar Designer
+Stefan Kristiansson
+Stefan O'Rear
+Szabolcs Nagy
+Timo Teräs
+Trutz Behn
+Will Dietz
+William Haddon
+William Pitcock
+
+Portions of this software are derived from third-party works licensed
+under terms compatible with the above MIT license:
+
+The TRE regular expression implementation (src/regex/reg* and
+src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
+under a 2-clause BSD license (license text in the source files). The
+included version has been heavily modified by Rich Felker in 2012, in
+the interests of size, simplicity, and namespace cleanliness.
+
+Much of the math library code (src/math/* and src/complex/*) is
+Copyright © 1993,2004 Sun Microsystems or
+Copyright © 2003-2011 David Schultz or
+Copyright © 2003-2009 Steven G. Kargl or
+Copyright © 2003-2009 Bruce D. Evans or
+Copyright © 2008 Stephen L. Moshier or
+Copyright © 2017-2018 Arm Limited
+and labelled as such in comments in the individual source files. All
+have been licensed under extremely permissive terms.
+
+The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
+The Android Open Source Project and is licensed under a two-clause BSD
+license. It was taken from Bionic libc, used on Android.
+
+The AArch64 memcpy and memset code (src/string/aarch64/*) are
+Copyright © 1999-2019, Arm Limited.
+
+The implementation of DES for crypt (src/crypt/crypt_des.c) is
+Copyright © 1994 David Burren. It is licensed under a BSD license.
+
+The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
+originally written by Solar Designer and placed into the public
+domain. The code also comes with a fallback permissive license for use
+in jurisdictions that may not recognize the public domain.
+
+The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
+Lynn Ochs and is licensed under an MIT-style license.
+
+The x86_64 port was written by Nicholas J. Kain and is licensed under
+the standard MIT terms.
+
+The mips and microblaze ports were originally written by Richard
+Pennington for use in the ellcc project. The original code was adapted
+by Rich Felker for build system and code conventions during upstream
+integration. It is licensed under the standard MIT terms.
+
+The mips64 port was contributed by Imagination Technologies and is
+licensed under the standard MIT terms.
+
+The powerpc port was also originally written by Richard Pennington,
+and later supplemented and integrated by John Spencer. It is licensed
+under the standard MIT terms.
+
+All other files which have no copyright comments are original works
+produced specifically for use as part of this library, written either
+by Rich Felker, the main author of the library, or by one or more
+contibutors listed above. Details on authorship of individual files
+can be found in the git version control history of the project. The
+omission of copyright and license comments in each file is in the
+interest of source tree size.
+
+In addition, permission is hereby granted for all public header files
+(include/* and arch/*/bits/*) and crt files intended to be linked into
+applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
+the copyright notice and permission notice otherwise required by the
+license, and to use these files without any requirement of
+attribution. These files include substantial contributions from:
+
+Bobby Bingham
+John Spencer
+Nicholas J. Kain
+Rich Felker
+Richard Pennington
+Stefan Kristiansson
+Szabolcs Nagy
+
+all of whom have explicitly granted such permission.
+
+This file previously contained text expressing a belief that most of
+the files covered by the above exception were sufficiently trivial not
+to be subject to copyright, resulting in confusion over whether it
+negated the permissions granted in the license. In the spirit of
+permissive licensing, and of not having licensing issues being an
+obstacle to adoption, that text has been removed.
diff --git a/wasm/flac-decoder.manifest.json b/wasm/flac-decoder.manifest.json
new file mode 100644
index 0000000..ecca467
--- /dev/null
+++ b/wasm/flac-decoder.manifest.json
@@ -0,0 +1,107 @@
+{
+  "asset": "flac-decoder.wasm",
+  "assetSha256": "5e282f9874ecb3f49b8ee8437efc318ec14ef5cff5b7580da9d875f94e5c5925",
+  "libflac": {
+    "version": "1.5.0",
+    "archive": "vendor/libflac-1.5.0/flac-1.5.0.tar.xz",
+    "archiveSha256": "f2c1c76592a82ffff8413ba3c4a1299b6c7ab06c734dee03fd88630485c2b920"
+  },
+  "sources": {
+    "wrapper": "native/decoder.c",
+    "wrapperSha256": "9063ad212a83f506ada7caaefdf47ebad4d34d2744f8a0628c722bf3ffec8743",
+    "runtime": "native/decoder-runtime.c",
+    "runtimeSha256": "13fdff77ed97c94a84f9a2f28433c694aa82184c147a2acf7eb6e4f019675e22"
+  },
+  "emscripten": {
+    "version": "6.0.9",
+    "compilerCommit": "4e4223852a0835923411059a3929907d7df1232e",
+    "sdkTagCommit": "5eb0bde7585670252e8ba05e9d361627bffd08b5",
+    "sdkReleasesCommit": "f04ea239d533260dd1db760dd2d668d5f9a88d6b",
+    "wasmOptVersion": "wasm-opt version 132 (version_132-49-gd03c25ea4)"
+  },
+  "build": {
+    "initialMemoryBytes": 2097152,
+    "maximumMemoryBytes": 2097152,
+    "stackBytes": 65536,
+    "asyncifyStackBytes": 65536,
+    "filesystem": false,
+    "memoryGrowth": false,
+    "imports": [
+      "codec.read:function"
+    ],
+    "exports": [
+      "asyncify_get_state:function",
+      "asyncify_start_rewind:function",
+      "asyncify_start_unwind:function",
+      "asyncify_stop_rewind:function",
+      "asyncify_stop_unwind:function",
+      "codec_decoder_abi_version:function",
+      "codec_decoder_allocator_free_calls:function",
+      "codec_decoder_allocator_live_bytes:function",
+      "codec_decoder_allocator_peak_heap_bytes:function",
+      "codec_decoder_allocator_peak_live_bytes:function",
+      "codec_decoder_allocator_realloc_calls:function",
+      "codec_decoder_bits_per_sample:function",
+      "codec_decoder_callback_error:function",
+      "codec_decoder_channels:function",
+      "codec_decoder_decoded_bytes_high:function",
+      "codec_decoder_decoded_bytes_low:function",
+      "codec_decoder_decoded_frames_high:function",
+      "codec_decoder_decoded_frames_low:function",
+      "codec_decoder_delete:function",
+      "codec_decoder_finish:function",
+      "codec_decoder_init:function",
+      "codec_decoder_maximum_block_frames:function",
+      "codec_decoder_md5_present:function",
+      "codec_decoder_minimum_block_frames:function",
+      "codec_decoder_new:function",
+      "codec_decoder_output_frame_offset_high:function",
+      "codec_decoder_output_frame_offset_low:function",
+      "codec_decoder_output_frames:function",
+      "codec_decoder_output_length:function",
+      "codec_decoder_output_ptr:function",
+      "codec_decoder_process_single:function",
+      "codec_decoder_release_output:function",
+      "codec_decoder_sample_rate:function",
+      "codec_decoder_state:function",
+      "codec_decoder_streaminfo_frames_high:function",
+      "codec_decoder_streaminfo_frames_known:function",
+      "codec_decoder_streaminfo_frames_low:function",
+      "codec_decoder_total_frames_high:function",
+      "codec_decoder_total_frames_known:function",
+      "codec_decoder_total_frames_low:function",
+      "free:function",
+      "malloc:function",
+      "memory:memory"
+    ],
+    "libflacUnits": [
+      "bitmath",
+      "bitreader",
+      "cpu",
+      "crc",
+      "fixed",
+      "format",
+      "lpc",
+      "md5",
+      "memory",
+      "stream_decoder"
+    ],
+    "compilerFlags": [
+      "-O3",
+      "-ffreestanding",
+      "-fno-builtin",
+      "-DFLAC__NO_DLL",
+      "-DHAVE_CONFIG_H"
+    ],
+    "linkerPolicy": {
+      "allowedUndefinedSymbols": [
+        "codec_read"
+      ],
+      "noEntry": true,
+      "stripAll": true
+    },
+    "asyncifyImports": [
+      "codec.read"
+    ]
+  }
+}
diff --git a/wasm/flac-decoder.wasm b/wasm/flac-decoder.wasm
new file mode 100644
index 0000000..62abfe6
Binary files /dev/null and b/wasm/flac-decoder.wasm differ
diff --git a/wasm/flac-encoder.manifest.json b/wasm/flac-encoder.manifest.json
new file mode 100644
index 0000000..22549a0
--- /dev/null
+++ b/wasm/flac-encoder.manifest.json
@@ -0,0 +1,110 @@
+{
+  "asset": "flac-encoder.wasm",
+  "assetSha256": "90da75c73784e7184ea6c27d3ea9509f74df2eda405d8ddc8f964d78a16a273e",
+  "libflac": {
+    "version": "1.5.0",
+    "archive": "vendor/libflac-1.5.0/flac-1.5.0.tar.xz",
+    "archiveSha256": "f2c1c76592a82ffff8413ba3c4a1299b6c7ab06c734dee03fd88630485c2b920",
+    "patch": "native/libflac-stream-only.patch",
+    "patchSha256": "1fd807633c0ff8fc8ecca50225df49749ef1286f4a9796ce8ea7303f76143ffe"
+  },
+  "sources": {
+    "wrapper": "native/encoder.c",
+    "wrapperSha256": "51468fc2376a9cf70c5b95ee8d6596b12c2ec3806e8036db3617f089a298c5b5"
+  },
+  "emscripten": {
+    "version": "6.0.9",
+    "compilerCommit": "4e4223852a0835923411059a3929907d7df1232e",
+    "sdkTagCommit": "5eb0bde7585670252e8ba05e9d361627bffd08b5",
+    "sdkReleasesCommit": "f04ea239d533260dd1db760dd2d668d5f9a88d6b",
+    "wasmOptVersion": "wasm-opt version 132 (version_132-49-gd03c25ea4)"
+  },
+  "build": {
+    "initialMemoryBytes": 16777216,
+    "maximumMemoryBytes": 16777216,
+    "stackBytes": 262144,
+    "filesystem": false,
+    "memoryGrowth": false,
+    "imports": [
+      "codec.seek:function",
+      "codec.write:function"
+    ],
+    "exports": [
+      "__em_lib_deps__em_malloc_deps:global",
+      "codec_encoder_delete:function",
+      "codec_encoder_finish:function",
+      "codec_encoder_init:function",
+      "codec_encoder_new:function",
+      "codec_encoder_process_interleaved:function",
+      "codec_encoder_state:function",
+      "free:function",
+      "malloc:function",
+      "memory:memory"
+    ],
+    "libflacUnits": [
+      "bitmath",
+      "bitreader",
+      "bitwriter",
+      "cpu",
+      "crc",
+      "fixed",
+      "float",
+      "format",
+      "lpc",
+      "md5",
+      "memory",
+      "stream_decoder",
+      "stream_encoder",
+      "stream_encoder_framing",
+      "window"
+    ],
+    "muslUnits": [
+      "string/memcpy",
+      "string/memmove",
+      "string/memset",
+      "string/memcmp",
+      "string/strcmp",
+      "string/strlen",
+      "stdlib/abs",
+      "stdlib/qsort",
+      "stdlib/qsort_nr",
+      "math/log",
+      "math/log_data",
+      "math/exp",
+      "math/exp_data",
+      "math/frexp",
+      "math/lround",
+      "math/round",
+      "math/floor",
+      "math/cosf",
+      "math/fabs",
+      "math/fabsf",
+      "math/scalbn",
+      "math/__cosdf",
+      "math/__sindf",
+      "math/__rem_pio2f",
+      "math/__rem_pio2_large",
+      "math/__math_uflow",
+      "math/__math_oflow",
+      "math/__math_divzero",
+      "math/__math_invalid",
+      "math/__math_xflow"
+    ],
+    "compilerFlags": [
+      "-O3",
+      "-ffreestanding",
+      "-fno-builtin",
+      "-DFLAC__NO_DLL",
+      "-DHAVE_CONFIG_H",
+      "-DCODEC_STREAM_ONLY=1"
+    ],
+    "linkerPolicy": {
+      "allowedUndefinedSymbols": [
+        "codec_seek",
+        "codec_write"
+      ],
+      "noEntry": true,
+      "stripAll": true
+    }
+  }
+}
diff --git a/wasm/flac-encoder.wasm b/wasm/flac-encoder.wasm
new file mode 100644
index 0000000..1269e21
Binary files /dev/null and b/wasm/flac-encoder.wasm differ