fix(decoder): report OutputFull when the output buffer is full

A RawDecoder that buffers a whole block internally (notably bzip2, which
absorbs an entire BWT block before draining it) could make a naive decode
loop fail with UnexpectedEnd. When the caller's output buffer filled
mid-block, the RawDecoder->Decoder bridge derived Status purely from
consumed >= input.len(); since the decoder had already swallowed all the
input, it returned InputEmpty instead of OutputFull. A loop that stops on
InputEmpty then called finish() on a half-drained stream and got
UnexpectedEnd — even on the decoder's own encoder output.

Return OutputFull whenever the output buffer is full (and non-empty),
which is always the correct "drain and call again" signal; a later call
with no remaining input yields InputEmpty once pending bytes are out.
Genuine truncation still errors (that path returns with output not full).

Adds round_trip_small_output_buffer_naive_loop, which drives the exact
documented decode loop with 1/64/4096/65536-byte output buffers over
100 KB-1 MB inputs and failed with UnexpectedEnd before this change.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: MagicalTux

CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+
+- *(decoder bridge)* a decoder that buffers a whole block internally (notably
+  `bzip2`) could fail a naive decode loop with `UnexpectedEnd`. When the
+  caller's `output` buffer filled mid-block, the `RawDecoder`→`Decoder` bridge
+  reported `InputEmpty` (because the decoder had already absorbed all the input)
+  instead of `OutputFull`; a loop that stops on `InputEmpty` then called
+  `finish` on a half-drained stream and got `UnexpectedEnd`. The bridge now
+  returns `OutputFull` whenever the output buffer is full, which is always the
+  correct "drain and call again" signal. Affected `bzip2` round-trips whenever a
+  decoded block was larger than the output buffer.
+
 ## [0.6.6](https://github.com/KarpelesLab/compcol/compare/v0.6.5...v0.6.6) - 2026-06-27
 
 ### Added

src/traits.rs

@@ -364,6 +364,17 @@ impl<T: RawDecoder> Decoder for T {
         let p = self.raw_decode(input, output)?;
         let status = if p.done {
             Status::StreamEnd
+        } else if p.written == output.len() && !output.is_empty() {
+            // Output buffer is full. A decoder that buffers input internally
+            // (e.g. bzip2 absorbs a whole block before draining it) reports
+            // `consumed == input.len()` here even though it still has decoded
+            // bytes pending — so keying the status off `consumed` alone would
+            // wrongly say `InputEmpty` and a standard loop would stop early
+            // (then `finish` sees a half-drained stream → `UnexpectedEnd`).
+            // A filled output always means "drain and call again", which is
+            // exactly `OutputFull`'s contract; calling again with no remaining
+            // input simply yields `InputEmpty` once the pending bytes are out.
+            Status::OutputFull
         } else if p.consumed >= input.len() {
             Status::InputEmpty
         } else {

tests/bzip2.rs

@@ -268,6 +268,55 @@ fn round_trip_streaming_one_byte() {
     assert_eq!(decoded, input);
 }
 
+/// Decode following the *exact* streaming loop documented on the `Decoder`
+/// trait — no defensive "drain after InputEmpty" workaround like
+/// [`decode_chunked`] has. A naive caller breaks out of the decode loop on
+/// `InputEmpty` and then calls `finish`. This is the pattern that regressed:
+/// the decoder buffers a whole block internally, so when the small `output`
+/// fills mid-block it used to report `InputEmpty` (instead of `OutputFull`),
+/// the loop stopped with the block half-drained, and `finish` then failed with
+/// `UnexpectedEnd`.
+fn decode_documented_loop(encoded: &[u8], out_chunk: usize) -> Result<Vec<u8>, Error> {
+    let mut dec = Decoder::new();
+    let mut buf = vec![0u8; out_chunk];
+    let mut out = Vec::new();
+    let mut consumed = 0;
+    loop {
+        let (p, status) = dec.decode(&encoded[consumed..], &mut buf)?;
+        out.extend_from_slice(&buf[..p.written]);
+        consumed += p.consumed;
+        match status {
+            Status::OutputFull => continue,
+            Status::InputEmpty => break,
+            Status::StreamEnd => return Ok(out),
+        }
+    }
+    loop {
+        let (p, status) = dec.finish(&mut buf)?;
+        out.extend_from_slice(&buf[..p.written]);
+        if matches!(status, Status::StreamEnd) {
+            break;
+        }
+    }
+    Ok(out)
+}
+
+#[test]
+fn round_trip_small_output_buffer_naive_loop() {
+    // Inputs larger than the output buffer force the decoder to drain a single
+    // decoded block across several `decode` calls. Before the fix this failed
+    // with `UnexpectedEnd` for any block bigger than `out_chunk`.
+    for &n in &[100_000usize, 600_000, 1_000_000] {
+        let input: Vec<u8> = (0..n).map(|i| (i.wrapping_mul(2654435761) >> 13) as u8).collect();
+        let encoded = encode_all(&input);
+        for &out_chunk in &[1usize, 64, 4096, 65536] {
+            let decoded = decode_documented_loop(&encoded, out_chunk)
+                .unwrap_or_else(|e| panic!("n={n} out_chunk={out_chunk}: {e:?}"));
+            assert_eq!(decoded, input, "n={n} out_chunk={out_chunk}");
+        }
+    }
+}
+
 // ─── reset / reuse ─────────────────────────────────────────────────────
 
 #[test]