fix: zero-extend U8/U16/U32 children in DateTimePartsArrays.readLong (#252)

U16 seconds-within-day values >= 32768 (tweets after 09:06 UTC) were
widened as signed shorts (-22093 for seconds=43443), multiplied by
unitsPerSecond=1_000_000, and produced a 65536-second error in the
reconstructed timestamp. Added U-ptype detection via array.dtype() and
use Byte/Short/Integer.toUnsignedLong for unsigned widening.

bi-euro2016 flips back to ok. covid-world-vaccination-progress stays
gap:253 (separate U32 vs I32 DType mismatch, different root cause).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: dfa1

CHANGELOG.md

@@ -14,6 +14,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `ScanIterator.sliceArray` now handles `NullArray`; previously threw on Rust-written files where a null-typed column used a coarser chunk grid than the other columns. ([#247](https://github.com/dfa1/vortex-java/issues/247))
 - `AlpRdEncodingDecoder` now reads `left_parts_ptype` from metadata and rejects any value other than U16 with a `VortexException`; previously the field was silently ignored and U16 was hardcoded, risking a 2-byte stride over a 1-byte buffer for spec-conformant non-Rust writers. ([#249](https://github.com/dfa1/vortex-java/issues/249))
 - `SparseEncodingDecoder` now asserts exactly two children (`patch_indices`, `patch_values`) and throws `VortexException` on any other count; previously a third child was silently accepted. ([#250](https://github.com/dfa1/vortex-java/issues/250))
+- `DateTimePartsArrays.readLong` now zero-extends unsigned children (`U8`/`U16`/`U32`) instead of sign-extending them; previously a `U16` seconds-within-day value ≥ 32 768 was widened as a negative short, producing a 65 536-second error in the reconstructed timestamp (#252, bi-euro2016 corpus).
 - `RaincloudConformanceIntegrationTest` now writes both the vortex-java and Parquet oracle CSVs to temp files and streams them line-by-line for comparison; previously it materialized both into heap `String` objects, causing OOM for large corpus files (≥157 MB) that were previously hidden by throwing before reaching the corrupted line. ([#254](https://github.com/dfa1/vortex-java/issues/254))
 
 ## [0.12.1] — 2026-07-08

integration/src/test/resources/raincloud/expected-status.csv

@@ -29,7 +29,7 @@ bi-cmsprovider,untriaged
 bi-commongovernment,untriaged
 bi-corporations,ok
 bi-eixo,untriaged
-bi-euro2016,gap:252
+bi-euro2016,ok
 bi-food,ok
 bi-generico,untriaged
 bi-hashtags,ok

reader/src/main/java/io/github/dfa1/vortex/reader/array/DateTimePartsArrays.java

@@ -1,36 +1,49 @@
 package io.github.dfa1.vortex.reader.array;
 
 import io.github.dfa1.vortex.core.error.VortexException;
+import io.github.dfa1.vortex.core.model.DType;
+import io.github.dfa1.vortex.core.model.PType;
 
 /// Package-private helper for the [LazyDateTimePartsLongArray] record.
 ///
 /// `days`, `seconds` and `subseconds` children can each be one of
-/// the four signed-integer typed array interfaces; the writer picks the narrowest
-/// ptype that fits. [#readLong(Array, long)] centralizes the per-row read so
-/// the record itself stays compact.
+/// the four integer-typed array interfaces (signed or unsigned); the writer picks
+/// the narrowest ptype that fits the value range. [#readLong(Array, long)]
+/// centralizes the per-row read so the record itself stays compact.
 final class DateTimePartsArrays {
 
     private DateTimePartsArrays() {
     }
 
-    /// Reads `arr[i]` as a signed long. Recurses through [MaskedArray] to its
-    /// raw payload without inspecting validity: the decoder intersects component
-    /// validities into the reassembled array's own mask (#235), so a null row's
-    /// filler value here is harmless — callers gate on that outer mask.
+    /// Reads `arr[i]` as a widened long, respecting the child's signedness.
+    ///
+    /// Unsigned children (`U8`, `U16`, `U32`) require zero-extension, not sign-extension.
+    /// The Rust writer encodes seconds-within-day (0–86 399) as `U16` when values fit;
+    /// without zero-extension, values ≥ 32 768 are misread as negative shorts and produce
+    /// a `2^16`-second offset in the reassembled timestamp (#252).
+    ///
+    /// Recurses through [MaskedArray] to its raw payload without inspecting validity:
+    /// the decoder intersects component validities into the reassembled array's own mask
+    /// (#235), so a null row's filler value here is harmless — callers gate on that outer mask.
     ///
     /// @param arr source typed Array
     /// @param i   row index
     /// @return cell value as long
     /// @throws VortexException for unsupported array types
     static long readLong(Array arr, long i) {
         return switch (arr) {
-            case ByteArray a -> a.getByte(i);
-            case ShortArray a -> a.getShort(i);
-            case IntArray a -> a.getInt(i);
+            case ByteArray a -> isUnsigned(a) ? Byte.toUnsignedLong(a.getByte(i)) : a.getByte(i);
+            case ShortArray a -> isUnsigned(a) ? Short.toUnsignedLong(a.getShort(i)) : a.getShort(i);
+            case IntArray a -> isUnsigned(a) ? Integer.toUnsignedLong(a.getInt(i)) : a.getInt(i);
             case LongArray a -> a.getLong(i);
             case MaskedArray a -> readLong(a.inner(), i);
             default -> throw new VortexException(
                     "DateTimeParts: unsupported child array type: " + arr.getClass().getSimpleName());
         };
     }
+
+    private static boolean isUnsigned(Array a) {
+        return a.dtype() instanceof DType.Primitive p
+                && (p.ptype() == PType.U8 || p.ptype() == PType.U16 || p.ptype() == PType.U32);
+    }
 }

reader/src/test/java/io/github/dfa1/vortex/reader/array/DateTimePartsArraysTest.java

@@ -1,8 +1,13 @@
 package io.github.dfa1.vortex.reader.array;
 
 import io.github.dfa1.vortex.core.error.VortexException;
+import io.github.dfa1.vortex.encoding.DTypes;
 import org.junit.jupiter.api.Test;
 
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.ValueLayout;
+
 import static io.github.dfa1.vortex.reader.array.TestArrays.bools;
 import static io.github.dfa1.vortex.reader.array.TestArrays.bytes;
 import static io.github.dfa1.vortex.reader.array.TestArrays.doubles;
@@ -23,6 +28,55 @@ void readLong_dispatchesEveryIntegerArrayType() {
         assertThat(DateTimePartsArrays.readLong(longs(5_000_000_000L), 0)).isEqualTo(5_000_000_000L);
     }
 
+    /// Seconds-within-day are encoded as U16 when the range fits (0–65 535, which covers
+    /// all seconds in a day up to 18:12:15 UTC). Without zero-extension, values ≥ 32 768
+    /// are sign-extended to negative shorts and produce a 2^16-second error in the
+    /// reconstructed timestamp (#252). Reproduces with seconds = 43 443 (≈ 12:04 UTC,
+    /// the tweet time from bi-euro2016 line 262 146 that first surfaced the bug).
+    @Test
+    void readLong_u16ShortArray_zeroExtends() {
+        // Given — U16 ShortArray with a value that overflows signed I16 (43443 > 32767)
+        short value = (short) 43_443;  // 0xA9B3 — fits U16, overflows I16 → -22093 if signed
+        MemorySegment seg = Arena.ofAuto().allocate(2L, 2);
+        seg.set(ValueLayout.JAVA_SHORT, 0, value);
+        ShortArray u16 = new MaterializedShortArray(DTypes.U16, 1, seg.asReadOnly());
+
+        // When
+        long result = DateTimePartsArrays.readLong(u16, 0);
+
+        // Then — zero-extended to 43443, NOT sign-extended to -22093
+        assertThat(result).isEqualTo(43_443L);
+    }
+
+    @Test
+    void readLong_u8ByteArray_zeroExtends() {
+        // Given — U8 ByteArray with value 200 (> 127, sign-extends to -56 if treated as I8)
+        MemorySegment seg = Arena.ofAuto().allocate(1L, 1);
+        seg.set(ValueLayout.JAVA_BYTE, 0, (byte) 200);
+        ByteArray u8 = new MaterializedByteArray(DTypes.U8, 1, seg.asReadOnly());
+
+        // When
+        long result = DateTimePartsArrays.readLong(u8, 0);
+
+        // Then
+        assertThat(result).isEqualTo(200L);
+    }
+
+    @Test
+    void readLong_u32IntArray_zeroExtends() {
+        // Given — U32 IntArray with value 2^31 + 1 (overflows signed I32)
+        int value = Integer.MIN_VALUE + 1;  // same bits as 2147483649 unsigned
+        MemorySegment seg = Arena.ofAuto().allocate(4L, 4);
+        seg.set(ValueLayout.JAVA_INT, 0, value);
+        IntArray u32 = new MaterializedIntArray(DTypes.U32, 1, seg.asReadOnly());
+
+        // When
+        long result = DateTimePartsArrays.readLong(u32, 0);
+
+        // Then — 2^31 + 1, not -2^31 + 1
+        assertThat(result).isEqualTo(2_147_483_649L);
+    }
+
     @Test
     void readLong_recursesThroughValidMaskedCell() {
         // Given — a masked array whose cell is valid