feat(writer): zone-map MIN/MAX for extension columns via storage primitive

flushZoneMaps gated min/max on `DType.Primitive`, so extension columns
(e.g. vortex.timestamp over I64) emitted NULL_COUNT-only zone-maps even
though ExtEncoding already propagates the storage array's min/max scalars
to each chunk. Generalise the gate via zoneStatPType, which unwraps an
Extension to its storage primitive; the per-zone stat column is stored as
that primitive, matching Rust (stats computed on the storage array).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: dfa1

writer/src/main/java/io/github/dfa1/vortex/writer/VortexWriter.java

@@ -706,17 +706,19 @@ private void flushZoneMaps() throws IOException {
             java.util.Arrays.fill(allValid, true);
 
             // NULL_COUNT is computable for every column type; MIN/MAX only for fixed-width
-            // primitives whose chunks all carry stats. Field/bit order follows
-            // ZonedStatsSchema: MAX(3), MIN(4), NULL_COUNT(6); each stat field is nullable.
+            // primitives whose chunks all carry stats. Extension columns unwrap to their storage
+            // primitive — ExtEncoding propagates the storage min/max, stored here as that primitive.
+            // Field/bit order follows ZonedStatsSchema: MAX(3), MIN(4), NULL_COUNT(6); each nullable.
             DType colDtype = schema.fieldTypes().get(schema.fieldNames().indexOf(colName));
-            boolean hasMinMax = colDtype instanceof DType.Primitive
+            PType statPtype = zoneStatPType(colDtype);
+            boolean hasMinMax = statPtype != null
                     && chunks.stream().allMatch(ChunkRef::hasStats);
 
             List<String> names = new java.util.ArrayList<>();
             List<DType> types = new java.util.ArrayList<>();
             List<Object> fields = new java.util.ArrayList<>();
             if (hasMinMax) {
-                PType ptype = ((DType.Primitive) colDtype).ptype();
+                PType ptype = statPtype;
                 DType nullablePrim = new DType.Primitive(ptype, true);
                 boolean[] notTruncated = new boolean[nZones];
                 names.add("max");
@@ -804,6 +806,17 @@ private static long countNulls(boolean[] validity) {
         return nulls;
     }
 
+    /// The primitive type whose min/max a zone-map stores for `dtype`, or `null` when the column
+    /// has no fixed-width min/max. Extension columns resolve to their storage primitive, since
+    /// `ExtEncoding` propagates the storage array's min/max scalars unchanged.
+    private static PType zoneStatPType(DType dtype) {
+        return switch (dtype) {
+            case DType.Primitive p -> p.ptype();
+            case DType.Extension ext when ext.storageDType() instanceof DType.Primitive p -> p.ptype();
+            default -> null;
+        };
+    }
+
     /// Builds the per-zone min (or max) values array in the storage shape the primitive encoder
     /// expects, decoding each chunk's serialised [ScalarValue] stat.
     private static Object statColumn(PType ptype, List<ChunkRef> chunks, boolean max) throws IOException {

writer/src/test/java/io/github/dfa1/vortex/writer/WriterZoneMapTest.java

@@ -255,6 +255,43 @@ void nonPrimitiveColumn_emitsNullCountOnlyZoneMap(@TempDir Path tmp) throws IOEx
         }
     }
 
+    @Test
+    void extensionColumn_emitsStorageMinMaxZoneMap(@TempDir Path tmp) throws IOException {
+        // Given an extension column over I64 storage written as a raw long[] (no spec auto-route),
+        // two zones of two rows: zone 0 = [10, 11], zone 1 = [20, 21]. ExtEncoding propagates the
+        // storage primitive's min/max, so the zone-map carries MAX+MIN+NULL_COUNT — same as I64.
+        DType ext = new DType.Extension(
+                "test.ext", new DType.Primitive(PType.I64, false), null, false);
+        DType.Struct schema = new DType.Struct(List.of("t"), List.of(ext), false);
+        WriteOptions opts = new WriteOptions(2, true, 0.90, 0, false, false);
+        Path file = tmp.resolve("ext.vtx");
+        try (var ch = FileChannel.open(file, StandardOpenOption.CREATE, StandardOpenOption.WRITE);
+             var sut = VortexWriter.create(ch, schema, opts)) {
+            sut.writeChunk(Map.of("t", new long[]{10, 11}));
+            sut.writeChunk(Map.of("t", new long[]{20, 21}));
+        }
+
+        // When / Then the column is zoned with MAX+MIN+NULL_COUNT and the stats decode per zone
+        try (VortexReader reader = VortexReader.open(file)) {
+            Layout column = reader.layout().children().get(0);
+            assertThat(column.isZoned()).isTrue();
+            ByteBuffer meta = column.metadata().duplicate().order(ByteOrder.LITTLE_ENDIAN);
+            assertThat(meta.get(meta.position() + 4)).isEqualTo((byte) 0x58); // MAX+MIN+NULL_COUNT
+
+            Layout zonesFlat = column.children().get(1);
+            SegmentSpec spec = reader.footer().segmentSpecs().get(zonesFlat.segments().getFirst());
+            try (Arena arena = Arena.ofConfined()) {
+                StructArray stats = (StructArray) reader.decodeFlatSegment(spec, statsTableDtype(), 2, arena);
+                LongArray max = (LongArray) ((MaskedArray) stats.field("max")).inner();
+                LongArray min = (LongArray) ((MaskedArray) stats.field("min")).inner();
+                assertThat(min.getLong(0)).isEqualTo(10);
+                assertThat(max.getLong(0)).isEqualTo(11);
+                assertThat(min.getLong(1)).isEqualTo(20);
+                assertThat(max.getLong(1)).isEqualTo(21);
+            }
+        }
+    }
+
     @Test
     void dictColumn_emitsNullCountZoneMapWrappingDict(@TempDir Path tmp) throws IOException {
         // Given a low-cardinality Utf8 column across 2 chunks of 6 with heavy repeats (so the