yeptris 0.6.26.2-arm-linux-eabihf → 0.6.28.1-arm-linux-eabihf

data/vendor/libyeptris/src/yeptris/tape.c

@@ -140,11 +140,12 @@ static int tape_put_root_scalar(tape_ctx* c, const char* p, size_t len, size_t a
 /* The punctuation inline (the simdjson tape-builder lesson): after a
  * value or a key, the next token is a comma/colon or the close —
  * consume it inline instead of paying a full loop iteration for a
- * one-byte state flip. Anything else (close, garbage, a tab) falls
- * through with the cursor parked for the main loop to judge. */
+ * one-byte state flip. Anything else (close, garbage) falls through
+ * with the cursor parked for the main loop to judge. Whitespace here
+ * is RFC 8259's set — tab included. */
 static inline uint8_t tape_inline_punct(const char* p, size_t len, size_t* i, uint8_t want) {
     size_t j = *i;
-    while (j < len && (p[j] == ' ' || p[j] == '\n' || p[j] == '\r')) {
+    while (j < len && (p[j] == ' ' || p[j] == '\t' || p[j] == '\n' || p[j] == '\r')) {
         j++;
     }
     if (j < len && (uint8_t)p[j] == want) {
@@ -186,10 +187,10 @@ static YeptrisStatus tape_walk(const char* p, size_t len, size_t open, yeptris_j
 
     size_t i = open + 1;
     for (;;) {
-        while (i < len && (p[i] == ' ' || p[i] == '\n' || p[i] == '\r')) {
+        while (i < len && (p[i] == ' ' || p[i] == '\t' || p[i] == '\n' || p[i] == '\r')) {
             i++;
         }
-        if (i >= len || p[i] == '\t') {
+        if (i >= len) {
             goto reject;
         }
         size_t at = i;
@@ -329,8 +330,8 @@ static YeptrisStatus tape_walk(const char* p, size_t len, size_t open, yeptris_j
             }
             if (at + wl < len) {
                 char z = p[at + wl];
-                if (z != ' ' && z != '\n' && z != '\r' && z != ',' && z != ']' && z != '}' &&
-                    z != ':') {
+                if (z != ' ' && z != '\t' && z != '\n' && z != '\r' && z != ',' && z != ']' &&
+                    z != '}' && z != ':') {
                     goto reject;
                 }
             }
@@ -546,70 +547,663 @@ static YEP_UNUSED_FN YeptrisStatus tape_walk_idx(const char* p, size_t len, size
             }
             if (at + wl < len) {
                 char z = p[at + wl];
-                if (z != ' ' && z != '\n' && z != '\r' && z != ',' && z != ']' && z != '}' &&
-                    z != ':') {
+                if (z != ' ' && z != '\t' && z != '\n' && z != '\r' && z != ',' && z != ']' &&
+                    z != '}' && z != ':') {
                     goto reject;
                 }
             }
-            kinds[count] = c == 'n' ? YEP_T_NULL : (c == 't' ? YEP_T_TRUE : YEP_T_FALSE);
-            offs[count] = (uint32_t)at;
-            lens[count] = (uint32_t)wl;
-            count++;
-            prev_end = at + wl;
-            top_expect = JW_COMMA_OR_CLOSE;
-            key_slot = 0;
-            continue;
+            kinds[count] = c == 'n' ? YEP_T_NULL : (c == 't' ? YEP_T_TRUE : YEP_T_FALSE);
+            offs[count] = (uint32_t)at;
+            lens[count] = (uint32_t)wl;
+            count++;
+            prev_end = at + wl;
+            top_expect = JW_COMMA_OR_CLOSE;
+            key_slot = 0;
+            continue;
+        }
+        goto reject;
+    }
+    /* trailing whitespace only */
+    while (prev_end < len && (p[prev_end] == ' ' || p[prev_end] == '\t' || p[prev_end] == '\n' ||
+                              p[prev_end] == '\r')) {
+        prev_end++;
+    }
+    if (prev_end != len) {
+        goto reject;
+    }
+    if (count > len + 2) {
+        goto mem;
+    }
+    t->count = count;
+    t->_src = p;
+    t->_srclen = len;
+    return YEPTRIS_OK;
+
+mem:
+    yeptris_tape_free(t);
+    return YEPTRIS_ERROR_MEMORY;
+reject:
+    yeptris_tape_free(t);
+    return YEPTRIS_ERROR_PARSE;
+}
+
+/* The LENIENT token walk (the simdjson deferred contract): stage-1
+ * positions consumed with the grammar arms removed. Structural
+ * alternation mirrors tape_walk_idx state for state — bracket
+ * matching, key/value placement, literals (packed compares), and
+ * string closes/escapes (yep_json_string) all stay parse-time
+ * checks; NUMBER grammar does not — the arm records the scalar-run
+ * span (start to the next token's position, trailing ws trimmed)
+ * as YEP_T_NUM and yeptris_tape_convert owns validation and the
+ * int/float split. A malformed number ("12ab") therefore rejects at
+ * drain, not parse. */
+/* The fused LENIENT walk: the strict walk's byte loop with the number
+ * grammar deferred — the arm records the run to its natural delimiter
+ * (the classify scan carries no accept/reject structure) and
+ * yeptris_tape_convert owns validation. Everything else matches
+ * tape_walk state for state. */
+/* LNUM_RUN — the initial digit run of a number span: SWAR words, eight
+ * bytes per pass, with the byte loop below as tail and classifier.
+ * digit iff 0x30-0x39: a lane flags when (c+0x46) carries into bit7
+ * (c > '9'), when ((c|0x80)-0xB0) goes negative (c < '0'), or when the
+ * byte is non-ASCII — and since the all-digit prefix never borrows
+ * across lanes, the flags are exact up to the first non-digit, where
+ * the scan stops and the byte loop classifies what follows (the
+ * consumed-only digits_only law is untouched: the run sets saw_digit,
+ * nothing else). */
+#define LNUM_RUN                                                                                   \
+    do {                                                                                           \
+        size_t ks_ = k;                                                                            \
+        while (k + 8 <= len) {                                                                     \
+            uint64_t w_;                                                                           \
+            memcpy(&w_, p + k, 8);                                                                 \
+            uint64_t nd_ =                                                                         \
+                ((w_ + 0x4646464646464646ull) & 0x8080808080808080ull) |                           \
+                (((w_ | 0x8080808080808080ull) - 0xB0B0B0B0B0B0B0B0ull) & 0x8080808080808080ull) | \
+                (w_ & 0x8080808080808080ull);                                                      \
+            if (nd_ != 0) {                                                                        \
+                k += (size_t)yep_ctz64(nd_) >> 3;                                                  \
+                break;                                                                             \
+            }                                                                                      \
+            k += 8;                                                                                \
+        }                                                                                          \
+        if (k > ks_) {                                                                             \
+            saw_digit = 1;                                                                         \
+        }                                                                                          \
+    } while (0)
+
+/* The strict RFC 8259 number check over one number-ish run — the
+ * in-walk float/exp validator (the out-of-line number_shape call +
+ * rescan was 13% of json-doc; the digits-only case never gets here).
+ * One pass, no state machine words: sign, digits (leading-zero rule),
+ * optional .digits, optional e[+-]digits, consume exactly len.
+ * always_inline: the spans are 3-8 bytes and the out-of-line call was
+ * the cost (the rescan itself is nothing). */
+#if defined(__GNUC__)
+#define TAPE_NUM_OK_INLINE __attribute__((always_inline)) inline
+#else
+#define TAPE_NUM_OK_INLINE
+#endif
+static TAPE_NUM_OK_INLINE int tape_num_ok(const char* p, size_t len) {
+    size_t k = 0;
+    if (k < len && p[k] == '-') {
+        k++;
+    }
+    size_t int_start = k;
+    while (k < len && (unsigned)(unsigned char)p[k] - '0' <= 9u) {
+        k++;
+    }
+    if (k == int_start) {
+        return 0; /* no integer part */
+    }
+    if (k - int_start > 1 && p[int_start] == '0') {
+        return 0; /* leading zero */
+    }
+    if (k < len && p[k] == '.') {
+        k++;
+        size_t frac = k;
+        while (k < len && (unsigned)(unsigned char)p[k] - '0' <= 9u) {
+            k++;
+        }
+        if (k == frac) {
+            return 0;
+        }
+    }
+    if (k < len && (p[k] == 'e' || p[k] == 'E')) {
+        k++;
+        if (k < len && (p[k] == '+' || p[k] == '-')) {
+            k++;
+        }
+        size_t exp = k;
+        while (k < len && (unsigned)(unsigned char)p[k] - '0' <= 9u) {
+            k++;
+        }
+        if (k == exp) {
+            return 0;
+        }
+    }
+    return k == len;
+}
+
+YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open,
+                                          yeptris_json_tape* t, int strict_nums, int clean_only,
+                                          int reuse_block) {
+    /* reuse_block: the caller owns the struct and zeroed it (the flow
+     * recorder's scratch) — a prior walk's block may be reused through
+     * the _srclen watermark. Consumer structs carry untrustworthy
+     * fields and always carve fresh. */
+    if (reuse_block && t->_block != NULL && t->recs != NULL && t->_rec_primary &&
+        t->_srclen >= len + 2) {
+        t->_cols_ready = 0;
+        t->_rec_primary = 1;
+    } else if (tape_carve(t, len) != YEPTRIS_OK) {
+        return YEPTRIS_ERROR_MEMORY;
+    }
+    t->_rec_primary = 1;
+    /* the interleaved records are the primary storage (item 07); the
+     * columns materialize lazily via yeptris_tape_columns */
+    t->_rec_primary = 1;
+    yeptris_tape_rec* recs = t->recs;
+    uint32_t open_at[YEP_JSON_WALK_DEPTH];
+    uint8_t kind[YEP_JSON_WALK_DEPTH];
+
+    recs[0] = ((uint64_t)0 << 32) | ((uint64_t)0 << 8) | YEP_T_DOC;
+
+    uint8_t top_kind = p[open] == '[' ? 0 : 1;
+    recs[1] =
+        ((uint64_t)0 << 32) | ((uint64_t)0 << 8) | (top_kind ? YEP_T_MAP_OPEN : YEP_T_SEQ_OPEN);
+    size_t count = 2;
+    int depth = 1;
+    open_at[0] = 1;
+    kind[0] = top_kind;
+
+    size_t i = open + 1;
+    /* clean_only (parse_json's route): tabs and non-ASCII bytes REJECT
+     * — the caller falls to the strict sequence, which owns the pinned
+     * error precedences those inputs carry (the tab reject, the UTF-8
+     * gate). This replaces the entry's full-input gate_scan +
+     * tab-memchr pre-passes: same routing by construction, zero scans
+     * before the walk. */
+    int cl = clean_only;
+    if (top_kind) {
+        goto lmap1;
+    }
+    goto lseq1;
+
+    /* strict_nums: the parse_json route's contract is RFC 8259 AT
+     * parse time, so its number arms validate the run in-place (the
+     * settle pass disappears — the span is cache-warm here); the
+     * standalone lenient entry keeps its deferred contract (0: the
+     * run records unvalidated, yeptris_tape_convert owns it). */
+
+    /* The specialized member loops (the #342 dispatch-chain cut): once
+     * inside a container the grammar is a 2-state cycle — member or
+     * separator — so the general chain's expect/key_slot machine and
+     * its per-token re-dispatch are replaced by direct loops per kind.
+     * Acceptance is IDENTICAL to the chain (the pinning suites hold:
+     * Tape suite, LenientMatchesStrict, ErrorParity, the json corpora).
+     *
+     * lmap / lseq: positioned at a member (or the container's closer).
+     * lvalue: scans one value (string/number/literal/container).
+     * lafter: positioned after a complete value — ',' or the closer.
+     * A close pops the frame; depth 0 ends the walk. */
+
+#define LWS()                                                                                      \
+    do {                                                                                           \
+        while (i < len &&                                                                          \
+               (p[i] == ' ' || p[i] == '\n' || p[i] == '\r' || (p[i] == '\t' && !cl))) {           \
+            i++;                                                                                   \
+        }                                                                                          \
+        if (i >= len) {                                                                            \
+            goto lreject;                                                                          \
+        }                                                                                          \
+    } while (0)
+
+#define LPUSH(k)                                                                                   \
+    do {                                                                                           \
+        if (depth >= YEP_JSON_WALK_DEPTH) {                                                        \
+            goto lreject;                                                                          \
+        }                                                                                          \
+        recs[count] = ((uint64_t)0 << 32) | ((uint64_t)0 << 8) |                                   \
+                      (uint64_t)((k) ? YEP_T_MAP_OPEN : YEP_T_SEQ_OPEN);                           \
+        kind[depth] = (k);                                                                         \
+        open_at[depth] = (uint32_t)count;                                                          \
+        count++;                                                                                   \
+        depth++;                                                                                   \
+        i++;                                                                                       \
+    } while (0)
+
+#define LCLOSE()                                                                                   \
+    do {                                                                                           \
+        uint32_t lo_ = open_at[depth - 1];                                                         \
+        recs[count] = ((uint64_t)lo_ << 32) | ((uint64_t)0 << 8) | YEP_T_CLOSE;                    \
+        recs[lo_] =                                                                                \
+            (recs[lo_] & ~(uint64_t)0xFFFFFFFF00000000u) | ((uint64_t)(uint32_t)count << 32);      \
+        count++;                                                                                   \
+        i++;                                                                                       \
+        depth--;                                                                                   \
+        if (depth == 0) {                                                                          \
+            goto ldone;                                                                            \
+        }                                                                                          \
+        if (kind[depth - 1]) {                                                                     \
+            goto lmapafter;                                                                        \
+        }                                                                                          \
+        goto lseqafter;                                                                            \
+    } while (0)
+
+/* LSTR_SCAN(after) — the fused string arm, positioned at p[i] == '"'.
+ * One SWAR round settles the common short span; quote_scan (the SIMD
+ * close scan) settles longer no-escape spans, with a c0 sweep over the
+ * content (quote_scan never tests control bytes); the kernel runs only
+ * when escapes appear — its grammar authority covers the escape rules
+ * quote_scan skips. `after` names the post-member label. */
+#define LSTR_SCAN(after)                                                                           \
+    do {                                                                                           \
+        size_t j_ = i + 1;                                                                         \
+        int esc_ = 0;                                                                              \
+        if (j_ + 8 <= len) {                                                                       \
+            uint64_t w_;                                                                           \
+            memcpy(&w_, p + j_, 8);                                                                \
+            uint64_t qm_ = (w_ ^ 0x2222222222222222ull);                                           \
+            uint64_t bm_ = (w_ ^ 0x5C5C5C5C5C5C5C5Cull);                                           \
+            qm_ = (qm_ - 0x0101010101010101ull) & ~qm_ & 0x8080808080808080ull;                    \
+            bm_ = (bm_ - 0x0101010101010101ull) & ~bm_ & 0x8080808080808080ull;                    \
+            uint64_t c0_ = (w_ - 0x2020202020202020ull) & ~w_ & 0x8080808080808080ull;             \
+            uint64_t hi_ = cl ? (w_ & 0x8080808080808080ull) : 0;                                  \
+            if (qm_ != 0 && ((bm_ | c0_ | hi_) & (qm_ - 1)) == 0) {                                \
+                size_t cl_ = j_ + (size_t)yep_ctz64(qm_) / 8;                                      \
+                recs[count] = ((uint64_t)((uint32_t)j_) << 32) |                                   \
+                              ((uint64_t)((uint32_t)(cl_ - j_)) << 8) | (uint64_t)(YEP_T_STR);     \
+                count++;                                                                           \
+                i = cl_ + 1;                                                                       \
+                goto after;                                                                        \
+            }                                                                                      \
+            /* rounds 2-4 (up to 32 bytes inline): the email-class strings                         \
+             * close here without the quote_scan call and its redundant                            \
+             * content re-sweep; reached only when round 1 had no close,                           \
+             * so the short-string case pays nothing */                                            \
+            if ((qm_ | bm_ | c0_ | hi_) == 0) {                                                    \
+                size_t nr_ = (len - j_) >> 3;                                                      \
+                if (nr_ > 4) {                                                                     \
+                    nr_ = 4;                                                                       \
+                }                                                                                  \
+                for (size_t r_ = 1; r_ < nr_; r_++) {                                              \
+                    size_t b2_ = j_ + (r_ << 3);                                                   \
+                    memcpy(&w_, p + b2_, 8);                                                       \
+                    qm_ = (w_ ^ 0x2222222222222222ull);                                            \
+                    bm_ = (w_ ^ 0x5C5C5C5C5C5C5C5Cull);                                            \
+                    qm_ = (qm_ - 0x0101010101010101ull) & ~qm_ & 0x8080808080808080ull;            \
+                    bm_ = (bm_ - 0x0101010101010101ull) & ~bm_ & 0x8080808080808080ull;            \
+                    c0_ = (w_ - 0x2020202020202020ull) & ~w_ & 0x8080808080808080ull;              \
+                    hi_ = cl ? (w_ & 0x8080808080808080ull) : 0;                                   \
+                    if (qm_ != 0 && ((bm_ | c0_ | hi_) & (qm_ - 1)) == 0) {                        \
+                        size_t cl_ = b2_ + (size_t)yep_ctz64(qm_) / 8;                             \
+                        recs[count] = ((uint64_t)((uint32_t)j_) << 32) |                           \
+                                      ((uint64_t)((uint32_t)(cl_ - j_)) << 8) |                    \
+                                      (uint64_t)(YEP_T_STR);                                       \
+                        count++;                                                                   \
+                        i = cl_ + 1;                                                               \
+                        goto after;                                                                \
+                    }                                                                              \
+                    if ((qm_ | bm_ | c0_ | hi_) != 0) {                                            \
+                        break; /* escape, c0 or hi: kernel authority */                            \
+                    }                                                                              \
+                }                                                                                  \
+            }                                                                                      \
+        }                                                                                          \
+        {                                                                                          \
+            const yep_text_kernels* kk_ = yep_text_active();                                       \
+            ptrdiff_t r_ = kk_->quote_scan(p + j_, len - j_, '"', &esc_);                          \
+            if (r_ >= 0 && esc_ == 0) {                                                            \
+                size_t cl_ = j_ + (size_t)r_;                                                      \
+                for (size_t b_ = j_; b_ < cl_;) {                                                  \
+                    size_t room_ = cl_ - b_;                                                       \
+                    if (room_ >= 8) {                                                              \
+                        uint64_t v_;                                                               \
+                        memcpy(&v_, p + b_, 8);                                                    \
+                        uint64_t bad_ =                                                            \
+                            (v_ - 0x2020202020202020ull) & ~v_ & 0x8080808080808080ull;            \
+                        if (cl) {                                                                  \
+                            bad_ |= v_ & 0x8080808080808080ull;                                    \
+                        }                                                                          \
+                        if (bad_) {                                                                \
+                            goto lreject;                                                          \
+                        }                                                                          \
+                        b_ += 8;                                                                   \
+                    } else {                                                                       \
+                        if ((unsigned char)p[b_] < 0x20 || (cl && (unsigned char)p[b_] >= 0x80)) { \
+                            goto lreject;                                                          \
+                        }                                                                          \
+                        b_++;                                                                      \
+                    }                                                                              \
+                }                                                                                  \
+                recs[count] = ((uint64_t)((uint32_t)j_) << 32) |                                   \
+                              ((uint64_t)((uint32_t)(cl_ - j_)) << 8) | (uint64_t)(YEP_T_STR);     \
+                count++;                                                                           \
+                i = cl_ + 1;                                                                       \
+                goto after;                                                                        \
+            }                                                                                      \
+        }                                                                                          \
+        {                                                                                          \
+            size_t at_ = i;                                                                        \
+            size_t cl_ = 0;                                                                        \
+            if (!yep_json_string(p, len, &i, &cl_, &esc_)) {                                       \
+                goto lreject;                                                                      \
+            }                                                                                      \
+            if (cl) { /* escaped strings skip the sweeps above: the                                \
+                       * clean route still owes the strict sequence's                              \
+                       * byte guarantees over the content */                                       \
+                for (size_t b_ = at_ + 1; b_ < cl_; b_++) {                                        \
+                    unsigned char uc_ = (unsigned char)p[b_];                                      \
+                    if (uc_ < 0x20 || uc_ >= 0x80) {                                               \
+                        goto lreject;                                                              \
+                    }                                                                              \
+                }                                                                                  \
+            }                                                                                      \
+            recs[count] = ((uint64_t)((uint32_t)(at_ + 1)) << 32) |                                \
+                          ((uint64_t)((uint32_t)(cl_ - at_ - 1)) << 8) | (uint64_t)(YEP_T_STR);    \
+            count++;                                                                               \
+            i = cl_ + 1;                                                                           \
+        }                                                                                          \
+        goto after;                                                                                \
+    } while (0)
+
+/* The map member cycle — ONE contiguous region (the json-doc lesson:
+ * a goto web across value/key/after regions scattered the hot path and
+ * cost 2.7x on the flat-map shape). Values scan inline; only nested
+ * containers, literals, and the kernel string fallback leave the
+ * cycle. Acceptance is the chain's: no trailing commas, string keys
+ * only, `:` required, closers only in first-member position. */
+lmap1: /* {} closes here */
+    LWS();
+    if (p[i] == '}') {
+        LCLOSE();
+    }
+    if (p[i] != '"') {
+        goto lreject;
+    }
+    goto lmapkey;
+
+lmap: /* a member MUST follow (after ','): JW_KEY — a closer rejects */
+    /* compact fast path: the byte is the key's quote already — LWS's
+     * loop would examine it once and exit */
+    if (i < len && p[i] == '"') {
+        goto lmapkey;
+    }
+    LWS();
+    if (p[i] != '"') {
+        goto lreject;
+    }
+lmapkey: { LSTR_SCAN(lmapcolon); }
+lmapcolon:
+    if (i < len && p[i] == ':') {
+        i++;
+        /* compact fast path: the value byte follows the colon with no
+         * whitespace — one load dispatches it (the ws test below is
+         * what LWS would run anyway) */
+        if (i < len) {
+            char v = p[i];
+            if (v != ' ' && v != '\n' && v != '\r' && (cl || v != '\t')) {
+                goto lmapval;
+            }
+        }
+        LWS();
+        goto lmapval;
+    }
+    LWS();
+    if (p[i] != ':') {
+        goto lreject;
+    }
+    i++;
+    LWS();
+lmapval: {
+    char c = p[i];
+    if (c == '"') {
+        LSTR_SCAN(lmapafter);
+    }
+    if ((unsigned)(c - '0') <= 9u || c == '-') {
+        size_t k = i + 1;
+        /* the digits-only tracking makes the pure-integer case a
+         * 3-cycle leading-zero check — number_shape (a call + a
+         * rescan, 13% of json-doc) runs only for dot/exp spans */
+        int digits_only = 1, saw_digit = (c != '-');
+        LNUM_RUN;
+        while (k < len) {
+            char d = p[k];
+            if ((unsigned)(d - '0') <= 9u) {
+                k++;
+                saw_digit = 1;
+                continue;
+            }
+            /* the flag clears only on a CONSUMED byte: the run's
+             * terminator (',', '}', ']', whitespace) must leave
+             * digits_only intact, or every plain integer followed
+             * by a delimiter falls into the full validator */
+            if (d == '-' || d == '+' || d == '.' || d == 'e' || d == 'E') {
+                digits_only = 0;
+                k++;
+                continue;
+            }
+            break;
+        }
+        if (strict_nums) {
+            int ok;
+            if (digits_only && saw_digit) {
+                size_t d0 = (c == '-') ? i + 1 : i;
+                ok = (k - d0 == 1) || p[d0] != '0';
+            } else {
+                ok = tape_num_ok(p + i, (size_t)(k - i));
+            }
+            if (!ok) {
+                goto lreject;
+            }
+        }
+        recs[count] =
+            ((uint64_t)((uint32_t)i) << 32) | ((uint64_t)((uint32_t)(k - i)) << 8) |
+            (uint64_t)(strict_nums ? ((digits_only && saw_digit) ? YEP_T_INT : YEP_T_FLOAT)
+                                   : (uint64_t)(YEP_T_NUM));
+        count++;
+        i = k;
+        goto lmapafter;
+    }
+    if (c == 't' || c == 'f' || c == 'n') {
+        size_t wl = c == 'f' ? 5 : 4;
+        if (i + wl > len) {
+            goto lreject;
+        }
+        uint32_t got4;
+        memcpy(&got4, p + i, 4);
+        if (got4 != (c == 't'   ? 0x65757274u /* "true" */
+                     : c == 'n' ? 0x6C6C756Eu /* "null" */
+                                : 0x736C6166u /* "fals" */) ||
+            (c == 'f' && p[i + 4] != 'e')) {
+            goto lreject;
+        }
+        if (i + wl < len) {
+            char z = p[i + wl];
+            if (z != ' ' && z != '\t' && z != '\n' && z != '\r' && z != ',' && z != ']' &&
+                z != '}' && z != ':') {
+                goto lreject;
+            }
+        }
+        recs[count] = ((uint64_t)((uint32_t)i) << 32) | ((uint64_t)((uint32_t)wl) << 8) |
+                      (uint64_t)(c == 'n' ? YEP_T_NULL : (c == 't' ? YEP_T_TRUE : YEP_T_FALSE));
+        count++;
+        i += wl;
+        goto lmapafter;
+    }
+    if (c == '{') {
+        LPUSH(1);
+        goto lmap1;
+    }
+    if (c == '[') {
+        LPUSH(0);
+        goto lseq1;
+    }
+    goto lreject;
+}
+
+lmapafter:
+    /* compact fast path: value ',' key directly — the two LWS hops the
+     * general form runs both exit on byte one here */
+    if (i < len && p[i] == ',') {
+        i++;
+        if (i < len && p[i] == '"') {
+            goto lmapkey;
+        }
+        goto lmap;
+    }
+    LWS();
+    if (p[i] == ',') {
+        i++;
+        goto lmap;
+    }
+    if (p[i] == '}') {
+        LCLOSE();
+    }
+    goto lreject;
+
+/* The sequence member cycle — the same single-region shape. */
+lseq1: /* [] closes here */
+    LWS();
+    if (p[i] == ']') {
+        LCLOSE();
+    }
+    goto lseqval;
+
+lseq: /* a member MUST follow (after ','): JW_VALUE */
+    LWS();
+lseqval: {
+    char c = p[i];
+    if (c == '"') {
+        LSTR_SCAN(lseqafter);
+    }
+    if ((unsigned)(c - '0') <= 9u || c == '-') {
+        size_t k = i + 1;
+        int digits_only = 1, saw_digit = (c != '-');
+        LNUM_RUN;
+        while (k < len) {
+            char d = p[k];
+            if ((unsigned)(d - '0') <= 9u) {
+                k++;
+                saw_digit = 1;
+                continue;
+            }
+            /* consumed-only clearing: see the map arm's comment */
+            if (d == '-' || d == '+' || d == '.' || d == 'e' || d == 'E') {
+                digits_only = 0;
+                k++;
+                continue;
+            }
+            break;
+        }
+        if (strict_nums) {
+            int ok;
+            if (digits_only && saw_digit) {
+                size_t d0 = (c == '-') ? i + 1 : i;
+                ok = (k - d0 == 1) || p[d0] != '0';
+            } else {
+                ok = tape_num_ok(p + i, (size_t)(k - i));
+            }
+            if (!ok) {
+                goto lreject;
+            }
+        }
+        recs[count] =
+            ((uint64_t)((uint32_t)i) << 32) | ((uint64_t)((uint32_t)(k - i)) << 8) |
+            (uint64_t)(strict_nums ? ((digits_only && saw_digit) ? YEP_T_INT : YEP_T_FLOAT)
+                                   : (uint64_t)(YEP_T_NUM));
+        count++;
+        i = k;
+        goto lseqafter;
+    }
+    if (c == 't' || c == 'f' || c == 'n') {
+        size_t wl = c == 'f' ? 5 : 4;
+        if (i + wl > len) {
+            goto lreject;
+        }
+        uint32_t got4;
+        memcpy(&got4, p + i, 4);
+        if (got4 != (c == 't'   ? 0x65757274u /* "true" */
+                     : c == 'n' ? 0x6C6C756Eu /* "null" */
+                                : 0x736C6166u /* "fals" */) ||
+            (c == 'f' && p[i + 4] != 'e')) {
+            goto lreject;
+        }
+        if (i + wl < len) {
+            char z = p[i + wl];
+            if (z != ' ' && z != '\t' && z != '\n' && z != '\r' && z != ',' && z != ']' &&
+                z != '}' && z != ':') {
+                goto lreject;
+            }
+        }
+        recs[count] = ((uint64_t)((uint32_t)i) << 32) | ((uint64_t)((uint32_t)wl) << 8) |
+                      (uint64_t)(c == 'n' ? YEP_T_NULL : (c == 't' ? YEP_T_TRUE : YEP_T_FALSE));
+        count++;
+        i += wl;
+        goto lseqafter;
+    }
+    if (c == '{') {
+        LPUSH(1);
+        goto lmap1;
+    }
+    if (c == '[') {
+        LPUSH(0);
+        goto lseq1;
+    }
+    goto lreject;
+}
+
+lseqafter:
+    /* compact fast path: value ',' value directly — both LWS hops exit
+     * on byte one here */
+    if (i < len && p[i] == ',') {
+        i++;
+        if (i < len) {
+            char v = p[i];
+            if (v != ' ' && v != '\n' && v != '\r' && (cl || v != '\t')) {
+                goto lseqval;
+            }
         }
-        goto reject;
+        goto lseq;
     }
-    /* trailing whitespace only */
-    while (prev_end < len && (p[prev_end] == ' ' || p[prev_end] == '\t' || p[prev_end] == '\n' ||
-                              p[prev_end] == '\r')) {
-        prev_end++;
+    LWS();
+    if (p[i] == ',') {
+        i++;
+        goto lseq;
     }
-    if (prev_end != len) {
-        goto reject;
+    if (p[i] == ']') {
+        LCLOSE();
     }
-    if (count > len + 2) {
-        goto mem;
+    goto lreject;
+
+ldone:
+#undef LWS
+#undef LNUM_RUN
+#undef LPUSH
+#undef LCLOSE
+#undef LSTR_SCAN
+
+{
+    size_t tail = i;
+    while (tail < len &&
+           (p[tail] == ' ' || p[tail] == '\n' || p[tail] == '\r' || (p[tail] == '\t' && !cl))) {
+        tail++;
+    }
+    if (tail != len) {
+        goto lreject;
     }
+}
     t->count = count;
     t->_src = p;
     t->_srclen = len;
     return YEPTRIS_OK;
 
-mem:
-    yeptris_tape_free(t);
-    return YEPTRIS_ERROR_MEMORY;
-reject:
+lreject:
     yeptris_tape_free(t);
     return YEPTRIS_ERROR_PARSE;
 }
 
-/* The LENIENT token walk (the simdjson deferred contract): stage-1
- * positions consumed with the grammar arms removed. Structural
- * alternation mirrors tape_walk_idx state for state — bracket
- * matching, key/value placement, literals (packed compares), and
- * string closes/escapes (yep_json_string) all stay parse-time
- * checks; NUMBER grammar does not — the arm records the scalar-run
- * span (start to the next token's position, trailing ws trimmed)
- * as YEP_T_NUM and yeptris_tape_convert owns validation and the
- * int/float split. A malformed number ("12ab") therefore rejects at
- * drain, not parse. */
-/* The fused LENIENT walk: the strict walk's byte loop with the number
- * grammar deferred — the arm records the run to its natural delimiter
- * (the classify scan carries no accept/reject structure) and
- * yeptris_tape_convert owns validation. Everything else matches
- * tape_walk state for state. */
-/* LNUM_RUN — the initial digit run of a number span: SWAR words, eight
- * bytes per pass, with the byte loop below as tail and classifier.
- * digit iff 0x30-0x39: a lane flags when (c+0x46) carries into bit7
- * (c > '9'), when ((c|0x80)-0xB0) goes negative (c < '0'), or when the
- * byte is non-ASCII — and since the all-digit prefix never borrows
- * across lanes, the flags are exact up to the first non-digit, where
- * the scan stops and the byte loop classifies what follows (the
- * consumed-only digits_only law is untouched: the run sets saw_digit,
- * nothing else). */
 #define LNUM_RUN                                                                                   \
     do {                                                                                           \
         size_t ks_ = k;                                                                            \
@@ -630,77 +1224,33 @@ reject:
             saw_digit = 1;                                                                         \
         }                                                                                          \
     } while (0)
-
-/* The strict RFC 8259 number check over one number-ish run — the
- * in-walk float/exp validator (the out-of-line number_shape call +
- * rescan was 13% of json-doc; the digits-only case never gets here).
- * One pass, no state machine words: sign, digits (leading-zero rule),
- * optional .digits, optional e[+-]digits, consume exactly len.
- * always_inline: the spans are 3-8 bytes and the out-of-line call was
- * the cost (the rescan itself is nothing). */
-#if defined(__GNUC__)
-#define TAPE_NUM_OK_INLINE __attribute__((always_inline)) inline
-#else
-#define TAPE_NUM_OK_INLINE
-#endif
-static TAPE_NUM_OK_INLINE int tape_num_ok(const char* p, size_t len) {
-    size_t k = 0;
-    if (k < len && p[k] == '-') {
-        k++;
-    }
-    size_t int_start = k;
-    while (k < len && (unsigned)(unsigned char)p[k] - '0' <= 9u) {
-        k++;
-    }
-    if (k == int_start) {
-        return 0; /* no integer part */
-    }
-    if (k - int_start > 1 && p[int_start] == '0') {
-        return 0; /* leading zero */
-    }
-    if (k < len && p[k] == '.') {
-        k++;
-        size_t frac = k;
-        while (k < len && (unsigned)(unsigned char)p[k] - '0' <= 9u) {
-            k++;
-        }
-        if (k == frac) {
-            return 0;
-        }
-    }
-    if (k < len && (p[k] == 'e' || p[k] == 'E')) {
-        k++;
-        if (k < len && (p[k] == '+' || p[k] == '-')) {
-            k++;
-        }
-        size_t exp = k;
-        while (k < len && (unsigned)(unsigned char)p[k] - '0' <= 9u) {
-            k++;
-        }
-        if (k == exp) {
-            return 0;
-        }
-    }
-    return k == len;
-}
-
-YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open,
-                                          yeptris_json_tape* t, int strict_nums, int clean_only) {
+static YeptrisStatus yep_tape_walk_columns_fused(const char* p, size_t len, size_t open,
+                                                 yeptris_json_tape* t, int strict_nums,
+                                                 int clean_only) {
+    /* The columns-primary edition of the record walk below: the same
+     * arms (specialized member cycles, LSTR_SCAN, the digits law)
+     * emitting the three columns directly — one pass, no records, no
+     * materialization pass. The strict route's columns-eager contract
+     * at the lenient lane's memory traffic. The record walk stays
+     * byte-identical beside it; the differential suites pin the
+     * equivalence. */
     if (tape_carve(t, len) != YEPTRIS_OK) {
         return YEPTRIS_ERROR_MEMORY;
     }
-    /* the interleaved records are the primary storage (item 07); the
-     * columns materialize lazily via yeptris_tape_columns */
-    t->_rec_primary = 1;
-    yeptris_tape_rec* recs = t->recs;
+    uint8_t* kinds = t->kinds;
+    uint32_t* offs = t->offs;
+    uint32_t* lens = t->lens;
     uint32_t open_at[YEP_JSON_WALK_DEPTH];
     uint8_t kind[YEP_JSON_WALK_DEPTH];
 
-    recs[0] = ((uint64_t)0 << 32) | ((uint64_t)0 << 8) | YEP_T_DOC;
+    kinds[0] = (uint8_t)YEP_T_DOC;
+    offs[0] = 0;
+    lens[0] = 0;
 
     uint8_t top_kind = p[open] == '[' ? 0 : 1;
-    recs[1] =
-        ((uint64_t)0 << 32) | ((uint64_t)0 << 8) | (top_kind ? YEP_T_MAP_OPEN : YEP_T_SEQ_OPEN);
+    kinds[1] = top_kind ? (uint8_t)YEP_T_MAP_OPEN : (uint8_t)YEP_T_SEQ_OPEN;
+    offs[1] = 0;
+    lens[1] = 0;
     size_t count = 2;
     int depth = 1;
     open_at[0] = 1;
@@ -753,8 +1303,9 @@ YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open
         if (depth >= YEP_JSON_WALK_DEPTH) {                                                        \
             goto lreject;                                                                          \
         }                                                                                          \
-        recs[count] = ((uint64_t)0 << 32) | ((uint64_t)0 << 8) |                                   \
-                      (uint64_t)((k) ? YEP_T_MAP_OPEN : YEP_T_SEQ_OPEN);                           \
+        kinds[count] = (k) ? (uint8_t)YEP_T_MAP_OPEN : (uint8_t)YEP_T_SEQ_OPEN;                    \
+        offs[count] = 0;                                                                           \
+        lens[count] = 0;                                                                           \
         kind[depth] = (k);                                                                         \
         open_at[depth] = (uint32_t)count;                                                          \
         count++;                                                                                   \
@@ -765,9 +1316,10 @@ YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open
 #define LCLOSE()                                                                                   \
     do {                                                                                           \
         uint32_t lo_ = open_at[depth - 1];                                                         \
-        recs[count] = ((uint64_t)lo_ << 32) | ((uint64_t)0 << 8) | YEP_T_CLOSE;                    \
-        recs[lo_] =                                                                                \
-            (recs[lo_] & ~(uint64_t)0xFFFFFFFF00000000u) | ((uint64_t)(uint32_t)count << 32);      \
+        kinds[count] = (uint8_t)YEP_T_CLOSE;                                                       \
+        offs[count] = lo_;                                                                         \
+        lens[count] = 0;                                                                           \
+        offs[lo_] = (uint32_t)count;                                                               \
         count++;                                                                                   \
         i++;                                                                                       \
         depth--;                                                                                   \
@@ -801,8 +1353,9 @@ YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open
             uint64_t hi_ = cl ? (w_ & 0x8080808080808080ull) : 0;                                  \
             if (qm_ != 0 && ((bm_ | c0_ | hi_) & (qm_ - 1)) == 0) {                                \
                 size_t cl_ = j_ + (size_t)yep_ctz64(qm_) / 8;                                      \
-                recs[count] = ((uint64_t)((uint32_t)j_) << 32) |                                   \
-                              ((uint64_t)((uint32_t)(cl_ - j_)) << 8) | (uint64_t)(YEP_T_STR);     \
+                kinds[count] = (uint8_t)YEP_T_STR;                                                 \
+                offs[count] = (uint32_t)(j_);                                                      \
+                lens[count] = (uint32_t)((cl_ - j_));                                              \
                 count++;                                                                           \
                 i = cl_ + 1;                                                                       \
                 goto after;                                                                        \
@@ -827,9 +1380,9 @@ YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open
                     hi_ = cl ? (w_ & 0x8080808080808080ull) : 0;                                   \
                     if (qm_ != 0 && ((bm_ | c0_ | hi_) & (qm_ - 1)) == 0) {                        \
                         size_t cl_ = b2_ + (size_t)yep_ctz64(qm_) / 8;                             \
-                        recs[count] = ((uint64_t)((uint32_t)j_) << 32) |                           \
-                                      ((uint64_t)((uint32_t)(cl_ - j_)) << 8) |                    \
-                                      (uint64_t)(YEP_T_STR);                                       \
+                        kinds[count] = (uint8_t)YEP_T_STR;                                         \
+                        offs[count] = (uint32_t)(j_);                                              \
+                        lens[count] = (uint32_t)((cl_ - j_));                                      \
                         count++;                                                                   \
                         i = cl_ + 1;                                                               \
                         goto after;                                                                \
@@ -866,8 +1419,9 @@ YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open
                         b_++;                                                                      \
                     }                                                                              \
                 }                                                                                  \
-                recs[count] = ((uint64_t)((uint32_t)j_) << 32) |                                   \
-                              ((uint64_t)((uint32_t)(cl_ - j_)) << 8) | (uint64_t)(YEP_T_STR);     \
+                kinds[count] = (uint8_t)YEP_T_STR;                                                 \
+                offs[count] = (uint32_t)(j_);                                                      \
+                lens[count] = (uint32_t)((cl_ - j_));                                              \
                 count++;                                                                           \
                 i = cl_ + 1;                                                                       \
                 goto after;                                                                        \
@@ -889,8 +1443,9 @@ YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open
                     }                                                                              \
                 }                                                                                  \
             }                                                                                      \
-            recs[count] = ((uint64_t)((uint32_t)(at_ + 1)) << 32) |                                \
-                          ((uint64_t)((uint32_t)(cl_ - at_ - 1)) << 8) | (uint64_t)(YEP_T_STR);    \
+            kinds[count] = (uint8_t)YEP_T_STR;                                                     \
+            offs[count] = (uint32_t)((at_ + 1));                                                   \
+            lens[count] = (uint32_t)((cl_ - at_ - 1));                                             \
             count++;                                                                               \
             i = cl_ + 1;                                                                           \
         }                                                                                          \
@@ -987,8 +1542,11 @@ lmapval: {
                 goto lreject;
             }
         }
-        recs[count] = ((uint64_t)((uint32_t)i) << 32) | ((uint64_t)((uint32_t)(k - i)) << 8) |
-                      (uint64_t)(YEP_T_NUM);
+        kinds[count] =
+            strict_nums ? ((digits_only && saw_digit) ? (uint8_t)YEP_T_INT : (uint8_t)YEP_T_FLOAT)
+                        : (uint8_t)YEP_T_NUM;
+        offs[count] = (uint32_t)i;
+        lens[count] = (uint32_t)(k - i);
         count++;
         i = k;
         goto lmapafter;
@@ -1013,8 +1571,10 @@ lmapval: {
                 goto lreject;
             }
         }
-        recs[count] = ((uint64_t)((uint32_t)i) << 32) | ((uint64_t)((uint32_t)wl) << 8) |
-                      (uint64_t)(c == 'n' ? YEP_T_NULL : (c == 't' ? YEP_T_TRUE : YEP_T_FALSE));
+        kinds[count] = c == 'n' ? (uint8_t)YEP_T_NULL
+                                : (c == 't' ? (uint8_t)YEP_T_TRUE : (uint8_t)YEP_T_FALSE);
+        offs[count] = (uint32_t)i;
+        lens[count] = (uint32_t)wl;
         count++;
         i += wl;
         goto lmapafter;
@@ -1096,8 +1656,11 @@ lseqval: {
                 goto lreject;
             }
         }
-        recs[count] = ((uint64_t)((uint32_t)i) << 32) | ((uint64_t)((uint32_t)(k - i)) << 8) |
-                      (uint64_t)(YEP_T_NUM);
+        kinds[count] =
+            strict_nums ? ((digits_only && saw_digit) ? (uint8_t)YEP_T_INT : (uint8_t)YEP_T_FLOAT)
+                        : (uint8_t)YEP_T_NUM;
+        offs[count] = (uint32_t)i;
+        lens[count] = (uint32_t)(k - i);
         count++;
         i = k;
         goto lseqafter;
@@ -1122,8 +1685,10 @@ lseqval: {
                 goto lreject;
             }
         }
-        recs[count] = ((uint64_t)((uint32_t)i) << 32) | ((uint64_t)((uint32_t)wl) << 8) |
-                      (uint64_t)(c == 'n' ? YEP_T_NULL : (c == 't' ? YEP_T_TRUE : YEP_T_FALSE));
+        kinds[count] = c == 'n' ? (uint8_t)YEP_T_NULL
+                                : (c == 't' ? (uint8_t)YEP_T_TRUE : (uint8_t)YEP_T_FALSE);
+        offs[count] = (uint32_t)i;
+        lens[count] = (uint32_t)wl;
         count++;
         i += wl;
         goto lseqafter;
@@ -1182,6 +1747,7 @@ ldone:
     t->count = count;
     t->_src = p;
     t->_srclen = len;
+    t->_cols_ready = 1;
     return YEPTRIS_OK;
 
 lreject:
@@ -1411,243 +1977,6 @@ reject:
     return YEPTRIS_ERROR_PARSE;
 }
 
-/* The span walk, single-pass edition: the classifier writes per-block
- * masks (no idx array, no emission loop), and this walk derives each
- * block's token mask in registers and dispatches straight off the set
- * bits. Numbers/keywords have no entry — a pending scalar occupies
- * [val_start, next token) and is recorded (with its charset
- * validation) when the next token arrives. String closes come from a
- * backward quote scan over a few bytes. Escape-carrying documents
- * never reach here (the route sends them to the validating fused
- * walk), so the fast path never scans string content. Same
- * accept/reject contract as the fused lenient walk (the differential
- * suite pins both). */
-static YEP_UNUSED_FN YeptrisStatus tape_walk_lnt_span(const char* p, size_t len, size_t open,
-                                                      const struct yep_s1_block* blocks,
-                                                      size_t nblocks, yeptris_json_tape* t) {
-    if (tape_carve(t, len) != YEPTRIS_OK) {
-        return YEPTRIS_ERROR_MEMORY;
-    }
-    t->_rec_primary = 1;
-    yeptris_tape_rec* recs = t->recs;
-    uint32_t open_at[YEP_JSON_WALK_DEPTH];
-    uint8_t kind[YEP_JSON_WALK_DEPTH];
-
-    recs[0] = ((uint64_t)0 << 32) | ((uint64_t)0 << 8) | YEP_T_DOC;
-    uint8_t top_kind = p[open] == '[' ? 0 : 1;
-    recs[1] =
-        ((uint64_t)0 << 32) | ((uint64_t)0 << 8) | (top_kind ? YEP_T_MAP_OPEN : YEP_T_SEQ_OPEN);
-    uint32_t top_open = 1;
-    size_t count = 2;
-    uint8_t top_expect = top_kind ? JW_KEY_OR_CLOSE : JW_VALUE_OR_CLOSE;
-    int key_slot = top_kind ? 1 : 0;
-    int depth = 1;
-    open_at[0] = top_open;
-    kind[0] = top_kind;
-
-    size_t bi = 0;
-    uint64_t tokens = 0;
-    size_t off = 0;
-    size_t val_start = open + 1;
-    size_t pos = 0;
-    for (;;) {
-        while (tokens == 0) {
-            if (bi >= nblocks) {
-                goto reject; /* EOF mid-structure (the root never closed) */
-            }
-            off = (size_t)bi * 64;
-            tokens = blocks[bi].tokens;
-            bi++;
-        }
-        pos = off + (size_t)yep_ctz64(tokens);
-        tokens &= tokens - 1;
-        if (pos == open) {
-            continue; /* the root opener: recs[1] already carries it */
-        }
-
-        /* the pending scalar (numbers/keywords only — a quote would be
-         * a token): [val_start, pos) with trailing ws trimmed. All-ws
-         * residue is harmless; a required value/key is satisfied by a
-         * quote entry (the string arm) or a container. */
-        if (val_start < pos) {
-            size_t end = pos;
-            while (end > val_start && (p[end - 1] == ' ' || p[end - 1] == '\t' ||
-                                       p[end - 1] == '\n' || p[end - 1] == '\r')) {
-                end--;
-            }
-            size_t vs = val_start;
-            while (vs < end && (p[vs] == ' ' || p[vs] == '\t' || p[vs] == '\n' || p[vs] == '\r')) {
-                vs++;
-            }
-            if (vs < end) {
-                char h = p[vs];
-                if (top_expect != JW_VALUE && top_expect != JW_VALUE_OR_CLOSE) {
-                    goto reject; /* bytes where no value may start: {x} [1 2] */
-                }
-                if (h == 't' || h == 'f' || h == 'n') {
-                    size_t wl = h == 'f' ? 5 : 4;
-                    if (end - vs != wl || memcmp(p + vs,
-                                                 h == 't'   ? "true"
-                                                 : h == 'n' ? "null"
-                                                            : "false",
-                                                 wl) != 0) {
-                        goto reject;
-                    }
-                    recs[count] =
-                        ((uint64_t)((uint32_t)vs) << 32) | ((uint64_t)((uint32_t)wl) << 8) |
-                        (uint64_t)(h == 'n' ? YEP_T_NULL : (h == 't' ? YEP_T_TRUE : YEP_T_FALSE));
-                    count++;
-                } else {
-                    if (!((unsigned)(h - '0') <= 9u || h == '-')) {
-                        goto reject;
-                    }
-                    for (size_t k = vs; k < end; k++) {
-                        char d = p[k];
-                        if ((d < '0' || d > '9') && d != '-' && d != '+' && d != '.' && d != 'e' &&
-                            d != 'E') {
-                            goto reject;
-                        }
-                    }
-                    recs[count] = ((uint64_t)((uint32_t)vs) << 32) |
-                                  ((uint64_t)((uint32_t)(end - vs)) << 8) | (uint64_t)(YEP_T_NUM);
-                    count++;
-                }
-                top_expect = JW_COMMA_OR_CLOSE;
-                key_slot = 0;
-            } else if ((top_expect == JW_VALUE || top_expect == JW_KEY) &&
-                       (p[pos] != '"' && p[pos] != '{' && p[pos] != '[')) {
-                goto reject; /* a value/key was required: [1,] {"a":} */
-            }
-            val_start = pos;
-        } else if ((top_expect == JW_VALUE || top_expect == JW_KEY) &&
-                   (p[pos] != '"' && p[pos] != '{' && p[pos] != '[')) {
-            goto reject; /* a value/key was required and none started */
-        }
-
-        {
-            char c = p[pos];
-            if (c == '"') {
-                size_t close = 0;
-                if (top_expect == JW_COMMA_OR_CLOSE || top_expect == JW_COLON) {
-                    goto reject; /* ["a" "b"] — no punct between values */
-                }
-                size_t end = (tokens != 0) ? off + (size_t)yep_ctz64(tokens) : 0;
-                if (end == 0) {
-                    size_t b2 = bi;
-                    while (b2 < nblocks && blocks[b2].q == 0 && blocks[b2].op == 0) {
-                        b2++;
-                    }
-                    end = (b2 < nblocks) ? b2 * 64 : len;
-                    uint64_t m = blocks[b2].q | blocks[b2].op;
-                    if (b2 < nblocks && m != 0) {
-                        end = b2 * 64 + (size_t)yep_ctz64(m);
-                    }
-                }
-                /* end may be the close quote itself (the raw q mask
-                 * feeds the forward position), so the scan includes it */
-                for (size_t k = end + 1; k-- > pos + 1;) {
-                    if (p[k] == '"') {
-                        close = k;
-                        break;
-                    }
-                }
-                if (close == 0) {
-                    goto reject;
-                }
-                recs[count] = ((uint64_t)((uint32_t)(pos + 1)) << 32) |
-                              ((uint64_t)((uint32_t)(close - pos - 1)) << 8) |
-                              (uint64_t)(YEP_T_STR);
-                count++;
-                val_start = close + 1;
-                if (key_slot) {
-                    top_expect = JW_COLON;
-                } else {
-                    top_expect = JW_COMMA_OR_CLOSE;
-                }
-                continue;
-            }
-            if (c == ':') {
-                if (top_expect != JW_COLON) {
-                    goto reject;
-                }
-                top_expect = JW_VALUE;
-                key_slot = 0;
-                val_start = pos + 1;
-                continue;
-            }
-            if (c == ',') {
-                if (top_expect != JW_COMMA_OR_CLOSE) {
-                    goto reject;
-                }
-                top_expect = top_kind ? JW_KEY : JW_VALUE;
-                key_slot = top_kind ? 1 : 0;
-                val_start = pos + 1;
-                continue;
-            }
-            if (c == ']' || c == '}') {
-                int want = c == ']' ? 0 : 1;
-                if (top_kind != want ||
-                    (top_expect != JW_VALUE_OR_CLOSE && top_expect != JW_KEY_OR_CLOSE &&
-                     top_expect != JW_COMMA_OR_CLOSE)) {
-                    goto reject;
-                }
-                recs[count] = ((uint64_t)top_open << 32) | ((uint64_t)0 << 8) | YEP_T_CLOSE;
-                recs[top_open] = (recs[top_open] & ~(uint64_t)0xFFFFFFFF00000000u) |
-                                 ((uint64_t)(uint32_t)count << 32);
-                count++;
-                depth--;
-                if (depth == 0) {
-                    break;
-                }
-                top_kind = kind[depth - 1];
-                top_expect = JW_COMMA_OR_CLOSE;
-                top_open = open_at[depth - 1];
-                key_slot = 0;
-                val_start = pos + 1;
-                continue;
-            }
-            if (c == '{' || c == '[') {
-                if (depth >= YEP_JSON_WALK_DEPTH || key_slot || top_expect == JW_COMMA_OR_CLOSE ||
-                    top_expect == JW_COLON) {
-                    goto reject;
-                }
-                kind[depth - 1] = top_kind;
-                open_at[depth - 1] = top_open;
-                top_kind = c == '[' ? 0 : 1;
-                recs[count] = ((uint64_t)0 << 32) | ((uint64_t)0 << 8) |
-                              (uint64_t)(c == '[' ? YEP_T_SEQ_OPEN : YEP_T_MAP_OPEN);
-                top_open = (uint32_t)count;
-                count++;
-                top_expect = top_kind ? JW_KEY_OR_CLOSE : JW_VALUE_OR_CLOSE;
-                key_slot = top_kind ? 1 : 0;
-                kind[depth] = top_kind;
-                open_at[depth] = top_open;
-                depth++;
-                val_start = pos + 1;
-                continue;
-            }
-        }
-        goto reject;
-    }
-    /* trailing residue: after the root close, only ws may follow */
-    size_t last = pos + 1;
-    while (last < len &&
-           (p[last] == ' ' || p[last] == '\t' || p[last] == '\n' || p[last] == '\r')) {
-        last++;
-    }
-    if (last != len) {
-        goto reject;
-    }
-    t->count = count;
-    t->_src = p;
-    t->_srclen = len;
-    return YEPTRIS_OK;
-
-reject:
-    yeptris_tape_free(t);
-    return YEPTRIS_ERROR_PARSE;
-}
-
 YEPTRIS_API YeptrisStatus yeptris_parse_json_tape_lenient(const char* source, size_t len,
                                                           yeptris_json_tape* tape) {
     if ((source == NULL && len != 0) || tape == NULL) {
@@ -1679,25 +2008,12 @@ YEPTRIS_API YeptrisStatus yeptris_parse_json_tape_lenient(const char* source, si
     }
 
     if (source[at] == '[' || source[at] == '{') {
-        /* the span route: per-block classification + the register-token
-         * walk — no idx array, no emission loop, content bytes never
-         * forward-scanned. Escape-carrying documents (validation needs
-         * the kernel) and C0-in-string ride the fused walk, which
-         * delivers today's verdicts byte for byte. */
-        struct yep_s1_block* blocks = malloc((len / 64 + 2) * sizeof(struct yep_s1_block));
-        if (blocks == NULL) {
-            return YEPTRIS_ERROR_MEMORY;
-        }
-        size_t nblocks = 0;
-        unsigned flags = 0;
-        if (yep_text_active()->json_stage1_masks(source, len, blocks, &nblocks, &flags) &&
-            (flags & (YEP_S1_C0_IN_STRING | YEP_S1_HAS_ESCAPE)) == 0) {
-            YeptrisStatus st = tape_walk_lnt_span(source, len, at, blocks, nblocks, tape);
-            free(blocks);
-            return st;
-        }
-        free(blocks);
-        return yep_tape_walk_lenient_fused(source, len, at, tape, 0, 0);
+        /* the fused walk IS the lenient route: one pass beats the
+         * stage-1 + span two-pass on every bench corpus (json-doc
+         * 1.65x, json-users 2.2x — the ledger's #85 scoping), and
+         * this exact call already carried the route's verdicts as the
+         * escape/C0 fallback, so acceptance is unchanged. */
+        return yep_tape_walk_lenient_fused(source, len, at, tape, 0, 0, 0);
     }
 
     /* scalar root: one record, same deferred split for numbers */
@@ -1812,6 +2128,19 @@ YEPTRIS_API YeptrisStatus yeptris_parse_json_tape(const char* source, size_t len
                 free(idx);
             }
 #endif
+            /* the record-primary fused walk first — the DOM route's
+             * exact call and flags (strict numbers at record time,
+             * clean-only gates; a reject frees the tape internally, so
+             * the column attempt below carves fresh). This route's
+             * contract is COLUMNS-EAGER (the suite reads kinds/offs/
+             * lens directly), so the records materialize here — the
+             * fused scan plus one sequential decode pass, still ahead
+             * of the column walk's inline three-stream writes. */
+            /* the columns-primary fused walk: one pass, columns eager
+             * by construction, strict numbers classified at walk time */
+            if (yep_tape_walk_columns_fused(source, len, off, tape, 1, 1) == YEPTRIS_OK) {
+                return YEPTRIS_OK;
+            }
             YeptrisStatus st = tape_walk(source, len, off, tape, 1);
             if (st != YEPTRIS_ERROR_PARSE) {
                 return st; /* OK or MEMORY; a reject falls through */