refactor: remove public segment() from all concrete Array subtypes

ArraySegments.of() is now the single public API for extracting a
MemorySegment from any Array. Concrete types expose their backing fields
at package-private level; ArraySegments accesses them directly. No
segment() method is visible to external callers.

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

Author: dfa1

core/src/main/java/io/github/dfa1/vortex/core/array/ArraySegments.java

@@ -21,16 +21,16 @@ private ArraySegments() {
     public static MemorySegment of(Array arr) {
         Array data = arr instanceof MaskedArray m ? m.inner() : arr;
         return switch (data) {
-            case IntArray a -> a.segment();
-            case LongArray a -> a.segment();
-            case DoubleArray a -> a.segment();
-            case FloatArray a -> a.segment();
-            case ShortArray a -> a.segment();
-            case ByteArray a -> a.segment();
-            case BoolArray a -> a.segment();
-            case Float16Array a -> a.segment();
-            case VarBinArray a -> a.segment();
-            case GenericArray a -> a.segment();
+            case IntArray a -> a.buffer;
+            case LongArray a -> a.buffer;
+            case DoubleArray a -> a.buffer;
+            case FloatArray a -> a.buffer;
+            case ShortArray a -> a.buffer;
+            case ByteArray a -> a.buffer;
+            case BoolArray a -> a.buffer;
+            case Float16Array a -> a.buffer;
+            case VarBinArray a -> a.bytes;
+            case GenericArray a -> a.buffers[0];
             default -> throw new VortexException(data.getClass().getSimpleName() + " has no primary segment");
         };
     }

core/src/main/java/io/github/dfa1/vortex/core/array/BoolArray.java

@@ -10,7 +10,7 @@ public final class BoolArray implements Array {
 
     private final DType dtype;
     private final long length;
-    private final MemorySegment buffer;
+    final MemorySegment buffer;
 
     /// Constructs a {@code BoolArray} backed by the given bit-packed buffer.
     ///
@@ -33,12 +33,6 @@ public long length() {
         return length;
     }
 
-    /// Returns the raw bit-packed backing segment (LSB-first, one byte per 8 elements).
-    ///
-    /// @return the backing {@link MemorySegment}
-    public MemorySegment segment() {
-        return buffer;
-    }
 
     /// Returns the boolean value at the given logical index.
     ///

core/src/main/java/io/github/dfa1/vortex/core/array/ByteArray.java

@@ -12,7 +12,7 @@ public final class ByteArray implements Array {
 
     private final DType dtype;
     private final long length;
-    private final MemorySegment buffer;
+    final MemorySegment buffer;
 
     /// Constructs a {@code ByteArray} backed by the given buffer.
     ///
@@ -35,12 +35,6 @@ public long length() {
         return length;
     }
 
-    /// Returns the raw backing segment (one byte per element).
-    ///
-    /// @return the backing {@link MemorySegment}
-    public MemorySegment segment() {
-        return buffer;
-    }
 
     /// Returns the raw byte value at the given logical index.
     ///

core/src/main/java/io/github/dfa1/vortex/core/array/DoubleArray.java

@@ -12,7 +12,7 @@ public final class DoubleArray implements Array {
 
     private final DType dtype;
     private final long length;
-    private final MemorySegment buffer;
+    final MemorySegment buffer;
 
     /// Constructs a {@code DoubleArray} backed by the given buffer.
     ///
@@ -35,12 +35,6 @@ public long length() {
         return length;
     }
 
-    /// Returns the raw backing segment (little-endian, 8 bytes per element).
-    ///
-    /// @return the backing {@link MemorySegment}
-    public MemorySegment segment() {
-        return buffer;
-    }
 
     /// Returns the double value at the given logical index.
     ///

core/src/main/java/io/github/dfa1/vortex/core/array/Float16Array.java

@@ -12,7 +12,7 @@ public final class Float16Array implements Array {
 
     private final DType dtype;
     private final long length;
-    private final MemorySegment buffer;
+    final MemorySegment buffer;
 
     /// Creates a new {@code Float16Array} backed by the given memory segment.
     ///
@@ -35,12 +35,6 @@ public long length() {
         return length;
     }
 
-    /// Returns the raw backing segment (little-endian, 2 bytes per element).
-    ///
-    /// @return the backing {@link MemorySegment}
-    public MemorySegment segment() {
-        return buffer;
-    }
 
     /// Returns the element at the given index widened to a single-precision float.
     ///

core/src/main/java/io/github/dfa1/vortex/core/array/FloatArray.java

@@ -11,7 +11,7 @@ public final class FloatArray implements Array {
 
     private final DType dtype;
     private final long length;
-    private final MemorySegment buffer;
+    final MemorySegment buffer;
 
     /// Creates a new {@code FloatArray} backed by the given memory segment.
     ///
@@ -34,12 +34,6 @@ public long length() {
         return length;
     }
 
-    /// Returns the raw backing segment (little-endian, 4 bytes per element).
-    ///
-    /// @return the backing {@link MemorySegment}
-    public MemorySegment segment() {
-        return buffer;
-    }
 
     /// Returns the float value at the given index.
     ///

core/src/main/java/io/github/dfa1/vortex/core/array/GenericArray.java

@@ -13,7 +13,7 @@ public final class GenericArray implements Array {
 
     private final DType dtype;
     private final long length;
-    private final MemorySegment[] buffers;
+    final MemorySegment[] buffers;
     private final Array[] children;
 
     /// Creates a new {@code GenericArray} with the given buffers and children.
@@ -48,10 +48,6 @@ public long length() {
         return length;
     }
 
-    public MemorySegment segment() {
-        return buffers[0];
-    }
-
     /// Returns the raw buffer at position {@code i}.
     ///
     /// @param i buffer index

core/src/main/java/io/github/dfa1/vortex/core/array/IntArray.java

@@ -12,7 +12,7 @@ public final class IntArray implements Array {
 
     private final DType dtype;
     private final long length;
-    private final MemorySegment buffer;
+    final MemorySegment buffer;
 
     /// Creates a new {@code IntArray} backed by the given memory segment.
     ///
@@ -35,12 +35,6 @@ public long length() {
         return length;
     }
 
-    /// Returns the raw backing segment (little-endian, 4 bytes per element).
-    ///
-    /// @return the backing {@link MemorySegment}
-    public MemorySegment segment() {
-        return buffer;
-    }
 
     /// Returns the int value at the given index.
     ///

core/src/main/java/io/github/dfa1/vortex/core/array/LongArray.java

@@ -12,7 +12,7 @@ public final class LongArray implements Array {
 
     private final DType dtype;
     private final long length;
-    private final MemorySegment buffer;
+    final MemorySegment buffer;
 
     /// Creates a new {@code LongArray} backed by the given memory segment.
     ///
@@ -35,12 +35,6 @@ public long length() {
         return length;
     }
 
-    /// Returns the raw backing segment (little-endian, 8 bytes per element).
-    ///
-    /// @return the backing {@link MemorySegment}
-    public MemorySegment segment() {
-        return buffer;
-    }
 
     /// Returns the long value at the given index.
     ///

core/src/main/java/io/github/dfa1/vortex/core/array/MaskedArray.java

@@ -2,8 +2,6 @@
 
 import io.github.dfa1.vortex.core.DType;
 
-import java.lang.foreign.MemorySegment;
-
 /// Decoded {@code vortex.masked} array: a non-nullable child paired with an optional validity bitmap.
 ///
 /// <p>Invariant: {@code child} has no actual nulls — nullability is expressed solely via
@@ -42,13 +40,6 @@ public Array inner() {
         return child;
     }
 
-    /// Delegates to {@link #inner()}'s segment; validity is not surfaced here.
-    ///
-    /// @return the primary segment of the inner array
-    public MemorySegment segment() {
-        return ArraySegments.of(child);
-    }
-
     /// Returns the validity bitmap, or {@code null} if all positions are valid.
     ///
     /// @return the validity bitmap, or {@code null} when all values are valid