refactor(reader): drop RLE Materialized fallbacks; close ADR 0013

Replace indicesValidity bit-scatter loop with OffsetBoolArray — lazy
slice over the decoded indices validity at the chunk offset.
Replace emptyArray Materialized returns with LazyConstantXxxArray(len=0).

Mark ADR 0013 Accepted; update 0.8.0 rollout section with what shipped.

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

Author: dfa1

docs/adr/0013-drop-materialized-fallbacks.md

@@ -1,6 +1,6 @@
 # ADR 0013: Drop Materialized fallbacks once Lazy has shipped
 
-- **Status:** Proposed
+- **Status:** Accepted
 - **Date:** 2026-06-16
 - **Deciders:** project maintainer
 - **Supersedes:** —
@@ -98,10 +98,15 @@ A Materialized branch may be deleted when **all** of these hold:
 ## Rollout
 
 - **0.7.x:** policy ratified, no removals yet.
-- **0.8.0:** remove eager paths from encodings that satisfy all four
-  criteria today: `ZigZag`, `FoR` (long/int variants), `ALP`,
-  `Constant`, `DateTimeParts`, `DecimalByteParts`, `Decimal`,
-  `VarBinView`, `Chunked` containers, `RunEnd`, `Sparse`, `RLE`, `Dict`.
+- **0.8.0:** eager paths removed from `ZigZag` (all PTypes + broadcast),
+  `FoR` (all integer PTypes), `ALP` (broadcast-without-patches),
+  `Constant` (Decimal → `LazyConstantDecimalArray`; `DecimalArray` interface
+  introduced to replace two concrete `Array` permits entries),
+  `RunEnd` (Bool → `LazyRunEndBoolArray`), `Sparse` (Bool → `LazySparseBoolArray`),
+  `RLE` (validity → `OffsetBoolArray`; empty → `LazyConstantXxxArray`).
+  `Dict` encoding-level path intentionally kept eager (layout-level path is lazy via ADR 0012).
+  `DateTimeParts`, `DecimalByteParts`, `Decimal`, `VarBinView`, `Chunked` were already
+  fully lazy before this sweep.
 - **0.9.0:** revisit Decompression encodings — if a Lazy variant lands
   (e.g. window-decoded `Pco`) the same criteria apply.
 

docs/compatibility.md

@@ -122,7 +122,7 @@ decoder falls into one of three shapes:
 | `fastlanes.bitpacked`       | Materialized  | Materialized  | window unpacks bits                                                      |
 | `fastlanes.delta`           | Materialized  | Materialized  | cumulative sum requires sequential decode                                |
 | `fastlanes.for`             | Lazy          | Lazy          | `LazyForXxxArray` (I8/U8/I16/U16/I32/U32/I64/U64), ADR 0010 + 0013      |
-| `fastlanes.rle`             | Materialized  | Lazy          | run-locating accessor possible                                           |
+| `fastlanes.rle`             | Lazy          | Lazy          | `LazyRleXxxArray`; validity → `OffsetBoolArray`; empty → `LazyConstantXxxArray`, ADR 0013 |
 | `vortex.patched`            | Materialized  | Materialized  | inner is full base + chunked patches (1024-elem blocks, lane-window-sorted); per-row access requires 2 laneOffsets reads + binary search inside the chunk window, so eager scatter wins for full scans |
 | `vortex.variant`            | Materialized  | TBD           | shredded child reassembly                                                |
 | `vortex.onpair`             | n/a           | n/a           | not ported                                                               |

reader/src/main/java/io/github/dfa1/vortex/reader/decode/RleEncodingDecoder.java

@@ -9,16 +9,16 @@
 import io.github.dfa1.vortex.reader.array.Array;
 import io.github.dfa1.vortex.reader.array.ArraySegments;
 import io.github.dfa1.vortex.reader.array.BoolArray;
+import io.github.dfa1.vortex.reader.array.LazyConstantByteArray;
+import io.github.dfa1.vortex.reader.array.LazyConstantIntArray;
+import io.github.dfa1.vortex.reader.array.LazyConstantLongArray;
+import io.github.dfa1.vortex.reader.array.LazyConstantShortArray;
 import io.github.dfa1.vortex.reader.array.LazyRleByteArray;
 import io.github.dfa1.vortex.reader.array.LazyRleIntArray;
 import io.github.dfa1.vortex.reader.array.LazyRleLongArray;
 import io.github.dfa1.vortex.reader.array.LazyRleShortArray;
 import io.github.dfa1.vortex.reader.array.MaskedArray;
-import io.github.dfa1.vortex.reader.array.MaterializedBoolArray;
-import io.github.dfa1.vortex.reader.array.MaterializedByteArray;
-import io.github.dfa1.vortex.reader.array.MaterializedIntArray;
-import io.github.dfa1.vortex.reader.array.MaterializedLongArray;
-import io.github.dfa1.vortex.reader.array.MaterializedShortArray;
+import io.github.dfa1.vortex.reader.array.OffsetBoolArray;
 
 import java.io.IOException;
 import java.lang.foreign.MemorySegment;
@@ -113,28 +113,18 @@ public Array decode(DecodeContext ctx) {
         if (indicesValidity == null) {
             return result;
         }
-        int validityBytes = (int) ((rowCount + 7) / 8);
-        MemorySegment validityBuf = ctx.arena().allocate(validityBytes);
-        for (long j = 0; j < rowCount; j++) {
-            if (indicesValidity.getBoolean(offset + j)) {
-                int byteIdx = (int) (j >>> 3);
-                byte current = validityBuf.get(ValueLayout.JAVA_BYTE, byteIdx);
-                validityBuf.set(ValueLayout.JAVA_BYTE, byteIdx, (byte) ((current & 0xff) | (1 << (j & 7))));
-            }
-        }
-        BoolArray outputValidity = new MaterializedBoolArray(new DType.Bool(false), rowCount, validityBuf);
+        BoolArray outputValidity = new OffsetBoolArray(new DType.Bool(false), rowCount, indicesValidity, offset);
         return new MaskedArray(result, outputValidity);
     }
 
     private static Array emptyArray(DecodeContext ctx) {
-        MemorySegment empty = ctx.arena().allocate(0);
         DType dt = ctx.dtype();
         PType ptype = ((DType.Primitive) dt).ptype();
         return switch (ptype) {
-            case I64, U64 -> new MaterializedLongArray(dt, 0L, empty);
-            case I32, U32 -> new MaterializedIntArray(dt, 0L, empty);
-            case I16, U16 -> new MaterializedShortArray(dt, 0L, empty);
-            case I8, U8 -> new MaterializedByteArray(dt, 0L, empty);
+            case I64, U64 -> new LazyConstantLongArray(dt, 0L, 0L);
+            case I32, U32 -> new LazyConstantIntArray(dt, 0L, 0);
+            case I16, U16 -> new LazyConstantShortArray(dt, 0L, (short) 0);
+            case I8, U8 -> new LazyConstantByteArray(dt, 0L, (byte) 0);
             default -> throw new VortexException(EncodingId.FASTLANES_RLE, "unsupported ptype " + ptype);
         };
     }