yeptris 0.6.48.0-arm-linux-eabihf → 0.6.50.0-arm-linux-eabihf

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

@@ -254,6 +254,52 @@ YEPTRIS_API char* yeptris_serialize_ex(YeptrisDocument handle, const yeptris_emi
     return out;
 }
 
+/* #739: the ONE-pass JSON route — one wet pass into a growable
+ * buffer; the dry exact-sizing pass priced the compact lane ~2x
+ * (the #352 slice-2 pattern). The estimate starts at the input size
+ * (+64) and doubles on demand; shrink-to-fit at the end. Owns the
+ * emitter's canon_names cleanup. */
+static char* yep_json_run_growable(yep_emitter* em, size_t* len) {
+    size_t est = em->doc->dom->input_len + 64;
+    if (est < 256) {
+        est = 256;
+    }
+    char* out = (char*)malloc(est);
+    if (out == NULL) {
+        if (em->canon_names.sys != NULL) {
+            yep_nametab_free(&em->canon_names);
+        }
+        return NULL;
+    }
+    em->w.p = out;
+    em->w.cap = est;
+    em->w.grow = 1;
+    size_t wrote = yep_emit_run(em, 0);
+    em->w.grow = 0;
+    out = em->w.p; /* wr_grow reallocs through w->p — the local is stale */
+    if (em->w.oom || em->w.unserializable) {
+        free(out);
+        if (em->canon_names.sys != NULL) {
+            yep_nametab_free(&em->canon_names);
+        }
+        return NULL;
+    }
+    if (em->w.cap - (wrote + 1) > em->w.cap / 8) {
+        char* tight = (char*)realloc(out, wrote + 1);
+        if (tight != NULL) {
+            out = tight;
+        }
+    }
+    if (em->canon_names.sys != NULL) {
+        yep_nametab_free(&em->canon_names);
+    }
+    out[wrote] = '\0';
+    if (len != NULL) {
+        *len = wrote;
+    }
+    return out;
+}
+
 YEPTRIS_API char* yeptris_serialize_json(YeptrisDocument handle, size_t* len) {
     if (handle == NULL) {
         return NULL;
@@ -290,51 +336,7 @@ YEPTRIS_API char* yeptris_serialize_json(YeptrisDocument handle, size_t* len) {
     em.w.sink_aborted = 0;
     em.w.flushed = 0;
     memset(&em.canon_names, 0, sizeof(em.canon_names));
-    if (em.w.canonical && !yep_nametab_init(&em.canon_names, yep_system_allocator())) {
-        return NULL;
-    }
-    /* #739: ONE wet pass into a growable buffer — the dry exact-sizing
-     * pass priced ~2x on the json lane (the #352 slice-2 pattern);
-     * the estimate starts at the input size (+64) and doubles on
-     * demand, shrink-to-fit at the end. */
-    size_t est = em.doc->dom->input_len + 64;
-    if (est < 256) {
-        est = 256;
-    }
-    char* out = (char*)malloc(est);
-    if (out == NULL) {
-        if (em.canon_names.sys != NULL) {
-            yep_nametab_free(&em.canon_names);
-        }
-        return NULL;
-    }
-    em.w.p = out;
-    em.w.cap = est;
-    em.w.grow = 1;
-    size_t wrote = yep_emit_run(&em, 0);
-    em.w.grow = 0;
-    out = em.w.p; /* wr_grow reallocs through w->p — the local is stale */
-    if (em.w.oom || em.w.unserializable) {
-        free(out);
-        if (em.canon_names.sys != NULL) {
-            yep_nametab_free(&em.canon_names);
-        }
-        return NULL;
-    }
-    if (em.w.cap - (wrote + 1) > em.w.cap / 8) {
-        char* tight = (char*)realloc(out, wrote + 1);
-        if (tight != NULL) {
-            out = tight;
-        }
-    }
-    if (em.canon_names.sys != NULL) {
-        yep_nametab_free(&em.canon_names);
-    }
-    out[wrote] = '\0';
-    if (len != NULL) {
-        *len = wrote;
-    }
-    return out;
+    return yep_json_run_growable(&em, len);
 }
 
 YEPTRIS_API char* yeptris_serialize_json_ex(YeptrisDocument handle, size_t* len, int compact) {
@@ -376,27 +378,7 @@ YEPTRIS_API char* yeptris_serialize_json_ex(YeptrisDocument handle, size_t* len,
     em.w.sink_aborted = 0;
     em.w.flushed = 0;
     memset(&em.canon_names, 0, sizeof(em.canon_names));
-    if (em.w.canonical && !yep_nametab_init(&em.canon_names, yep_system_allocator())) {
-        return NULL;
-    }
-    size_t need = yep_emit_run(&em, 1);
-    char* out = malloc(need + 1);
-    if (out == NULL) {
-        if (em.canon_names.sys != NULL) {
-            yep_nametab_free(&em.canon_names);
-        }
-        return NULL;
-    }
-    em.w.p = out;
-    size_t wrote = yep_emit_run(&em, 0);
-    if (em.canon_names.sys != NULL) {
-        yep_nametab_free(&em.canon_names);
-    }
-    out[wrote] = '\0';
-    if (len != NULL) {
-        *len = wrote;
-    }
-    return out;
+    return yep_json_run_growable(&em, len);
 }
 
 YEPTRIS_API char* yeptris_serialize_json_pretty(YeptrisDocument handle, size_t* len,
@@ -440,27 +422,7 @@ char* yep_serialize_json_compact(const yeptris_document* doc, size_t* len) {
     em.w.sink_aborted = 0;
     em.w.flushed = 0;
     memset(&em.canon_names, 0, sizeof(em.canon_names));
-    if (em.w.canonical && !yep_nametab_init(&em.canon_names, yep_system_allocator())) {
-        return NULL;
-    }
-    size_t need = yep_emit_run(&em, 1);
-    char* out = malloc(need + 1);
-    if (out == NULL) {
-        if (em.canon_names.sys != NULL) {
-            yep_nametab_free(&em.canon_names);
-        }
-        return NULL;
-    }
-    em.w.p = out;
-    size_t wrote = yep_emit_run(&em, 0);
-    if (em.canon_names.sys != NULL) {
-        yep_nametab_free(&em.canon_names);
-    }
-    out[wrote] = '\0';
-    if (len != NULL) {
-        *len = wrote;
-    }
-    return out;
+    return yep_json_run_growable(&em, len);
 }
 
 char* yep_serialize_json_pretty(const yeptris_document* doc, size_t* len) {

data/vendor/libyeptris/src/yeptris/emit/style.c

@@ -75,6 +75,49 @@ int yep_style_plain_safe(const char* p, uint32_t len) {
         const uint64_t HIGH = 0x8080808080808080ull;
 #define YST_ZDET(w, ch)                                                                            \
     ((((w) ^ (uint64_t)(ch) * ONES) - ONES) & ~((w) ^ (uint64_t)(ch) * ONES) & HIGH)
+        /* the all-boring accept (#742): a span of pure [0-9A-Za-z_]
+         * makes EVERY rule in this function vacuous — no indicators
+         * (the head switch), no blanks at the ends, no BOM, no
+         * ': '/' #' adjacency, no breaks, and no ---/... marker — so
+         * one range test per word accepts without the six-mask walk.
+         * Anything else falls through to the exact scan below. */
+        {
+            uint32_t bi = 0;
+            int boring = 1;
+            while (bi + 8 <= len) {
+                uint64_t bw;
+                memcpy(&bw, p + bi, 8);
+                if (bw & HIGH) {
+                    boring = 0;
+                    break;
+                }
+                /* per-lane unsigned range checks via borrow bits: alpha
+                 * is (t - 'a') and ('z' - t) both borrow-free with
+                 * t = w|0x20 (A-Z fold); digits bound 0x30..0x39 */
+                uint64_t t = bw | (ONES * 0x20);
+                uint64_t bad = ((t - ONES * 0x61) | (ONES * 0x7A - t)) & HIGH; /* alpha */
+                bad |= ((bw - ONES * 0x30) | (ONES * 0x39 - bw)) & HIGH;       /* digit */
+                bad &= ~YST_ZDET(bw, '_'); /* the one extra boring byte */
+                if (bad != 0) {
+                    boring = 0;
+                    break;
+                }
+                bi += 8;
+            }
+            if (boring) {
+                for (; bi < len; bi++) {
+                    char c = p[bi];
+                    int a = (c | 0x20);
+                    if (!((c >= '0' && c <= '9') || (a >= 'a' && a <= 'z') || c == '_')) {
+                        boring = 0;
+                        break;
+                    }
+                }
+                if (boring) {
+                    return 1;
+                }
+            }
+        }
         uint32_t i = 0;
         int prev_blank7 = 0;
         while (i + 8 <= len) {

data/vendor/libyeptris/src/yeptris/emit/writer.c

@@ -528,9 +528,18 @@ static uint8_t sc_route(yep_writer* w, const char* p, uint32_t len, int as_key,
             }
         }
     }
-    if ((sty_in == 1) && len > 0 &&
-        (as_key ? yep_style_plain_key_safe(p, len) : yep_style_plain_safe(p, len))) {
-        return YEP_SC_PLAIN; /* plain-safe implies no breaks: memchr skipped */
+    /* the plain verdict is computed AT MOST ONCE: the case-1 arm below
+     * re-tests the same bytes when the head check already ran — the
+     * #742 profile's second call site (every plain-UNSAFE scalar paid
+     * the walk twice) */
+    int plain_ok = 0;
+    int plain_checked = 0;
+    if ((sty_in == 1) && len > 0) {
+        plain_ok = as_key ? yep_style_plain_key_safe(p, len) : yep_style_plain_safe(p, len);
+        plain_checked = 1;
+        if (plain_ok) {
+            return YEP_SC_PLAIN; /* plain-safe implies no breaks: memchr skipped */
+        }
     }
     int multiline = (len > 0 && memchr(p, '\n', len) != NULL);
     int blockable = 0;
@@ -584,7 +593,11 @@ static uint8_t sc_route(yep_writer* w, const char* p, uint32_t len, int as_key,
         if (len == 0) {
             return as_key ? YEP_SC_DQ : YEP_SC_NOTHING;
         }
-        if (as_key ? yep_style_plain_key_safe(p, len) : yep_style_plain_safe(p, len)) {
+        if (!plain_checked) {
+            plain_ok = as_key ? yep_style_plain_key_safe(p, len) : yep_style_plain_safe(p, len);
+            plain_checked = 1;
+        }
+        if (plain_ok) {
             return YEP_SC_PLAIN;
         }
         if (!multiline) {
@@ -941,8 +954,16 @@ static int key_written_over_limit(yep_writer* w, const yep_dnode* kn) {
     if (w->json) {
         return 0; /* JSON has no simple-key law: every key writes (#739) */
     }
-    uint64_t est = 2; /* the quotes */
     yep_view kv_ = wv(w, kn->value);
+    if (kn->anchor.len == 0 && kn->tag.len == 0 && kv_.len <= 255) {
+        /* the exact bound: even at the factor-4 expansion the walk
+         * budgets per byte, 255 raw bytes top out at est = 2 + 1020 —
+         * under the law. Table-shaped documents pay the two field
+         * checks instead of the byte walk (the #742 profile's 22%
+         * lane) */
+        return 0;
+    }
+    uint64_t est = 2; /* the quotes */
     const unsigned char* q = (const unsigned char*)kv_.p;
     uint32_t n = kv_.len;
     /* NO early return on an empty value: the tag arm below must run —
@@ -1384,6 +1405,98 @@ static void emit_node(yep_emitter* em, uint32_t id, int parent_col, int as_key)
     emit_scalar(w, n, parent_col, as_key);
 }
 
+/* ============================================================
+ * yeptris#739 slice 3: JSON's own tree walk. In JSON mode every
+ * collection is flow, the separators are fixed, and the YAML
+ * machinery (props lines, style analysis, explicit-key law,
+ * pretty depth) never fires — yet the generic emit_node ->
+ * emit_flow path re-tests all of it per node and looks every
+ * child up twice. This walk emits the same bytes with one
+ * dispatch per node and two per map pair. Pretty output keeps
+ * the generic path: its depth/indent bookkeeping is the point
+ * there.
+ * ============================================================ */
+static void emit_json_node(yep_emitter* em, uint32_t id);
+
+static void emit_json_flow(yep_emitter* em, uint32_t id) {
+    yep_writer* w = &em->w;
+    int saved_flow = w->in_flow;
+    w->in_flow = 1;
+    const yep_dom* d = em->doc->dom;
+    const yep_dnode* n = yep_dom_node(d, id);
+    if (n->tag.len > 0) {
+        emit_tag(w, n);
+    }
+    if (n->anchor.len > 0) {
+        emit_anchor_ex(em, n);
+    }
+    int map = (n->kind == 2);
+    wr_byte(w, map ? '{' : '[');
+    uint32_t child = n->first_child;
+    uint32_t idx = 0;
+    while (child != UINT32_MAX) {
+        const yep_dnode* cn = yep_dom_node(d, child);
+        if (idx > 0) {
+            if (w->json_compact) {
+                wr_byte(w, ',');
+            } else {
+                wr_put(w, ", ", 2);
+            }
+        }
+        if (map) {
+            /* the one generic-path rule JSON keeps: a non-scalar key
+             * (or one carrying props) rides the explicit "? key : "
+             * form — same bytes emit_flow writes */
+            if (cn->anchor.len > 0 || cn->tag.len > 0 || cn->kind != 0) {
+                wr_put(w, "? ", 2);
+                emit_json_node(em, child);
+                wr_put(w, " : ", 3);
+            } else {
+                emit_json_node(em, child);
+                if (w->json_compact) {
+                    wr_byte(w, ':');
+                } else {
+                    wr_put(w, ": ", 2);
+                }
+            }
+            uint32_t val = cn->next_sibling;
+            emit_json_node(em, val);
+            const yep_dnode* vn = yep_dom_node(d, val);
+            child = vn != NULL ? vn->next_sibling : UINT32_MAX;
+        } else {
+            emit_json_node(em, child);
+            child = cn->next_sibling;
+        }
+        idx++;
+    }
+    wr_byte(w, map ? '}' : ']');
+    w->in_flow = saved_flow;
+}
+
+static void emit_json_node(yep_emitter* em, uint32_t id) {
+    yep_writer* w = &em->w;
+    const yep_dom* d = em->doc->dom;
+    const yep_dnode* n = yep_dom_node(d, id);
+    if (n == NULL) {
+        return;
+    }
+    if (n->kind == 3) { /* alias */
+        emit_alias_ex(em, n);
+        return;
+    }
+    if (n->kind == 1 || n->kind == 2) {
+        emit_json_flow(em, id);
+        return;
+    }
+    if (n->tag.len > 0) {
+        emit_tag(w, n);
+    }
+    if (n->anchor.len > 0) {
+        emit_anchor_ex(em, n);
+    }
+    emit_canonical_scalar(w, n);
+}
+
 /* ============================================================
  * yeptris-ruby#322: the marshal READER — Ruby Marshal.dump bytes
  * to JSON text in one C call (no per-scalar crossings, no object
@@ -1975,7 +2088,11 @@ size_t yep_emit_run(yep_emitter* em, int dry) {
         /* JSON has no multi-document streams and no document marker */
         if (d->dcount == 1) {
             const yep_dnode* root = yep_dom_node(d, d->docs[0]);
-            emit_node(em, d->docs[0], -2, 0);
+            if (w->json_pretty) {
+                emit_node(em, d->docs[0], -2, 0);
+            } else {
+                emit_json_node(em, d->docs[0]);
+            }
             if (root != NULL && root->kind != 0 && w->last != '\n') {
                 wr_byte(w, '\n');
             }

data/vendor/libyeptris/src/yeptris/parse/engine.c

@@ -4192,7 +4192,7 @@ yep_engine* yep_engine_create(const yep_allocator* sys) {
  * nightly's run 38524928004: "\0\n---\r<U+2028>" whole-parsed as an
  * empty stream while the chunked cut skipped the copy). */
 static const char* e_normalize_breaks(yep_engine* e, const char* p, size_t len, size_t* out_len) {
-    char* out = yep_engine_normalize_breaks(e->sys, p, len, out_len);
+    char* out = yep_engine_normalize_breaks(e->sys, p, len, out_len, NULL);
     if (out == NULL) {
         return p;
     }
@@ -4567,7 +4567,10 @@ static yep_norm_tok norm_step(yep_norm_ctx* c, const char* p, size_t len, size_t
 }
 
 char* yep_engine_normalize_breaks(const yep_allocator* sys, const char* p, size_t len,
-                                  size_t* out_len) {
+                                  size_t* out_len, int* kept_raw) {
+    if (kept_raw != NULL) {
+        *kept_raw = 0;
+    }
     const unsigned char* q = (const unsigned char*)p;
     const yep_text_kernels* k = yep_text_active();
     size_t i = 0;
@@ -4597,6 +4600,9 @@ char* yep_engine_normalize_breaks(const yep_allocator* sys, const char* p, size_
         j += t.n;
     }
     if (!found) {
+        if (kept_raw != NULL) {
+            *kept_raw = 1; /* every exotic byte rides raw */
+        }
         return NULL; /* the exotic bytes all ride inside quoted regions:
                       * the zero-copy path keeps them raw (the fix) */
     }
@@ -4611,6 +4617,14 @@ char* yep_engine_normalize_breaks(const yep_allocator* sys, const char* p, size_
     for (size_t j = 0; j < len;) {
         yep_norm_tok t = norm_step(&cp, p, len, j);
         if (t.fold_off < 0) {
+            if (kept_raw != NULL && *kept_raw == 0) {
+                for (size_t m = 0; m + 1 < t.n; m++) {
+                    if (yep_scan_mb_break_len(p + j + m, t.n - m, 0) > 0) {
+                        *kept_raw = 1;
+                        break;
+                    }
+                }
+            }
             memcpy(out + o, p + j, t.n);
             o += t.n;
         } else {

data/vendor/libyeptris/src/yeptris/parse/engine.h

@@ -76,8 +76,13 @@ const yep_error* yep_engine_error(const yep_engine* e);
  * the stopset kernel). One-shot parse runs this BEFORE the engine so
  * the copy owns the document's transcoded slot; the engine's per-feed
  * copy (norm_buf) stays for the streaming feeds. */
+/* kept_raw (nullable) reports whether raw NEL/LS/PS SURVIVED the
+ * quote-aware walk (they ride inside quoted regions). The packed-tape
+ * fused runner predates the multibyte break cut — a document still
+ * carrying raw sequences parses on the engine route instead (the
+ * nightly's r75). */
 char* yep_engine_normalize_breaks(const yep_allocator* sys, const char* p, size_t len,
-                                  size_t* out_len);
+                                  size_t* out_len, int* kept_raw);
 
 #ifdef __cplusplus
 }

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

@@ -244,6 +244,9 @@ static YeptrisDocument parse_impl(const char* buf, size_t len, const YeptrisPars
     unsigned char* transcoded = NULL;
     size_t transcoded_len = 0;
     yep_encoding enc = YEP_ENC_UNKNOWN;
+    int norm_kept_raw = 0; /* raw NEL/LS/PS survived the quote-aware
+                            * walk: the engine route owns the document
+                            * (the tape runner predates the cut) */
 
     if (json_mode) {
         /* JSON mode validated grammar and UTF-8 well-formedness at the
@@ -307,7 +310,7 @@ static YeptrisDocument parse_impl(const char* buf, size_t len, const YeptrisPars
      * U+0085 raw inside strings, only the YAML reader normalizes. */
     {
         size_t nlen = 0;
-        char* norm = yep_engine_normalize_breaks(sys, data, data_len, &nlen);
+        char* norm = yep_engine_normalize_breaks(sys, data, data_len, &nlen, &norm_kept_raw);
         if (norm != NULL) {
             yep_free(sys, transcoded);
             transcoded = (unsigned char*)norm;
@@ -410,12 +413,12 @@ engine_enter:
                           .on_block_item = dom_on_block_item};
     }
     int rc = 0;
-    if (have_tape && ytap_flow_rooted(&yt) == 0) {
+    if (have_tape && !norm_kept_raw && ytap_flow_rooted(&yt) == 0) {
         /* a pure flow-rooted document: the classification ran once and
          * the scaffolding landed — neither runner nor engine runs */
         yep_engine_destroy(eng);
         eng = NULL;
-    } else if (have_tape &&
+    } else if (have_tape && !norm_kept_raw &&
                ytap_fused_run(&yt, (opts != NULL && opts->schema == YEPTRIS_SCHEMA_11_COMPAT)
                                        ? yep_resolver_compat11()
                                        : yep_resolver_core12()) == 0) {

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

@@ -74,6 +74,8 @@ static YeptrisStatus tape_carve(yeptris_json_tape* t, size_t len) {
     t->int_min = 0;
     t->_rec_primary = 0;
     t->_cols_ready = 0;
+    t->_long_key_known = 0;
+    t->_long_key = 0;
     return YEPTRIS_OK;
 }
 
@@ -695,6 +697,9 @@ static TAPE_NUM_OK_INLINE int tape_num_ok(const char* p, size_t len) {
  * a long simple key, so the fast parse defers to the engine's clean
  * error — the nightly's run 38143486175). */
 int yep_tape_long_simple_key(const yeptris_json_tape* s) {
+    if (s->_long_key_known) {
+        return s->_long_key; /* settled during the lenient walk */
+    }
     struct {
         uint8_t map;
         uint8_t key_next;
@@ -758,6 +763,8 @@ YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open
         t->_srclen >= len + 2) {
         t->_cols_ready = 0;
         t->_rec_primary = 1;
+        t->_long_key_known = 0;
+        t->_long_key = 0;
     } else if (tape_carve(t, len) != YEPTRIS_OK) {
         return YEPTRIS_ERROR_MEMORY;
     }
@@ -997,7 +1004,18 @@ lmap: /* a member MUST follow (after ','): JW_KEY — a closer rejects */
         goto lreject;
     }
 lmapkey: { LSTR_SCAN(lmapcolon); }
-lmapcolon:
+lmapcolon: { /* the key verdict rides the walk: the just-emitted record IS the
+              * key — a >1024-byte candidate pays the char-budget check once
+              * instead of a post-parse full-tape re-walk (#739) */
+    uint64_t kr_ = recs[count - 1];
+    uint32_t kl_ = (uint32_t)(kr_ >> 8) & 0xFFFFFFu;
+    if (kl_ + 2u > 1024u && !t->_long_key_known) {
+        t->_long_key_known = 1;
+        t->_long_key =
+            (unsigned char)(yep_simple_key_chars(p + (size_t)(uint32_t)(kr_ >> 32), kl_) + 2 >
+                            1024);
+    }
+}
     if (i < len && p[i] == ':') {
         i++;
         /* compact fast path: the value byte follows the colon with no
@@ -2183,55 +2201,61 @@ YEPTRIS_API YeptrisStatus yeptris_parse_json_tape(const char* source, size_t len
         return YEPTRIS_ERROR_ARG;
     }
 
-    int gated = len > 0 && yep_text_active()->gate_scan(source, len);
-    if (!gated) {
-        size_t off = 0;
-        while (off < len && (source[off] == ' ' || source[off] == '\t' || source[off] == '\n' ||
-                             source[off] == '\r')) {
-            off++;
-        }
-        if (off < len && (source[off] == '[' || source[off] == '{')) {
-            /* the token-contract route: stage 1 (vector indexes) + the
-             * lean walk. Measured BEHIND the fused walk on json-doc
-             * (417-426 vs 526-533: stage 1 at 1408 MB/s + a walk whose
-             * arms carry the same grammar cost) — gated OFF until the
-             * sized cuts land (the op-table classifier trick, the
-             * specialized map/seq loops, stage-1 string closes). The
-             * fused walk is the shipped route; the law. */
+    /* #474: the entry's full-input gate_scan pre-pass moves to the
+     * reject path (the #342/#81 law on parse_json, now here): the
+     * columns-primary fused walk runs clean_only — tabs and non-ASCII
+     * bytes REJECT inline — so on accepted documents the NEON gate
+     * scan (the profile's 5% lane) never runs. A walk reject re-gates:
+     * the record walk and the encoding-owed decision read `gated` only
+     * when actually taken, and every error precedence below is
+     * unchanged (the validating sequence consumes the same bit). */
+    int gated;
+    size_t off = 0;
+    while (off < len && (source[off] == ' ' || source[off] == '\t' || source[off] == '\n' ||
+                         source[off] == '\r')) {
+        off++;
+    }
+    int container = off < len && (source[off] == '[' || source[off] == '{');
+    if (container) {
+        /* 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;
+        }
+    }
+    gated = len > 0 && yep_text_active()->gate_scan(source, len);
+    if (container && !gated) {
+        /* the token-contract route: stage 1 (vector indexes) + the
+         * lean walk. Measured BEHIND the fused walk on json-doc
+         * (417-426 vs 526-533: stage 1 at 1408 MB/s + a walk whose
+         * arms carry the same grammar cost) — gated OFF until the
+         * sized cuts land (the op-table classifier trick, the
+         * specialized map/seq loops, stage-1 string closes). The
+         * fused walk is the shipped route; the law. */
 #if YEP_TOKEN_CONTRACT_ROUTE
-            uint32_t* idx = (uint32_t*)malloc((len + 2) * sizeof(uint32_t));
-            if (idx == NULL) {
-                return YEPTRIS_ERROR_MEMORY;
-            }
-            size_t nidx = 0;
-            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) {
-                    return st; /* OK or MEMORY; a reject falls through */
-                }
-            } else {
-                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);
+        uint32_t* idx = (uint32_t*)malloc((len + 2) * sizeof(uint32_t));
+        if (idx == NULL) {
+            return YEPTRIS_ERROR_MEMORY;
+        }
+        size_t nidx = 0;
+        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) {
                 return st; /* OK or MEMORY; a reject falls through */
             }
+        } else {
+            free(idx);
+        }
+#endif
+        /* the record walk — the DOM route's exact call and flags
+         * (strict numbers at record time). Non-ASCII documents stay
+         * out of it: the gate above keeps today's routing, where the
+         * validated lenient walk below owns them. */
+        YeptrisStatus st = tape_walk(source, len, off, tape, 1);
+        if (st != YEPTRIS_ERROR_PARSE) {
+            return st; /* OK or MEMORY; a reject falls through */
         }
     }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.48.0
+  version: 0.6.50.0
 platform: arm-linux-eabihf
 authors:
 - Ribose Inc.
@@ -93,6 +93,8 @@ files:
 - vendor/libyeptris/src/yeptris/cbor/cbor.h
 - vendor/libyeptris/src/yeptris/cbor/decode.c
 - vendor/libyeptris/src/yeptris/cbor/encode.c
+- vendor/libyeptris/src/yeptris/cbor/encode_priv.h
+- vendor/libyeptris/src/yeptris/cbor/from_marshal.c
 - vendor/libyeptris/src/yeptris/cbor/sink.h
 - vendor/libyeptris/src/yeptris/common/chartype.c
 - vendor/libyeptris/src/yeptris/common/chartype.h