yeptris 0.6.15.2 → 0.6.16.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1326388a6f59887d9b8f541ec6f4c835071ca05f4821d429a82b8acc1a990e2
-  data.tar.gz: 521f5abbcebb9611a0c67699b1952e72d3790d228fe606148f095d622f5b4387
+  metadata.gz: f6b3f2406ea8b763cfa7bd0d0a36ea30ba7bb80c8322c6ebe5fd8300725e47d2
+  data.tar.gz: 9a500939ce7f65be9219acc0a44c62819ddd09f4f64486177065681b8490e686
 SHA512:
-  metadata.gz: 7b6e36f35a32d480af8635023bbaf173194e8295e34851ae53ec8121cdf872e9d71c4877f70cc94d1ee62d0d22e4f74e868edc7746b2fbbd9d66af47f31daad0
-  data.tar.gz: 21a442ef4c99c57f46b837af822db3d98434c476b5a0b7c56d52f03bbfac0c8849be28b2a7fd2109a95b15a80ea6eda9116c3631ff5c6faff2d134e5b2a861fc
+  metadata.gz: 6c4eeced42673cb9613462d239f6427bdb1190e14b0a733976e3bd9c17ee061a4fe7fb5f14ace52ea05242b186410570b8d44f1fc5bbc2ab2aacbcd65188d7ef
+  data.tar.gz: 5b84d8229ff419ab0c04fba154088775776ed5f70f4e6be5a9939e9b495e61ac82656a1bf0d7cbddbdf55ae9c1ba1912c44fc2af5b22e16d40a432e71009b185

data/ext/yeptris_native/cbor_ruby.c

@@ -17,6 +17,14 @@
 #include <stdlib.h>
 #include <string.h>
 
+static rb_encoding* cr_utf8_enc;
+
+/* Map keys repeat across records in CBOR corpora; interning shares one
+ * VALUE per distinct key (the json_ruby.c on_key pattern, #157). */
+static VALUE cr_key_str(const char* p, size_t len) {
+    return rb_enc_interned_str(p, (long)len, cr_utf8_enc);
+}
+
 #include "dom/dom.h"
 #include "doc.h" /* the public YeptrisDocument wrapper: ->dom */
 #include <yeptris/cbor.h>
@@ -91,8 +99,17 @@ static VALUE cr_walk(const yep_dom* d, uint32_t id) {
         VALUE h = HASH_NEW_CAPA(pairs);
         uint32_t c = n->first_child;
         for (long i = 0; i < pairs && c != UINT32_MAX; i++) {
-            VALUE k = cr_walk(d, c);
-            c = d->nodes[c].next_sibling;
+            VALUE k;
+            const yep_dnode* kn = &d->nodes[c];
+            if (kn->kind == YEP_DOM_SCALAR && kn->tag_id == YEPTRIS_TAG_STR) {
+                uint32_t klen = 0;
+                const char* kp = cr_view(d, kn->value, &klen);
+                k = cr_key_str(kp, klen);
+                c = kn->next_sibling;
+            } else {
+                k = cr_walk(d, c);
+                c = d->nodes[c].next_sibling;
+            }
             VALUE v = (c != UINT32_MAX) ? cr_walk(d, c) : Qnil;
             if (c != UINT32_MAX) {
                 c = d->nodes[c].next_sibling;
@@ -107,6 +124,9 @@ static VALUE cr_walk(const yep_dom* d, uint32_t id) {
 }
 
 VALUE yep_rb_cbor_load(const char* p, size_t len, int strict) {
+    if (cr_utf8_enc == NULL) {
+        cr_utf8_enc = rb_utf8_encoding();
+    }
     YeptrisStatus st = YEPTRIS_OK;
     /* the DOM borrows the input buffer zero-copy; the walk ALLOCATES,
      * and a GC compaction mid-walk moves the caller's String — the

data/ext/yeptris_native/yeptris_native.c

@@ -423,8 +423,51 @@ static VALUE native_gc_mode_set(VALUE self, VALUE mode) {
     return mode;
 }
 
+/* ABI-drift self-check (the #157-audit silent-nil class): the bundle
+ * is compiled against a specific yep_dom layout; engine drift makes
+ * the walkers read fields at stale offsets — cbor_load returned NIL
+ * on valid CBOR in the dev-checkout audit, with no error anywhere.
+ * Both walkers must round-trip a known document at load, or Init
+ * raises LoadError: lib/yeptris.rb's existing rescue falls back to
+ * the FFI ladder (loudly), and the stale bundle never answers with
+ * garbage. Runs inside rb_protect so a drifted walk raises instead of
+ * crashing the load. */
+static VALUE native_self_check_body(VALUE unused) {
+    /* JSON: {"a"=>[1, 2.5, "x", true, nil]} */
+    const char* json = "{\"a\":[1,2.5,\"x\",true,null]}";
+    VALUE j = yep_rb_parse_json(json, strlen(json), 0);
+    if (j == Qundef || !RB_TYPE_P(j, T_HASH)) return Qfalse;
+    VALUE a = rb_hash_lookup(j, rb_str_new_cstr("a"));
+    if (!RB_TYPE_P(a, T_ARRAY) || RARRAY_LEN(a) != 5) return Qfalse;
+    if (!RB_INTEGER_TYPE_P(rb_ary_entry(a, 0))) return Qfalse;
+    if (!RB_FLOAT_TYPE_P(rb_ary_entry(a, 1))) return Qfalse;
+    if (!RB_TYPE_P(rb_ary_entry(a, 2), T_STRING)) return Qfalse;
+    if (rb_ary_entry(a, 3) != Qtrue || !NIL_P(rb_ary_entry(a, 4))) return Qfalse;
+
+    /* CBOR: A1 61 6B 01 = {"k" => 1} (canonical, hand-encoded) */
+    const char cbor[] = "\xA1\x61\x6B\x01";
+    VALUE c = yep_rb_cbor_load(cbor, sizeof(cbor) - 1, 0);
+    if (c == Qundef || !RB_TYPE_P(c, T_HASH)) return Qfalse;
+    VALUE one = rb_hash_lookup(c, rb_str_new_cstr("k"));
+    if (!RB_INTEGER_TYPE_P(one) || !rb_eql(one, INT2FIX(1))) return Qfalse;
+    return Qtrue;
+}
+
+static void native_self_check(void) {
+    int state = 0;
+    VALUE ok = rb_protect(native_self_check_body, Qnil, &state);
+    if (state != 0 || ok != Qtrue) {
+        if (state != 0) rb_set_errinfo(Qnil);
+        rb_raise(rb_eLoadError,
+                 "yeptris: native materializer failed its ABI self-check "
+                 "(stale build against a drifted engine?) — refusing to "
+                 "register; the FFI ladder will carry the load");
+    }
+}
+
 RUBY_FUNC_EXPORTED void Init_native(void) {
     utf8_enc = rb_utf8_encoding();
+    native_self_check();
     VALUE mYep = rb_define_module("Yeptris");
     VALUE mNat = rb_define_module_under(mYep, "Native");
     rb_define_singleton_method(mNat, "load_json", native_load_json, -1);

data/lib/yeptris/document.rb

@@ -8,6 +8,11 @@ class Yeptris::Document
   # explicit free path and the finalizer both flip the same flag.
   Freed = Struct.new(:state) # :alive | :freed
 
+  # The raw C handle — the Yeptris::Node wrappers cache by its
+  # address; stream-children wrappers (Document.without_finalizer)
+  # carry it without registering a finalizer (#182).
+  attr_reader :c_ptr
+
   # The schema this document was parsed with (a parse property).
   attr_reader :parse_schema
 
@@ -80,6 +85,18 @@ class Yeptris::Document
     new(c_ptr, Freed.new(:alive), schema)
   end
 
+  # #182: the stream-children wrapper owns NOTHING (the parent
+  # Document wrapper is the sole freer of the C memory). A plain
+  # Document.new would register a finalizer on a c_ptr we don't own;
+  # a parse_stream on a multi-doc stream would free the same pointer
+  # three times at GC → SIGABRT. This factory builds the wrapper
+  # WITHOUT a finalizer; the wrapper's lifetime follows the owner.
+  def self.without_finalizer(c_ptr)
+    doc = new(c_ptr)
+    ObjectSpace.undefine_finalizer(doc)
+    doc
+  end
+
   def ensure_alive!
     raise Yeptris::FreedError, "document is freed" if @freed.state == :freed
   end

data/lib/yeptris/json.rb

@@ -119,7 +119,7 @@ module Yeptris
       end
     end
 
-    def walk_tape(src, tape)
+    def walk_tape(src, tape, strict_dup = STRICT_DUPLICATE_KEYS)
       n = tape[:count]
       kinds = tape[:kinds].read_bytes(n).unpack("C*")
       offs = tape[:offs].read_bytes(n * 4).unpack("V*")
@@ -139,7 +139,7 @@ module Yeptris
 
       docs = [nil] # record 0 (DOC) pre-consumed — the root's slot
       stack = []
-      key_sets = STRICT_DUPLICATE_KEYS ? [{}] : nil
+      key_sets = strict_dup ? [{}] : nil
       pending_key = nil
       i = 1
       while i < n
@@ -152,8 +152,12 @@ module Yeptris
           place(docs, stack, pending_key) { {} }
           pending_key = nil
         when T_CLOSE
+          # Key frames are pushed per MAP_OPEN — an ARRAY close must
+          # not pop the enclosing map's frame (issue found by ea's CI:
+          # {"a":[1],"b":[2],"c":[3]} exhausted the frames and the next
+          # map key hit key_sets.last.key? on nil under strict mode).
+          key_sets&.pop if stack.last.is_a?(Hash)
           stack.pop
-          key_sets&.pop
         when T_STR
           # empty-string literals are frozen+shared since Ruby 3.4
           # (and `+""` binds after the method chain anyway), so the
@@ -256,8 +260,8 @@ module Yeptris
           place(docs, stack, pending_key) { {} }
           pending_key = nil
         when ValueML::CLOSE
+          key_sets&.pop if stack.last.is_a?(Hash)
           stack.pop
-          key_sets&.pop
         when ValueML::V_STR
           text = arena.byteslice(offs[i], lens[i])
           if ikeys[i] == 1 && !stack.empty? && stack.last.is_a?(Hash)

data/lib/yeptris/psych/class_loader.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Yeptris
+  module Psych
+    # The minimal ClassLoader face the ScalarScanner port drives
+    # (stdlib's loader resolves through the class hierarchy; the
+    # scanner only needs the date class and symbolize).
+    class ClassLoader
+      def date
+        Date
+      end
+
+      def symbolize str
+        str.to_sym
+      end
+
+      def load name
+        Object.const_get(name)
+      end
+    end
+  end
+end

data/lib/yeptris/psych/scalar_scanner.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Yeptris
+  module Psych
+    ###
+    # Scan scalars for built in types — the stdlib Psych::ScalarScanner
+    # port (#179): same regexes, same precedence, same edge verdicts.
+    # The load path types through the C resolver; this class is the
+    # standalone API stdlib code (and Psych's own tests) drive directly.
+    class ScalarScanner
+      # Taken from http://yaml.org/type/timestamp.html
+      TIME = /^-?\d{4}-\d{1,2}-\d{1,2}(?:[Tt]|\s+)\d{1,2}:\d\d:\d\d(?:\.\d*)?(?:\s*(?:Z|[-+]\d{1,2}:?(?:\d\d)?))?$/
+
+      # Taken from http://yaml.org/type/float.html
+      # Base 60, [-+]inf and NaN are handled separately
+      FLOAT = /^(?:[-+]?([0-9][0-9_,]*)?\.[0-9]*([eE][-+][0-9]+)?(?# base 10))$/x
+
+      # Taken from http://yaml.org/type/int.html and modified to ensure at least one numerical symbol exists
+      INTEGER_STRICT = /^(?:[-+]?0b[_]*[0-1][0-1_]*             (?# base 2)
+                           |[-+]?0[_]*[0-7][0-7_]*              (?# base 8)
+                           |[-+]?(0|[1-9][0-9_]*)               (?# base 10)
+                           |[-+]?0x[_]*[0-9a-fA-F][0-9a-fA-F_]* (?# base 16))$/x
+
+      # Same as above, but allows commas.
+      # Not to YML spec, but kept for backwards compatibility
+      INTEGER_LEGACY = /^(?:[-+]?0b[_,]*[0-1][0-1_,]*                (?# base 2)
+                           |[-+]?0[_,]*[0-7][0-7_,]*                 (?# base 8)
+                           |[-+]?(?:0|[1-9](?:[0-9]|,[0-9]|_[0-9])*) (?# base 10)
+                           |[-+]?0x[_,]*[0-9a-fA-F][0-9a-fA-F_,]*    (?# base 16))$/x
+
+      BOOLEAN_TRUE  = /^(yes|true|on)$/i
+      BOOLEAN_FALSE = /^(no|false|off)$/i
+
+      attr_reader :class_loader
+
+      # Create a new scanner
+      def initialize class_loader = ClassLoader, strict_integer: false, parse_symbols: true
+        @symbol_cache = {}
+        @class_loader = class_loader
+        @strict_integer = strict_integer
+        @parse_symbols = parse_symbols
+      end
+
+      # Tokenize +string+ returning the Ruby object
+      def tokenize string
+        return nil if string.empty?
+        return @symbol_cache[string] if @symbol_cache.key?(string)
+        integer_regex = @strict_integer ? INTEGER_STRICT : INTEGER_LEGACY
+        # Check for a String type, being careful not to get caught by hash keys, hex values, and
+        # special floats (e.g., -.inf).
+        if string.match?(%r{^[^\d.:-]?[[:alpha:]_\s!@#$%\^&*(){}<>|/\\~;=]+}) || string.match?(/\n/)
+          return string if string.length > 5
+
+          if string.match?(/^[^ytonf~]/i)
+            string
+          elsif string == '~' || string.match?(/^null$/i)
+            nil
+          elsif string.match?(BOOLEAN_TRUE)
+            true
+          elsif string.match?(BOOLEAN_FALSE)
+            false
+          else
+            string
+          end
+        elsif string.match?(TIME)
+          begin
+            parse_time string
+          rescue ArgumentError
+            string
+          end
+        elsif string.match?(/^\d{4}-(?:1[012]|0\d|\d)-(?:[12]\d|3[01]|0\d|\d)$/)
+          begin
+            class_loader.date.strptime(string, '%F', Date::GREGORIAN)
+          rescue ArgumentError
+            string
+          end
+        elsif string.match?(/^\+?\.inf$/i)
+          Float::INFINITY
+        elsif string.match?(/^-\.inf$/i)
+          -Float::INFINITY
+        elsif string.match?(/^\.nan$/i)
+          Float::NAN
+        elsif @parse_symbols && string.match?(/^:./)
+          if string =~ /^:(["'])(.*)\1/
+            @symbol_cache[string] = class_loader.symbolize($2.sub(/^:/, ''))
+          else
+            @symbol_cache[string] = class_loader.symbolize(string.sub(/^:/, ''))
+          end
+        elsif string.match?(/^[-+]?[0-9][0-9_]*(:[0-5]?[0-9]){1,2}$/)
+          i = 0
+          string.split(':').each_with_index do |n, e|
+            i += (n.to_i * 60**(e - 2).abs)
+          end
+          i
+        elsif string.match?(/^[-+]?[0-9][0-9_]*(:[0-5]?[0-9]){1,2}\.[0-9_]*$/)
+          i = 0
+          string.split(':').each_with_index do |n, e|
+            i += (n.to_f * 60**(e - 2).abs)
+          end
+          i
+        elsif string.match?(FLOAT)
+          if string.match?(/\A[-+]?\.\Z/)
+            string
+          else
+            Float(string.delete(',_').gsub(/\.([Ee]|$)/, '\1'))
+          end
+        elsif string.match?(integer_regex)
+          parse_int string
+        else
+          string
+        end
+      end
+
+      # Parse and return an int from +string+
+      def parse_int string
+        Integer(string.delete(',_'))
+      end
+
+      ###
+      # Parse and return a Time from +string+
+      def parse_time string
+        date, time = *(string.split(/[Tt]|\s+/, 2))
+        (yy, m, dd) = date.match(/^(-?\d{4})-(\d{1,2})-(\d{1,2})/).captures.map { |x| x.to_i }
+        md = time.match(/(\d+:\d+:\d+)(?:\.(\d*))?\s*(Z|[-+]\d+(:\d\d)?)?/)
+
+        (hh, mm, ss) = md[1].split(':').map { |x| x.to_i }
+        us = (md[2] ? Rational("0.#{md[2]}") : 0) * 1_000_000
+
+        time = Time.utc(yy, m, dd, hh, mm, ss, us)
+
+        return time if 'Z' == md[3]
+        return Time.at(time.to_i, us) unless md[3]
+
+        tz = md[3].match(/^([+\-]?\d{1,2})\:?(\d{1,2})?$/)[1..-1].compact.map { |digit| Integer(digit, 10) }
+        offset = tz.first * 3600
+
+        if offset < 0
+          offset -= ((tz[1] || 0) * 60)
+        else
+          offset += ((tz[1] || 0) * 60)
+        end
+
+        Time.new(yy, m, dd, hh, mm, ss + us / 1_000_000r, offset)
+      end
+    end
+  end
+end

data/lib/yeptris/psych.rb

@@ -22,6 +22,9 @@ require "yeptris"
 # document without materializing.
 module Yeptris
   module Psych
+    autoload :ClassLoader, "yeptris/psych/class_loader"
+    autoload :ScalarScanner, "yeptris/psych/scalar_scanner"
+
     # The tag registries (Psych's class-level API, #95 bug 4):
     # load_tags maps a serialized tag to the Class that revives it;
     # dump_tags overrides the emitted tag for a Class. Consulted by
@@ -258,18 +261,28 @@ module Yeptris
         ::Yeptris::Psych.dump(obj, io, options)
       end
 
-      def load_stream(yaml, **kwargs)
+      def load_stream(yaml, **kwargs, &block)
         # materialize each document's root directly — the stream
         # children share one C document, so their handles would all
-        # resolve to the first document's tree
+        # resolve to the first document's tree. stdlib's block form
+        # yields each loaded document's object (#179 round 4).
         doc = Yeptris::Document.parse(yaml, schema: :compat_11)
         return nil if doc.nil? # the legal empty stream
 
         begin
-          (0...doc.document_count).map { |i| doc.root(i).to_ruby }
+          docs = (0...doc.document_count).map { |i| doc.root(i).to_ruby }
         ensure
           doc.free
         end
+        docs.each { |d| block.call(d) } if block
+        docs
+      end
+
+      # safe_load_stream: stdlib's surface — the stream form of
+      # safe_load. Our load_stream is already safe-by-default
+      # (Psych 5 semantics), so this is the yielding wrapper.
+      def safe_load_stream(yaml, **kwargs, &block)
+        load_stream(yaml, **kwargs, &block)
       end
 
       # The first document's node tree (no Ruby materialization).
@@ -291,13 +304,22 @@ module Yeptris
         raise SyntaxError.from_parse_error(e)
       end
 
-      def parse_stream(yaml)
+      def parse_stream(yaml, &block)
+        # stdlib yields each document to a block if one was given (and
+        # the stream it returns holds the same children either way).
+        # #182: the wrapper is the sole owner of the C memory — the
+        # stream merely REFERENCES it; the wrapper's own finalizer
+        # handles GC-free. (The block-yielding form is tracked under
+        # #179: the current implementation materializes eagerly; the
+        # block is only honored as a no-op convenience.)
         doc = Yeptris::Document.parse(yaml, schema: :compat_11)
         return nil if doc.nil? || doc.document_count.zero?
 
         stream = Nodes::Stream.new
         (0...doc.document_count).each do |i|
-          stream.children << Nodes::Builder.document_stream_child(doc, i)
+          child = Nodes::Builder.document_stream_child(doc, i)
+          stream.children << child
+          block.call(child) if block # stdlib's yielding form (#179 round 4)
         end
         # ownership: the DOCUMENT wrapper is the sole owner — its own
         # finalizer (pointer-only closure) frees the C memory; the
@@ -308,6 +330,8 @@ module Yeptris
       rescue Yeptris::ParseError => e
         raise SyntaxError.from_parse_error(e)
       ensure
+        # the returned stream OWNS the doc's lifetime (its free delegates
+        # to the owner); only free here when the stream wasn't built
         doc&.free if doc && !stream
       end
 
@@ -440,6 +464,10 @@ module Yeptris
       # tree stay valid while the tree is reachable; a GC finalizer
       # releases the C memory when it is not.
       class Document < Node
+          # The document's root as a Ruby object (the stream-yield face).
+          def to_ruby
+            children.first&.to_ruby
+          end
         attr_reader :version, :tags
 
         def initialize(version = [], tags = {})
@@ -522,8 +550,12 @@ module Yeptris
         # stream owns the yeptris document)
         def document_stream_child(doc, index)
           root = doc.root(index)
-          d = Document.new
-          d.handle = root&.document
+          # #182's root cause: three per-stream Document wrappers all
+          # capture the same c_ptr in their finalizers → three frees.
+          # The stream-children WRAPPER owns nothing (the owner wrapper
+          # is the real Document; this one just references it). Build
+          # a non-owning wrapper with no finalizer.
+          d = Document.send(:new, root&.document, false)
           d.children << node(root) if root
           d
         end

data/lib/yeptris/schema.rb

@@ -66,6 +66,92 @@ module Yeptris
       end
     end
 
+    # #184 (lutaml-model KV path): zip Schema columns into record
+    # hashes ready for Serializable.instantiate. Mapping root → one
+    # hash; sequence-of-mappings → one hash per element; nested
+    # mappings → nested hashes. Returns Array<Hash> always. when_attribute
+    # / polymorphic stay out of scope (interpretive fallback).
+    def load_records(source, schema: :core_12, desc:, capacity: 64)
+      cols = load(source, schema: schema, desc: desc, capacity: capacity)
+      zip_records(desc, cols)
+    end
+
+    def zip_records(desc, cols)
+      root = desc[0] || {}
+      case root[:kind]
+      when :sequence
+        child_start = root[:child_index] || 1
+        child_count = root[:child_count] || 0
+        return [] if child_count.zero?
+
+        child = desc[child_start]
+        if child && child[:kind] == :mapping
+          field_start = child[:child_index] || (child_start + 1)
+          field_count = child[:child_count] || 0
+          fields = desc[field_start, field_count] || []
+          field_cols = cols[field_start, field_count] || []
+          nrows = field_cols.map(&:length).max || 0
+          Array.new(nrows) do |r|
+            h = {}
+            fields.each_with_index do |f, i|
+              next unless f[:wire_name]
+              col = field_cols[i] || []
+              # ABSENT keys are OMITTED, not nil-filled (lutaml-model's
+              # load-bearing edge: absent seeds defaults +
+              # using_default?; explicit nil is a present value with
+              # different render semantics). The C columns fill in
+              # document order — col.length > r means present.
+              next if col.length <= r
+
+              h[f[:wire_name].to_sym] = materialize_field(f, desc, cols, col[r])
+            end
+            h
+          end
+        else
+          (cols[child_start] || []).map { |v| { value: v } }
+        end
+      when :mapping
+        field_start = root[:child_index] || 1
+        field_count = root[:child_count] || 0
+        fields = desc[field_start, field_count] || []
+        field_cols = cols[field_start, field_count] || []
+        h = {}
+        fields.each_with_index do |f, i|
+          next unless f[:wire_name]
+          col = field_cols[i] || []
+          next if col.empty? # absent: omitted, not nil-filled (#184)
+
+          h[f[:wire_name].to_sym] = materialize_field(f, desc, cols, col[0])
+        end
+        [h]
+      else
+        [{ value: cols[0]&.first }]
+      end
+    end
+    private_class_method :zip_records
+
+    def materialize_field(field, desc, cols, cell)
+      case field[:kind]
+      when :mapping
+        start = field[:child_index] || 0
+        count = field[:child_count] || 0
+        return nil if count.zero? || cell.nil?
+
+        nested = {}
+        desc[start, count]&.each_with_index do |nf, i|
+          next unless nf[:wire_name]
+          ncol = cols[start + i] || []
+          nested[nf[:wire_name].to_sym] = ncol.is_a?(Array) ? (ncol[0] rescue cell) : cell
+        end
+        nested
+      when :sequence
+        cell.is_a?(Array) ? cell : Array(cell)
+      else
+        cell
+      end
+    end
+    private_class_method :materialize_field
+
     def compile(desc)
       desc.map do |n|
         { kind: KIND.fetch(n.fetch(:kind)),

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.15.2".freeze
+  VERSION = "0.6.16.2".freeze
   # The error hierarchy lives in THIS file (the parent namespace's
   # own file): nested constants do not trigger a parent-constant
   # autoload, and the law forbids internal requires — defining the

data/vendor/libyeptris/CMakeLists.txt

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

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

@@ -65,7 +65,9 @@ enum {
                                     (default: last, as at parse) */
 };
 
-/* One plan node. 32 bytes, ABI-pinned. */
+/* One plan node. ABI-pinned: a pointer plus 16 fixed-width bytes —
+ * 24 on LP64, 20 on 32-bit (the hosts' FFI mirrors size :pointer
+ * per-process, so the layout contract is the POINTER plus the tail). */
 typedef struct yeptris_desc_node {
     const char* wire_name; /* mapping key to match (NULL: the root) */
     uint8_t kind;          /* YEP_SK_* */
@@ -77,7 +79,7 @@ typedef struct yeptris_desc_node {
     uint32_t reserved;     /* must be 0 (ABI headroom) */
 } yeptris_desc_node;
 
-YEPTRIS_CT_ASSERT(sizeof(yeptris_desc_node) == 24);
+YEPTRIS_CT_ASSERT(sizeof(yeptris_desc_node) == sizeof(const char*) + 16);
 
 /* One column's output. Caller allocates the payload array (sized by
  * expectation); the call fills it and sets count. No per-value FFI: