docs(adr-0013): record fused-kernel baseline + encoded-domain negative result

Baseline (100M rows, memory-bound): the fused Compute.filteredSum carries
~5% overhead over a hand-fused accessor loop (443.9 vs 421.4 ms/op) since
it still decodes via the accessor — no per-row win yet, by design.

Fail-fast probe on encoded-domain value comparison, per encoding:
- ALP / FoR are memory-bound (46.5 ms/op, identical to a plain i64 scan):
  the decode arithmetic is free under bandwidth, nothing to save.
- Dict is the only decode with real overhead (~11x a plain scan), but
  comparing codes instead of gathering values does NOT help
  (forLoopDictEncoded ties forLoopDict ~520 ms/op) — the gather is not the
  bottleneck, per-element accessor dispatch is.

Adds forLoopDictEncoded as a negative control and documents the finding
in the ADR: encoded-domain value specialization stays deferred because
the value path is not compute-bound at these column widths; the real
lever is a monomorphic/vectorized code scan, a separate effort.

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

Author: dfa1

docs/adr/0013-compute-primitives.md

@@ -41,6 +41,40 @@ consumer). The `Predicate` (§4) and `RowFilter` unification (§5) vocabulary is
 these kernels consume. The sections below are preserved as the original proposal; read §1–§3 as
 history, not as the built design.
 
+### Baseline for the encoded-domain specialization (2026-07-01)
+
+`ComputeKernelBenchmark` (100M rows, ≈ 800 MB/column, memory-bound, Apple silicon, JMH avg time):
+
+| Benchmark | Score |
+| --- | --- |
+| `forLoopFilteredSum` — hand-fused accessor loop (`price > 500` ALP filter, FoR `measure` sum) | 421.4 ms/op |
+| `fusedFilteredSumAlp` — today's `Compute.filteredSum`, same predicate | 443.9 ms/op |
+
+The fused kernel carries a ≈ 5 % overhead over the naive loop because it still decodes every element
+through the typed accessor before comparing — there is no per-row win yet, by design. This is the
+control the encoded-domain specialization must beat: compare and reduce in the ALP/FoR/Dict integer
+domain, below the naive-loop number. Note the fused kernel is still ≈ 1.5× faster than the *removed*
+`Mask` two-pass path it replaced — the overhead here is only against a hand-fused single loop.
+
+A fail-fast probe measured whether encoded-domain value comparison actually wins, per encoding:
+
+| Per-encoding count baseline | Score | Data read |
+| --- | --- | --- |
+| `forLoopPlainControl` (i64, no decode) | 46.4 ms/op | 800 MB |
+| `forLoopForLong` (FoR `+ ref`) | 46.7 ms/op | 800 MB |
+| `forLoopAlpDouble` (ALP `× f × e`) | 46.5 ms/op | 800 MB |
+| `forLoopDict` (gather `values[code]`) | ≈ 420–530 ms/op | 100 MB codes |
+| `forLoopDictEncoded` (compare codes, no gather) | ≈ 520 ms/op | 100 MB codes |
+
+The finding is negative and it is why encoded-domain specialization stays deferred: ALP and FoR are
+**memory-bound** — their decode arithmetic is free under bandwidth, identical to a plain i64 scan, so
+there is nothing for an integer-domain compare to save. Dict is the only decode with real overhead
+(≈ 11× a plain scan while reading 8× less data), but comparing codes instead of gathering values
+does **not** help (`forLoopDictEncoded` ties `forLoopDict`): the gather is not the bottleneck — the
+per-element accessor dispatch is, and both paths pay it. So the lever for dict is a monomorphic /
+vectorized segment scan of the codes, not the encoded-domain compare this ADR envisioned. Encoded
+values buy a win only once the value path is compute-bound, which at these column widths it is not.
+
 ## Context
 
 ADR 0010 establishes that the reader defers transform work until access

performance/src/main/java/io/github/dfa1/vortex/performance/ComputeKernelBenchmark.java

@@ -5,6 +5,7 @@
 import io.github.dfa1.vortex.reader.ReadRegistry;
 import io.github.dfa1.vortex.reader.VortexReader;
 import io.github.dfa1.vortex.reader.array.Array;
+import io.github.dfa1.vortex.reader.array.ByteArray;
 import io.github.dfa1.vortex.reader.array.DictLongArray;
 import io.github.dfa1.vortex.reader.array.DoubleArray;
 import io.github.dfa1.vortex.reader.array.LazyAlpDoubleArray;
@@ -296,6 +297,57 @@ public long forLoopDict() {
         return count;
     }
 
+    /// Encoded-domain `category == 7` count: the ADR-0013 encoded-domain control for a dictionary
+    /// equality filter. Resolves the constant to its dictionary code **once per chunk** (a scan of
+    /// the tiny value pool), then compares the raw `u8` codes directly — skipping the per-element
+    /// `values.getLong(readCode(i))` gather that [#forLoopDict()] pays.
+    ///
+    /// Result (2026-07-01, 100M rows): this is within noise of [#forLoopDict()] (≈ 520 vs ≈ 530
+    /// ms/op), so the value gather is NOT the dict path's bottleneck — both pay the same per-element
+    /// accessor cost (≈ 500 ms for a 100 MB code scan vs ≈ 46 ms for a plain 800 MB scan). Kept as a
+    /// negative control: encoded-domain value specialization alone does not speed up dict equality;
+    /// the lever is a monomorphic / vectorized segment scan of the codes, a separate optimization.
+    ///
+    /// @return the number of rows with `category == 7` over the whole dataset
+    @Benchmark
+    public long forLoopDictEncoded() {
+        long count = 0;
+        for (LongArray array : categoryChunks) {
+            // Chunked decode wraps some chunks in an OffsetLongArray slice view; unwrap it to the
+            // DictLongArray and carry its offset into the code index (codes[i + offset]).
+            LongArray base = array;
+            long codeOffset = 0;
+            if (base instanceof OffsetLongArray off) {
+                codeOffset = off.offset();
+                base = off.inner();
+            }
+            DictLongArray dict = (DictLongArray) base;
+            LongArray values = dict.values();
+            ByteArray codes = (ByteArray) dict.codes();
+            // Resolve category==7 to its code once. The pool holds distinct values, so at most one
+            // code matches; an absent value means no row in this chunk matches.
+            long match = -1;
+            long poolSize = values.length();
+            for (long c = 0; c < poolSize; c++) {
+                if (values.getLong(c) == CATEGORY_VALUE) {
+                    match = c;
+                    break;
+                }
+            }
+            long n = array.length();
+            if (match < 0) {
+                continue;
+            }
+            byte matchByte = (byte) match;
+            for (long i = 0; i < n; i++) {
+                if (codes.getByte(i + codeOffset) == matchByte) {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+
     /// Naive `plain > 0` count baseline: the hand-written count loop over the materialized accessor
     /// across every chunk, reading each long straight from the segment per element.
     ///