yeptris 0.6.29.2 → 0.6.31.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7651542429f94334197d4065c3742763cbd56cf9910e572fd0bc4350a6ee9af8
-  data.tar.gz: 51cb4f4e38ad1347f29ab35372c83ef4d132b54556df34e4657ca03874a627b3
+  metadata.gz: 944eb6ddb09530a26c295a550eef46c41485243c50dc0c9a966fc48dc5640338
+  data.tar.gz: 782a73ac7a8e21f7bf7269186360caaed28a7d8d7c445796eb8adee8d468a6bc
 SHA512:
-  metadata.gz: 9953f85b1cf9f192102ff6ed71c276719c8cdf537c63cbf95e9940c8093c08783e2ec8773aa763f38b5bf2bf71ea5017a252c45b9af726cf6629fb23cd7fa036
-  data.tar.gz: 04b77e4bba61b1bf7382a1957c42df0ae129cef5f3f9f16b1b049b6004a1243b2540f88172931ecf835b00ee92eb2b5d462aa235a5109d122dd93a9f9236e2a9
+  metadata.gz: 9dc853f4a4a6009c5968d48d8a6d9152dcd097bd0931943b0e3365d3e6844acaa66356ec4e7e1dfc3e9f6c613358cf795037e86bf65ad00ea3cf72cac2045cf2
+  data.tar.gz: 768c7b473eda6aa1c8150539bfda46b87c091a99690553d719b545b764b7f1cadbe7c6d1a6f906e47237344f431f11c3bb771afe55b00f8dbe07992c46c3252f

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.29.2".freeze
+  VERSION = "0.6.31.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.29
+    VERSION 0.6.31
     DESCRIPTION "Ultra-fast YAML 1.2 parser, emitter and streamer in C"
     LANGUAGES C CXX
 )
@@ -100,8 +100,12 @@ endif()
 
 # libFuzzer implies ASAN (libleptris TODO 40 pattern).
 if(YEPTRIS_ENABLE_FUZZING)
+    # instrument everything, but link the fuzzer MAIN only into the
+    # harnesses: a global -fsanitize=fuzzer link option demands
+    # LLVMFuzzerTestOneInput from every executable (the CLI and the
+    # test binaries died on it once CXX also pinned to clang++)
     add_compile_options(-fsanitize=fuzzer-no-link,address -fno-omit-frame-pointer -g)
-    add_link_options(-fsanitize=fuzzer,address)
+    add_link_options(-fsanitize=address)
     message(STATUS "libFuzzer: ENABLED (implies ASAN)")
 endif()
 
@@ -206,10 +210,20 @@ endif()
 # config; relative paths keep relocatable installs.
 include(GNUInstallDirs)
 
-install(TARGETS yeptris_static
-    EXPORT yeptris-targets
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-)
+if(TARGET yeptris_static)
+    install(TARGETS yeptris_static
+        EXPORT yeptris-targets
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    )
+endif()
+if(TARGET yeptris_shared)
+    install(TARGETS yeptris_shared
+        EXPORT yeptris-targets
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    )
+endif()
 if(TARGET yeptris_jsonc)
     install(TARGETS yeptris_jsonc
         EXPORT yeptris-targets

data/vendor/libyeptris/src/yeptris/common/simd_text_avx2.c

@@ -179,6 +179,11 @@ static ptrdiff_t yep_avx2_quote_scan(const char* s, size_t len, char q, int* has
             }
             return (ptrdiff_t)(i + k);
         }
+        if (i >= len) {
+            break; /* an escape at the boundary consumed the rest: unterminated
+                    * (a lone '\' as the last byte pushed i past len; the tail
+                    * call would underflow len - i and read out of bounds) */
+        }
         if (i + YEP_AVX2_CHUNK > len) {
             int tail_esc = 0;
             ptrdiff_t r = yep_text_quote_scan_scalar(s + i, len - i, q, &tail_esc);

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

@@ -1422,7 +1422,8 @@ static int yt_f_run(yt_fused* F) {
                        (line_stop + 1 >= line_end || p[line_stop + 1] == ' ' ||
                         p[line_stop + 1] == '\t') &&
                        !(c == '&' || c == '!' || c == '*' || c == '\'' || c == '"' || c == '[' ||
-                         c == '{' || c == '|' || c == '>' || c == '%' || c == '?' || c == '-')) {
+                         c == '{' || c == '|' || c == '>' || c == '%' || c == '?' || c == '-') &&
+                       yep_plain_first_ok((unsigned char)c)) {
                 uint32_t kend = line_stop;
                 while (kend > t0 && (p[kend - 1] == ' ' || p[kend - 1] == '\t')) {
                     kend--;
@@ -1450,6 +1451,10 @@ static int yt_f_run(yt_fused* F) {
                     }
                     aoff = (uint32_t)(vt + 1);
                     alen = (uint32_t)(ne - vt - 1);
+                    if (alen == 0) {
+                        return 1; /* an anchor needs a name (libyaml):
+                                     the engine owns the error */
+                    }
                     F->anchor_seq++;
                     aid = F->anchor_seq;
                     if (!yt_anchor_table(F)) {
@@ -1810,13 +1815,20 @@ static int yt_f_run(yt_fused* F) {
                         goto line_done;
                     }
                     if (vc == '"' || vc == '\'' || vc == '|' || vc == '>' || vc == '[' ||
-                        vc == '{' || vc == '!' || vc == '%') {
-                        return 1; /* quoted/block/flow/tag values: the engine */
+                        vc == '{' || vc == '!' || vc == '%' || vc == '&' || vc == '*') {
+                        return 1; /* quoted/block/flow/tag/anchor/alias values:
+                                     the engine */
                     }
                     if ((vc == '-' || vc == '?') && (vt + 1 >= line_end || p[vt + 1] == ' ' ||
                                                      p[vt + 1] == '\t' || p[vt + 1] == '#')) {
                         return 1; /* an indicator-as-value: the engine errors */
                     }
+                    if (!yep_plain_first_ok(vc)) {
+                        return 1; /* '}' ']' ',' '@' '`' '%': no node
+                                   * content can start there (the nightly's
+                                   * fuzz_roundtrip crasher, "u: }") — the engine
+                                   * errors cleanly */
+                    }
                     /* a terminating ':' inside the value is the
                      * mapping-values error — the engine owns it */
                     for (const char* h = (const char*)memchr(p + vt, ':', line_end - vt);

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

@@ -65,24 +65,31 @@ YEPTRIS_API size_t yeptris_serialize_into_ex(YeptrisDocument handle,
     em.w.watermark = 0;
     em.w.sink_aborted = 0;
     em.w.flushed = 0;
-    if (!yep_nametab_init(&em.canon_names, yep_system_allocator())) {
+    memset(&em.canon_names, 0, sizeof(em.canon_names));
+    if (em.w.canonical && !yep_nametab_init(&em.canon_names, yep_system_allocator())) {
         return 0;
     }
     em.w.sc_dec = (uint8_t*)malloc(em.doc->dom->ncount > 0 ? em.doc->dom->ncount : 1);
     if (em.w.sc_dec == NULL) {
-        yep_nametab_free(&em.canon_names);
+        if (em.canon_names.sys != NULL) {
+            yep_nametab_free(&em.canon_names);
+        }
         return 0;
     }
     size_t need = yep_emit_run(&em, 1);
     if (buf == NULL || cap < need + 1) {
         free(em.w.sc_dec);
-        yep_nametab_free(&em.canon_names);
+        if (em.canon_names.sys != NULL) {
+            yep_nametab_free(&em.canon_names);
+        }
         return need;
     }
     em.w.p = buf;
     size_t wrote = yep_emit_run(&em, 0);
     free(em.w.sc_dec);
-    yep_nametab_free(&em.canon_names);
+    if (em.canon_names.sys != NULL) {
+        yep_nametab_free(&em.canon_names);
+    }
     buf[wrote] = '\0';
     return wrote;
 }
@@ -123,7 +130,8 @@ YEPTRIS_API char* yeptris_serialize_ex(YeptrisDocument handle, const yeptris_emi
     em.w.watermark = 0;
     em.w.sink_aborted = 0;
     em.w.flushed = 0;
-    if (!yep_nametab_init(&em.canon_names, yep_system_allocator())) {
+    memset(&em.canon_names, 0, sizeof(em.canon_names));
+    if (em.w.canonical && !yep_nametab_init(&em.canon_names, yep_system_allocator())) {
         return NULL;
     }
     /* #352 slice 2: ONE wet pass into a growable buffer — the dry
@@ -138,7 +146,9 @@ YEPTRIS_API char* yeptris_serialize_ex(YeptrisDocument handle, const yeptris_emi
     }
     char* out = (char*)malloc(est);
     if (out == NULL) {
-        yep_nametab_free(&em.canon_names);
+        if (em.canon_names.sys != NULL) {
+            yep_nametab_free(&em.canon_names);
+        }
         return NULL;
     }
     em.w.p = out;
@@ -152,16 +162,20 @@ YEPTRIS_API char* yeptris_serialize_ex(YeptrisDocument handle, const yeptris_emi
     out = em.w.p;
     if (em.w.oom) {
         free(out);
-        yep_nametab_free(&em.canon_names);
+        if (em.canon_names.sys != NULL) {
+            yep_nametab_free(&em.canon_names);
+        }
         return NULL;
     }
-    if (wrote + 1 < em.w.cap) {
+    if (em.w.cap - (wrote + 1) > em.w.cap / 8) {
         char* tight = (char*)realloc(out, wrote + 1);
         if (tight != NULL) {
             out = tight;
         }
     }
-    yep_nametab_free(&em.canon_names);
+    if (em.canon_names.sys != NULL) {
+        yep_nametab_free(&em.canon_names);
+    }
     out[wrote] = '\0';
     if (len != NULL) {
         *len = wrote;
@@ -200,18 +214,23 @@ YEPTRIS_API char* yeptris_serialize_json(YeptrisDocument handle, size_t* len) {
     em.w.watermark = 0;
     em.w.sink_aborted = 0;
     em.w.flushed = 0;
-    if (!yep_nametab_init(&em.canon_names, yep_system_allocator())) {
+    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) {
-        yep_nametab_free(&em.canon_names);
+        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);
-    yep_nametab_free(&em.canon_names);
+    if (em.canon_names.sys != NULL) {
+        yep_nametab_free(&em.canon_names);
+    }
     out[wrote] = '\0';
     if (len != NULL) {
         *len = wrote;
@@ -253,18 +272,23 @@ YEPTRIS_API char* yeptris_serialize_json_ex(YeptrisDocument handle, size_t* len,
     em.w.watermark = 0;
     em.w.sink_aborted = 0;
     em.w.flushed = 0;
-    if (!yep_nametab_init(&em.canon_names, yep_system_allocator())) {
+    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) {
-        yep_nametab_free(&em.canon_names);
+        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);
-    yep_nametab_free(&em.canon_names);
+    if (em.canon_names.sys != NULL) {
+        yep_nametab_free(&em.canon_names);
+    }
     out[wrote] = '\0';
     if (len != NULL) {
         *len = wrote;
@@ -300,18 +324,23 @@ char* yep_serialize_json_compact(const yeptris_document* doc, size_t* len) {
     em.w.watermark = 0;
     em.w.sink_aborted = 0;
     em.w.flushed = 0;
-    if (!yep_nametab_init(&em.canon_names, yep_system_allocator())) {
+    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) {
-        yep_nametab_free(&em.canon_names);
+        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);
-    yep_nametab_free(&em.canon_names);
+    if (em.canon_names.sys != NULL) {
+        yep_nametab_free(&em.canon_names);
+    }
     out[wrote] = '\0';
     if (len != NULL) {
         *len = wrote;
@@ -347,18 +376,23 @@ char* yep_serialize_json_pretty(const yeptris_document* doc, size_t* len) {
     em.w.watermark = 0;
     em.w.sink_aborted = 0;
     em.w.flushed = 0;
-    if (!yep_nametab_init(&em.canon_names, yep_system_allocator())) {
+    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) {
-        yep_nametab_free(&em.canon_names);
+        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);
-    yep_nametab_free(&em.canon_names);
+    if (em.canon_names.sys != NULL) {
+        yep_nametab_free(&em.canon_names);
+    }
     out[wrote] = '\0';
     if (len != NULL) {
         *len = wrote;
@@ -409,13 +443,16 @@ YEPTRIS_API size_t yeptris_serialize_stream(YeptrisDocument handle,
     em.w.sink = sink;
     em.w.sink_ctx = ctx;
     em.w.watermark = YEP_EMIT_WATERMARK;
-    if (!yep_nametab_init(&em.canon_names, yep_system_allocator())) {
+    memset(&em.canon_names, 0, sizeof(em.canon_names));
+    if (em.w.canonical && !yep_nametab_init(&em.canon_names, yep_system_allocator())) {
         return 0;
     }
     /* one scratch window; the writer flushes it when it fills */
     char* window = malloc(YEP_EMIT_WATERMARK * 2);
     if (window == NULL) {
-        yep_nametab_free(&em.canon_names);
+        if (em.canon_names.sys != NULL) {
+            yep_nametab_free(&em.canon_names);
+        }
         return 0;
     }
     em.w.p = window;
@@ -429,6 +466,8 @@ YEPTRIS_API size_t yeptris_serialize_stream(YeptrisDocument handle,
         }
     }
     free(window);
-    yep_nametab_free(&em.canon_names);
+    if (em.canon_names.sys != NULL) {
+        yep_nametab_free(&em.canon_names);
+    }
     return em.w.sink_aborted ? 0 : total;
 }

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

@@ -142,6 +142,45 @@ static void emit_dq(yep_writer* w, const char* p, uint32_t n) {
     uint32_t run = 0;
     for (uint32_t i = 0; i < n; i++) {
         unsigned char c = (unsigned char)p[i];
+        /* U+0085 (NEL) is a BREAK in YAML: raw it would fold on
+         * re-parse. Escape it ('\N' replaces the exact UTF-8 pair, so
+         * lengths stay equal). The nightly's fuzz_roundtrip
+         * byte-instability crasher, "\"1 \\N\"". */
+        if (c == 0xc2 && i + 1 < n && (unsigned char)p[i + 1] == 0x85) {
+            if (run) {
+                wr_put(w, p + i - run, run);
+                run = 0;
+            }
+            wr_put(w, "\\N", 2);
+            i++;
+            continue;
+        }
+        /* LS/PS (U+2028/U+2029) are libyaml breaks: raw, re-parse
+         * folds them (the nightly's ";\\P" catch). 2-char escapes of
+         * 3-byte sequences: the one-pass dry count sizes them. */
+        if (c == 0xe2 && i + 2 < n && (unsigned char)p[i + 1] == 0x80 &&
+            ((unsigned char)p[i + 2] == 0xa8 || (unsigned char)p[i + 2] == 0xa9)) {
+            if (run) {
+                wr_put(w, p + i - run, run);
+                run = 0;
+            }
+            wr_put(w, (unsigned char)p[i + 2] == 0xa8 ? "\\L" : "\\P", 2);
+            i += 2;
+            continue;
+        }
+        /* U+FEFF must never ride raw: at the buffer head it IS the
+         * BOM and re-parse would strip it (the nightly's UTF-32LE
+         * catch); Psych escapes it everywhere ("") */
+        if (c == 0xef && i + 2 < n && (unsigned char)p[i + 1] == 0xbb &&
+            (unsigned char)p[i + 2] == 0xbf) {
+            if (run) {
+                wr_put(w, p + i - run, run);
+                run = 0;
+            }
+            wr_put(w, "\\uFEFF", 6);
+            i += 2;
+            continue;
+        }
         if (c >= 0x20 && c != '"' && c != '\\' && c != 0x7f) {
             run++;
             continue;
@@ -330,6 +369,34 @@ enum { YEP_SC_NOTHING = 0, YEP_SC_PLAIN, YEP_SC_SQ, YEP_SC_DQ, YEP_SC_LITERAL };
 
 static uint8_t sc_route(yep_writer* w, const char* p, uint32_t len, int as_key, uint8_t sty_in,
                         int has_tag) {
+    /* U+0085 is a break (only its \\N escape is byte-stable) and U+FEFF
+     * raw is the BOM (re-parse would strip it): both force the
+     * double-quoted route BEFORE the plain fast path can take them
+     * (the nightly's fuzz_roundtrip crashers). The NEL scan matches
+     * the UTF-8 PAIR only — a lone 0x85 is a continuation byte
+     * (U+315B = E3 85 9B). */
+    int has_nel = 0;
+    int has_bom = 0;
+    for (uint32_t k = 0; k + 1 < len; k++) {
+        if ((unsigned char)p[k] == 0xc2 && (unsigned char)p[k + 1] == 0x85) {
+            has_nel = 1;
+            break;
+        }
+        /* 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)) {
+            has_nel = 1;
+            break;
+        }
+        if ((unsigned char)p[k] == 0xef && k + 2 < len && (unsigned char)p[k + 1] == 0xbb &&
+            (unsigned char)p[k + 2] == 0xbf) {
+            has_bom = 1;
+            break;
+        }
+    }
+    if (has_nel || has_bom) {
+        return YEP_SC_DQ;
+    }
     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 */
@@ -611,6 +678,67 @@ static void emit_block_map(yep_emitter* em, uint32_t id, int content_col) {
     uint32_t child = n->first_child;
     uint32_t pair = 0;
     while (child != UINT32_MAX) {
+        /* #352: the flat plain member specialist — tiny scalar pairs
+         * pay dispatch and props checks, not byte work. Strictly
+         * narrower than the general body below: plain unpropertied
+         * key, plain unpropertied scalar value, both safety-proven by
+         * the exact predicates sc_route consults (no memo touch, so
+         * the dry/wet sc_i streams stay aligned). Anything else falls
+         * through untouched — parity by construction. */
+        const yep_dnode* kn0 = yep_dom_node(d, child);
+        const yep_dnode* vn0 = yep_dom_node(d, kn0->next_sibling);
+        if (!w->canonical && !w->json && !w->force_flow && vn0 != NULL && kn0->kind == 0 &&
+            kn0->style == 1 && kn0->anchor.len == 0 && kn0->tag.len == 0 && kn0->count == 0 &&
+            vn0->kind == 0 && vn0->style == 1 && vn0->anchor.len == 0 && vn0->tag.len == 0 &&
+            vn0->count == 0) {
+            yep_view kv = wv(w, kn0->value);
+            yep_view vv = wv(w, vn0->value);
+            if (kv.len > 0 && yep_style_plain_key_safe((const char*)kv.p, kv.len) &&
+                (vv.len == 0 || yep_style_plain_safe((const char*)vv.p, vv.len))) {
+                /* fused member write: plain-safe spans carry no breaks,
+                 * so the col scan is arithmetic and one reservation
+                 * covers the whole member (line + key + ':' + value) */
+                uint32_t ind = pair > 0 ? (uint32_t)content_col : 0u;
+                uint32_t nl = (pair > 0 && w->last != '\n') ? 1u : 0u;
+                uint32_t total = nl + ind + kv.len + 1u + (vv.len > 0 ? vv.len + 1u : 0u);
+                w->last = vv.len > 0 ? (char)vv.p[vv.len - 1] : ':';
+                if (nl) {
+                    w->col = (int)(total - 1u); /* the break resets, then the line */
+                } else {
+                    w->col += (int)total;
+                }
+                if (w->dry) {
+                    w->len += total;
+                } else {
+                    if (w->grow && w->len + total + 1 > w->cap) {
+                        wr_grow(w, total);
+                    }
+                    if (w->oom) {
+                        w->len += total; /* keep counting: the caller fails on oom */
+                    } else {
+                        char* q = w->p + w->len;
+                        if (nl) {
+                            *q++ = '\n';
+                        }
+                        for (uint32_t i = 0; i < ind; i++) {
+                            *q++ = ' ';
+                        }
+                        memcpy(q, kv.p, kv.len);
+                        q += kv.len;
+                        *q++ = ':';
+                        if (vv.len > 0) {
+                            *q++ = ' ';
+                            memcpy(q, vv.p, vv.len);
+                        }
+                        w->len += total;
+                        wr_maybe_flush(w);
+                    }
+                }
+                pair++;
+                child = vn0->next_sibling;
+                continue;
+            }
+        }
         const yep_dnode* kn = yep_dom_node(d, child);
         const yep_dnode* vn = yep_dom_node(d, kn->next_sibling);
         if (pair > 0) {

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

@@ -119,6 +119,11 @@ struct yep_engine {
     char* norm_buf;                      /* owned input copy with exotic breaks normalized */
     const struct yep_resolver* resolver; /* implicit-typing schema (10) */
     int max_depth;                       /* runtime nesting limit (options) */
+    uint16_t rec;                        /* e_node<->e_parse_value call depth:
+                                            the props/value-line chain opens NO
+                                            container frame, so e->depth cannot
+                                            bound it (the nightly's stack
+                                            overflow crasher) */
     int last_root_flow;                  /* a root-level flow node just completed */
     int tag_undef;                       /* an unresolved !handle! was seen (QLJ7) */
     int doc_inline;                      /* content node opened on the --- line */
@@ -1090,16 +1095,32 @@ static void e_props(yep_engine* e, yep_view* anchor, yep_view* tag) {
             e->pos = yep_scan_prop_end(e->p, e->len, start);
             anchor->p = e->p + start;
             anchor->len = (uint32_t)(e->pos - start);
+            if (anchor->len == 0) {
+                /* libyaml requires one or more anchor characters
+                 * ("did not find expected alphabetic or numeric
+                 * character"); the nightly fuzz_roundtrip crasher,
+                 * a lone '&' */
+                e_fail(e, YEP_ERR_UNEXPECTED, e->pos);
+                return;
+            }
         } else if (c == '!') {
             size_t start = e->pos;
             e->pos++;
             if (e->pos < e->len && e->p[e->pos] == '<') {
-                while (e->pos < e->len && e->p[e->pos] != '>') {
-                    e->pos++;
-                }
-                if (e->pos < e->len) {
-                    e->pos++;
-                }
+                /* a verbatim tag closes '>' on the same line, with no
+                 * interior space and non-empty content — libyaml errors
+                 * otherwise ("did not find expected '>'"; the nightly's
+                 * fuzz_roundtrip byte-instability crasher, "!<") */
+                size_t gt = e->pos + 1;
+                while (gt < e->len && e->p[gt] != '>' && e->p[gt] != '\n' && e->p[gt] != '\r' &&
+                       e->p[gt] != ' ' && e->p[gt] != '\t') {
+                    gt++;
+                }
+                if (gt >= e->len || e->p[gt] != '>' || gt == e->pos + 1) {
+                    e_fail(e, YEP_ERR_UNEXPECTED, start);
+                    return;
+                }
+                e->pos = gt + 1;
             } else {
                 while (e->pos < e->len && yep_scan_prop_char((unsigned char)e->p[e->pos])) {
                     e->pos++;
@@ -1282,6 +1303,9 @@ static int e_flow_node(yep_engine* e, yep_event* ev, int keyish) {
     ev->col = e_col(e, e->pos) + 1;
     yep_view anchor = {0}, tag = {0};
     e_props(e, &anchor, &tag);
+    if (e->err.code != YEP_ERR_NONE) {
+        return -1; /* e_props failed (empty anchor name, unresolved tag) */
+    }
     ev->anchor = anchor;
     ev->tag = tag;
     if (!yep_view_is_empty(anchor)) {
@@ -1290,10 +1314,17 @@ static int e_flow_node(yep_engine* e, yep_event* ev, int keyish) {
     if (e_flow_ws(e) != 0) {
         return -1;
     }
+    if (e->pos >= e->len) {
+        /* props at EOF: no node follows the properties (the entry
+         * guard above cannot cover this — e_props consumed to the
+         * end; found by fuzz_parse, input "[!<<\r\n!]" x8) */
+        return e_fail(e, YEP_ERR_UNEXPECTED, e->pos);
+    }
     c = (unsigned char)e->p[e->pos];
     if ((c == ',' || c == ']' || c == '}' || c == ':') &&
         (!yep_view_is_empty(anchor) || !yep_view_is_empty(tag))) {
         ev->implicit = 1; /* properties with no node: a tagged null */
+        ev->style = YEP_STYLE_PLAIN;
         e_pos_mark(e, e->pos, &ev->end_line, &ev->end_col);
         return 1;
     }
@@ -1813,6 +1844,7 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                 /* '? : v' / '?' at the boundary: an EMPTY explicit key */
                 e_event_init(&ev, YEP_EV_SCALAR);
                 ev.implicit = 1;
+                ev.style = YEP_STYLE_PLAIN;
                 ev.line = e->line;
                 ev.col = e_col(e, e->pos) + 1;
                 rc = 1;
@@ -1984,6 +2016,7 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                     yep_event nv;
                     e_event_init(&nv, YEP_EV_SCALAR);
                     nv.implicit = 1;
+                    nv.style = YEP_STYLE_PLAIN;
                     if (emit_now(e, &nv) != 0) {
                         return -2;
                     }
@@ -2026,6 +2059,7 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                     yep_event nv;
                     e_event_init(&nv, YEP_EV_SCALAR);
                     nv.implicit = 1;
+                    nv.style = YEP_STYLE_PLAIN;
                     if (emit_now(e, &nv) != 0) {
                         return -2;
                     }
@@ -2059,6 +2093,7 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                 yep_event nv;
                 e_event_init(&nv, YEP_EV_SCALAR);
                 nv.implicit = 1;
+                nv.style = YEP_STYLE_PLAIN;
                 if (emit_now(e, &nv) != 0) {
                     return -2;
                 }
@@ -2076,6 +2111,7 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                     yep_event nv;
                     e_event_init(&nv, YEP_EV_SCALAR);
                     nv.implicit = 1;
+                    nv.style = YEP_STYLE_PLAIN;
                     if (emit_now(e, &nv) != 0) {
                         return -2;
                     }
@@ -2104,6 +2140,7 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                 yep_event nv;
                 e_event_init(&nv, YEP_EV_SCALAR);
                 nv.implicit = 1;
+                nv.style = YEP_STYLE_PLAIN;
                 if (emit_now(e, &nv) != 0) {
                     return -2;
                 }
@@ -2114,6 +2151,7 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                     yep_event nv;
                     e_event_init(&nv, YEP_EV_SCALAR);
                     nv.implicit = 1;
+                    nv.style = YEP_STYLE_PLAIN;
                     if (emit_now(e, &nv) != 0) {
                         return -2;
                     }
@@ -2657,7 +2695,13 @@ static int e_node(yep_engine* e, yep_ctx ctx, uint16_t floor_col) {
         e->pend_anchor_id = anchor_ordinal;
         e->pend_tag = node_t;
         e->doc_inline = 0; /* the node starts on a later line */
-        return e_parse_value(e, ctx, floor_col);
+        if (++e->rec >= e->max_depth) {
+            e->rec--;
+            return e_fail(e, YEP_ERR_DEPTH, e->pos);
+        }
+        int rc = e_parse_value(e, ctx, floor_col);
+        e->rec--;
+        return rc;
         /* (ctx stays: AFTER_COLON converts to VALUE_LINE at the break) */
     }
 
@@ -3069,7 +3113,15 @@ static int e_parse_value(yep_engine* e, yep_ctx ctx, uint16_t floor_col) {
             (vctx == YEP_CTX_VALUE_LINE && (li.first == '|' || li.first == '>') &&
              li.indent == floor_col)) {
             e->pos += li.indent;
-            return e_node(e, vctx, floor_col);
+            if (++e->rec >= e->max_depth) {
+                e->rec--;
+                return e_fail(e, YEP_ERR_DEPTH, e->pos);
+            }
+            {
+                int rc = e_node(e, vctx, floor_col);
+                e->rec--;
+                return rc;
+            }
         }
         /* indentless sequence as a mapping value; under a sequence frame
          * a dash at the same column is a SIBLING, not a continuation */

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

@@ -199,6 +199,10 @@ static void shape_value(const char* p, size_t len, const yep_line_info* li, size
     }
     if (c == '&') {
         size_t a_end = yep_scan_prop_end(p, len, vt + 1);
+        if (a_end == vt + 1) {
+            return; /* an anchor needs a name (libyaml): the general
+                     * chain owns the error */
+        }
         size_t t = a_end;
         while (t < len && (p[t] == ' ' || p[t] == '\t')) {
             t++;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.29.2
+  version: 0.6.31.1
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-07 00:00:00.000000000 Z
+date: 2026-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi