yeptris 0.6.20.2-aarch64-linux → 0.6.21.1-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f38d811bfb5d528f0fe714a37d5b1d3098c4387b4e17ddc4f5ceb1b1d4e792d
-  data.tar.gz: 97317d6f12a73d35fa2b38e780742631729823daa9f6e87f9af8a6cb30673791
+  metadata.gz: 5d1fa4e8d3637757def7e98646b997efcf9f34e5b2335e6204200233bac8513a
+  data.tar.gz: 72a73f4d7545cdb8bbf4c276833675805ca331e7d7327954418207c24c32eaf8
 SHA512:
-  metadata.gz: 9d2d9c6092f09c30e2db903e8ffd1c43c16c5c146a0696732c3aa6393d510cfd9f8dc30abbdd7e8d51f7798b0f7b088227b10d60731350ca872061364b95915a
-  data.tar.gz: c2b04861f13e33c47a90387e909c4179d846888a640bd8c754e9bdcd59a45e4648d4d6e7ee8edd0c8944935d044fd2fd5beea9ff497d85f6697c5433cbbe25f3
+  metadata.gz: b4ac43d4cf4e3bc79c97cc0e617760d5ce0f7a14bd6eae195b9cd13fe801c7a146175ef3786f5523de51499827bc52b7daf60b08920e21a8ed4b18ca08e5fded
+  data.tar.gz: e24ea1b81fc184268f6ee5a88464c2d91d9f4ad17ac36c84aa193de972fc0f9dd5359ff6081f43ebfd6dc1145fa5f3dc50ba794161cb4c8436c09d61cb770dce

data/lib/yeptris.rb

@@ -3,7 +3,7 @@
 module Yeptris
   # The gem's version lives in the parent namespace's file — the last
   # internal require (yeptris/version) retired with it.
-  VERSION = "0.6.20.2".freeze
+  VERSION = "0.6.21.1".freeze
 
   # Informational notices are OPT-IN (yeptris-ruby#217): consumers
   # embed yeptris inside CLIs that assert clean stderr, and a

data/vendor/libyeptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(yeptris
-    VERSION 0.6.20
+    VERSION 0.6.21
     DESCRIPTION "Ultra-fast YAML 1.2 parser, emitter and streamer in C"
     LANGUAGES C CXX
 )

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

@@ -31,6 +31,7 @@ YEPTRIS_API YeptrisDocument yeptris_document_new(void) {
         yep_dom_destroy(dom);
         return NULL;
     }
+    yep_mutex_init(&doc->lazy_mu);
     memset(doc, 0, sizeof(*doc));
     doc->dom = dom;
     doc->sys = sys;

data/vendor/libyeptris/src/yeptris/cbor/decode.c

@@ -860,6 +860,7 @@ static YeptrisDocument cbor_wrap(yep_dom* dom, const void* buf, const yep_alloca
         yep_dom_destroy(dom);
         return NULL;
     }
+    yep_mutex_init(&d->lazy_mu);
     d->dom = dom;
     d->sys = sys;
     d->schema = YEPTRIS_SCHEMA_12_CORE;
@@ -967,6 +968,7 @@ YEPTRIS_API YeptrisDocument yeptris_cbor_decode(const void* buf, size_t len, uin
         }
         return NULL;
     }
+    yep_mutex_init(&doc->lazy_mu);
     doc->dom = dom;
     doc->sys = sys;
     doc->schema = YEPTRIS_SCHEMA_12_CORE; /* CBOR's model is the core schema */

data/vendor/libyeptris/src/yeptris/doc.h

@@ -7,6 +7,7 @@
 
 #include <stddef.h>
 
+#include "common/mutex.h"
 #include "dom/dom.h"
 #include "memory/allocator.h"
 
@@ -18,19 +19,24 @@ typedef struct yeptris_document {
                                 * conditioned on it (TODO.restructure/32) */
     unsigned char* transcoded; /* owned when non-NULL */
     size_t transcoded_len;
-    const char* input; /* borrowed input (lifetime documentation) */
-    void* finish_pool; /* engine finish pool: resolved tags, folded and
-                          escaped scalars outlive the engine through the
-                          document */
-    void* lazy_tape;   /* #342 slice 2: the parsed tape when the tree is
-                        * deferred (gate-clean strict JSON; #378: the YAML
-                        * record tape). dom==NULL until the first tree
-                        * access materializes; freed with the document.
-                        * void* to avoid a header cycle — parse.c casts
-                        * per lazy_kind */
-    int lazy_kind;     /* 0 = none/json (yeptris_json_tape), 1 = yaml
-                        * (yep_ytape) — every constructor must set it
-                        * (the field-by-field ctor trap) */
+    const char* input;     /* borrowed input (lifetime documentation) */
+    void* finish_pool;     /* engine finish pool: resolved tags, folded and
+                              escaped scalars outlive the engine through the
+                              document */
+    void* lazy_tape;       /* #342 slice 2: the parsed tape when the tree is
+                            * deferred (gate-clean strict JSON; #378: the YAML
+                            * record tape). dom==NULL until the first tree
+                            * access materializes; freed with the document.
+                            * void* to avoid a header cycle — parse.c casts
+                            * per lazy_kind */
+    int lazy_kind;         /* 0 = none/json (yeptris_json_tape), 1 = yaml
+                            * (yep_ytape) — every constructor must set it
+                            * (the field-by-field ctor trap) */
+    yep_mutex_raw lazy_mu; /* materialization lock: the first tree
+                            * access builds; concurrent first accesses
+                            * wait (read-only sharing stays lock-free
+                            * once dom is set — every constructor must
+                            * yep_mutex_init it, the ctor trap) */
 } yeptris_document;
 
 /* Node handle: a (document, node-id) pair so nodes stay usable even if

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

@@ -542,18 +542,18 @@ uint32_t dom_indexed_child(yep_dom* d, uint32_t cid, size_t index, uint32_t* cou
         *count_out = 0;
         return UINT32_MAX;
     }
+    /* the midx discipline (TSAN, Threads.ReadOnlySharing): READS of
+     * the cache ride the mutex too — a concurrent builder publishes
+     * under it, so the old unlocked hit path raced the build's
+     * stores. Uncontended in the single-threaded hot path. */
+    yep_mutex_lock(&d->midx.mu);
+    uint32_t out;
     *count_out = n->count;
     if (d->child_cache_id == cid) {
-        if (index < d->child_cache_len) {
-            return d->child_cache[index];
-        }
-        return UINT32_MAX;
-    }
-    /* miss: build once under the lazy-init mutex (Threads.
-     * ReadOnlySharing — concurrent first calls race here exactly like
-     * the handle pool's) */
-    yep_mutex_lock(&d->midx.mu);
-    if (d->child_cache_id != cid) {
+        out = index < d->child_cache_len ? d->child_cache[index] : UINT32_MAX;
+    } else {
+        /* miss: build once under the lazy-init mutex (concurrent
+         * first calls race here exactly like the handle pool's) */
         yep_free(d->sys, d->child_cache);
         d->child_cache = NULL;
         d->child_cache_len = 0;
@@ -574,12 +574,10 @@ uint32_t dom_indexed_child(yep_dom* d, uint32_t cid, size_t index, uint32_t* cou
             }
         }
         d->child_cache_id = cid;
+        out = index < d->child_cache_len ? d->child_cache[index] : UINT32_MAX;
     }
     yep_mutex_unlock(&d->midx.mu);
-    if (index < d->child_cache_len) {
-        return d->child_cache[index];
-    }
-    return UINT32_MAX;
+    return out;
 }
 
 void yep_dom_destroy(yep_dom* d) {

data/vendor/libyeptris/src/yeptris/dom/ytape.c

@@ -14,6 +14,7 @@
  * (test/unit/test_ytape.cpp) pins tree identity across the corpora.
  */
 
+#include <stdio.h>
 #include <string.h>
 
 #include "dom/dom.h"
@@ -327,6 +328,7 @@ static int yt_on_flow_build(void* ctx, const char* p, size_t open, size_t len, u
      * the same reject/long-key verdicts, then ONE record for the
      * whole staged span (replay runs the full build through
      * dom_on_flow_build). */
+    t->max_depth = max_depth; /* replay re-walks at the engine's limit */
     yep_json_walk w;
     yep_json_tok tok;
     yep_json_walk_init(&w, p, len, open, max_depth);

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

@@ -756,14 +756,19 @@ YEPTRIS_API YeptrisStatus yeptris_marshal_node(YeptrisNode node, char** out, siz
     *out = NULL;
     *out_len = 0;
     yeptris_node* h = (yeptris_node*)node;
-    if (dom_subtree_tagged(h->doc->dom, h->id) != 0) {
+    yep_dom* dom = yep_doc_dom(h->doc); /* #378: a lazy parse carries the
+                                         * tape — the tree materializes here */
+    if (dom == NULL) {
+        return YEPTRIS_ERROR_MEMORY; /* the lazy route's retry contract */
+    }
+    if (dom_subtree_tagged(dom, h->id) != 0) {
         yep_error_set(yep_error_tls(), YEP_ERR_UNEXPECTED, 0, 0, 0,
                       "marshal: explicitly tagged node not expressible; "
                       "fall back to the value walk");
         return YEPTRIS_ERROR_UNSUPPORTED;
     }
     yep_value_ctx* c = NULL;
-    if (yep_values_from_dom(h->doc->dom, h->id, 0, &c) != 0) {
+    if (yep_values_from_dom(dom, h->id, 0, &c) != 0) {
         return YEPTRIS_ERROR_MEMORY;
     }
     YeptrisStatus st = marshal_records(c, h->doc->schema == YEPTRIS_SCHEMA_11_COMPAT,

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

@@ -48,89 +48,57 @@ yep_dom* yep_doc_dom(yeptris_document* doc) {
     if (doc == NULL) {
         return NULL;
     }
-    if (doc->dom == NULL && doc->lazy_tape != NULL && doc->lazy_kind == 1) {
-        /* #378: the YAML record tape — replay through the eager
-         * builders; the finish pool (whose spans the records carry)
-         * dies once the builders copied what must outlive it */
-        yep_ytape* t = (yep_ytape*)doc->lazy_tape;
-        yep_dom* dom = yep_dom_create(doc->sys);
-        if (dom != NULL) {
-            dom->resolver = (doc->schema == YEPTRIS_SCHEMA_11_COMPAT) ? yep_resolver_compat11()
-                                                                      : yep_resolver_core12();
-        }
-        if (dom != NULL && dom_from_ytape(dom, t) == 0) {
-            doc->dom = dom;
-            ytap_free(t);
-            yep_free(doc->sys, t);
-            doc->lazy_tape = NULL;
-            yep_pool_destroy((yep_pool*)doc->finish_pool);
-            doc->finish_pool = NULL;
-        } else {
-            yep_dom_destroy(dom);
-            dom = NULL; /* the tape stays: a later access retries, or
-                         * free drops it (replay fails only on
-                         * allocation/depth, as the builders do) */
-        }
-        return dom;
-    }
+    /* the midx discipline (the #157 TSAN lesson): EVERY dom read and
+     * write rides the mutex — the unlock publishes the built tree
+     * (readers get their happens-before through the lock), so the
+     * plain field needs no atomics. Entry-level only: node walks ride
+     * handles created after this returns. */
+    yep_mutex_lock(&doc->lazy_mu);
     if (doc->dom == NULL && doc->lazy_tape != NULL) {
-        yeptris_json_tape* t = (yeptris_json_tape*)doc->lazy_tape;
-        yep_dom* dom = yep_dom_create(doc->sys);
-        if (dom != NULL && dom_from_tape(dom, t) == 0) {
-            doc->dom = dom;
-            yeptris_tape_free(t);
-            yep_free(doc->sys, t);
-            doc->lazy_tape = NULL;
-        } else {
-            yep_dom_destroy(dom);
-            dom = NULL; /* the tape stays: a later access retries, or
-                           free drops it (the materializer only fails on
-                           malformed NUM spans, which the strict gate
-                           already rejected at parse) */
-        }
-        return dom;
-    }
-    return doc->dom;
-}
-
-/* The strict-JSON document wrapper (both routes share it). */
-/* The lazy route's acceptance debt: the fused lenient walk records
- * number runs UNVALIDATED (its simdjson-style deferred contract).
- * parse_json's contract is RFC 8259 at parse time, so the deferred
- * spans settle HERE — full-span shape check per NUM record, decoding
- * the packed records directly (no columns build at parse; the walk
- * guarantees recs are primary on this route). */
-static int lazy_nums_settled(const yeptris_json_tape* t) {
-    const char* p = (const char*)t->_src;
-    for (uint32_t i = 0; i < t->count; i++) {
-        uint64_t r = t->recs[i];
-        if ((uint8_t)(r & 0xFFu) != YEP_T_NUM) {
-            continue;
-        }
-        uint32_t len = (uint32_t)((r >> 8) & 0x7FFFFFu);
-        uint32_t off = (uint32_t)(r >> 32);
-        { /* the pure-integer fast path: all digits (optional '-'), no
-           * leading zero unless a lone digit — number_shape would
-           * consume the whole span and answer float-less; skip it */
-            const char* q = p + off;
-            size_t d = (*q == '-') ? 1 : 0;
-            size_t w = d;
-            for (; w < len; w++) {
-                if ((unsigned)(unsigned char)q[w] - '0' > 9u) {
-                    break;
-                }
+        if (doc->lazy_kind == 1) {
+            /* #378: the YAML record tape — replay through the eager
+             * builders; the finish pool (whose spans the records
+             * carry) dies once the builders copied what must outlive
+             * it */
+            yep_ytape* t = (yep_ytape*)doc->lazy_tape;
+            yep_dom* dom = yep_dom_create(doc->sys);
+            if (dom != NULL) {
+                dom->resolver = (doc->schema == YEPTRIS_SCHEMA_11_COMPAT) ? yep_resolver_compat11()
+                                                                          : yep_resolver_core12();
             }
-            if (w == len && len > d && (len - d == 1 || q[d] != '0')) {
-                continue;
+            if (dom != NULL && dom_from_ytape(dom, t) == 0) {
+                doc->dom = dom;
+                ytap_free(t);
+                yep_free(doc->sys, t);
+                doc->lazy_tape = NULL;
+                yep_pool_destroy((yep_pool*)doc->finish_pool);
+                doc->finish_pool = NULL;
+            } else {
+                yep_dom_destroy(dom);
+                /* the tape stays: a later access retries, or free
+                 * drops it (replay fails only on allocation/depth, as
+                 * the builders do) */
+            }
+        } else {
+            yeptris_json_tape* t = (yeptris_json_tape*)doc->lazy_tape;
+            yep_dom* dom = yep_dom_create(doc->sys);
+            if (dom != NULL && dom_from_tape(dom, t) == 0) {
+                doc->dom = dom;
+                yeptris_tape_free(t);
+                yep_free(doc->sys, t);
+                doc->lazy_tape = NULL;
+            } else {
+                yep_dom_destroy(dom);
+                /* the tape stays: a later access retries, or free
+                 * drops it (the materializer only fails on malformed
+                 * NUM spans, which the strict gate already rejected at
+                 * parse) */
             }
-        }
-        size_t adv = 0;
-        int flt = 0;
-        if (yep_json_number_shape(p + off, len, &adv, &flt) == 0 || adv != (size_t)len) {
-            return -1;
         }
     }
-    return 0;
+    yep_dom* dom = doc->dom;
+    yep_mutex_unlock(&doc->lazy_mu);
+    return dom;
 }
 
 /* The strict-JSON document wrapper (both routes share it). */
@@ -145,6 +113,7 @@ static YeptrisDocument yep_json_doc_wrap(yep_dom* dom, const char* buf, size_t l
         }
         return NULL;
     }
+    yep_mutex_init(&doc->lazy_mu);
     doc->dom = dom;
     doc->sys = sys;
     doc->lazy_tape = NULL;
@@ -166,40 +135,31 @@ YEPTRIS_API YeptrisDocument yeptris_parse_json(const char* buf, size_t len, Yept
         st = YEPTRIS_ERROR_ARG;
         goto jfail;
     }
-    /* Clean-gate fast route (TODO.restructure/81 stage 2): a gate-clean
-     * buffer is printable ASCII, and the FUSED builder's walk runs
-     * STRICT here (dom->flow_strict) — one pass validates RFC 8259 and
-     * builds. Rejects, non-opener roots, and surprises fall to the
-     * original sequence below, whose error precedence is byte-for-byte
-     * the pinned behavior (json-suite-strict gates this). */
-    int gated = len > 0 && yep_text_active()->gate_scan(buf, len);
-    if (!gated) {
+    /* Clean-walk fast route (TODO.restructure/81 stage 2, #342): the
+     * fused walk runs clean_only — tabs and non-ASCII bytes REJECT —
+     * and ANY reject falls to the original sequence below, whose error
+     * precedence is byte-for-byte the pinned behavior
+     * (json-suite-strict gates this). The entry's full-input gate_scan
+     * + tab-memchr pre-passes are GONE: the walk's own byte guarantees
+     * route identically by construction, and the strict path re-gates
+     * only when actually taken (the profile's 5% + 2% lanes). */
+    {
         size_t off = 0;
         while (off < len &&
                (buf[off] == ' ' || buf[off] == '\t' || buf[off] == '\n' || buf[off] == '\r')) {
             off++;
         }
-        /* tabs: the lenient walk's own pinned acceptance (its route
-         * takes them); the strict routes reject them (ErrorParity's
-         * pinned agreement). A tab-carrying buffer must NOT take the
-         * lazy walk — the validating sequence below reports exactly
-         * the pinned reject. */
-        if (off < len && (buf[off] == '[' || buf[off] == '{') && memchr(buf, '\t', len) == NULL) {
-            /* #342 slice 2: the fused LENIENT walk (one pass, records
-             * only — no node building) settles the deferred number
-             * grammar inline, then the tape rides the document and
-             * dom_from_tape builds nodes on the first tree access.
-             * A reject or malformed span falls to the original
-             * sequence below, whose error precedence is byte-for-byte
-             * the pinned behavior. */
+        if (off < len && (buf[off] == '[' || buf[off] == '{')) {
             const yep_allocator* sys = yep_system_allocator();
             yeptris_json_tape* t = yep_alloc(sys, sizeof(*t));
             if (t == NULL) {
                 st = YEPTRIS_ERROR_MEMORY;
                 goto jfail;
             }
-            if (yep_tape_walk_lenient_fused(buf, len, off, t) == YEPTRIS_OK &&
-                lazy_nums_settled(t) == 0) {
+            if (yep_tape_walk_lenient_fused(buf, len, off, t, 1, 1) == YEPTRIS_OK) {
+                /* strict_nums=1: the arms validated the numbers at
+                 * record time — the settle pass is gone (the profile's
+                 * 10% lane; the spans were cache-warm in the walk) */
                 YeptrisDocument h = yep_json_doc_wrap(NULL, buf, len, sys, status);
                 if (h != NULL) {
                     ((yeptris_document*)h)->lazy_tape = t;
@@ -208,7 +168,8 @@ YEPTRIS_API YeptrisDocument yeptris_parse_json(const char* buf, size_t len, Yept
                 }
                 yeptris_tape_free(t); /* wrap failed (memory): below */
             } else {
-                yeptris_tape_free(t); /* reject/malformed: below */
+                yeptris_tape_free(t); /* reject (incl. clean-route tabs
+                                         and non-ASCII): below */
             }
             yep_free(sys, t);
         }
@@ -220,6 +181,9 @@ YEPTRIS_API YeptrisDocument yeptris_parse_json(const char* buf, size_t len, Yept
         st = YEPTRIS_ERROR_PARSE;
         goto jfail;
     }
+    /* the fallback re-gates: a buffer here was walk-rejected, so its
+     * printability decides whether UTF-8 validation is owed */
+    int gated = len > 0 && yep_text_active()->gate_scan(buf, len);
     size_t uerr = 0;
     if (gated && !yep_utf8_validate((const unsigned char*)buf, len, &uerr)) {
         yep_error_set(yep_error_tls(), YEP_ERR_ENCODING, 0, 0, uerr, "ill-formed UTF-8 at byte %zu",
@@ -370,9 +334,11 @@ engine_enter:
         dom->input_base = transcoded ? (const char*)transcoded : buf;
         yep_dom_prepare_len(dom, data_len);
     }
-    {
+    if (!json_mode) {
         /* the nametab reserve survives: a memchr chain for '&' is
-         * far cheaper than the class sweep it replaced */
+         * far cheaper than the class sweep it replaced. JSON skips it
+         * entirely — no anchors exist (the profile's 4.4% memchr
+         * lane on the json corpora). */
         yep_text_stats amp_only = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
         const char* q = data;
         const char* end = data + data_len;
@@ -465,6 +431,7 @@ engine_enter:
         st = YEPTRIS_ERROR_MEMORY;
         goto fail;
     }
+    yep_mutex_init(&doc->lazy_mu);
     doc->sys = sys;
     doc->schema = (opts != NULL && opts->schema == YEPTRIS_SCHEMA_11_COMPAT)
                       ? YEPTRIS_SCHEMA_11_COMPAT
@@ -504,7 +471,11 @@ fail:
 YEPTRIS_API YeptrisDocument yeptris_parse_ex(const char* buf, size_t len,
                                              const YeptrisParseOptions* opts,
                                              YeptrisStatus* status) {
-    return parse_impl(buf, len, opts, 0, 0, status);
+    /* #378 slice 2: the default YAML route carries the packed record
+     * tape — the tree materializes on first access (yep_doc_dom).
+     * Same grammar, same errors; parse-only workloads never build
+     * nodes. The eager form stays on yeptris_parse_eager_ex. */
+    return parse_impl(buf, len, opts, 0, 1, status);
 }
 
 /* #378 slice 1 (internal seam): the YAML parse rides the packed record
@@ -515,6 +486,13 @@ YeptrisDocument yeptris_parse_ytape_ex(const char* buf, size_t len, const Yeptri
     return parse_impl(buf, len, opts, 0, 1, status);
 }
 
+/* The eager form, kept for the parse-only A/B (bench_matrix's #378
+ * table) and as the reference lane the differential gates ride. */
+YeptrisDocument yeptris_parse_eager_ex(const char* buf, size_t len, const YeptrisParseOptions* opts,
+                                       YeptrisStatus* status) {
+    return parse_impl(buf, len, opts, 0, 0, status);
+}
+
 YEPTRIS_API void yeptris_document_free(YeptrisDocument handle) {
     yeptris_document* doc = (yeptris_document*)handle;
     if (doc == NULL) {
@@ -528,6 +506,7 @@ YEPTRIS_API void yeptris_document_free(YeptrisDocument handle) {
         }
         yep_free(doc->sys, doc->lazy_tape);
     }
+    yep_mutex_destroy(&doc->lazy_mu);
     yep_dom_destroy(doc->dom);
     yep_pool_destroy((yep_pool*)doc->finish_pool);
     yep_free(doc->sys, doc->transcoded);
@@ -536,7 +515,10 @@ YEPTRIS_API void yeptris_document_free(YeptrisDocument handle) {
 
 YEPTRIS_API size_t yeptris_document_count(YeptrisDocument handle) {
     yeptris_document* doc = (yeptris_document*)handle;
-    return doc ? yep_doc_dom(doc)->dcount : 0;
+    yep_dom* dom = doc ? yep_doc_dom(doc) : NULL; /* NULL: the lazy
+                                                   * route's failed/retrying materialization — an
+                                                   * unusable tree counts as zero documents */
+    return dom ? dom->dcount : 0;
 }
 
 yeptris_node* yep_handle_new(yeptris_document* doc, uint32_t id) {

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

@@ -601,8 +601,54 @@ reject:
  * (the classify scan carries no accept/reject structure) and
  * yeptris_tape_convert owns validation. Everything else matches
  * tape_walk state for state. */
+/* 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. */
+static 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) {
+                                          yeptris_json_tape* t, int strict_nums, int clean_only) {
     if (tape_carve(t, len) != YEPTRIS_OK) {
         return YEPTRIS_ERROR_MEMORY;
     }
@@ -624,11 +670,24 @@ YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open
     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
@@ -643,7 +702,8 @@ YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open
 
 #define LWS()                                                                                      \
     do {                                                                                           \
-        while (i < len && (p[i] == ' ' || p[i] == '\n' || p[i] == '\r' || p[i] == '\t')) {         \
+        while (i < len &&                                                                          \
+               (p[i] == ' ' || p[i] == '\n' || p[i] == '\r' || (p[i] == '\t' && !cl))) {           \
             i++;                                                                                   \
         }                                                                                          \
         if (i >= len) {                                                                            \
@@ -701,7 +761,8 @@ YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open
             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) {                                      \
+            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);     \
@@ -720,12 +781,17 @@ YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open
                     if (room_ >= 8) {                                                              \
                         uint64_t v_;                                                               \
                         memcpy(&v_, p + b_, 8);                                                    \
-                        if ((v_ - 0x2020202020202020ull) & ~v_ & 0x8080808080808080ull) {          \
+                        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) {                                         \
+                        if ((unsigned char)p[b_] < 0x20 || (cl && (unsigned char)p[b_] >= 0x80)) { \
                             goto lreject;                                                          \
                         }                                                                          \
                         b_++;                                                                      \
@@ -744,6 +810,16 @@ YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open
             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++;                                                                               \
@@ -788,15 +864,36 @@ lmapcolon:
         }
         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 != '-');
             while (k < len) {
                 char d = p[k];
-                if ((d >= '0' && d <= '9') || d == '-' || d == '+' || d == '.' || d == 'e' ||
-                    d == 'E') {
+                if ((unsigned)(d - '0') <= 9u) {
+                    k++;
+                    saw_digit = 1;
+                    continue;
+                }
+                digits_only = 0;
+                if (d == '-' || d == '+' || d == '.' || d == 'e' || d == 'E') {
                     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)(YEP_T_NUM);
             count++;
@@ -868,15 +965,33 @@ lseqval: {
     }
     if ((unsigned)(c - '0') <= 9u || c == '-') {
         size_t k = i + 1;
+        int digits_only = 1, saw_digit = (c != '-');
         while (k < len) {
             char d = p[k];
-            if ((d >= '0' && d <= '9') || d == '-' || d == '+' || d == '.' || d == 'e' ||
-                d == 'E') {
+            if ((unsigned)(d - '0') <= 9u) {
+                k++;
+                saw_digit = 1;
+                continue;
+            }
+            digits_only = 0;
+            if (d == '-' || d == '+' || d == '.' || d == 'e' || d == 'E') {
                 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)(YEP_T_NUM);
         count++;
@@ -940,7 +1055,7 @@ ldone:
 {
     size_t tail = i;
     while (tail < len &&
-           (p[tail] == ' ' || p[tail] == '\t' || p[tail] == '\n' || p[tail] == '\r')) {
+           (p[tail] == ' ' || p[tail] == '\n' || p[tail] == '\r' || (p[tail] == '\t' && !cl))) {
         tail++;
     }
     if (tail != len) {
@@ -1465,7 +1580,7 @@ YEPTRIS_API YeptrisStatus yeptris_parse_json_tape_lenient(const char* source, si
             return st;
         }
         free(blocks);
-        return yep_tape_walk_lenient_fused(source, len, at, tape);
+        return yep_tape_walk_lenient_fused(source, len, at, tape, 0, 0);
     }
 
     /* scalar root: one record, same deferred split for numbers */

data/vendor/libyeptris/src/yeptris/tape_in.h

@@ -15,7 +15,7 @@
 
 /* tape.c (was tape_walk_lnt_fused) */
 YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open,
-                                          yeptris_json_tape* t);
+                                          yeptris_json_tape* t, int strict_nums, int clean_only);
 
 /* parse.c (#378 slice 1): the YAML parse carrying the packed record
  * tape — the tree materializes on first access (yep_doc_dom). */
@@ -24,6 +24,11 @@ extern "C" {
 #endif
 YeptrisDocument yeptris_parse_ytape_ex(const char* buf, size_t len, const YeptrisParseOptions* opts,
                                        YeptrisStatus* status);
+
+/* the eager form (the A/B reference lane): the engine builds nodes at
+ * parse, no tape */
+YeptrisDocument yeptris_parse_eager_ex(const char* buf, size_t len, const YeptrisParseOptions* opts,
+                                       YeptrisStatus* status);
 #ifdef __cplusplus
 }
 #endif

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.20.2
+  version: 0.6.21.1
 platform: aarch64-linux
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-24 00:00:00.000000000 Z
+date: 2026-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi