@@ -347,7 +347,7 @@ where
     let (values, num_bytes) = slice.value_bytes()?;
     // Each value is length-prefixed, so the frames can only be walked in order — which is the
     // order `append_valid_slices` visits the valid rows in. A walk that runs out early hands back
-    // its undecoded remainder, which the builder rejects as a byte-count mismatch.
+    // its remainder, which the builder rejects as a byte-count mismatch.
     let mut values = ZstdValues::new(values);
     builder.append_valid_slices(num_bytes, mask, |_| values.next_value())
 }
@@ -804,12 +804,11 @@ impl DecompressedSlice {
     /// slice's values.
     ///
     /// Walking the length prefixes is a dependent load chain, so both ends are derived from the
-    /// slice metadata where possible: an unsliced array skips both walks. That makes the far end a
-    /// claim by the frame metadata rather than a checked fact, so a caller must still hold the
-    /// values it reads to the count [`Self::value_range`] gives — by walking them with
-    /// [`ZstdValues`], whose shortfall shows up in the byte total from [`Self::value_bytes`], or by
-    /// counting the ones it decodes, as [`try_reconstruct_views`] does. A region that ends part way
-    /// through a value is otherwise free to pass its trailing bytes off as values of their own.
+    /// slice metadata where possible: an unsliced array skips both walks. The far end is then a
+    /// claim rather than a checked fact, so a caller must hold the values it reads to the count
+    /// from [`Self::value_range`] — with [`ZstdValues`], whose shortfall shows up in the byte total
+    /// from [`Self::value_bytes`], or by counting decoded values as [`try_reconstruct_views`] does.
+    /// Otherwise a region ending part way through a value passes its trailing bytes off as values.
     fn value_byte_range(&self) -> VortexResult<Range<usize>> {
         let Range { start, end } = self.value_range()?;
         let buffer = self.bytes.as_slice();
@@ -903,13 +902,11 @@ impl<'a> ZstdValues<'a> {
 
     /// The next value, or every byte the walk could not decode once a prefix leaves the region.
     ///
-    /// Handing back the remainder is what lets a caller that knows how many values the region holds
-    /// detect a walk that fell short purely from the byte total, without a second walk to validate
-    /// the region up front. A caller sizes that total as the region minus one length prefix per
-    /// value, so `k` of `n` values decoded leaves it expecting the `n - k` prefixes the walk
-    /// abandoned as well: the remainder either covers them and more, or is empty because the region
-    /// ended exactly and the decoded values already fall short of the total. Neither can add up, so
-    /// a shortfall is always rejected rather than passed off as trailing empty values.
+    /// The remainder is what makes a shortfall visible in the byte total alone, without a second
+    /// walk to validate the region up front. A caller sizes that total as the region minus one
+    /// prefix per value, so `k` of `n` values decoded leaves it still expecting the `n - k`
+    /// prefixes the walk abandoned; the remainder covers those and more, or is empty only because
+    /// the region ended exactly and the decoded bytes already fall short. Neither can add up.
     fn next_value(&mut self) -> &'a [u8] {
         let value_start = self.offset + size_of::<ViewLen>();
         let value = zstd_value_len(self.buffer, self.offset)
@@ -1783,17 +1780,14 @@ mod tests {
         Ok(())
     }
 
-    /// Both ends of the region a slice reads come from the frame metadata where they can, so the
-    /// values in it have to be held to the value count the metadata declared. Otherwise a buffer
-    /// whose last value is only a length prefix reads back as a trailing empty value.
     #[test]
     fn test_append_to_varbin_rejects_a_dangling_length_prefix() {
         let mut buffer = Vec::new();
         buffer.extend_from_slice(&3u32.to_le_bytes());
         buffer.extend_from_slice(b"cat");
-        // A prefix with no value after it. It takes up exactly the four bytes the second value's
-        // own prefix would have, so treating that value as empty would still total the byte count
-        // the metadata implies and append ["cat", ""].
+        // A prefix with no value after it. It takes up exactly the four bytes the missing value's
+        // own prefix would have, so treating that value as empty still totals the byte count the
+        // metadata implies and appends ["cat", ""].
         buffer.extend_from_slice(&1u32.to_le_bytes());
 
         let slice = decompressed_slice(ByteBuffer::copy_from(buffer.as_slice()), 0, 2, 0, 2);
 
@@ -383,18 +383,16 @@ fn test_zstd_rejects_corrupt_frame_metadata(
     Ok(())
 }
 
-/// Frame bytes are as untrusted as the metadata describing them, so a frame whose last value is
-/// nothing but a length prefix has to surface as an error from every read path rather than as a
-/// trailing empty value.
+/// Frame bytes are as untrusted as the metadata describing them: a frame whose last value is
+/// nothing but a length prefix has to error from every read path, not read back as an empty value.
 #[test]
 fn test_zstd_rejects_a_frame_ending_in_a_dangling_length_prefix() -> VortexResult<()> {
     let mut ctx = array_session().create_execution_ctx();
     let mut values = Vec::new();
     values.extend_from_slice(&3u32.to_le_bytes());
     values.extend_from_slice(b"cat");
-    // A prefix with no value after it. It takes up exactly the four bytes the second value's own
-    // prefix would have, so treating that value as empty totals the byte count the metadata
-    // implies: two values holding three bytes between them.
+    // A prefix with no value after it. Treating the missing value as empty still totals the three
+    // bytes the metadata implies for two values.
     values.extend_from_slice(&1u32.to_le_bytes());
 
     let dtype = DType::Utf8(Nullability::NonNullable);