yeptris 0.6.50.0-powerpc64le-linux → 0.6.52.0-powerpc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 502d9d312839f1bbb60cd18717903b08a307b49573cc70b2c7d6ca23795e1288
-  data.tar.gz: 78ec8de12de58a6d89eea7614d3da4588c697f4042e3d8d2fe70071cf2fc98b2
+  metadata.gz: e0c07adf577e2e780cf60cca0edc2597d9b0c092e58eb9455615e5c3f761a6c1
+  data.tar.gz: af94b80492df46bcef17f16e180aab09b6782c271a3a4baa09293613e636d458
 SHA512:
-  metadata.gz: 0506cd4bc37ab0616d8d0f075af345af89e260adacc19f53603c04584103608f2b720c8fcb4c732d20ff3980a6bbdc0d1d394c38a384892bbf5f97953a6dc769
-  data.tar.gz: 1971d74f5e1e38ef400cdf4a4d7c70cf65891c7a504941ff474ff8f79bb592d4e0fe36f874409ad41b3c7bdb87a99abb74a28e741d6907f2d40108ac918b806d
+  metadata.gz: 715691702baccf4f08175887df320a73918d131aae2211866bf12349fae3e3201088a2a0981f289c3b517e8f91d4e46322edb3eec16e7b0406b1636eca586b9b
+  data.tar.gz: 3ffe41b6d9fa191c93121537da91a862b83467d37d3b930cc2dc94986fd7ebd939122700e4ed2cfd6096fd30fd5f20a957e0da428d46d616078278d5ad13d0b3

data/ext/yeptris_native/version.h

@@ -11,8 +11,8 @@
 
 #define YEPTRIS_VERSION_MAJOR 0
 #define YEPTRIS_VERSION_MINOR 6
-#define YEPTRIS_VERSION_PATCH 50
-#define YEPTRIS_VERSION_STRING "0.6.50"
+#define YEPTRIS_VERSION_PATCH 51
+#define YEPTRIS_VERSION_STRING "0.6.51"
 
 #ifdef __cplusplus
 extern "C" {

data/ext/yeptris_native/yeptris_native.c

@@ -483,7 +483,17 @@ RUBY_FUNC_EXPORTED void Init_native(void) {
     rb_define_singleton_method(mNat, "shape_mode", native_shape_mode, 0);
     rb_define_singleton_method(mNat, "shape_mode=", native_shape_mode_set, 1);
     rb_define_singleton_method(mNat, "scan_time", native_scan_time, 2);
-    rb_define_const(mNat, "AVAILABLE", Qtrue);
+    /* the leptris bridge vendors this same ext (leptris's
+     * lib/leptris/xml/native_3_3.so), so both gems can co-initialize
+     * in one process: the second init re-ran rb_define_const and
+     * warned "already initialized constant Yeptris::Native::AVAILABLE"
+     * — which moxml treated as an adapter load failure and fell back
+     * to nokogiri for the rest of the process (yeptris-ruby#336).
+     * Re-registration is idempotent: skip the const when the first
+     * init (either gem's copy) already defined it. */
+    if (!rb_const_defined_at(mNat, rb_intern("AVAILABLE"))) {
+        rb_define_const(mNat, "AVAILABLE", Qtrue);
+    }
     const char* env = getenv("YEPTRIS_NATIVE_GC");
     if (env != NULL && strcmp(env, "none") == 0) yep_rb_set_gc_mode(1);
     else if (env != NULL && strcmp(env, "start") == 0) yep_rb_set_gc_mode(2);

data/lib/yeptris/document.rb

@@ -16,7 +16,7 @@ class Yeptris::Document
   # The schema this document was parsed with (a parse property).
   attr_reader :parse_schema
 
-  def initialize(c_ptr = nil, freed = Freed.new(:alive), parse_schema = :core_12)
+  def initialize(c_ptr = nil, freed = Freed.new(:alive), parse_schema = :core_12, source = nil)
     # The pointer is produced by the FFI parse/create calls; a nil (or
     # non-pointer) argument is an API misuse — Document.parse and
     # Document.create are the entry points. Fail with that guidance
@@ -30,6 +30,13 @@ class Yeptris::Document
     @c_ptr = c_ptr
     @freed = freed
     @parse_schema = parse_schema
+    # the C document BORROWS the input: string values are zero-copy
+    # views over the caller's bytes (parse.h/doc.h) — the FFI call only
+    # pins the String for the call's duration, so the document must
+    # retain it or the next GC frees memory every later node.value/
+    # tag read still points into (audit 2026-10-31: parse(io.read) was
+    # collectable immediately)
+    @source = source
     @readonly = false
     # Strong wrapper cache keyed on the C node address: the same C node
     # always yields the same Ruby object (identity for aliases/eql?),
@@ -61,7 +68,7 @@ class Yeptris::Document
       raise Yeptris::ParseError,
             "parse failed: #{Yeptris::FFI.last_error_message}"
     end
-    wrap_schema(doc, schema)
+    wrap_schema(doc, schema, yaml)
   end
 
   def self.parse_json(json)
@@ -71,7 +78,7 @@ class Yeptris::Document
     raise Yeptris::ParseError,
           "json parse failed: #{Yeptris::FFI.last_error_message}" if doc.null?
 
-    wrap_schema(doc, :core_12) # strict JSON is core by construction
+    wrap_schema(doc, :core_12, json) # strict JSON is core by construction
   end
 
   # An empty document for from-scratch construction (TODO.impl/11 p3).
@@ -99,8 +106,8 @@ class Yeptris::Document
   # host scalar policies (Psych's dot-required float) are conditioned
   # on it. The parse constructors set the real one; plain wrap keeps
   # the core_12 default (yeptris_parse's default).
-  def self.wrap_schema(c_ptr, schema)
-    new(c_ptr, Freed.new(:alive), schema)
+  def self.wrap_schema(c_ptr, schema, source = nil)
+    new(c_ptr, Freed.new(:alive), schema, source)
   end
 
   # #182: the stream-children wrapper owns NOTHING (the parent

data/lib/yeptris/json.rb

@@ -34,12 +34,21 @@ module Yeptris
 
     module_function
 
-    def load(source)
+    # allow_duplicate_key: opts out of the resolved json gem's strict
+    # duplicate-key contract (json >= 3 rejects by default) — last value
+    # wins, exactly the historical JSON.parse contract. System-boundary
+    # parsers need it: third-party feeds (Crossref book records keyed by
+    # ISBN, NIST's pubs export keyed by "&nbsp", the UN search API's blank
+    # keys) genuinely carry duplicates, and rejecting them breaks the fetch
+    # rather than flagging the data (relaton/relaton#413, the ask in
+    # yeptris-ruby#335). Default stays the json-gem-parity strictness.
+    def load(source, allow_duplicate_key: false)
+      strict = STRICT_DUPLICATE_KEYS && !allow_duplicate_key
       source = ::Yeptris.read_input(source)
       source = source.to_s
       if defined?(::Yeptris::Native)
         begin
-          return ::Yeptris::Native.load_json(source, STRICT_DUPLICATE_KEYS)
+          return ::Yeptris::Native.load_json(source, strict)
         rescue ::Yeptris::ParseError => e
           raise ParseError, e.message
         end
@@ -53,9 +62,9 @@ module Yeptris
       # none) answered last-wins under json >= 3 — found by canon's
       # dependent CI, whose parity pin now names the lane.
       return marshal_engine(
-        source, STRICT_DUPLICATE_KEYS ? ::Yeptris::FFI::MARSHAL_STRICT_DUP_KEYS : 0
+        source, strict ? ::Yeptris::FFI::MARSHAL_STRICT_DUP_KEYS : 0
       ) if ::Yeptris::FFI::MARSHAL_STRICT_DUP
-      tape_engine(source)
+      tape_engine(source, strict)
     end
 
     # The marshal engine (#278): yeptris_parse_json gates the strict
@@ -156,19 +165,19 @@ module Yeptris
       out.force_encoding(Encoding::UTF_8)
     end
 
-    def tape_engine(source)
+    def tape_engine(source, strict_dup = STRICT_DUPLICATE_KEYS)
       tape = ::Yeptris::FFI::JsonTape.new
       rc = ::Yeptris::FFI.yeptris_parse_json_tape(source, source.bytesize, tape)
       raise ParseError, ::Yeptris::FFI.last_error_message if rc != ::Yeptris::FFI::OK
 
       begin
-        walk_tape(source, tape)
+        walk_tape(source, tape, strict_dup)
       ensure
         ::Yeptris::FFI.yeptris_tape_free(tape)
       end
     end
 
-    def walk_tape(src, tape, strict_dup = STRICT_DUPLICATE_KEYS)
+    def walk_tape(src, tape, strict_dup)
       n = tape[:count]
       kinds = tape[:kinds].read_bytes(n).unpack("C*")
       offs = tape[:offs].read_bytes(n * 4).unpack("V*")

data/lib/yeptris/psych/parser.rb

@@ -25,6 +25,10 @@ module Yeptris
         yaml = yaml.to_s
         @filename = filename
         flat, arena = Materializer.drain(yaml, schema: :compat_11)
+        # the engine's arena is UTF-8 bytes; without the tag every
+        # scalar reached handlers as ASCII-8BIT (stdlib Psych hands
+        # UTF-8; TreeBuilder then propagated binary into node values)
+        arena.force_encoding(Encoding::UTF_8)
         dispatch(flat, arena)
         self
       rescue ParseError => e

data/lib/yeptris/psych.rb

@@ -143,8 +143,21 @@ module Yeptris
       # Psych 5: load is safe — plain data structures only. Tagged
       # nodes raise DisallowedClass unless their class is permitted
       # (Date/Time/Symbol are built in; they are plain data here).
-      def load(yaml, permitted_classes: [::Date, ::Time], aliases: false, **)
-        safe_load(yaml, permitted_classes: permitted_classes, aliases: aliases)
+      def load(yaml, permitted_classes: [::Date, ::Time], aliases: false,
+               symbolize_names: false, fallback: nil, filename: nil, **)
+        res = safe_load(yaml, permitted_classes: permitted_classes, aliases: aliases,
+                        symbolize_names: symbolize_names)
+        if res.nil? && !fallback.nil?
+          # stdlib's fallback: answers when the stream is empty or has
+          # NO documents — a document whose content IS nil still loads
+          # as nil. The safe path cannot tell those two apart, so the
+          # corner re-checks the count (only when a fallback rides).
+          doc = ::Yeptris::Document.parse(yaml, schema: :compat_11)
+          empty = doc.nil? || doc.document_count.zero?
+          doc&.free
+          return fallback if empty
+        end
+        res
       end
 
       # Full revival over the Nodes tree: !ruby/object, !ruby/struct,

data/lib/yeptris/valueml.rb

@@ -20,6 +20,25 @@ module Yeptris
   # int64 the C resolver leaves the scalar a string; Psych
   # materializes Integer (issue #31) — every walk rebuilds it.
   PSYCH_INT_SHAPE = /\A[-+]?(?:0|[1-9](?:[0-9]|,[0-9]|_[0-9])*)\z/.freeze
+
+  # The typed-string conversion law, ONE place: a big-int-shaped
+  # string rebuilds to Integer, an implicit-plain ':name' scans to a
+  # Symbol (Psych's ScalarScanner; quoted ':x' stays a String).
+  # Every str-column conversion rides this — the pair fast path
+  # drifted once and handed bignums/symbol-keys through as Strings
+  # (audit 2026-10-31).
+  def self.str_to_value(text, typed)
+    return text unless typed
+
+    if text.length > 18 && PSYCH_INT_SHAPE.match?(text)
+      text.delete(",_").to_i
+    elsif text.length > 1 && text.start_with?(":") && !text.start_with?("::")
+      text[1..].to_sym
+    else
+      text
+    end
+  end
+
     V_TS = 6
     SEQ_OPEN = 7
     MAP_OPEN = 8
@@ -155,15 +174,7 @@ module Yeptris
           text = arena.byteslice(flat[i + OFF], flat[i + LEN])
           # implicit-plain ':name' scans to a Symbol (Psych's
           # ScalarScanner); quoted ':x' stays a String
-          v = if flat[i + B] == 1 && text.length > 18 &&
-                PSYCH_INT_SHAPE.match?(text)
-                text.delete(",_").to_i
-              elsif flat[i + B] == 1 && text.length > 1 &&
-                text.start_with?(":") && !text.start_with?("::")
-                text[1..].to_sym
-              else
-                text
-              end
+          v = str_to_value(text, flat[i + B] == 1)
           if pending_anchor
             anchors[pending_anchor] = v
             pending_anchor = nil
@@ -284,20 +295,9 @@ module Yeptris
            pending_anchor.nil? && !stack.empty? && stack.last.is_a?(Hash)
           kt = arena.byteslice(offs[i], lens[i])
           if kt != "<<"
-            key = if bools[i] == 1 && kt.length > 1 && kt.start_with?(":") &&
-                     !kt.start_with?("::")
-              kt[1..].to_sym
-            else
-              kt
-            end
+            key = str_to_value(kt, bools[i] == 1)
             vt = arena.byteslice(offs[i + 1], lens[i + 1])
-            stack.last[key] =
-              if bools[i + 1] == 1 && vt.length > 1 && vt.start_with?(":") &&
-                 !vt.start_with?("::")
-                vt[1..].to_sym
-              else
-                vt
-              end
+            stack.last[key] = str_to_value(vt, bools[i + 1] == 1)
             i += 2
             next
           end
@@ -305,15 +305,7 @@ module Yeptris
         case kinds[i]
         when V_STR
           text = arena.byteslice(offs[i], lens[i])
-          v = if bools[i] == 1 && text.length > 18 &&
-                PSYCH_INT_SHAPE.match?(text)
-                text.delete(",_").to_i
-              elsif bools[i] == 1 && text.length > 1 &&
-                text.start_with?(":") && !text.start_with?("::")
-                text[1..].to_sym
-              else
-                text
-              end
+          v = str_to_value(text, bools[i] == 1)
           if pending_anchor
             anchors[pending_anchor] = v
             pending_anchor = nil

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.50.0".freeze
+  VERSION = "0.6.52.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.50
+    VERSION 0.6.51
     DESCRIPTION "Ultra-fast YAML 1.2 parser, emitter and streamer in C"
     LANGUAGES C CXX
 )

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

@@ -53,6 +53,55 @@ extern "C" {
 YEPTRIS_API YeptrisDocument yeptris_cbor_decode(const void* buf, size_t len, uint32_t opts,
                                                 YeptrisStatus* status);
 
+/* The SAX decode face (#742): yeptris_cbor_decode's grammar driving
+ * consumer callbacks — items land as they parse, no document, no
+ * nodes. Measured (perf ledger 2026-10-29): the scan-only route reads
+ * ~2.1x the DOM entry on the same corpus (DOM construction is over
+ * half the decode lane), so validation, counting, and streaming
+ * transforms belong here. Items arrive in encoding order; map items
+ * set is_key on the key half. Strings with borrowed=1 point INTO buf —
+ * keep it valid while you hold them; borrowed=0 is decoder scratch.
+ * tag ("N N N", outermost first; NULL when none) and tag_len are
+ * callback-call-local. open's cap is the expected item count (maps
+ * count pairs*2; UINT64_MAX = indefinite); close fires for both the
+ * definite-complete and the break path, after the last child. The
+ * rendered text forms match the DOM ledger exactly (numbers-as-text,
+ * false/true/null/undefined, simple(N)).
+ *
+ * Every callback returns 0 on sink failure — the decode then reports
+ * YEPTRIS_ERROR_MEMORY — and may raise through host languages; the
+ * decoder owns no host state across them except the indefinite buffer,
+ * which its own exit paths free. All seven callbacks and sax itself
+ * must be non-NULL (YEPTRIS_ERROR_ARG otherwise): the loop dispatches
+ * unconditionally.
+ *
+ * consumed == NULL: trailing bytes after the one data item fail
+ * YEPTRIS_ERROR_PARSE. consumed != NULL: on success it receives the
+ * byte count of the items decoded — walk a CBOR Sequence (RFC 8742)
+ * by advancing buf by it. On failure *status (may be NULL) carries the
+ * code and yeptris_last_error() the message with the byte offset.
+ *
+ * Memory: none — the decoder allocates only its indefinite-chunk
+ * scratch and frees it on every exit. */
+typedef struct yeptris_cbor_sax {
+    void* ctx;
+    int (*text)(void* ctx, const char* s, uint32_t n, uint8_t tag_id, int is_key, const char* tag,
+                uint32_t tag_len);
+    int (*int_val)(void* ctx, int negative, uint64_t mag, int is_key, const char* tag,
+                   uint32_t tag_len);
+    int (*float_val)(void* ctx, double dv, int is_key, const char* tag, uint32_t tag_len);
+    int (*str_val)(void* ctx, const unsigned char* p, uint32_t n, int borrowed, int is_key,
+                   const char* tag, uint32_t tag_len);
+    int (*bytes_val)(void* ctx, const unsigned char* p, uint32_t n, int borrowed, int is_key,
+                     const char* tag, uint32_t tag_len);
+    int (*open)(void* ctx, int is_map, uint64_t cap, const char* tag, uint32_t tag_len);
+    int (*close)(void* ctx, int is_map);
+} yeptris_cbor_sax;
+
+YEPTRIS_API YeptrisStatus yeptris_cbor_decode_sax(const void* buf, size_t len, uint32_t opts,
+                                                  const yeptris_cbor_sax* sax, size_t* consumed,
+                                                  YeptrisStatus* status);
+
 /* CBOR Sequences (RFC 8742): top-level data items, concatenated —
  * no framing bytes. Iterates the buffer, one document per item; the
  * callback OWNS each item (free it with yeptris_document_free) and

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

@@ -1032,3 +1032,25 @@ YEPTRIS_API YeptrisDocument yeptris_cbor_decode(const void* buf, size_t len, uin
     }
     return (YeptrisDocument)doc;
 }
+
+YEPTRIS_API YeptrisStatus yeptris_cbor_decode_sax(const void* buf, size_t len, uint32_t opts,
+                                                  const yeptris_cbor_sax* sax, size_t* consumed,
+                                                  YeptrisStatus* status) {
+    if ((buf == NULL && len != 0) || sax == NULL || (opts & ~YEPTRIS_CBOR_STRICT) != 0 ||
+        sax->text == NULL || sax->int_val == NULL || sax->float_val == NULL ||
+        sax->str_val == NULL || sax->bytes_val == NULL || sax->open == NULL || sax->close == NULL) {
+        if (status != NULL) {
+            *status = YEPTRIS_ERROR_ARG;
+        }
+        return YEPTRIS_ERROR_ARG;
+    }
+    /* yeptris_cbor_sax IS yep_cbor_sink (sink.h aliases the public
+     * face): the decoder drives the caller's vtable directly. */
+    YeptrisStatus st = (YeptrisStatus)yep_cbor_decode_gen((const unsigned char*)buf, len,
+                                                          (opts & YEPTRIS_CBOR_STRICT) != 0,
+                                                          consumed, (const yep_cbor_sink*)sax);
+    if (status != NULL) {
+        *status = st;
+    }
+    return st;
+}

data/vendor/libyeptris/src/yeptris/cbor/sink.h

@@ -4,7 +4,11 @@
  * source of CBOR semantics; a sink implements the item constructors
  * on top of it. Two sinks exist: the DOM builder (the default, the
  * yeptris_cbor_decode public path) and the native ext's VALUE builder
- * (one pass, no intermediate). Sinks receive the resolver's tag_id
+ * (one pass, no intermediate). The sink vtable IS the public SAX face
+ * (yeptris_cbor_sax, <yeptris/cbor.h> — #742): the alias keeps the
+ * decoder driving the same layout the public entry hands over, so
+ * yeptris_cbor_decode_sax is a straight passthrough. Callback/field
+ * contracts are documented there; sinks receive the resolver's tag_id
  * and the pending semantic-tag chain in its text form ("N N N",
  * outermost first — NULL when the item carries no chain).
  */
@@ -15,35 +19,9 @@
 #include <stdint.h>
 
 #include <yeptris/api.h> /* YEPTRIS_API (the ext links these) */
+#include <yeptris/cbor.h>
 
-typedef struct yep_cbor_sink {
-    void* ctx;
-    /* All callbacks return 0 on sink failure (the decoder reports
-     * MEMORY). They may raise through host languages (longjmp): the
-     * decoder owns no host-managed state across them except the
-     * indefinite buffer, which its own exit paths free. */
-    /* is_key: 1 = the item lands in the enclosing map's key slot
-     * (sinks key-intern strings; the DOM ignores it). Rendered text:
-     * numbers-as-text, false/true/null/undefined, simple(N) — the
-     * exact bytes the DOM path stores. */
-    int (*text)(void* ctx, const char* s, uint32_t n, uint8_t tag_id, int is_key, const char* tag,
-                uint32_t tag_len);
-    /* Known integers: value = negative ? -(mag) : mag, mag <= 2^63. */
-    int (*int_val)(void* ctx, int negative, uint64_t mag, int is_key, const char* tag,
-                   uint32_t tag_len);
-    int (*float_val)(void* ctx, double dv, int is_key, const char* tag, uint32_t tag_len);
-    /* Strings. borrowed: 1 = p is the input (a sink may record the
-     * offset), 0 = the decoder's scratch buffer (copy or take it). */
-    int (*str_val)(void* ctx, const unsigned char* p, uint32_t n, int borrowed, int is_key,
-                   const char* tag, uint32_t tag_len);
-    int (*bytes_val)(void* ctx, const unsigned char* p, uint32_t n, int borrowed, int is_key,
-                     const char* tag, uint32_t tag_len);
-    /* Containers. cap: expected item count (maps: pairs*2), UINT64_MAX
-     * for indefinite. close fires for BOTH the definite-complete and
-     * the break paths, after the last child. */
-    int (*open)(void* ctx, int is_map, uint64_t cap, const char* tag, uint32_t tag_len);
-    int (*close)(void* ctx, int is_map);
-} yep_cbor_sink;
+typedef yeptris_cbor_sax yep_cbor_sink;
 
 /* The generic engine: the grammar, driving `sink`. Same reject/
  * encoding/depth semantics as the DOM entry. */

data/vendor/libyeptris/src/yeptris/events/values.c

@@ -72,6 +72,16 @@ void yep_val_put(yep_value_ctx* c, const YeptrisValue* v) {
 void yep_val_slot(yep_value_ctx* c, YeptrisValue* v) {
     if (c->depth > 0 && c->depth <= YEP_V_MAX_DEPTH) {
         int di = c->depth - 1;
+        if (c->is_seq[di]) {
+            /* a sequence entry never takes a key slot — the toggle
+             * flagged every ODD-position entry is_key=1, and the
+             * marshal strict-dup scan then false-flagged arrays with a
+             * repeated value at two odd positions ("[\"a\",\"b\",\"a\"]"
+             * = "duplicate key in object"; yeptris-ruby#333, the
+             * yeptris#680 class resurfacing through the value
+             * stream's own parity) */
+            return;
+        }
         if (c->key_pend[di] == 0) {
             v->is_key = 1;
             c->key_pend[di] = 1;
@@ -169,6 +179,7 @@ static int transform(yep_value_ctx* c, const yep_rec_store* store) {
             yep_val_put(c, &v);
             if (c->depth < YEP_V_MAX_DEPTH) {
                 c->key_pend[c->depth] = 0;
+                c->is_seq[c->depth] = 1;
             }
             c->depth++;
             continue;
@@ -179,6 +190,7 @@ static int transform(yep_value_ctx* c, const yep_rec_store* store) {
             yep_val_put(c, &v);
             if (c->depth < YEP_V_MAX_DEPTH) {
                 c->key_pend[c->depth] = 0;
+                c->is_seq[c->depth] = 0;
             }
             c->depth++;
             continue;
@@ -285,6 +297,7 @@ static int lin_node(yep_value_ctx* c, const yep_dom* d, uint32_t id) {
     yep_val_put(c, &v);
     if (c->depth < YEP_V_MAX_DEPTH) {
         c->key_pend[c->depth] = 0;
+        c->is_seq[c->depth] = (n->kind == YEP_DOM_SEQUENCE);
     }
     c->depth++;
     if (lin_children(c, d, n) != 0) {

data/vendor/libyeptris/src/yeptris/events/values_priv.h

@@ -24,6 +24,8 @@ typedef struct yep_value_ctx {
     int oom;
     int unsupported;                   /* linearize: construct the emitter cannot express */
     uint8_t key_pend[YEP_V_MAX_DEPTH]; /* per open map: key slot taken */
+    uint8_t is_seq[YEP_V_MAX_DEPTH];   /* per open frame: 1 = sequence —
+                                        * entries never take key slots */
     int depth;
 } yep_value_ctx;
 

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

@@ -379,7 +379,8 @@ static int e_comment_at(const yep_engine* e) {
 }
 
 static int e_at_eol(yep_engine* e) {
-    return e->pos >= e->len || e->p[e->pos] == '\n' || e->p[e->pos] == '\r' || e_comment_at(e);
+    return e->pos >= e->len || e->p[e->pos] == '\n' || e->p[e->pos] == '\r' || e_comment_at(e) ||
+           yep_scan_mb_break_len(e->p, e->len, e->pos) > 0;
 }
 
 static int e_skip_to_eol(yep_engine* e) {
@@ -3890,6 +3891,16 @@ static int e_parse_value(yep_engine* e, yep_ctx ctx, uint16_t floor_col) {
         if (e->pos >= e->len) {
             goto empty_value;
         }
+        /* a raw NEL/LS/PS here is this line's break: consume it exactly
+         * as the BLANK branch below consumes an LF-ended empty line —
+         * yep_scan_line's line model does not treat a break byte at the
+         * loop head as a line end, so without this the props-only line
+         * re-entered e_node on the break byte (rows 1-2) and the marker
+         * became the scalar's value (row 5's consume-first form) */
+        if (yep_scan_mb_break_len(e->p, e->len, e->pos) > 0) {
+            e_line_done(e, e->pos);
+            continue;
+        }
         yep_line_info li;
         if (e->pos == e->line_start) {
             /* seed the memo: the fast arms re-read this line's facts —

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.50.0
+  version: 0.6.52.0
 platform: powerpc64le-linux
 authors:
 - Ribose Inc.