diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 0206546..993d9da 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -39,8 +39,12 @@ jobs:
       - name: Pytest Validation
         uses: i2mint/isee/actions/pytest-validation@master
         with:
-          root-dir: ${{ env.PROJECT_NAME }}
-          paths-to-ignore: examples,scrap
+          # Repo root, not the package dir: `test_recode.py` lives at the top level, so
+          # with root-dir=recode the action's `find` never reached it and the test suite
+          # had never once run in CI (25 doctests collected, 0 tests). Widening it here
+          # is what makes the wav-parsing regression guards actually gate a merge.
+          root-dir: .
+          paths-to-ignore: notebooks,setup.py
 
   publish:
     name: Publish
diff --git a/recode/audio.py b/recode/audio.py
index 532cfcc..9bf7268 100644
--- a/recode/audio.py
+++ b/recode/audio.py
@@ -36,6 +36,8 @@
 
 """
 
+import struct
+import warnings
 from io import BytesIO
 from typing import Union
 from collections.abc import Iterable
@@ -112,16 +114,32 @@ def decode_pcm_bytes(pcm_bytes: bytes, width: Width = 2, n_channels: int = 1):
     return decode(pcm_bytes)
 
 
-MIN_WAV_N_BYTES = 44
+_RIFF_HEADER_SIZE = 12  # 'RIFF' + form size + 'WAVE'
+_CHUNK_HEADER_SIZE = 8  # chunk id + chunk size
+_CHUNK_ID_SIZE = 4
+
+
+class ShortWavData(UserWarning):
+    """The `data` chunk carries fewer bytes than its own header declares.
+
+    Raised as a warning rather than an error because the audio that *is* present is
+    still worth decoding -- a partially downloaded file, or one written to a stream
+    whose length was never patched back into the header. What must not happen is for
+    the shortfall to pass unmentioned, since the caller cannot otherwise tell a
+    truncated file from a complete one.
+    """
 
 
 def decode_wav_bytes(wav_bytes: bytes):
-    r"""
+    r"""Decode WAV bytes into a ``(waveform, sample_rate)`` pair.
 
-    :param width: The width of a sample (in bits, bytes, numpy dtype, pyaudio ...)
-        (Will try to figure it out)
-    :param n_channels: Number of channels
-    :return: The decoded waveform
+    :param wav_bytes: The bytes of a RIFF/WAVE container holding uncompressed PCM
+    :return: ``(wf, sr)`` -- the decoded waveform and its sample rate
+
+    :raises ValueError: if `wav_bytes` is not a RIFF/WAVE container with a `data`
+        chunk. (Before recode#4 the same inputs raised `AssertionError`, `wave.Error`
+        or `EOFError` depending on how they were malformed; they are unified here.)
+    :raises ShortWavData: *warning*, not an exception -- see below.
 
     >>> wav_bytes = (
     ...     b'RIFF.\x00\x00\x00WAVEfmt \x10\x00\x00\x00\x01\x00\x01\x00'  # header
@@ -133,30 +151,193 @@ def decode_wav_bytes(wav_bytes: bytes):
     [0, 1, -1, 2, -2]
     >>> sr
     42
+
+    The `data` chunk is located by walking the RIFF structure, so chunks that sit
+    *after* the audio -- `LIST`/`INFO` metadata, which ffmpeg, Audacity and iTunes
+    all append -- do not shift the waveform:
+
+    >>> import struct
+    >>> info = b'INFOISFT' + struct.pack('<I', 6) + b'Lavf58'
+    >>> with_trailing_metadata = wav_bytes + b'LIST' + struct.pack('<I', len(info)) + info
+    >>> decode_wav_bytes(with_trailing_metadata)[0]
+    [0, 1, -1, 2, -2]
+
+    A file carrying less audio than its header declares decodes to the whole frames
+    that are actually there, and says so:
+
+    >>> truncated = wav_bytes[:-4]
+    >>> import warnings
+    >>> with warnings.catch_warnings(record=True) as caught:
+    ...     _ = warnings.simplefilter('always')
+    ...     wf, sr = decode_wav_bytes(truncated)
+    >>> wf
+    [0, 1, -1]
+    >>> caught[0].category.__name__
+    'ShortWavData'
     """
+    offset, size = _wav_data_chunk(wav_bytes)
     meta = decode_wav_header_bytes(wav_bytes)
-    header_size = header_size_of_wav_bytes(wav_bytes, meta)
+    # Decoding is defined on whole frames, and a frame is every channel's sample: a
+    # file cut mid-frame drops the remainder rather than raising a struct-size error.
+    frame_size = int(meta["n_channels"] * meta["width_bytes"])
+    if frame_size:
+        size -= size % frame_size
+        if size // frame_size < meta["nframes"]:
+            warnings.warn(
+                f"WAV `data` chunk is short: the header declares {meta['nframes']} "
+                f"frames, {size // frame_size} are present. Decoding what is there.",
+                ShortWavData,
+                stacklevel=2,
+            )
+    if size == 0:
+        # No whole frame survived. Answering with an empty waveform is the consistent
+        # reading of "decode the frames that are present"; letting it through would
+        # surface as an IndexError from inside the chunked decoder instead.
+        return [], meta["sr"]
     wf = decode_pcm_bytes(
-        wav_bytes[header_size:],
+        wav_bytes[offset : offset + size],
         width=meta["width_bytes"],
         n_channels=meta["n_channels"],
     )
     return wf, meta["sr"]
 
 
-def header_size_of_wav_bytes(wav_bytes: bytes, meta: dict = None):
-    """Compute the header size"""
-    if meta is None:
-        meta = decode_wav_header_bytes(wav_bytes)
-    # the header tells us how many samples (frames) of data there are, how many
-    # channels, and how many bytes each sample (frame) takes, so the header size is
-    # the total size (number of bytes), minus the product of those three quantities
-    data_size = int(meta["n_channels"] * meta["width_bytes"] * meta["nframes"])
-    header_size = len(wav_bytes) - data_size
-    assert (
-        header_size >= MIN_WAV_N_BYTES
-    ), f"Header size of wav bytes should be at least 44 bytes"
-    return header_size
+def _wav_data_chunk(wav_bytes: bytes) -> tuple:
+    r"""Locate the audio payload: ``(offset, size)`` of the `data` chunk's contents.
+
+    Walks the RIFF chunk list rather than inferring the position arithmetically, which
+    is what makes it robust to the shapes real-world WAV files take that a
+    size-subtraction cannot survive (recode#4):
+
+    - **chunks after `data`.** `LIST`/`INFO` tags are routinely appended by encoders.
+      Deriving the header size as ``len(wav_bytes) - n_channels * width * nframes``
+      silently counts those trailing bytes as header, so the waveform is read from too
+      far in -- returning audio of the right *length* and the wrong *content*, with no
+      error raised.
+    - **an over-declared `data` size.** Files written to a stream (length unknown at
+      write time, patched afterwards -- or never) declare more samples than they carry,
+      commonly with the sentinel ``0xFFFFFFFF``. The size is clamped to what is really
+      there instead of asserting.
+
+    Those two interact, and naively clamping an over-declared size to end-of-file
+    would re-create the very bug this function exists to kill -- a trailing `LIST`
+    would be handed back as audio. So when the declared size overruns, the payload is
+    bounded by the next chunk that the remainder of the file parses cleanly from,
+    rather than by EOF. Only when no such boundary exists does it fall back to EOF.
+
+    Sizes are read as unsigned little-endian, per the RIFF spec.
+
+    >>> import struct, wave, io
+    >>> b = io.BytesIO()
+    >>> with wave.open(b, 'wb') as w:
+    ...     _ = w.setnchannels(1), w.setsampwidth(2), w.setframerate(8000)
+    ...     w.writeframes(struct.pack('<3h', 1, 2, 3))
+    >>> raw = b.getvalue()
+    >>> offset, size = _wav_data_chunk(raw)
+    >>> size
+    6
+    >>> raw[offset:offset + size] == struct.pack('<3h', 1, 2, 3)
+    True
+
+    An over-declared size does not swallow what follows the audio:
+
+    >>> broken = bytearray(raw)
+    >>> at = broken.find(b'data')
+    >>> broken[at + 4:at + 8] = struct.pack('<I', 0xFFFFFFFF)  # stream sentinel
+    >>> trailing = b'LIST' + struct.pack('<I', 4) + b'INFO'
+    >>> _wav_data_chunk(bytes(broken) + trailing)
+    (44, 6)
+    """
+    if (
+        len(wav_bytes) < _RIFF_HEADER_SIZE
+        or wav_bytes[:4] != b"RIFF"
+        or wav_bytes[8:12] != b"WAVE"
+    ):
+        raise ValueError(
+            "Not WAV bytes: expected a RIFF/WAVE container, got "
+            f"{bytes(wav_bytes[:4])!r}...{bytes(wav_bytes[8:12])!r}"
+        )
+    pos = _RIFF_HEADER_SIZE
+    while pos + _CHUNK_HEADER_SIZE <= len(wav_bytes):
+        chunk_id = bytes(wav_bytes[pos : pos + _CHUNK_ID_SIZE])
+        (declared,) = struct.unpack(
+            "<I", wav_bytes[pos + _CHUNK_ID_SIZE : pos + _CHUNK_HEADER_SIZE]
+        )
+        contents = pos + _CHUNK_HEADER_SIZE
+        if chunk_id == b"data":
+            available = len(wav_bytes) - contents
+            if declared <= available:
+                return contents, declared
+            return contents, _payload_end_of_overrunning_data(wav_bytes, contents)
+        # RIFF chunks are word-aligned: an odd-sized chunk carries a pad byte.
+        pos = contents + declared + (declared % 2)
+        if declared > len(wav_bytes) - contents:
+            raise ValueError(
+                f"Not WAV bytes: chunk walk desynced at offset {pos - declared - 8} "
+                f"({chunk_id!r} declares {declared} bytes but only "
+                f"{len(wav_bytes) - contents} remain); no `data` chunk reachable"
+            )
+    raise ValueError("Not WAV bytes: no `data` chunk found")
+
+
+def _payload_end_of_overrunning_data(wav_bytes: bytes, contents: int) -> int:
+    """How many bytes of audio a `data` chunk whose declared size overruns really has.
+
+    The declared size is unusable, so the extent has to come from the file itself: the
+    audio runs until the next thing that is demonstrably a chunk, meaning a position
+    (word-aligned, as RIFF requires) from which the rest of the buffer parses as a
+    well-formed chunk list ending exactly at EOF. Requiring the parse to reach EOF is
+    what keeps this from firing on audio that merely happens to contain four
+    plausible-looking bytes.
+
+    Falls back to end-of-file when no such position exists -- a genuinely truncated
+    file, where reading to the end is right.
+    """
+    end = len(wav_bytes)
+    start = contents + (contents % 2)
+    for candidate in range(start, end - _CHUNK_HEADER_SIZE + 1, 2):
+        if _parses_as_chunk_list_to_eof(wav_bytes, candidate):
+            return candidate - contents
+    return end - contents
+
+
+def _parses_as_chunk_list_to_eof(wav_bytes: bytes, pos: int) -> bool:
+    """Does the buffer from `pos` read as a chunk list that lands exactly on EOF?"""
+    end = len(wav_bytes)
+    while pos < end:
+        if pos + _CHUNK_HEADER_SIZE > end:
+            return False
+        chunk_id = wav_bytes[pos : pos + _CHUNK_ID_SIZE]
+        # A chunk id is four printable ASCII characters; anything else is audio.
+        if not all(0x20 <= b < 0x7F for b in chunk_id):
+            return False
+        (declared,) = struct.unpack(
+            "<I", wav_bytes[pos + _CHUNK_ID_SIZE : pos + _CHUNK_HEADER_SIZE]
+        )
+        pos += _CHUNK_HEADER_SIZE + declared + (declared % 2)
+    return pos == end
+
+
+def header_size_of_wav_bytes(wav_bytes: bytes) -> int:
+    r"""Size, in bytes, of everything preceding the audio payload.
+
+    That is the offset of the `data` chunk's contents, found by walking the RIFF
+    structure (see :func:`_wav_data_chunk`). For a well-formed file with nothing after
+    the audio this is the same number the old size-subtraction produced; unlike it, it
+    stays correct when the file carries trailing metadata or an over-declared `data`
+    size.
+
+    `meta` is accepted for backwards compatibility and no longer used.
+
+    >>> header_size_of_wav_bytes(
+    ...     b'RIFF.\x00\x00\x00WAVEfmt \x10\x00\x00\x00\x01\x00\x01\x00'
+    ...     b'*\x00\x00\x00T\x00\x00\x00\x02\x00\x10\x00data\n\x00\x00\x00'
+    ...     b'\x00\x00\x01\x00\xff\xff\x02\x00\xfe\xff'
+    ... )
+    44
+    """
+    offset, _ = _wav_data_chunk(wav_bytes)
+    return offset
 
 
 # # TODO: Repair. See https://github.com/otosense/recode/issues/3
@@ -389,8 +570,12 @@ def decode_wav_header_bytes(wav_header_bytes: bytes) -> dict:
     """
     wav_read_obj = Wave_read(BytesIO(wav_header_bytes))
     params = wav_read_obj.getparams()
-    if params.comptype == "NONE":  # it's the only one supported
-        comptype = None  # but we're making it compatible with encoding anyway
+    # Normalized to None so the value round-trips with `encode_wav_header_bytes`.
+    # Unconditional on purpose: `Wave_read` rejects any non-PCM fmt tag with
+    # `wave.Error` before `getparams()` returns, so comptype is always 'NONE' here.
+    # It used to be assigned inside `if params.comptype == "NONE"`, an unreachable
+    # guard that would have left the name unbound if that ever changed.
+    comptype = None
     return dict(
         sr=params.framerate,
         width_bytes=params.sampwidth,
diff --git a/test_recode.py b/test_recode.py
index e11d6b5..80269b9 100644
--- a/test_recode.py
+++ b/test_recode.py
@@ -270,3 +270,243 @@ def test_decode_wav_bytes():
 
 
 # mk_test_wav_file()
+
+
+# ------ recode#4: the `data` chunk must be located, not inferred -----------------------
+#
+# `decode_wav_bytes` used to derive the header size by subtraction:
+#
+#     header_size = len(wav_bytes) - n_channels * width_bytes * nframes
+#
+# which reads any bytes that follow the audio as though they were header. The failure is
+# silent -- the waveform comes back the right LENGTH and the wrong CONTENT -- so these
+# tests assert decoded samples, never just a length or a "did not raise".
+#
+# Each case below is a real shape a WAV file takes in the wild, and each one is read
+# correctly by `soundfile`, which is how the original report noticed the discrepancy.
+
+import io
+import struct
+import warnings
+import wave as _wave
+
+from recode.audio import ShortWavData
+
+_WF = [0, 1, -1, 2, -2, 3, -3, 4, -4, 5]
+_SR = 44100
+
+
+_STRUCT_CODE_FOR_WIDTH = {1: "b", 2: "h", 4: "i"}
+
+
+def _wav(wf=_WF, sr=_SR, n_channels=1, width=2):
+    """A minimal, well-formed PCM WAV, built with the stdlib only.
+
+    `width` drives the packing as well as the header, so a non-default width yields a
+    valid file rather than a header that disagrees with its own payload.
+    """
+    code = _STRUCT_CODE_FOR_WIDTH[width]
+    b = io.BytesIO()
+    with _wave.open(b, "wb") as w:
+        w.setnchannels(n_channels)
+        w.setsampwidth(width)
+        w.setframerate(sr)
+        w.writeframes(b"".join(struct.pack("<" + code, x) for x in wf))
+    return b.getvalue()
+
+
+def _with_riff_size_fixed(raw):
+    raw = bytearray(raw)
+    raw[4:8] = struct.pack("<I", len(raw) - 8)
+    return bytes(raw)
+
+
+def _insert_chunk_before_data(raw, chunk):
+    at = raw.find(b"data")
+    return _with_riff_size_fixed(raw[:at] + chunk + raw[at:])
+
+
+def test_decode_wav_bytes_ignores_metadata_after_the_audio():
+    """A `LIST`/`INFO` chunk after `data` -- what ffmpeg, Audacity and iTunes append.
+
+    This is the regression the issue was filed for. Before the fix this returned
+    `[0, 20041, 20294, ...]`: same number of samples, different audio, no exception.
+    """
+    info = b"INFOISFT" + struct.pack("<I", 6) + b"Lavf58"
+    raw = _with_riff_size_fixed(_wav() + b"LIST" + struct.pack("<I", len(info)) + info)
+    assert decode_wav_bytes(raw) == (_WF, _SR)
+
+
+@pytest.mark.parametrize("over_declare_by", [200, 0xFFFFFFFF - 20])
+def test_decode_wav_bytes_survives_an_over_declared_data_size(over_declare_by):
+    """Files written to a stream declare a length they may never go back and patch.
+
+    Before the fix this tripped `assert header_size >= 44` and raised. `0xFFFFFFFF` is
+    the sentinel a stream writer leaves behind when it never learns the length.
+    """
+    raw = bytearray(_wav())
+    at = raw.find(b"data")
+    (declared,) = struct.unpack("<I", bytes(raw[at + 4 : at + 8]))
+    raw[at + 4 : at + 8] = struct.pack(
+        "<I", min(declared + over_declare_by, 0xFFFFFFFF)
+    )
+    with pytest.warns(ShortWavData):
+        assert decode_wav_bytes(bytes(raw)) == (_WF, _SR)
+
+
+def test_over_declared_data_does_not_swallow_a_trailing_chunk():
+    """The two malformations combined -- where a naive clamp-to-EOF re-creates the bug.
+
+    An over-declared `data` size says "read to the end"; a trailing `LIST` says "the
+    end is not audio". Getting this wrong returns the metadata bytes as extra samples,
+    silently, which is the exact failure class this whole change exists to remove.
+    """
+    info = b"INFOISFT" + struct.pack("<I", 6) + b"Lavf58"
+    trailing = b"LIST" + struct.pack("<I", len(info)) + info
+    raw = bytearray(_wav())
+    at = raw.find(b"data")
+    raw[at + 4 : at + 8] = struct.pack("<I", 0xFFFFFFFF)  # stream sentinel
+    raw = _with_riff_size_fixed(bytes(raw) + trailing)
+
+    from recode.audio import _wav_data_chunk
+
+    assert _wav_data_chunk(raw) == (44, len(_WF) * 2)
+    with pytest.warns(ShortWavData):
+        assert decode_wav_bytes(raw) == (_WF, _SR)
+
+
+def test_over_declared_data_falls_back_to_eof_when_nothing_follows():
+    """No trailing chunk to find, so end-of-file is the right boundary."""
+    raw = bytearray(_wav())
+    at = raw.find(b"data")
+    raw[at + 4 : at + 8] = struct.pack("<I", 0xFFFFFFFF)
+    with pytest.warns(ShortWavData):
+        assert decode_wav_bytes(bytes(raw)) == (_WF, _SR)
+
+
+def test_decode_wav_bytes_skips_chunks_before_the_audio():
+    """`fact` is legal and common; an odd-sized chunk also carries a RIFF pad byte."""
+    fact = b"fact" + struct.pack("<I", 4) + struct.pack("<I", len(_WF))
+    assert decode_wav_bytes(_insert_chunk_before_data(_wav(), fact)) == (_WF, _SR)
+
+    odd = b"note" + struct.pack("<I", 3) + b"abc" + b"\x00"  # 3 bytes + pad
+    assert decode_wav_bytes(_insert_chunk_before_data(_wav(), odd)) == (_WF, _SR)
+
+
+@pytest.mark.parametrize("n_channels", [1, 2, 3])
+@pytest.mark.parametrize("cut", range(0, 8))
+def test_decode_wav_bytes_drops_a_partial_trailing_frame(n_channels, cut):
+    """Truncation yields whole FRAMES, and a frame is width * n_channels bytes.
+
+    Parametrized over channel count on purpose: with mono-only coverage, dropping the
+    `* n_channels` from the frame size leaves the whole suite green while breaking
+    truncated stereo with a struct error.
+    """
+    flat = [(-1) ** i * (i + 1) for i in range(12 * n_channels)]
+    raw = _wav(flat, n_channels=n_channels)
+    kept_frames = (len(flat) * 2 - cut) // (2 * n_channels)
+    frames = [tuple(flat[i : i + n_channels]) for i in range(0, len(flat), n_channels)]
+    expected = frames[:kept_frames]
+    if n_channels == 1:
+        expected = [f[0] for f in expected]
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", ShortWavData)
+        assert decode_wav_bytes(raw[: len(raw) - cut] if cut else raw) == (
+            expected,
+            _SR,
+        )
+
+
+def test_decode_wav_bytes_returns_empty_when_no_whole_frame_survives():
+    """A stream cut before any audio arrived: an empty waveform, not an IndexError."""
+    with pytest.warns(ShortWavData):
+        assert decode_wav_bytes(_wav()[:44]) == ([], _SR)
+
+
+def test_decode_wav_bytes_warns_when_the_data_chunk_is_short():
+    """The caller must be able to tell a half-downloaded file from a complete one."""
+    with pytest.warns(ShortWavData, match="declares 10 frames, 8 are present"):
+        decode_wav_bytes(_wav()[:-4])
+
+    # ... and stays quiet on a complete file
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", ShortWavData)
+        assert decode_wav_bytes(_wav()) == (_WF, _SR)
+
+
+def test_decode_wav_bytes_still_reads_a_plain_file():
+    """The unremarkable case, stereo included -- the fix must not move the happy path."""
+    assert decode_wav_bytes(_wav()) == (_WF, _SR)
+
+    stereo = [1, -1, 2, -2, 3, -3]
+    assert decode_wav_bytes(_wav(stereo, n_channels=2)) == (
+        [(1, -1), (2, -2), (3, -3)],
+        _SR,
+    )
+
+
+@pytest.mark.parametrize(
+    "not_wav",
+    [
+        b"",
+        b"short",
+        b"not a wav file at all, really",
+        b"RIFF" + struct.pack("<I", 4) + b"AVI ",  # RIFF, but not a WAVE form
+    ],
+)
+def test_decode_wav_bytes_rejects_non_wav_input_clearly(not_wav):
+    """Say what is wrong, rather than failing somewhere inside the codec.
+
+    These inputs used to raise `wave.Error` or `EOFError` from the stdlib; unifying on
+    `ValueError` is a deliberate new contract, not pre-existing behaviour.
+    """
+    with pytest.raises(ValueError, match="RIFF/WAVE"):
+        decode_wav_bytes(not_wav)
+
+
+def test_decode_wav_bytes_says_when_the_chunk_walk_desyncs():
+    """A file that plainly has a `data` chunk, reached through a lying earlier one."""
+    liar = b"junk" + struct.pack("<I", 10**6)
+    with pytest.raises(ValueError, match="desynced"):
+        decode_wav_bytes(_insert_chunk_before_data(_wav(), liar))
+
+
+def test_decode_wav_bytes_rejects_a_riff_with_no_data_chunk():
+    raw = _wav()
+    assert decode_wav_bytes(raw) == (_WF, _SR)  # guard: the fixture is a real WAV
+    with pytest.raises(ValueError, match="no `data` chunk"):
+        decode_wav_bytes(raw.replace(b"data", b"xxxx", 1))
+
+
+def test_header_size_of_wav_bytes_is_the_data_offset():
+    from recode.audio import header_size_of_wav_bytes
+
+    raw = _wav()
+    assert header_size_of_wav_bytes(raw) == 44  # unchanged for a well-formed file
+    # ... and stays put when metadata is appended, where subtraction would have grown it
+    info = b"INFOISFT" + struct.pack("<I", 6) + b"Lavf58"
+    padded = _with_riff_size_fixed(raw + b"LIST" + struct.pack("<I", len(info)) + info)
+    assert header_size_of_wav_bytes(padded) == 44
+
+
+def test_decode_wav_header_bytes_reports_comptype_for_pcm():
+    """`comptype` is normalized to None so it round-trips with the encoder.
+
+    It used to be bound only inside `if params.comptype == "NONE"`. That branch is
+    unreachable -- stdlib `wave` rejects non-PCM formats itself -- so the guard bought
+    nothing while leaving the name unbound if `wave` ever widened. Pinning the PCM
+    value here keeps the round-trip honest.
+    """
+    from recode.audio import decode_wav_header_bytes, encode_wav_header_bytes
+
+    meta = decode_wav_header_bytes(_wav())
+    assert meta["comptype"] is None
+    assert meta["sr"] == _SR and meta["width_bytes"] == 2 and meta["n_channels"] == 1
+    # and it is accepted straight back by its inverse
+    assert (
+        decode_wav_header_bytes(
+            encode_wav_header_bytes(_SR, 2, n_channels=1, comptype=meta["comptype"])
+        )["comptype"]
+        is None
+    )