yeptris 0.6.45.0-arm-linux-eabihf → 0.6.46.0-arm-linux-eabihf

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c43c41fe4992b16d17647b108a65e492fa37907b403ec8df6011c4fb46348a76
-  data.tar.gz: 3c13e230140a3d121a9aa41cac1f9db7572e65cd0a76a6dfeb2387be68c1a98c
+  metadata.gz: 4ba6e0359c7ce80fe647880e6917a7acd6590207d5566e33fb14fe13d9016368
+  data.tar.gz: 266c14566415ef1a11979fd6db82400f4be5a53c3932d0809d7ed38e83677393
 SHA512:
-  metadata.gz: b5e4613c94c3fe7afa2a7000f463d910483fc233e7fb5140b7d05d7d1926e853103ac2ad8811a18b5aec55ae7920d76e9742f01eb1e1eafa7b168b643bd16060
-  data.tar.gz: 5a30b4478873097dd683eef2ea56f1b1bdac5d643a34b1bea71b31ea266a9322727a5f5de6e1c3edce9dbacb7a6873a1cd9abef2c9fcf9b92d87c1d6fa9092f6
+  metadata.gz: 6eb1a6c429713ceb24a2e071de720cd37ff7b6deb91cabc18ff6f369de4c7cf7af78fa73510f54de6b93afcefe118fa134223aed543b584c574bcd7a09843af0
+  data.tar.gz: df2847bf2aa28d99b9a5d444ce9602a110ce9cb0ed0d7685c31d031ce2a7131303f583189874af962afaab42a84b3bb09ed134e60d60fa41f657b5b9a984d22b

data/ext/yeptris_native/version.h

@@ -11,8 +11,8 @@
 
 #define YEPTRIS_VERSION_MAJOR 0
 #define YEPTRIS_VERSION_MINOR 6
-#define YEPTRIS_VERSION_PATCH 45
-#define YEPTRIS_VERSION_STRING "0.6.45"
+#define YEPTRIS_VERSION_PATCH 46
+#define YEPTRIS_VERSION_STRING "0.6.46"
 
 #ifdef __cplusplus
 extern "C" {

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.45.0".freeze
+  VERSION = "0.6.46.0".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.45
+    VERSION 0.6.46
     DESCRIPTION "Ultra-fast YAML 1.2 parser, emitter and streamer in C"
     LANGUAGES C CXX
 )

data/vendor/libyeptris/src/include/yeptris/marshal.h

@@ -56,6 +56,18 @@ YEPTRIS_API YeptrisStatus yeptris_marshal_node_ex(YeptrisNode node, uint32_t fla
 
 YEPTRIS_API void yeptris_marshal_free(char* out);
 
+/* yeptris-ruby#322: the dump face's marshal reader — Ruby
+ * Marshal.dump bytes IN, JSON text OUT, one C call (no per-scalar
+ * crossings, no object reconstruction). Handles the JSON-relevant
+ * subset (nil/bool/int/string/float/array/hash + symbols/links/ivars);
+ * anything else — objects, structs, user marshal, bignums beyond i64,
+ * non-finite floats, cycles — returns YEPTRIS_ERROR_UNSUPPORTED and
+ * the binding falls back to its per-node walk. *out is malloc'd, free
+ * with yeptris_marshal_free exactly once; on failure nothing is
+ * allocated. compact selects the no-space separators. */
+YEPTRIS_API YeptrisStatus yeptris_json_from_marshal(const char* m, size_t m_len, int compact,
+                                                    char** out, size_t* out_len);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -9,6 +9,8 @@
 
 #include "dom.h"
 
+#include "../scan/scan.h" /* the dq-forced SSOT (the fact bit) */
+
 #include <yeptris/resolve.h> /* the tag-id SSOT (the strict literal arm) */
 
 /* The bounded-parse caps: each node consumes at least one input byte
@@ -140,6 +142,16 @@ static yep_sview dom_str_in(yep_dom* d, const yep_view* v, int borrowed) {
  * given metadata; tag/anchor views encode through dom_str_in (tags and
  * event-path anchors copy to the arena; input-backed views borrow).
  * tag_id stays 0 — the caller resolves (scalars) or leaves 0. */
+/* Value assign + the emit-side fact bit (issue #352 lane 2): the bit
+ * is "verified clean" of the dq-forced byte set — the serializer's
+ * sc_route then skips its per-derive rescan. The scan is the SSOT
+ * predicate (yep_scan_dq_forced); every value assignment routes
+ * through here so no path can leave a dirty scalar marked clean. */
+static void dom_set_value(yep_dom* d, uint32_t id, const yep_view* v, int borrowed) {
+    d->nodes[id].value = dom_str_in(d, v, borrowed);
+    d->nodes[id].no_exotic = !yep_scan_dq_forced(v->p, v->len);
+}
+
 uint32_t dom_open_node(yep_dom* d, uint8_t kind, const yep_view* tag, const yep_view* anchor,
                        int anchor_borrowed, uint8_t style, uint8_t implicit, uint8_t flow) {
     if (!dom_grow_nodes(d, 1)) {
@@ -421,7 +433,7 @@ int yep_dom_on_event(void* ctx, const yep_event* ev) {
         if (id == UINT32_MAX) {
             return -1;
         }
-        d->nodes[id].value = dom_str_in(d, &ev->value, ev->borrowed);
+        dom_set_value(d, id, &ev->value, ev->borrowed);
         if (ev->anchor_id != 0 && dom_anchor_set(d, ev->anchor_id, id) != 0) {
             return -1;
         }
@@ -437,7 +449,7 @@ int yep_dom_on_event(void* ctx, const yep_event* ev) {
         if (id == UINT32_MAX) {
             return -1;
         }
-        d->nodes[id].value = dom_str_in(d, &ev->value, ev->borrowed);
+        dom_set_value(d, id, &ev->value, ev->borrowed);
         d->nodes[id].target = target;
         return dom_place(d, id);
     }
@@ -902,9 +914,11 @@ int dom_on_flow_build(void* ctx, const char* p, size_t open, size_t len, uint32_
                 d->nodes[sid].value =
                     yep_dom_str_commit(d, yep_finish_double_into(p, (uint32_t)(t.at + 1),
                                                                  (uint32_t)(t.end - 1), dst, span));
+                d->nodes[sid].no_exotic = 1; /* JSON-class strings: the
+                    walker rejected every control byte */
             } else {
                 yep_view v = {p + t.at + 1, (uint32_t)(t.end - t.at - 2)};
-                d->nodes[sid].value = dom_str_in(d, &v, 1);
+                dom_set_value(d, sid, &v, 1);
             }
             if (dom_place(d, sid) != 0) {
                 goto fail;
@@ -918,6 +932,8 @@ int dom_on_flow_build(void* ctx, const char* p, size_t open, size_t len, uint32_
             }
             yep_view v = {p + t.at, (uint32_t)(t.end - t.at)};
             d->nodes[sid].value = dom_str_in(d, &v, 1);
+            d->nodes[sid].no_exotic = 1; /* the walker validated the
+                span as a JSON number or literal */
             if (t.cls == '#') {
                 d->nodes[sid].tag_id = yep_resolve_number(r, t.is_float);
             } else if (d->flow_strict) {
@@ -1087,13 +1103,15 @@ int dom_from_tape(yep_dom* d, const yeptris_json_tape* t) {
                     }
                     d->nodes[id].value = yep_dom_str_commit(
                         d, yep_finish_double_into(src, off, off + len, dst, len));
+                    d->nodes[id].no_exotic = 1; /* JSON-class: escapes
+                        only, the walker's law */
                 } else {
                     yep_view v = {src + off, len};
-                    d->nodes[id].value = dom_str_in(d, &v, 1);
+                    dom_set_value(d, id, &v, 1);
                 }
             } else {
                 yep_view v = {src + off, len};
-                d->nodes[id].value = dom_str_in(d, &v, 1);
+                dom_set_value(d, id, &v, 1);
             }
             d->nodes[id].tag_id = tag;
             if (dom_place(d, id) != 0) {
@@ -1141,7 +1159,7 @@ int dom_on_block_open(void* ctx, const yep_view* key, uint32_t line, uint16_t ke
         d->depth--;
         return -1;
     }
-    d->nodes[kid].value = dom_str_in(d, key, 1);
+    dom_set_value(d, kid, key, 1);
     d->nodes[kid].tag_id = r->resolve(NULL, key->p, key->len);
     return dom_place(d, kid) == 0 ? 1 : -1;
 }
@@ -1156,7 +1174,7 @@ int dom_on_block_item(void* ctx, const yep_block_value* v) {
     if (vid == UINT32_MAX) {
         return -1;
     }
-    d->nodes[vid].value = dom_str_in(d, &v->value, v->borrowed);
+    dom_set_value(d, vid, &v->value, v->borrowed);
     d->nodes[vid].tag_id = r->resolve(NULL, v->value.p, v->value.len);
     return dom_place(d, vid) == 0 ? 1 : -1;
 }
@@ -1183,7 +1201,7 @@ int dom_on_block_pair(void* ctx, const yep_view* key, const yep_block_value* v,
     if (kid == UINT32_MAX) {
         return -1;
     }
-    d->nodes[kid].value = dom_str_in(d, key, 1);
+    dom_set_value(d, kid, key, 1);
     d->nodes[kid].tag_id = r->resolve(NULL, key->p, key->len);
     if (dom_place(d, kid) != 0) {
         return -1;
@@ -1193,7 +1211,7 @@ int dom_on_block_pair(void* ctx, const yep_view* key, const yep_block_value* v,
         if (vid == UINT32_MAX) {
             return -1;
         }
-        d->nodes[vid].value = dom_str_in(d, &v->value, 1); /* borrowed — the
+        dom_set_value(d, vid, &v->value, 1); /* borrowed — the
             event path stamps it too now (73); the gates compare decoded
             views, not arena placement */
         d->nodes[vid].target = target;
@@ -1205,7 +1223,7 @@ int dom_on_block_pair(void* ctx, const yep_view* key, const yep_block_value* v,
     if (vid == UINT32_MAX) {
         return -1;
     }
-    d->nodes[vid].value = dom_str_in(d, &v->value, v->borrowed);
+    dom_set_value(d, vid, &v->value, v->borrowed);
     d->nodes[vid].tag_id = r->resolve(NULL, v->value.p, v->value.len);
     if (anchored && v->anchor_id != 0 && dom_anchor_set(d, v->anchor_id, vid) != 0) {
         return -1;
@@ -1224,7 +1242,7 @@ int dom_on_scalar(void* ctx, const yep_view* value, const yep_view* tag, const y
     if (id == UINT32_MAX) {
         return -1;
     }
-    d->nodes[id].value = dom_str_in(d, value, borrowed);
+    dom_set_value(d, id, value, borrowed);
     d->nodes[id].tag_id = tag_id;
     if (anchor_id != 0 && dom_anchor_set(d, anchor_id, id) != 0) {
         return -1;

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

@@ -60,12 +60,16 @@ typedef struct yep_sview {
  * fields left the record — they live in the DOM's lazily-built side
  * tables (parse pays nothing; dom.c owns them). */
 typedef struct yep_dnode {
-    uint8_t kind : 2;     /* yep_dom_kind (0-3) */
-    uint8_t style : 3;    /* yep_scalar_style (0-5) */
-    uint8_t flow : 1;     /* collection opened in flow style */
-    uint8_t implicit : 1; /* scalar written without quotes/tag */
-    uint8_t tag_id;       /* resolved tag (resolve/resolver.h) */
-    uint32_t first_child; /* child link (mappings: key,value,key,value…) */
+    uint8_t kind : 2;      /* yep_dom_kind (0-3) */
+    uint8_t style : 3;     /* yep_scalar_style (0-5) */
+    uint8_t flow : 1;      /* collection opened in flow style */
+    uint8_t implicit : 1;  /* scalar written without quotes/tag */
+    uint8_t no_exotic : 1; /* value verified clean of the dq-forced
+                            * byte set (#352 lane 2): the serializer's
+                            * sc_route skips its rescan. Set at every
+                            * value assignment; 0 = unknown = scan. */
+    uint8_t tag_id;        /* resolved tag (resolve/resolver.h) */
+    uint32_t first_child;  /* child link (mappings: key,value,key,value…) */
     uint32_t last_child;
     uint32_t next_sibling;
     uint32_t count;  /* children (mappings: 2 × pairs) */

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

@@ -486,31 +486,12 @@ enum { YEP_SC_NOTHING = 0, YEP_SC_PLAIN, YEP_SC_SQ, YEP_SC_DQ, YEP_SC_LITERAL, Y
  * The block map's explicit-key promotion consults the same predicate:
  * a key whose content demotes to DQ re-parses as a QUOTED key and must
  * ride simple, or round two's render differs (the nightly's round 118). */
-static int sc_dq_forced(const char* p, uint32_t len) {
-    for (uint32_t k = 0; k + 1 < len; k++) {
-        if ((unsigned char)p[k] == 0xc2 && (unsigned char)p[k + 1] == 0x85) {
-            return 1;
-        }
-        /* LS/PS are breaks like NEL: only their escapes are stable */
-        if ((unsigned char)p[k] == 0xe2 && k + 2 < len && (unsigned char)p[k + 1] == 0x80 &&
-            ((unsigned char)p[k + 2] == 0xa8 || (unsigned char)p[k + 2] == 0xa9)) {
-            return 1;
-        }
-        if ((unsigned char)p[k] == 0xef && k + 2 < len && (unsigned char)p[k + 1] == 0xbb &&
-            (unsigned char)p[k + 2] == 0xbf) {
-            return 1;
-        }
-        if ((unsigned char)p[k] == 0xef && k + 2 < len && (unsigned char)p[k + 1] == 0xbf &&
-            ((unsigned char)p[k + 2] == 0xbe || (unsigned char)p[k + 2] == 0xbf)) {
-            return 1; /* noncharacter: only its escape re-parses */
-        }
-    }
-    return 0;
-}
-
 static uint8_t sc_route(yep_writer* w, const char* p, uint32_t len, int as_key, uint8_t sty_in,
-                        int has_tag) {
-    if (sc_dq_forced(p, len)) {
+                        int has_tag, int no_exotic) {
+    /* the parse-time fact bit (#352 lane 2): a dnode verified clean of
+     * the dq-forced set skips the rescan — 0 (mutation-built or JSON
+     * classes) keeps the scan */
+    if (!no_exotic && yep_scan_dq_forced(p, len)) {
         return YEP_SC_DQ;
     }
     if (w->in_flow && len > 0) {
@@ -641,14 +622,14 @@ static void emit_scalar(yep_writer* w, const yep_dnode* n, int parent_col, int a
      * memoized long scalars, in visit order either way. */
     if (w->sc_dec != NULL && len >= YEP_SC_MEMO_MIN) {
         if (w->dry) {
-            route = sc_route(w, p, len, as_key, n->style, n->tag.len > 0);
+            route = sc_route(w, p, len, as_key, n->style, n->tag.len > 0, n->no_exotic);
             w->sc_dec[w->sc_i] = route;
         } else {
             route = w->sc_dec[w->sc_i];
         }
         w->sc_i++;
     } else {
-        route = sc_route(w, p, len, as_key, n->style, n->tag.len > 0);
+        route = sc_route(w, p, len, as_key, n->style, n->tag.len > 0, n->no_exotic);
     }
     switch (route) {
     case YEP_SC_NOTHING:
@@ -1190,7 +1171,7 @@ static void emit_block_map(yep_emitter* em, uint32_t id, int content_col) {
          * anyway (the nightly's run 38177622733, ":\n! |-\n r\n:") */
         if (!complex_key && kn->style >= 4 && kn->style <= 5 && kn->value.len > 0 &&
             kn->tag.len > 0 && memchr(wv(w, kn->value).p, '\n', wv(w, kn->value).len) == NULL &&
-            !sc_dq_forced(wv(w, kn->value).p, wv(w, kn->value).len)) {
+            (kn->no_exotic || !yep_scan_dq_forced(wv(w, kn->value).p, wv(w, kn->value).len))) {
             /* a TAGGED SINGLE-LINE literal/folded key keeps the block
              * form in sc_route (the #290 law), so the value separator
              * would glue onto the block's CONTENT line (colons are
@@ -1403,6 +1384,560 @@ 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-ruby#322: the marshal READER — Ruby Marshal.dump bytes
+ * to JSON text in one C call (no per-scalar crossings, no object
+ * reconstruction). The format facts mirror marshal.c's emission
+ * contract (empirically pinned against Ruby 3.4): w_long small form
+ * x==0 -> 0x00, |x| <= 122 -> sign*(|x|+5), size form tag +-k with
+ * LE payload (2^8k - m for negatives); strings carry 'I' ivar
+ * wrappers; arrays/hashes/strings/floats register for '@' links.
+ * A JSON dump duplicates linked re-references (cycled or shared
+ * subtrees re-walk from the registered position, depth-guarded).
+ * The JSON-irrelevant constructs ('o' objects, 'S' structs, 'u'
+ * user marshal, 'l' bignums beyond i64, non-finite floats) return
+ * UNSUPPORTED — the binding falls back to its per-node walk.
+ * ============================================================ */
+
+#include <inttypes.h>
+
+typedef struct {
+    const char* p;
+    size_t len;
+    size_t at;
+} mj_stream;
+
+typedef struct {
+    uint32_t kind; /* 1 seq, 2 map */
+    uint32_t items;
+} mj_frame;
+
+typedef struct {
+    yep_writer* w;
+    mj_stream s;
+    mj_frame* frames;
+    int depth;
+    int compact;
+    /* the symbol table: ';' links resolve to these names */
+    struct {
+        const char* p;
+        uint32_t len;
+    }* syms;
+    size_t syms_n, syms_cap;
+    /* the object table: '@' links re-walk from these positions */
+    struct {
+        size_t pos;
+        uint32_t chain_pos;
+    }* objs;
+    size_t objs_n, objs_cap;
+    size_t* chain; /* the active positions (cycle guard) */
+    size_t chain_n, chain_cap;
+    int failed; /* 0 ok, YEPTRIS_ERROR_UNSUPPORTED */
+} mj_ctx;
+
+static int mj_fail(mj_ctx* c) {
+    c->failed = YEPTRIS_ERROR_UNSUPPORTED;
+    return -1;
+}
+
+static int mj_byte(mj_ctx* c, unsigned char* out) {
+    if (c->s.at >= c->s.len)
+        return mj_fail(c);
+    *out = (unsigned char)c->s.p[c->s.at++];
+    return 0;
+}
+
+/* the w_long inverse — mirrors m_w_long's encode exactly:
+ *   0x00 -> 0; 1..4 -> positive size form k=b; 5..127 -> small +(
+ *   b-5); 129..250 -> small -(251-b); 251..255 -> negative size form
+ *   k=256-b (payload = LE(2^(8k) - m)); 128/248..250 unreachable (the
+ *   writer takes the small form first). */
+static int mj_long(mj_ctx* c, int64_t* out) {
+    unsigned char b;
+    if (mj_byte(c, &b) != 0)
+        return -1;
+    if (b == 0) {
+        *out = 0;
+        return 0;
+    }
+    if (b <= 4) { /* positive size form, k = b */
+        int64_t v = 0;
+        for (int i = 0; i < (int)b; i++) {
+            unsigned char d;
+            if (mj_byte(c, &d) != 0)
+                return -1;
+            v |= (int64_t)d << (8 * i);
+        }
+        *out = v;
+        return 0;
+    }
+    if (b <= 127) {
+        *out = (int64_t)b - 5;
+        return 0;
+    }
+    if (b >= 129 && b <= 250) {
+        *out = (int64_t)b - 251;
+        return 0;
+    }
+    { /* 251..255: negative size form */
+        int bytes = 256 - (int)b;
+        int64_t v = 0;
+        for (int i = 0; i < bytes; i++) {
+            unsigned char d;
+            if (mj_byte(c, &d) != 0)
+                return -1;
+            v |= (int64_t)d << (8 * i);
+        }
+        *out = v - ((int64_t)1 << (8 * bytes));
+        return 0;
+    }
+}
+
+static const char* mj_sym_name(mj_ctx* c, int64_t idx, uint32_t* len_out) {
+    if (idx < 0 || (size_t)idx >= c->syms_n) {
+        mj_fail(c);
+        return NULL;
+    }
+    *len_out = c->syms[idx].len;
+    return c->syms[idx].p;
+}
+
+static int mj_ivar_skip(mj_ctx* c);
+static int mj_link_key(mj_ctx* c, int64_t idx);
+
+static int mj_value(mj_ctx* c);
+
+static int mj_string_body(mj_ctx* c, int64_t len) {
+    if (len < 0 || (uint64_t)len > (uint64_t)(c->s.len - c->s.at))
+        return mj_fail(c);
+    emit_dq_json(c->w, c->s.p + c->s.at, (uint32_t)len);
+    c->s.at += (size_t)len;
+    return 0;
+}
+
+/* a symbol: ':' + long(len) + bytes — registers in the table; the
+ * name is emitted as a JSON string when emit is set */
+static int mj_symbol(mj_ctx* c, int emit) {
+    int64_t len;
+    if (mj_long(c, &len) != 0)
+        return -1;
+    if (len < 0 || (uint64_t)len > (uint64_t)(c->s.len - c->s.at))
+        return mj_fail(c);
+    const char* name = c->s.p + c->s.at;
+    uint32_t nlen = (uint32_t)len;
+    c->s.at += (size_t)len;
+    if (c->syms_n == c->syms_cap) {
+        c->syms_cap = c->syms_cap ? c->syms_cap * 2 : 16;
+        c->syms = (void*)realloc(c->syms, c->syms_cap * sizeof(*c->syms));
+        if (!c->syms)
+            return mj_fail(c);
+    }
+    c->syms[c->syms_n].p = name;
+    c->syms[c->syms_n].len = nlen;
+    c->syms_n++;
+    if (emit) {
+        emit_dq_json(c->w, name, nlen);
+    }
+    return 0;
+}
+
+/* an ivar wrapper 'I': the value then long(count) then count pairs of
+ * (symbol, value) — read-and-discard (encodings and such) */
+static int mj_ivar_skip(mj_ctx* c);
+
+static int mj_discard_value(mj_ctx* c) {
+    unsigned char t;
+    if (mj_byte(c, &t) != 0)
+        return -1;
+    switch (t) {
+    case '0':
+    case 'T':
+    case 'F':
+        return 0;
+    case 'i': {
+        int64_t v;
+        return mj_long(c, &v);
+    }
+    case '"': {
+        int64_t len;
+        if (mj_long(c, &len) != 0)
+            return -1;
+        if (len < 0 || (uint64_t)len > (uint64_t)(c->s.len - c->s.at))
+            return mj_fail(c);
+        c->s.at += (size_t)len;
+        return 0;
+    }
+    case ':':
+        return mj_symbol(c, 0);
+    case ';': {
+        int64_t idx;
+        if (mj_long(c, &idx) != 0)
+            return -1;
+        return mj_sym_name(c, idx, &(uint32_t){0}) ? 0 : -1;
+    }
+    case 'I':
+        return mj_ivar_skip(c);
+    default:
+        return mj_fail(c); /* ivars on JSON trees carry symbol/E
+                              pairs only in practice */
+    }
+}
+
+/* the count + (symbol, value) pairs that follow an 'I' wrapper's
+ * wrapped value */
+static int mj_ivar_pairs(mj_ctx* c) {
+    int64_t count;
+    if (mj_long(c, &count) != 0)
+        return -1;
+    for (int64_t i = 0; i < count; i++) {
+        if (mj_discard_value(c) != 0)
+            return -1; /* the name symbol */
+        if (mj_discard_value(c) != 0)
+            return -1; /* the ivar value */
+    }
+    return 0;
+}
+
+/* a standalone 'I' wrapper: the wrapped value, then the pairs */
+static int mj_ivar_skip(mj_ctx* c) {
+    if (mj_discard_value(c) != 0)
+        return -1; /* the wrapped value */
+    return mj_ivar_pairs(c);
+}
+
+static int mj_value(mj_ctx* c) {
+    unsigned char t;
+    size_t tpos = c->s.at;
+    if (mj_byte(c, &t) != 0)
+        return -1;
+    /* arrays, hashes, strings and floats register for '@' links (the
+     * marshal.c emission contract, 0-based stream order); integers,
+     * bignums, symbols and immediates never register */
+    if (t == '[' || t == '{' || t == '"' || t == 'f') {
+        if (c->objs_n == c->objs_cap) {
+            c->objs_cap = c->objs_cap ? c->objs_cap * 2 : 16;
+            c->objs = (void*)realloc(c->objs, c->objs_cap * sizeof(*c->objs));
+            if (!c->objs)
+                return mj_fail(c);
+        }
+        c->objs[c->objs_n].pos = tpos;
+        c->objs[c->objs_n].chain_pos = 0;
+        c->objs_n++;
+    }
+    switch (t) {
+    case '0':
+        wr_put(c->w, "null", 4);
+        return 0;
+    case 'T':
+        wr_put(c->w, "true", 4);
+        return 0;
+    case 'F':
+        wr_put(c->w, "false", 5);
+        return 0;
+    case 'i': {
+        int64_t v;
+        if (mj_long(c, &v) != 0)
+            return -1;
+        char buf[24];
+        int n = snprintf(buf, sizeof buf, "%lld", (long long)v);
+        wr_put(c->w, buf, (uint32_t)n);
+        return 0;
+    }
+    case '"': {
+        int64_t len;
+        if (mj_long(c, &len) != 0)
+            return -1;
+        int rc = mj_string_body(c, len);
+        if (rc != 0)
+            return -1;
+        /* the 'I' wrapper follows when the string carries ivars: the
+         * value is already parsed — pairs only */
+        if (c->s.at < c->s.len && c->s.p[c->s.at] == 'I') {
+            c->s.at++;
+            if (mj_ivar_pairs(c) != 0)
+                return -1;
+        }
+        return 0;
+    }
+    case 'I': {
+        /* the wrapped value IS the payload: re-dispatch into it, then
+         * the ivar pairs ride */
+        if (mj_value(c) != 0)
+            return -1;
+        return mj_ivar_pairs(c);
+    }
+    case 'l': {
+        /* the bignum: sign byte + w_long(limb count) + LE 16-bit
+         * limbs; the i64-representable range emits, wider falls back */
+        unsigned char sign;
+        if (mj_byte(c, &sign) != 0)
+            return -1;
+        if (sign != 0x2b && sign != 0x2d)
+            return mj_fail(c); /* + / - */
+        int64_t words;
+        if (mj_long(c, &words) != 0)
+            return -1;
+        if (words < 0 || words > 4)
+            return mj_fail(c);
+        int64_t v = 0;
+        for (int64_t i = 0; i < words; i++) {
+            for (int b = 0; b < 2; b++) {
+                unsigned char d;
+                if (mj_byte(c, &d) != 0)
+                    return -1;
+                v |= (int64_t)d << (16 * i + 8 * b);
+            }
+        }
+        if (sign == 0x2d) {
+            v = -v;
+        }
+        char buf[24];
+        int n = snprintf(buf, sizeof buf, "%lld", (long long)v);
+        wr_put(c->w, buf, (uint32_t)n);
+        return 0;
+    }
+    case 'f': {
+        int64_t len;
+        if (mj_long(c, &len) != 0)
+            return -1;
+        if (len < 0 || (uint64_t)len > (uint64_t)(c->s.len - c->s.at))
+            return mj_fail(c);
+        char tmp[64];
+        uint32_t tl = (uint32_t)len < sizeof tmp - 1 ? (uint32_t)len : (uint32_t)sizeof tmp - 1;
+        memcpy(tmp, c->s.p + c->s.at, tl);
+        tmp[tl] = '\0';
+        c->s.at += (size_t)len;
+        if (strcmp(tmp, "inf") == 0 || strcmp(tmp, "-inf") == 0 || strcmp(tmp, "nan") == 0) {
+            return mj_fail(c); /* JSON has no inf/nan spelling */
+        }
+        double d = strtod(tmp, NULL);
+        char buf[40];
+        int wl = yep_d2s_json(d, buf);
+        wr_put(c->w, buf, (uint32_t)wl);
+        return 0;
+    }
+    case '[':
+    case '{': {
+        int64_t count;
+        if (mj_long(c, &count) != 0)
+            return -1;
+        if (count < 0)
+            return mj_fail(c);
+        if (c->depth >= 512)
+            return mj_fail(c);
+        c->depth++;
+        wr_byte(c->w, t == '[' ? '[' : '{');
+        for (int64_t i = 0; i < count; i++) {
+            if (i > 0) {
+                wr_put(c->w, c->compact ? "," : ", ", c->compact ? 1 : 2);
+            }
+            if (t == '{') {
+                /* the key: a string or a symbol — JSON keys are strings */
+                unsigned char kt;
+                if (mj_byte(c, &kt) != 0)
+                    return -1;
+                if (kt == 'I') {
+                    /* an ivar-wrapped key: the inner value emits, then
+                     * the pairs (the 'I' is consumed) */
+                    if (mj_value(c) != 0)
+                        return -1;
+                    if (mj_ivar_pairs(c) != 0)
+                        return -1;
+                } else if (kt == '@') {
+                    /* a linked key: re-emit the target (#322's corpus
+                     * links the users' repeated key strings) */
+                    int64_t idx;
+                    if (mj_long(c, &idx) != 0)
+                        return -1;
+                    if (mj_link_key(c, idx) != 0)
+                        return -1;
+                } else if (kt == '"') {
+                    int64_t len;
+                    if (mj_long(c, &len) != 0)
+                        return -1;
+                    int rc = mj_string_body(c, len);
+                    if (rc != 0)
+                        return -1;
+                    if (c->s.at < c->s.len && c->s.p[c->s.at] == 'I') {
+                        c->s.at++;
+                        if (mj_ivar_pairs(c) != 0)
+                            return -1;
+                    }
+                } else if (kt == ':') {
+                    if (mj_symbol(c, 1) != 0)
+                        return -1;
+                } else if (kt == ';') {
+                    int64_t idx;
+                    if (mj_long(c, &idx) != 0)
+                        return -1;
+                    uint32_t nlen;
+                    const char* nm = mj_sym_name(c, idx, &nlen);
+                    if (!nm)
+                        return -1;
+                    emit_dq_json(c->w, nm, nlen);
+                } else {
+                    return mj_fail(c);
+                }
+                wr_put(c->w, c->compact ? ":" : ": ", c->compact ? 1 : 2);
+                if (mj_value(c) != 0)
+                    return -1;
+            } else {
+                if (mj_value(c) != 0)
+                    return -1;
+            }
+        }
+        c->depth--;
+        wr_byte(c->w, t == '[' ? ']' : '}');
+        return 0;
+    }
+    case ';': {
+        int64_t idx;
+        if (mj_long(c, &idx) != 0)
+            return -1;
+        uint32_t nlen;
+        const char* nm = mj_sym_name(c, idx, &nlen);
+        if (!nm)
+            return -1;
+        emit_dq_json(c->w, nm, nlen);
+        return 0;
+    }
+    case ':': {
+        /* a bare symbol VALUE: emitted as its name string */
+        if (mj_symbol(c, 1) != 0)
+            return -1;
+        return 0;
+    }
+    case '@': {
+        /* an object link: re-walk from the registered position */
+        int64_t idx;
+        if (mj_long(c, &idx) != 0)
+            return -1;
+        if (idx < 0 || (size_t)idx >= c->objs_n)
+            return mj_fail(c);
+        size_t save = c->s.at;
+        c->s.at = c->objs[idx].pos;
+        /* cycle guard: the link target is in the active chain */
+        for (size_t k = 0; k < c->chain_n; k++) {
+            if (c->chain[k] == c->objs[idx].pos) {
+                c->s.at = save;
+                return mj_fail(c);
+            }
+        }
+        if (c->chain_n == c->chain_cap) {
+            c->chain_cap = c->chain_cap ? c->chain_cap * 2 : 16;
+            c->chain = (size_t*)realloc(c->chain, c->chain_cap * sizeof(*c->chain));
+            if (!c->chain) {
+                c->s.at = save;
+                return mj_fail(c);
+            }
+        }
+        c->chain[c->chain_n++] = c->objs[idx].pos;
+        int rc = mj_value(c);
+        c->chain_n--;
+        c->s.at = save;
+        if (rc != 0)
+            return -1;
+        return 0;
+    }
+    default:
+        return mj_fail(c);
+    }
+}
+
+/* an '@' object link in KEY position: the link's target re-emitted as
+ * the key string (Ruby links repeated key objects — the users' "id"
+ * keys, yeptris-ruby#322's corpus). The link consumes no stream
+ * bytes; the key walk resumes at the caller's cursor. */
+static int mj_link_key(mj_ctx* c, int64_t idx) {
+    if (idx < 0 || (size_t)idx >= c->objs_n)
+        return mj_fail(c);
+    size_t save = c->s.at;
+    for (size_t k = 0; k < c->chain_n; k++) {
+        if (c->chain[k] == c->objs[idx].pos) {
+            c->s.at = save;
+            return mj_fail(c);
+        }
+    }
+    c->s.at = c->objs[idx].pos;
+    if (c->chain_n == c->chain_cap) {
+        c->chain_cap = c->chain_cap ? c->chain_cap * 2 : 16;
+        c->chain = (size_t*)realloc(c->chain, c->chain_cap * sizeof(*c->chain));
+        if (!c->chain) {
+            c->s.at = save;
+            return mj_fail(c);
+        }
+    }
+    c->chain[c->chain_n++] = c->objs[idx].pos;
+    int rc = mj_value(c);
+    c->chain_n--;
+    c->s.at = save;
+    return rc;
+}
+
+YEPTRIS_API YeptrisStatus yeptris_json_from_marshal(const char* m, size_t m_len, int compact,
+                                                    char** out, size_t* out_len) {
+    if (out == NULL || out_len == NULL)
+        return YEPTRIS_ERROR_ARG;
+    *out = NULL;
+    *out_len = 0;
+    if (m == NULL || m_len < 2 || (unsigned char)m[0] != 0x04 || (unsigned char)m[1] != 0x08) {
+        return YEPTRIS_ERROR_UNSUPPORTED;
+    }
+    yep_emitter em;
+    memset(&em, 0, sizeof(em));
+    em.doc = NULL;
+    yep_writer* w = &em.w;
+    w->sc_dec = NULL;
+    w->sc_i = 0;
+    w->json = 1;
+    w->json_compact = compact ? 1 : 0;
+    w->json_pretty = 0;
+    w->canonical = 0;
+    w->explicit_doc_start = 0;
+    w->best_width = 0;
+    w->sv_input = NULL;
+    w->sv_arena = NULL;
+    w->sink = NULL;
+    w->force_flow = 0;
+    w->in_flow = 0;
+    w->flow_item = 0;
+    w->unserializable = 0;
+
+    mj_ctx c;
+    memset(&c, 0, sizeof(c));
+    c.w = w;
+    c.s.p = m;
+    c.s.len = m_len;
+    c.s.at = 2; /* the 4.8 header */
+    c.compact = compact ? 1 : 0;
+
+    /* one wet pass into a growable buffer (the #352 slice-2 shape) */
+    size_t est = m_len * 2 + 64;
+    char* buf = (char*)malloc(est);
+    if (!buf)
+        return YEPTRIS_ERROR_MEMORY;
+    w->p = buf;
+    w->cap = est;
+    w->grow = 1;
+
+    mj_value(&c);
+
+    int failed = c.failed;
+    size_t wrote = w->len;
+    buf = w->p;
+    free(c.syms);
+    free(c.objs);
+    free(c.chain);
+    if (failed || w->oom) {
+        free(buf);
+        return failed ? (YeptrisStatus)failed : YEPTRIS_ERROR_MEMORY;
+    }
+    buf[wrote] = '\0';
+    *out = buf;
+    *out_len = wrote;
+    return YEPTRIS_OK;
+}
+
 size_t yep_emit_run(yep_emitter* em, int dry) {
     yep_writer* w = &em->w;
     const yep_dom* d = em->doc->dom;

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

@@ -1895,7 +1895,12 @@ static int e_flow_key_after(const char* p, size_t len, size_t close) {
 static int e_flow_floor_ok(const char* p, size_t open, size_t close, uint16_t floor) {
     size_t j = open;
     while (j < close) {
-        if (p[j] == '\n') {
+        /* the break rule is the scan's: \n, or a \r the next byte does
+         * not join into CRLF — a \n-only walk let a CR-broken content
+         * line escape the indent check (issue #771: the whole parse
+         * took the fast path past a floor violation the windowed
+         * parse's general kernel rejected) */
+        if (p[j] == '\n' || (p[j] == '\r' && (j + 1 >= close || p[j + 1] != '\n'))) {
             size_t k = j + 1;
             uint32_t ind = 0;
             while (k < close && p[k] == ' ') {
@@ -1908,12 +1913,17 @@ static int e_flow_floor_ok(const char* p, size_t open, size_t close, uint16_t fl
         }
         j++;
     }
-    if (close < (size_t)-1 && close > open) {
-        size_t ls = close;
-        uint32_t ind = 0;
-        while (ls > 0 && p[ls - 1] != '\n') {
-            ls--;
+    if (close > open) {
+        size_t from = open;
+        uint32_t ln = 0;
+        size_t ls = open;
+        yep_scan_advance_line(p, &from, close, &ln, &ls);
+        /* advance_line cannot peek past its `to`: a lone \r at
+         * close - 1 ends the closer's line AT close */
+        if (p[close - 1] == '\r' && p[close] != '\n') {
+            ls = close;
         }
+        uint32_t ind = 0;
         while (ls < close && p[ls] == ' ') {
             ind++;
             ls++;
@@ -1950,7 +1960,8 @@ static int e_flow_json(yep_engine* e, yep_view anchor, yep_view tag, uint32_t an
             return 0; /* not JSON-class: the general kernel */
         }
         if (rc == 1) {
-            int single = (memchr(p + open_pos, '\n', bclose - open_pos) == NULL);
+            int single = (memchr(p + open_pos, '\n', bclose - open_pos) == NULL) &&
+                         (memchr(p + open_pos, '\r', bclose - open_pos) == NULL);
             if (e_flow_key_after(p, len, bclose) ||
                 (e->flow_enforce && !single &&
                  !e_flow_floor_ok(p, open_pos, bclose, e->flow_floor))) {

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

@@ -153,8 +153,46 @@ int yep_scan_prop_char(unsigned char c) {
     return !yep_ct_any(c, YEP_CT_BLANK | YEP_CT_LBREAK | YEP_CT_FLOW_IND) && c != ',' && c != '#';
 }
 
+int yep_scan_dq_forced(const char* p, uint32_t len) {
+    for (uint32_t k = 0; k + 1 < len; k++) {
+        if ((unsigned char)p[k] == 0xc2 && (unsigned char)p[k + 1] == 0x85) {
+            return 1;
+        }
+        /* LS/PS are breaks like NEL: only their escapes are stable */
+        if ((unsigned char)p[k] == 0xe2 && k + 2 < len && (unsigned char)p[k + 1] == 0x80 &&
+            ((unsigned char)p[k + 2] == 0xa8 || (unsigned char)p[k + 2] == 0xa9)) {
+            return 1;
+        }
+        if ((unsigned char)p[k] == 0xef && k + 2 < len && (unsigned char)p[k + 1] == 0xbb &&
+            (unsigned char)p[k + 2] == 0xbf) {
+            return 1;
+        }
+        if ((unsigned char)p[k] == 0xef && k + 2 < len && (unsigned char)p[k + 1] == 0xbf &&
+            ((unsigned char)p[k + 2] == 0xbe || (unsigned char)p[k + 2] == 0xbf)) {
+            return 1; /* noncharacter: only its escape re-parses */
+        }
+    }
+    return 0;
+}
+
 size_t yep_scan_prop_end(const char* p, size_t len, size_t pos) {
-    while (pos < len && yep_scan_prop_char((unsigned char)p[pos])) {
+    while (pos < len) {
+        unsigned char c = (unsigned char)p[pos];
+        if (!yep_scan_prop_char(c)) {
+            break;
+        }
+        /* NEL/LS/PS end the name (libyaml's IS_BLANKZ anchor law: the
+         * suite's ns-anchor-char excludes breaks): the byte-level
+         * table cannot classify a multibyte break, and the name run
+         * then swallowed it — the r69/r70 nightly divergence class
+         * ("&k:":(<PS>..."), shape-dependent clip downstream */
+        if (c == 0xC2 && pos + 1 < len && (unsigned char)p[pos + 1] == 0x85) {
+            break;
+        }
+        if (c == 0xE2 && pos + 2 < len && (unsigned char)p[pos + 1] == 0x80 &&
+            ((unsigned char)p[pos + 2] & 0xFE) == 0xA8) {
+            break;
+        }
         pos++;
     }
     return pos;

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

@@ -98,6 +98,12 @@ int yep_scan_prop_char(unsigned char c);
 /* First offset at/after pos that cannot continue an anchor/alias name. */
 size_t yep_scan_prop_end(const char* p, size_t len, size_t pos);
 
+/* The dq-forced byte set (issue #352 lane 2): NEL, LS/PS, the BOM,
+ * and the noncharacters — the bytes whose only stable spelling is
+ * the double-quoted escape. One home for the emitter's route check
+ * AND the DOM's parse-time fact bit, so the two cannot drift. */
+int yep_scan_dq_forced(const char* p, uint32_t len);
+
 /* Tag-shorthand suffix byte: libyaml's URI set (";/?:@&=+$,_.!~*'()%"
  * plus alphanumerics; flow indicators and ',' terminate instead).
  * Stray non-set bytes stay visible as the props follower, which

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.45.0
+  version: 0.6.46.0
 platform: arm-linux-eabihf
 authors:
 - Ribose Inc.