yeptris 0.6.19.1-arm-linux-eabihf → 0.6.20.2-arm-linux-eabihf

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

@@ -618,200 +618,335 @@ YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open
     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;
+    open_at[0] = 1;
     kind[0] = top_kind;
 
     size_t i = open + 1;
-    for (;;) {
-        while (i < len && (p[i] == ' ' || p[i] == '\n' || p[i] == '\r' || p[i] == '\t')) {
-            i++;
-        }
-        if (i >= len) {
-            goto lreject;
-        }
-        size_t at = i;
-        char c = p[i];
+    if (top_kind) {
+        goto lmap1;
+    }
+    goto lseq1;
 
-        if (top_expect == JW_COLON) {
-            if (c != ':') {
-                goto lreject;
-            }
-            top_expect = JW_VALUE;
-            key_slot = 0;
-            i = at + 1;
-            continue;
-        }
-        if (top_expect == JW_COMMA_OR_CLOSE) {
-            if (c == ',') {
-                top_expect = top_kind ? JW_KEY : JW_VALUE;
-                key_slot = top_kind ? 1 : 0;
-                i = at + 1;
-                continue;
-            }
-            if (c != ']' && c != '}') {
-                goto lreject;
-            }
-        } else if (key_slot && c != '"' && c != ']' && c != '}') {
-            goto lreject;
-        }
+    /* 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')) {         \
+            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;             \
+            if (qm_ != 0 && ((bm_ | c0_) & (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;                                                                        \
+            }                                                                                      \
+        }                                                                                          \
+        {                                                                                          \
+            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);                                                    \
+                        if ((v_ - 0x2020202020202020ull) & ~v_ & 0x8080808080808080ull) {          \
+                            goto lreject;                                                          \
+                        }                                                                          \
+                        b_ += 8;                                                                   \
+                    } else {                                                                       \
+                        if ((unsigned char)p[b_] < 0x20) {                                         \
+                            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;                                                                      \
+            }                                                                                      \
+            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 */
+    LWS();
+    if (p[i] != '"') {
+        goto lreject;
+    }
+lmapkey: { LSTR_SCAN(lmapcolon); }
+lmapcolon:
+    LWS();
+    if (p[i] != ':') {
+        goto lreject;
+    }
+    i++;
+    LWS();
+    {
+        char c = p[i];
         if (c == '"') {
-            size_t j = at + 1;
-            size_t close = 0;
-            /* SWAR settle first (the lenient walk's own fast path); the
-             * kernel stays the authority on escapes/C0/long spans */
-            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;
-                if (qm != 0 && ((bm | c0) & (qm - 1)) == 0) {
-                    close = j + (size_t)yep_ctz64(qm) / 8;
-                    recs[count] = ((uint64_t)((uint32_t)j) << 32) |
-                                  ((uint64_t)((uint32_t)(close - j)) << 8) | (uint64_t)(YEP_T_STR);
-                    count++;
-                    i = close + 1;
-                    goto lstr_done;
-                }
-            }
-            int esc = 0;
-            if (!yep_json_string(p, len, &i, &close, &esc)) {
-                goto lreject;
-            }
-            recs[count] = ((uint64_t)((uint32_t)(at + 1)) << 32) |
-                          ((uint64_t)((uint32_t)(close - at - 1)) << 8) | (uint64_t)(YEP_T_STR);
-            count++;
-        lstr_done:
-            if (key_slot) {
-                if (i < len && p[i] == ':') {
-                    i++;
-                    top_expect = JW_VALUE;
-                    key_slot = 0;
-                } else {
-                    top_expect = JW_COLON;
-                }
-            } else {
-                goto lcomma;
-            }
-            continue;
+            LSTR_SCAN(lmapafter);
         }
         if ((unsigned)(c - '0') <= 9u || c == '-') {
-            /* deferred: classify-scan to the run's end — no grammar */
-            i = at + 1;
-            while (i < len) {
-                char d = p[i];
+            size_t k = i + 1;
+            while (k < len) {
+                char d = p[k];
                 if ((d >= '0' && d <= '9') || d == '-' || d == '+' || d == '.' || d == 'e' ||
                     d == 'E') {
-                    i++;
+                    k++;
                     continue;
                 }
                 break;
             }
-            recs[count] = ((uint64_t)((uint32_t)at) << 32) | ((uint64_t)((uint32_t)(i - at)) << 8) |
+            recs[count] = ((uint64_t)((uint32_t)i) << 32) | ((uint64_t)((uint32_t)(k - i)) << 8) |
                           (uint64_t)(YEP_T_NUM);
             count++;
-        lcomma:
-            if (i < len && p[i] == ',') {
-                i++;
-                top_expect = top_kind ? JW_KEY : JW_VALUE;
-                key_slot = top_kind ? 1 : 0;
-            } else {
-                top_expect = JW_COMMA_OR_CLOSE;
-            }
-            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 lreject;
-            }
-            recs[count] = ((uint64_t)top_open << 32) | ((uint64_t)0 << 8) | YEP_T_CLOSE;
-            /* back-patch the opener's count link: keep the original
-             * off/len, set the link into the record's off word */
-            recs[top_open] = (recs[top_open] & ~(uint64_t)0xFFFFFFFF00000000u) |
-                             ((uint64_t)(uint32_t)count << 32);
-            count++;
-            i = at + 1;
-            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;
-            continue;
-        }
-        if (c == '{' || c == '[') {
-            if (depth >= YEP_JSON_WALK_DEPTH) {
-                goto lreject;
-            }
-            if (key_slot) {
-                goto lreject;
-            }
-            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++;
-            i = at + 1;
-            continue;
+            i = k;
+            goto lmapafter;
         }
         if (c == 't' || c == 'f' || c == 'n') {
             size_t wl = c == 'f' ? 5 : 4;
-            if (at + wl > len) {
+            if (i + wl > len) {
                 goto lreject;
             }
             uint32_t got4;
-            memcpy(&got4, p + at, 4);
+            memcpy(&got4, p + i, 4);
             if (got4 != (c == 't'   ? 0x65757274u /* "true" */
                          : c == 'n' ? 0x6C6C756Eu /* "null" */
                                     : 0x736C6166u /* "fals" */) ||
-                (c == 'f' && p[at + 4] != 'e')) {
+                (c == 'f' && p[i + 4] != 'e')) {
                 goto lreject;
             }
-            if (at + wl < len) {
-                char z = p[at + wl];
+            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)at) << 32) | ((uint64_t)((uint32_t)wl) << 8) |
+            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 = at + wl;
-            goto lcomma;
+            i += wl;
+            goto lmapafter;
+        }
+        if (c == '{') {
+            LPUSH(1);
+            goto lmap1;
+        }
+        if (c == '[') {
+            LPUSH(0);
+            goto lseq1;
         }
         goto lreject;
     }
-    {
-        size_t tail = i;
-        while (tail < len &&
-               (p[tail] == ' ' || p[tail] == '\t' || p[tail] == '\n' || p[tail] == '\r')) {
-            tail++;
+
+lmapafter:
+    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;
+        while (k < len) {
+            char d = p[k];
+            if ((d >= '0' && d <= '9') || d == '-' || d == '+' || d == '.' || d == 'e' ||
+                d == 'E') {
+                k++;
+                continue;
+            }
+            break;
         }
-        if (tail != len) {
+        recs[count] = ((uint64_t)((uint32_t)i) << 32) | ((uint64_t)((uint32_t)(k - i)) << 8) |
+                      (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:
+    LWS();
+    if (p[i] == ',') {
+        i++;
+        goto lseq;
     }
+    if (p[i] == ']') {
+        LCLOSE();
+    }
+    goto lreject;
+
+ldone:
+#undef LWS
+#undef LPUSH
+#undef LCLOSE
+#undef LSTR_SCAN
+
+{
+    size_t tail = i;
+    while (tail < len &&
+           (p[tail] == ' ' || p[tail] == '\t' || p[tail] == '\n' || p[tail] == '\r')) {
+        tail++;
+    }
+    if (tail != len) {
+        goto lreject;
+    }
+}
     t->count = count;
     t->_src = p;
     t->_srclen = len;
@@ -1044,6 +1179,243 @@ 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) {
@@ -1075,21 +1447,24 @@ YEPTRIS_API YeptrisStatus yeptris_parse_json_tape_lenient(const char* source, si
     }
 
     if (source[at] == '[' || source[at] == '{') {
-#if YEP_TOKEN_CONTRACT_ROUTE
-        /* the indexed twin: stage 1 + the idx walk (reference route —
-         * measured behind the fused lenient walk, same differential) */
-        uint32_t* idx = (uint32_t*)malloc((len + 2) * sizeof(uint32_t));
-        if (idx == NULL) {
+        /* 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 nidx = 0;
-        if (yep_text_active()->json_stage1(source, len, idx, &nidx)) {
-            YeptrisStatus st = tape_walk_lnt(source, len, at, idx, nidx, tape);
-            free(idx);
+        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(idx);
-#endif
+        free(blocks);
         return yep_tape_walk_lenient_fused(source, len, at, tape);
     }
 
@@ -1194,7 +1569,8 @@ YEPTRIS_API YeptrisStatus yeptris_parse_json_tape(const char* source, size_t len
                 return YEPTRIS_ERROR_MEMORY;
             }
             size_t nidx = 0;
-            if (yep_text_active()->json_stage1(source, len, idx, &nidx)) {
+            unsigned sflags = 0;
+            if (yep_text_active()->json_stage1(source, len, idx, &nidx, &sflags)) {
                 YeptrisStatus st = tape_walk_idx(source, len, off, idx, nidx, tape);
                 free(idx);
                 if (st != YEPTRIS_ERROR_PARSE) {