style: S7474+S6218 in new lazy array files

dfa1 · claude · dfa1 · commit 11fe0c41c796 · 2026-06-16T05:22:11.000+02:00
- Convert {code}/{link} → backtick/[ClassName] in /// Markdown javadoc across 20 new lazy array files (RLE, RunEnd, Sparse, AlpRd) - Add @SuppressWarnings("java:S6218") to LazyAlpRdDoubleArray and LazyAlpRdFloatArray (internal data carriers with array components) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyAlpRdDoubleArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyAlpRdDoubleArray.java
@@ -5,27 +5,28 @@
 import java.util.function.DoubleBinaryOperator;
 import java.util.function.DoubleConsumer;
 
-/// Lazy ALP-RD-encoded {@link DoubleArray}.
+/// Lazy ALP-RD-encoded [DoubleArray].
 ///
 /// ALP-RD splits each f64 into a "left" u16 dictionary code and a "right" u64 payload
 /// (the low `rightBitWidth` bits of the original bit pattern). Reconstruction is
 /// `Double.longBitsToDouble((dict[left[i]] << rightBitWidth) | right[i])`. A small
 /// patches table overrides the dict lookup at specific absolute indices for outlier
 /// values that don't compress through the dictionary.
 ///
-/// {@code getDouble(i)} resolves on demand: read left/right children, dispatch through
+/// `getDouble(i)` resolves on demand: read left/right children, dispatch through
 /// dict (or patch if `i + patchOffset` hits a patch index), shift+or, then bits-to-double.
 ///
 /// @param dtype            logical element type
 /// @param length           total logical row count
 /// @param dict             small u16 dictionary lookup table (length typically ≤ 16)
-/// @param rightBitWidth    a bit width of the right payload
+/// @param rightBitWidth    bit width of the right payload
 /// @param leftArr          per-row u16 dict codes
 /// @param rightArr         per-row u64 right payloads (raw bits)
-/// @param patchIndices     sorted absolute indices of patched rows (or {@code null} when no patches)
+/// @param patchIndices     sorted absolute indices of patched rows (or `null` when no patches)
 /// @param patchLeftValues  actual left u16 values for patched rows; aligned with
-///                         {@code patchIndices}
+///                         `patchIndices`
 /// @param patchOffset      absolute origin subtracted from row positions before patch lookup
+@SuppressWarnings("java:S6218") // internal data carrier; record components are arrays of immutable primitives or refs that flow through pipelines without ever being compared.
 public record LazyAlpRdDoubleArray(
         DType dtype, long length,
         short[] dict, int rightBitWidth,
diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyAlpRdFloatArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyAlpRdFloatArray.java
@@ -4,19 +4,20 @@
 
 import java.util.function.DoubleBinaryOperator;
 
-/// Lazy ALP-RD-encoded {@link FloatArray}. See {@link LazyAlpRdDoubleArray} for the
+/// Lazy ALP-RD-encoded [FloatArray]. See [LazyAlpRdDoubleArray] for the
 /// dict + right + patches reconstruction model. The right payload is u32 instead of
-/// u64 and the result is reinterpreted via {@link Float#intBitsToFloat}.
+/// u64 and the result is reinterpreted via [Float#intBitsToFloat].
 ///
 /// @param dtype            logical element type
 /// @param length           total logical row count
 /// @param dict             small u16 dictionary lookup table
 /// @param rightBitWidth    bit width of the right payload
 /// @param leftArr          per-row u16 dict codes
 /// @param rightArr         per-row u32 right payloads (raw bits)
-/// @param patchIndices     sorted absolute indices of patched rows (or {@code null})
+/// @param patchIndices     sorted absolute indices of patched rows (or `null`)
 /// @param patchLeftValues  actual left u16 values for patched rows
 /// @param patchOffset      absolute origin subtracted from row positions before patch lookup
+@SuppressWarnings("java:S6218") // internal data carrier; record components are arrays of immutable primitives or refs that flow through pipelines without ever being compared.
 public record LazyAlpRdFloatArray(
         DType dtype, long length,
         short[] dict, int rightBitWidth,
diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyRleByteArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyRleByteArray.java
@@ -4,7 +4,7 @@
 
 import java.util.function.LongBinaryOperator;
 
-/// Lazy FastLanes-RLE-encoded {@link ByteArray}. See {@link LazyRleLongArray} for semantics.
+/// Lazy FastLanes-RLE-encoded [ByteArray]. See [LazyRleLongArray] for semantics.
 ///
 /// @param dtype             logical element type
 /// @param length            total logical row count
@@ -15,7 +15,7 @@
 /// @param valuesLen         total values pool length
 /// @param numChunks         number of FastLanes chunks covered
 /// @param offset            starting absolute position
-/// @param unsigned          {@code true} when the dtype is U8 (affects {@link #getInt(long)} widening)
+/// @param unsigned          `true` when the dtype is U8 (affects [#getInt(long)] widening)
 @SuppressWarnings("java:S6218") // internal data carrier; record components are arrays of immutable primitives or refs that flow through pipelines without ever being compared.
 public record LazyRleByteArray(
         DType dtype, long length, byte[] values, int[] indices,
diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyRleIntArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyRleIntArray.java
@@ -5,7 +5,7 @@
 import java.util.function.IntBinaryOperator;
 import java.util.function.IntConsumer;
 
-/// Lazy FastLanes-RLE-encoded {@link IntArray}. See {@link LazyRleLongArray} for semantics.
+/// Lazy FastLanes-RLE-encoded [IntArray]. See [LazyRleLongArray] for semantics.
 ///
 /// @param dtype             logical element type
 /// @param length            total logical row count
diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyRleLongArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyRleLongArray.java
@@ -5,27 +5,27 @@
 import java.util.function.LongBinaryOperator;
 import java.util.function.LongConsumer;
 
-/// Lazy FastLanes-RLE-encoded {@link LongArray}.
+/// Lazy FastLanes-RLE-encoded [LongArray].
 ///
 /// FastLanes RLE encodes 1024-row chunks of values + indices. For each chunk the
-/// distinct values are concatenated into {@code values}; the per-row local index
-/// into the chunk's value range lives in {@code indices}; {@code valuesIdxOffsets}
-/// gives the chunk-start offset into the global values pool. {@code getLong(i)}
-/// resolves {@code values[valuesIdxOffsets[chunkIdx(i)] + clampedLocalIdx(...)]}.
+/// distinct values are concatenated into `values`; the per-row local index
+/// into the chunk's value range lives in `indices`; `valuesIdxOffsets`
+/// gives the chunk-start offset into the global values pool. `getLong(i)`
+/// resolves `values[valuesIdxOffsets[chunkIdx(i)] + clampedLocalIdx(...)]`.
 ///
-/// {@code forEachLong} / {@code fold} iterate chunk-by-chunk so the constant-run
+/// `forEachLong` / `fold` iterate chunk-by-chunk so the constant-run
 /// fast path (`numChunkValues <= 1`) emits each value once with a tight inner loop.
 ///
 /// @param dtype             logical element type
 /// @param length            total logical row count
 /// @param values            concatenated distinct values per chunk
-/// @param indices           per-row local index table; length {@code numChunks * 1024}
-/// @param valuesIdxOffsets  per-chunk values-pool start offsets; length {@code numChunks}
+/// @param indices           per-row local index table; length `numChunks * 1024`
+/// @param valuesIdxOffsets  per-chunk values-pool start offsets; length `numChunks`
 /// @param firstOffset       absolute origin of the values pool
 /// @param valuesLen         total values pool length
 /// @param numChunks         number of FastLanes chunks covered
-/// @param offset            starting absolute position; logical row {@code i} maps to
-///                          absolute {@code i + offset}
+/// @param offset            starting absolute position; logical row `i` maps to
+///                          absolute `i + offset`
 @SuppressWarnings("java:S6218") // internal data carrier; record components are arrays of immutable primitives or refs that flow through pipelines without ever being compared.
 public record LazyRleLongArray(
         DType dtype, long length, long[] values, int[] indices,
diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyRleShortArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyRleShortArray.java
@@ -4,7 +4,7 @@
 
 import java.util.function.LongBinaryOperator;
 
-/// Lazy FastLanes-RLE-encoded {@link ShortArray}. See {@link LazyRleLongArray} for semantics.
+/// Lazy FastLanes-RLE-encoded [ShortArray]. See [LazyRleLongArray] for semantics.
 ///
 /// @param dtype             logical element type
 /// @param length            total logical row count
@@ -15,7 +15,7 @@
 /// @param valuesLen         total values pool length
 /// @param numChunks         number of FastLanes chunks covered
 /// @param offset            starting absolute position
-/// @param unsigned          {@code true} when the dtype is U16 (affects {@link #getInt(long)} widening)
+/// @param unsigned          `true` when the dtype is U16 (affects [#getInt(long)] widening)
 @SuppressWarnings("java:S6218") // internal data carrier; record components are arrays of immutable primitives or refs that flow through pipelines without ever being compared.
 public record LazyRleShortArray(
         DType dtype, long length, short[] values, int[] indices,
diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyRunEndByteArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyRunEndByteArray.java
@@ -4,12 +4,12 @@
 
 import java.util.function.LongBinaryOperator;
 
-/// Lazy RunEnd-encoded {@link ByteArray}. See {@link LazyRunEndLongArray} for semantics.
+/// Lazy RunEnd-encoded [ByteArray]. See [LazyRunEndLongArray] for semantics.
 ///
 /// @param dtype   logical element type
 /// @param length  total logical row count
 /// @param values  values per run
-/// @param runEnds cumulative run-end positions (absolute, before {@code offset})
+/// @param runEnds cumulative run-end positions (absolute, before `offset`)
 /// @param offset  starting absolute position
 public record LazyRunEndByteArray(DType dtype, long length, ByteArray values, Array runEnds, long offset)
         implements ByteArray {
diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyRunEndIntArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyRunEndIntArray.java
@@ -5,12 +5,12 @@
 import java.util.function.IntBinaryOperator;
 import java.util.function.IntConsumer;
 
-/// Lazy RunEnd-encoded {@link IntArray}. See {@link LazyRunEndLongArray} for semantics.
+/// Lazy RunEnd-encoded [IntArray]. See [LazyRunEndLongArray] for semantics.
 ///
 /// @param dtype   logical element type
 /// @param length  total logical row count
 /// @param values  values per run
-/// @param runEnds cumulative run-end positions (absolute, before {@code offset})
+/// @param runEnds cumulative run-end positions (absolute, before `offset`)
 /// @param offset  starting absolute position
 public record LazyRunEndIntArray(DType dtype, long length, IntArray values, Array runEnds, long offset)
         implements IntArray {
diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyRunEndLongArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyRunEndLongArray.java
@@ -5,21 +5,21 @@
 import java.util.function.LongBinaryOperator;
 import java.util.function.LongConsumer;
 
-/// Lazy RunEnd-encoded {@link LongArray}. {@code getLong(i) = values.getLong(findRun(i + offset))}.
-/// {@code forEachLong} / {@code fold} walk runs (one binary search at start, then per-run loops)
+/// Lazy RunEnd-encoded [LongArray]. `getLong(i) = values.getLong(findRun(i + offset))`.
+/// `forEachLong` / `fold` walk runs (one binary search at start, then per-run loops)
 /// so sequential reads are O(numRuns) work plus length emissions.
 ///
-/// The {@code runEnds} array is typed as {@link Array} because the run-ends ptype varies with
-/// the longest-run count — backed by one of {@link ByteArray}, {@link ShortArray},
-/// {@link IntArray}, {@link LongArray}.
+/// The `runEnds` array is typed as [Array] because the run-ends ptype varies with
+/// the longest-run count — backed by one of [ByteArray], [ShortArray],
+/// [IntArray], [LongArray].
 ///
 /// @param dtype   logical element type
 /// @param length  total logical row count
-/// @param values  values per run; length = {@code numRuns}
-/// @param runEnds cumulative run-end positions (absolute, before {@code offset});
-///                length = {@code numRuns}
-/// @param offset  starting absolute position; logical row {@code i} maps to
-///                absolute {@code i + offset}
+/// @param values  values per run; length = `numRuns`
+/// @param runEnds cumulative run-end positions (absolute, before `offset`);
+///                length = `numRuns`
+/// @param offset  starting absolute position; logical row `i` maps to
+///                absolute `i + offset`
 public record LazyRunEndLongArray(DType dtype, long length, LongArray values, Array runEnds, long offset)
         implements LongArray {
 
diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyRunEndShortArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazyRunEndShortArray.java
@@ -4,12 +4,12 @@
 
 import java.util.function.LongBinaryOperator;
 
-/// Lazy RunEnd-encoded {@link ShortArray}. See {@link LazyRunEndLongArray} for semantics.
+/// Lazy RunEnd-encoded [ShortArray]. See [LazyRunEndLongArray] for semantics.
 ///
 /// @param dtype   logical element type
 /// @param length  total logical row count
 /// @param values  values per run
-/// @param runEnds cumulative run-end positions (absolute, before {@code offset})
+/// @param runEnds cumulative run-end positions (absolute, before `offset`)
 /// @param offset  starting absolute position
 public record LazyRunEndShortArray(DType dtype, long length, ShortArray values, Array runEnds, long offset)
         implements ShortArray {
diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazySparseByteArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazySparseByteArray.java
@@ -4,7 +4,7 @@
 
 import java.util.function.LongBinaryOperator;
 
-/// Lazy Sparse-encoded {@link ByteArray}. See {@link LazySparseLongArray} for semantics.
+/// Lazy Sparse-encoded [ByteArray]. See [LazySparseLongArray] for semantics.
 ///
 /// @param dtype         logical element type
 /// @param length        total logical row count
diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazySparseDoubleArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazySparseDoubleArray.java
@@ -5,7 +5,7 @@
 import java.util.function.DoubleBinaryOperator;
 import java.util.function.DoubleConsumer;
 
-/// Lazy Sparse-encoded {@link DoubleArray}. See {@link LazySparseLongArray} for semantics.
+/// Lazy Sparse-encoded [DoubleArray]. See [LazySparseLongArray] for semantics.
 ///
 /// @param dtype         logical element type
 /// @param length        total logical row count
diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazySparseFloatArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazySparseFloatArray.java
@@ -4,7 +4,7 @@
 
 import java.util.function.DoubleBinaryOperator;
 
-/// Lazy Sparse-encoded {@link FloatArray}. See {@link LazySparseLongArray} for semantics.
+/// Lazy Sparse-encoded [FloatArray]. See [LazySparseLongArray] for semantics.
 ///
 /// @param dtype         logical element type
 /// @param length        total logical row count
diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazySparseIntArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazySparseIntArray.java
@@ -5,7 +5,7 @@
 import java.util.function.IntBinaryOperator;
 import java.util.function.IntConsumer;
 
-/// Lazy Sparse-encoded {@link IntArray}. See {@link LazySparseLongArray} for semantics.
+/// Lazy Sparse-encoded [IntArray]. See [LazySparseLongArray] for semantics.
 ///
 /// @param dtype         logical element type
 /// @param length        total logical row count
diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazySparseLongArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazySparseLongArray.java
@@ -5,22 +5,22 @@
 import java.util.function.LongBinaryOperator;
 import java.util.function.LongConsumer;
 
-/// Lazy Sparse-encoded {@link LongArray}: {@code getLong(i) = patches[binSearch(i + offset)]
-/// or fillValue}. The {@code patchIndices} array is typed as {@link Array} because the
-/// indices ptype varies — backed by one of {@link ByteArray}, {@link ShortArray},
-/// {@link IntArray}, {@link LongArray}.
+/// Lazy Sparse-encoded [LongArray]: {@code getLong(i) = patches[binSearch(i + offset)]
+/// or fillValue}. The `patchIndices` array is typed as [Array] because the
+/// indices ptype varies — backed by one of [ByteArray], [ShortArray],
+/// [IntArray], [LongArray].
 ///
-/// {@code forEachLong} / {@code fold} walk the patches in order, emitting {@code fillValue}
+/// `forEachLong` / `fold` walk the patches in order, emitting `fillValue`
 /// for runs of unpatched positions — O(numPatches) binary-search-equivalent steps plus
-/// {@code length} emissions, not O(length × log(numPatches)).
+/// `length` emissions, not O(length × log(numPatches)).
 ///
 /// @param dtype         logical element type
 /// @param length        total logical row count
 /// @param fillValue     value at every unpatched position
-/// @param patchValues   values for patched positions; length = {@code numPatches}
-/// @param patchIndices  sorted absolute positions of patches; length = {@code numPatches}
-/// @param offset        starting absolute position; logical row {@code i} maps to
-///                      absolute {@code i + offset}
+/// @param patchValues   values for patched positions; length = `numPatches`
+/// @param patchIndices  sorted absolute positions of patches; length = `numPatches`
+/// @param offset        starting absolute position; logical row `i` maps to
+///                      absolute `i + offset`
 public record LazySparseLongArray(
         DType dtype, long length, long fillValue,
         LongArray patchValues, Array patchIndices, long offset)
diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazySparseShortArray.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/LazySparseShortArray.java
@@ -4,7 +4,7 @@
 
 import java.util.function.LongBinaryOperator;
 
-/// Lazy Sparse-encoded {@link ShortArray}. See {@link LazySparseLongArray} for semantics.
+/// Lazy Sparse-encoded [ShortArray]. See [LazySparseLongArray] for semantics.
 ///
 /// @param dtype         logical element type
 /// @param length        total logical row count
diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/RleArrays.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/RleArrays.java
@@ -1,36 +1,36 @@
 package io.github.dfa1.vortex.reader.array;
 
-/// Package-private constants and helpers shared by the {@code LazyRleXxxArray} records.
+/// Package-private constants and helpers shared by the `LazyRleXxxArray` records.
 ///
 /// FastLanes RLE works in fixed 1024-row chunks; per-row decode is
-/// {@code chunkIdx = absRow >> 10}, {@code rowInChunk = absRow & 1023}. The chunk's
-/// local value count comes from {@code valuesIdxOffsets[chunkIdx+1] - valuesIdxOffsets[chunkIdx]};
-/// the per-row local index sits in {@code indices[chunkIdx * 1024 + rowInChunk]} and
-/// must be clamped to {@code numChunkValues - 1} (the writer encodes the constant-run
+/// `chunkIdx = absRow >> 10`, `rowInChunk = absRow & 1023`. The chunk's
+/// local value count comes from `valuesIdxOffsets[chunkIdx+1] - valuesIdxOffsets[chunkIdx]`;
+/// the per-row local index sits in `indices[chunkIdx * 1024 + rowInChunk]` and
+/// must be clamped to `numChunkValues - 1` (the writer encodes the constant-run
 /// case with a single value and may leave the slot's bits as 0).
 final class RleArrays {
 
     /// Fixed FastLanes chunk size in rows.
     static final int FL_CHUNK_SIZE = 1024;
 
-    /// {@code log2(FL_CHUNK_SIZE)} — used for cheap shift-based chunk indexing.
+    /// `log2(FL_CHUNK_SIZE)` — used for cheap shift-based chunk indexing.
     static final int FL_LOG2 = 10;
 
-    /// Mask for {@code absRow % FL_CHUNK_SIZE}.
+    /// Mask for `absRow % FL_CHUNK_SIZE`.
     static final int FL_MASK = FL_CHUNK_SIZE - 1;
 
     private RleArrays() {
     }
 
-    /// Returns the number of distinct values in {@code chunkIdx}.
+    /// Returns the number of distinct values in `chunkIdx`.
     ///
-    /// @param chunkIdx         chunk index in {@code [0, numChunks)}
+    /// @param chunkIdx         chunk index in `[0, numChunks)`
     /// @param numChunks        total chunk count
     /// @param valuesIdxOffsets per-chunk starting offsets into the global values pool
-    ///                         (length = {@code numChunks})
+    ///                         (length = `numChunks`)
     /// @param firstOffset      absolute origin of the pool (subtracted before lookup)
     /// @param valuesLen        total length of the values pool
-    /// @return distinct value count for {@code chunkIdx}
+    /// @return distinct value count for `chunkIdx`
     static int chunkValueCount(int chunkIdx, int numChunks, long[] valuesIdxOffsets,
             long firstOffset, long valuesLen) {
         long start = valuesIdxOffsets[chunkIdx] - firstOffset;
diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/RunEndArrays.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/RunEndArrays.java
@@ -2,20 +2,20 @@
 
 import io.github.dfa1.vortex.core.VortexException;
 
-/// Package-private helpers shared by the {@code LazyRunEndXxxArray} records.
+/// Package-private helpers shared by the `LazyRunEndXxxArray` records.
 ///
 /// Centralises:
 /// - the run-ends array-type switch in [#readRunEnd(Array, long)] so all four records
 ///   agree on supported run-ends Array types (U8/U16/U32/U64 backed by
-///   {@link ByteArray}/{@link ShortArray}/{@link IntArray}/{@link LongArray}); and
+///   [ByteArray]/[ShortArray]/[IntArray]/[LongArray]); and
 /// - the binary search in [#findRun(Array, long, long)] used by every scalar
 ///   accessor.
 final class RunEndArrays {
 
     private RunEndArrays() {
     }
 
-    /// Reads run-end {@code k} from {@code endsArr} as an unsigned long. One switch on the
+    /// Reads run-end `k` from `endsArr` as an unsigned long. One switch on the
     /// run-time concrete type per call — JIT inline-caches on the stable type.
     static long readRunEnd(Array endsArr, long k) {
         return switch (endsArr) {
@@ -28,9 +28,9 @@ static long readRunEnd(Array endsArr, long k) {
         };
     }
 
-    /// Locates the run that covers absolute position {@code absPos}: the smallest
-    /// {@code k} such that {@code runEnds[k] > absPos}. Binary searches over the
-    /// {@code numRuns} entries of {@code endsArr}.
+    /// Locates the run that covers absolute position `absPos`: the smallest
+    /// `k` such that `runEnds[k] > absPos`. Binary searches over the
+    /// `numRuns` entries of `endsArr`.
     static int findRun(Array endsArr, long numRuns, long absPos) {
         int lo = 0;
         int hi = (int) (numRuns - 1);
diff --git a/reader/src/main/java/io/github/dfa1/vortex/reader/array/SparseArrays.java b/reader/src/main/java/io/github/dfa1/vortex/reader/array/SparseArrays.java
diff --git a/reader/src/test/java/io/github/dfa1/vortex/reader/decode/LazyRunEndArrayTest.java b/reader/src/test/java/io/github/dfa1/vortex/reader/decode/LazyRunEndArrayTest.java
