docs: record GitHub cold path win after nested FASS

Stateless GitHub 7-field extract ~5.6µs (was ~37–47µs), ahead of sonic
arm64 ~14µs; document that nested object-arrays no longer ban strides.

Author: shiaho777

README.md

@@ -566,8 +566,7 @@ Representative results on an Apple M4 Pro (lower is better):
 | Deep access + tape | **1.58 µs** / 0 B | — | — |
 
 `jseek` leads the lazy class on single-field, multi-path, deep homogeneous arrays
-(FASS), and IndexTape reuse — all **zero allocation**. Deep `users[250]` is also
-ahead of sonic's arm64 path (~22.7 µs). **It is not universally fastest:** tiny
-flat NDJSON field-by-field and some nested non-uniform cold shapes can still
-favor gjson/sonic — see [`docs/BENCHMARKS.md`](docs/BENCHMARKS.md) for the full
-honest boundaries, methodology, and how to reproduce.
+(FASS), and IndexTape reuse — all **zero allocation**. Deep `users[250]` (~3 µs) and GitHub-style issue arrays (~5.6 µs cold) are both
+ahead of sonic's arm64 path. **It is not universally fastest:** tiny flat NDJSON
+field-by-field can still favor gjson by single-digit percent — see
+[`docs/BENCHMARKS.md`](docs/BENCHMARKS.md) for full boundaries and methodology.

docs/ARCHITECTURE.md

@@ -112,11 +112,11 @@ gate that catches `$0-N` / `ret` vs `ret1` mistakes).
 ### Array strides (FASS)
 
 `findIndexObjectStride` in `navigate.go` accelerates minified homogeneous object
-arrays. Pure endpoint arithmetic only runs after **two** consecutive elements
-agree on `skipContainer` length (`strideConfirmed`); bulk/direct landings call
-`skipContainer` again. That keeps the fast path for real API-list payloads while
-preventing false index matches on malformed siblings that merely place a `}` at
-the expected offset.
+arrays — including elements that embed nested objects/arrays (GitHub-style
+`issues[].labels[]`). Pure endpoint arithmetic only runs after **two**
+consecutive elements agree on `skipContainer` length (`strideConfirmed`);
+bulk/direct landings call `skipContainer` again. Nested structure is allowed;
+safety is confirm+landing validation, not a ban on nested object-arrays.
 
 ### Sibling multi-key scan
 
@@ -139,8 +139,8 @@ member walk, using a small active-key set rather than a full multi-path trie.
    but need not match any particular library. Fast-path array strides over
    homogeneous object elements (FASS equal-size jumps in `navigate.go`) only
    activate after two consecutive `skipContainer` lengths match, and direct
-   landings are re-validated — endpoint shape alone is never enough to accept
-   an index.
+   landings are re-validated — nested object-arrays inside elements are allowed;
+   endpoint shape alone is never enough to accept an index.
 6. **The indexed engine is correct at any document size.** The structural index
    packs a 29-bit offset, so documents above 512 MiB cannot be indexed; rather
    than truncate the index (which would silently mis-answer queries into the

docs/BENCHMARKS.md

@@ -147,16 +147,17 @@ order-of-magnitude gain on deep/scattered access, queries still zero-allocation.
 
 | Approach | time | allocs |
 | --- | --- | --- |
-| jseek IndexTape (reused) | **1.54 µs** | 0 B |
-| jseek stateless | 47.4 µs | 0 B |
-| jseek per-request (pooled) | 55.4 µs | ~0–39 B |
-| sonic (arm64 cold) | **15.5 µs** | 328 B |
-| gjson GetMany | 60.3 µs | 664 B |
-| jsonparser | 154 µs | 0 B |
-
-**Takeaway:** reused IndexTape remains a blowout (**~39× vs gjson**). Cold
-stateless still trails sonic on this nested shape (sonic ~3×); per-request
-pooled stays competitive with gjson at near-zero alloc.
+| jseek IndexTape (reused) | **1.42 µs** | 0 B |
+| jseek stateless (FASS on nested issues) | **5.61 µs** | 0 B |
+| sonic (arm64 cold) | 14.3 µs | 331 B |
+| gjson GetMany | 50.2 µs | 664 B |
+| jsonparser | 137 µs | 0 B |
+
+**Takeaway:** FASS now applies to homogeneous object arrays **even when elements
+contain nested object-arrays** (safety is the two-element `skipContainer`
+confirm + landing re-validate, not a structural ban). Cold stateless GitHub is
+**~2.5× faster than sonic arm64** and **~9× faster than gjson**, still 0 B.
+IndexTape remains the multi-query blowout (~1.4 µs).
 
 ---
 
@@ -214,13 +215,13 @@ than JIT). Even so:
 | Large, shallow 2 fields | **93 ns** / 0 B | ~350 ns / 81 B | **jseek ~3.8×** |
 | Large, deep indexed 2 fields | **3.05 µs** / 0 B | 22.7 µs / 90 B | **jseek ~6.5×** (FASS) |
 | 12 scattered fields | **86 µs** / 0 B | 119 µs / 572 B | **jseek ~1.4×** |
-| GitHub 7 nested fields | 47.4 µs / 0 B | **15.5 µs** / 328 B | **sonic ~3×** |
+| GitHub 7 nested fields | **5.61 µs** / 0 B | 14.3 µs / 331 B | **jseek ~2.5×** |
 
 **Updated takeaway (2026-07-16):** FASS + confirmed equal-size strides closed the
-old "deep array index loses to sonic" hole on the large homogeneous-users
-fixture. The remaining cold loss is **deeply nested, non-uniform** documents
-(GitHub-style), where object shapes do not admit fixed strides and sonic's
-single pass still pays off.
+old deep-array and GitHub cold losses vs sonic arm64 on homogeneous issue/
+user arrays — including elements that embed nested object-arrays. Remaining
+lazy losses are tiny flat NDJSON field-by-field shapes (Result 6), not nested
+API documents.
 
 ### Amortized access (IndexTape reused)
 
@@ -236,7 +237,7 @@ single pass still pays off.
 | --- | --- |
 | Small / shallow cold | jseek leads, 0 alloc |
 | Homogeneous deep array cold | **jseek leads (FASS), 0 alloc** |
-| Nested non-uniform cold | sonic still leads ~3× |
+| Nested homogeneous cold (GitHub issues) | **jseek leads ~2.5×** |
 | IndexTape reuse | **jseek 10–46×, 0 alloc** |
 
 ---
@@ -250,6 +251,9 @@ single pass still pays off.
    deep-index CPU).
 3. **`EachKey` array edges use `findIndex` / relative `findIndexObjectStride`**
    — multi-path no longer walks every preceding array element with `skipValue`.
+4. **Drop the nested-object-array ban on FASS** — `labels:[{...}]` inside equal-size
+   issue objects no longer disables strides; confirm+landing checks keep it safe.
+5. **`EachArrayFields`** — single member pass per array element for column harvest.
 
 ## Discipline about the numbers