yeptris 0.6.12.1 → 0.6.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffeaeb76cbc3a0a575cf5fce09e5ceff42ae233fa38125c4fb575eb15c2aafab
-  data.tar.gz: d6667ffc31e29fd13f97d7bd5378b6a3611c39f849f7a69075d9e90c6e262df6
+  metadata.gz: c5dd96eb5583028d0da7d38ee4addaf108b8a2495696aacc6f68c43117773da3
+  data.tar.gz: b489c5bfc4b41d9cb3d8b836ac4b88f62aaeab5856788412301cde79ee0dfd2f
 SHA512:
-  metadata.gz: 52298af429a38b41b55adf972d89156e5c214367debc1ccf618fd8e1a438414004861c8b6a7e9a1cc1e5235c68ba07a734ae580da668b3b7751b708102c9d46c
-  data.tar.gz: c40301fda3424c9ef0d3d314a71dbf05b9a50af488c12b470f14cb8523912416ceb762de6e73ca6b44a97ac04b549d565113b688333320dabe9f3a2861895e50
+  metadata.gz: 4d91f1cdb572d444d4f7a43aec756400375581b3fa7bb1f6bbf62e9ad134ffa392fb1a763f11daffb07ae865e4046b6379a15b7f57eec5fb72c842bb580aee52
+  data.tar.gz: 7ac70b81ca8cf423226b48f8e6422686dc6edd9593a94bc82ebc7d0470ee40a9de9f28b4bd0f4ddf1c85ee1e132156fa1d889db8a1af9a788a6f5384f60c08c6

data/lib/yeptris/ffi.rb

@@ -28,6 +28,32 @@ module Yeptris
       MSG
     end
 
+    class << self
+      # #138's class, hit again by the oiml-cs report: a stale
+      # libyeptris on the machine (the Windows base-name dedupe makes
+      # a system copy win) lacks newer symbols, and a raising attach
+      # aborts this file mid-evaluation — every constant after it
+      # never defines, so the next autoload dies with
+      # 'uninitialized constant Yeptris::FFI::NODE_SCALAR'. Attaches
+      # now record the miss and define a raising stub of the same
+      # name: the load completes, optional surfaces fail with a clear
+      # message at USE, and the ESSENTIAL self-check at the bottom of
+      # this file raises the friendly load error for truly old
+      # engines.
+      def attach_function(name, args, ret, opts = {})
+        super
+      rescue ::FFI::NotFoundError, ::FFI::TypeError
+        define_singleton_method(name) do |*_a, **_kw|
+          raise ::FFI::NotFoundError,
+                "yeptris: #{name} is unavailable — the loaded " \
+                "libyeptris is older than this gem. Update the engine " \
+                "library (or clear the stale copy shadowing it)."
+        end
+        (@missing ||= []) << name
+        nil
+      end
+    end
+
 
     typedef :pointer, :yeptris_document
     typedef :pointer, :yeptris_node
@@ -194,18 +220,14 @@ module Yeptris
     # instead of walking per-value records in pure Ruby. Same feature-
     # detect discipline as the columnar drain (older libraries fall
     # back to the record walk).
-    MARSHAL = begin
-      MARSHAL_ALL_DOCS = 0
-      MARSHAL_FIRST_DOC = 1
-      attach_function :yeptris_marshal,
-                      %i[pointer size_t int int pointer pointer], :int
-      attach_function :yeptris_marshal_node,
-                      %i[yeptris_node pointer pointer], :int
-      attach_function :yeptris_marshal_free, [:pointer], :void
-      true
-    rescue ::FFI::NotFoundError
-      false
-    end
+    MARSHAL_ALL_DOCS = 0
+    MARSHAL_FIRST_DOC = 1
+    attach_function :yeptris_marshal,
+                    %i[pointer size_t int int pointer pointer], :int
+    attach_function :yeptris_marshal_node,
+                    %i[yeptris_node pointer pointer], :int
+    attach_function :yeptris_marshal_free, [:pointer], :void
+    MARSHAL = !(@missing ||= []).include?(:yeptris_marshal_node)
 
     # bulk build (TODO.impl/15 phase D): one call raises a document
     BUILD_SCALAR = 1
@@ -238,19 +260,15 @@ module Yeptris
 
     # CBOR (RFC 8949, TODO.cbor): absent on libraries before the
     # codec's release — the CBOR module feature-detects
-    CBOR_EX = begin
-      attach_function :yeptris_cbor_decode, %i[pointer size_t uint32 yeptris_status_out],
-                      :yeptris_document
-      callback :cbor_item_cb, %i[pointer yeptris_document size_t], :int
-      attach_function :yeptris_cbor_decode_sequence,
-                      %i[pointer size_t uint32 cbor_item_cb pointer yeptris_status_out], :size_t
-      attach_function :yeptris_cbor_encode, %i[yeptris_document uint32 pointer], :pointer
-      attach_function :yeptris_cbor_encode_sequence,
-                      %i[pointer size_t uint32 pointer], :pointer
-      true
-    rescue ::FFI::NotFoundError
-      false
-    end
+    attach_function :yeptris_cbor_decode, %i[pointer size_t uint32 yeptris_status_out],
+                    :yeptris_document
+    callback :cbor_item_cb, %i[pointer yeptris_document size_t], :int
+    attach_function :yeptris_cbor_decode_sequence,
+                    %i[pointer size_t uint32 cbor_item_cb pointer yeptris_status_out], :size_t
+    attach_function :yeptris_cbor_encode, %i[yeptris_document uint32 pointer], :pointer
+    attach_function :yeptris_cbor_encode_sequence,
+                    %i[pointer size_t uint32 pointer], :pointer
+    CBOR_EX = !(@missing ||= []).include?(:yeptris_cbor_decode)
 
     # Owned char* results (serialize*): one reader, freed exactly once.
     # The release goes through yeptris_free (libyeptris's own
@@ -368,5 +386,24 @@ module Yeptris
     ERROR_ARG = 6
     ERROR_UNSUPPORTED = 7
     ERROR_INTERNAL = 8
+    # The load-time essentials (the read path + the ownership
+    # contract): absent on engines far older than the optional
+    # surfaces — raise the friendly error once every constant has
+    # fully defined, so no partial-module state leaks into autoloads
+    # (the #138 class, closed at the root).
+    ESSENTIAL = %i[
+      yeptris_version yeptris_last_error yeptris_parse yeptris_parse_ex
+      yeptris_parse_json yeptris_document_free yeptris_document_count
+      yeptris_document_root yeptris_node_kind yeptris_node_value
+      yeptris_node_tag_id yeptris_node_style yeptris_document_new
+      yeptris_document_set_root yeptris_serialize yeptris_serialize_ex
+    ].freeze
+    missing_core = ESSENTIAL & (@missing ||= [])
+    raise ::FFI::NotFoundError,
+          "yeptris: the loaded libyeptris is older than this gem " \
+          "requires (missing: #{missing_core.join(', ')}). Update the " \
+          "engine library, or clear the stale copy shadowing it." \
+          unless missing_core.empty?
+
   end
 end

data/lib/yeptris/schema.rb

@@ -9,13 +9,37 @@ module Yeptris
     module_function
 
     KIND = { scalar: 0, sequence: 1, mapping: 2, callback: 3 }.freeze
-    TYPE = { str: 0, int: 1, float: 2, bool: 3, null: 4 }.freeze
+    TYPE = { str: 0, int: 1, float: 2, bool: 3, null: 4, any: 5 }.freeze
     REQUIRED = 1 << 0
+    FIRST_WINS = 1 << 1 # duplicates within one mapping: first kept
+
+    # The :any verdict (#238's headroom): the resolver's own typing,
+    # one 24-byte record per value — Integer/Float/true/false/nil, a
+    # zero-copy String for str/timestamp spans
+    ANY_SIZE = 24 # yeptris_value.h's YeptrisValue: kind@0 tag_id@1
+    # is_key@2 b@3 off@4 len@8 p@16 — the C layout, ABI-pinned
+    ANY_KIND = { 1 => :null, 2 => :bool, 3 => :int, 4 => :float,
+                 5 => :str, 6 => :timestamp }.freeze
 
     class Error < Yeptris::Error; end
+
+    # #238's executed headroom (ST_ANY/FIRST_WINS) rides the C tag
+    # AFTER v0.6.12; probe the engine rather than trusting versions
+    class << self
+      def headroom_supported?
+        return @headroom_supported unless @headroom_supported.nil?
+        @headroom_supported = begin
+          load("x: 1\n",
+               desc: [{ kind: :mapping, child_index: 1, child_count: 1 },
+                      { wire_name: "x", kind: :scalar, type: :any }]) && true
+        rescue Error, Yeptris::ParseError, Yeptris::Error
+          false
+        end
+      end
+    end
     class RequiredMissing < Error; end
 
-    ELEMENT_SIZE = { 0 => 16, 1 => 8, 2 => 8, 3 => 1, 4 => 1 }.freeze # by TYPE value
+    ELEMENT_SIZE = { 0 => 16, 1 => 8, 2 => 8, 3 => 1, 4 => 1, 5 => ANY_SIZE }.freeze # by TYPE value
 
     # A materialized span: zero-copy off/len into the source plus the
     # node's byte offset (the CALLBACK escape hatch).
@@ -47,7 +71,7 @@ module Yeptris
         { kind: KIND.fetch(n.fetch(:kind)),
           type: TYPE.fetch(n[:type] || :str),
           wire: n[:wire_name],
-          flags: n[:required] ? REQUIRED : 0,
+          flags: (n[:required] ? REQUIRED : 0) | (n[:first_wins] ? FIRST_WINS : 0),
           child_index: n[:child_index] || 0,
           child_count: n[:child_count] || 0 }
       end
@@ -120,6 +144,16 @@ module Yeptris
           when TYPE[:float] then data.get_double(k * 8)
           when TYPE[:bool] then data.get_uchar(k) == 1
           when TYPE[:null] then nil
+          when TYPE[:any]
+            rec = k * ANY_SIZE
+            case ANY_KIND[data.get_uint8(rec)]
+            when :int then data.get_int64(rec + 16)
+            when :float then data.get_double(rec + 16)
+            when :bool then data.get_uint8(rec + 3) == 1
+            when :null then nil
+            else # str/timestamp: the zero-copy span
+              source.byteslice(data.get_uint32(rec + 4), data.get_uint32(rec + 8))
+            end
           else
             off = data.get_uint32(k * 16)
             len = data.get_uint32(k * 16 + 4)

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.12.1".freeze
+  VERSION = "0.6.13.1".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.12
+    VERSION 0.6.13
     DESCRIPTION "Ultra-fast YAML 1.2 parser, emitter and streamer in C"
     LANGUAGES C CXX
 )

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

@@ -1,5 +1,6 @@
 /* dom.c — event-built DOM (builder sink + storage). */
 
+#include <stdio.h>
 #include <string.h>
 
 #include "common/simd_text.h"
@@ -864,6 +865,118 @@ int dom_on_flow_commit(void* ctx) {
     return 1;
 }
 
+int dom_from_tape(yep_dom* d, const yeptris_json_tape* t) {
+    if (d == NULL || t == NULL || t->_src == NULL) {}
+    /* the columns are the one representation valid on every route
+     * (strict: native; lenient fused: lazily materialized from the
+     * records; scalar-root lenient: native column writes) */
+    if (yeptris_tape_columns((yeptris_json_tape*)t) != 0) {}
+    if (t->kinds == NULL) {}
+    d->input_base = (const char*)t->_src;
+    d->input_len = t->_srclen;
+    const char* src = (const char*)t->_src;
+    d->depth = 0;
+    for (uint32_t i = 0; i < t->count; i++) {
+        const uint8_t kind = t->kinds[i];
+        const uint32_t len = t->lens[i];
+        const uint32_t off = t->offs[i];
+        switch (kind) {
+        case YEP_T_DOC:
+            break; /* the stream boundary record */
+        case YEP_T_SEQ_OPEN:
+        case YEP_T_MAP_OPEN: {
+            if (d->depth >= YEP_DOM_MAX_DEPTH) {}
+            uint32_t id =
+                dom_open_node(d, kind == YEP_T_SEQ_OPEN ? YEP_DOM_SEQUENCE : YEP_DOM_MAPPING, NULL,
+                              NULL, 0, 0, 0, 1);
+            if (id == UINT32_MAX || dom_place(d, id) != 0) {}
+            d->map_pending_key[d->depth] = 0;
+            d->stack[d->depth++] = id;
+            break;
+        }
+        case YEP_T_CLOSE:
+            if (d->depth == 0) {}
+            d->depth--;
+            break;
+        case YEP_T_NULL:
+        case YEP_T_TRUE:
+        case YEP_T_FALSE:
+        case YEP_T_INT:
+        case YEP_T_FLOAT:
+        case YEP_T_NUM:
+        case YEP_T_STR: {
+            yep_tag_id tag = YEPTRIS_TAG_STR;
+            uint8_t style = YEP_STYLE_PLAIN;
+            int implicit = 0;
+            switch (kind) {
+            case YEP_T_NULL:
+                tag = YEPTRIS_TAG_NULL;
+                implicit = 1;
+                break;
+            case YEP_T_TRUE:
+            case YEP_T_FALSE:
+                tag = YEPTRIS_TAG_BOOL;
+                implicit = 1;
+                break;
+            case YEP_T_INT:
+            case YEP_T_FLOAT:
+            case YEP_T_NUM:
+                tag = YEPTRIS_TAG_INT;
+                implicit = 1;
+                if (kind == YEP_T_NUM) {
+                    /* the lenient route's deferred contract: the span
+                     * carried NO number grammar at parse — classify
+                     * now (the tape convert's own authority) */
+                    size_t adv = 0;
+                    int flt = 0;
+                    if (yep_json_number_shape(src + off, len, &adv, &flt) == 0 || adv != len) {
+                        return -1; /* malformed: the strict route rejected at parse */
+                    }
+                    tag = flt ? YEPTRIS_TAG_FLOAT : YEPTRIS_TAG_INT;
+                } else if (kind == YEP_T_FLOAT) {
+                    tag = YEPTRIS_TAG_FLOAT;
+                }
+                break;
+            default:
+                style = YEP_STYLE_DOUBLE_QUOTED;
+                break;
+            }
+            uint32_t id =
+                dom_open_node(d, YEP_DOM_SCALAR, NULL, NULL, 0, style, (uint8_t)implicit, 0);
+            if (id == UINT32_MAX) {
+                return -1;
+            }
+            if (kind == YEP_T_STR) {
+                /* the record's span is the INNER bytes (quotes off) */
+                if (memchr(src + off, '\\', len) != NULL) {
+                    /* escaped: unescape into the arena (the fused
+                     * builder's arm, byte for byte) */
+                    char* dst = yep_dom_str_tail(d, len);
+                    if (dst == NULL) {}
+                    d->nodes[id].value = yep_dom_str_commit(
+                        d, yep_finish_double_into(src, off, off + len, dst, len));
+                } else {
+                    yep_view v = {src + off, len};
+                    d->nodes[id].value = dom_str_in(d, &v, 1);
+                }
+            } else {
+                yep_view v = {src + off, len};
+                d->nodes[id].value = dom_str_in(d, &v, 1);
+            }
+            d->nodes[id].tag_id = tag;
+            if (dom_place(d, id) != 0) {
+                return -1;
+            }
+            break;
+        }
+        default:
+            return -1; /* a CONT run or an unknown kind: neither reaches a
+                          strict-legal tape (CONT only past 16 MiB tokens) */
+        }
+    }
+    return d->depth == 0 ? 0 : -1;
+}
+
 void dom_on_flow_rollback(void* ctx) {
     yep_dom* d = (yep_dom*)ctx;
     if (d->flow_staged) {

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

@@ -18,6 +18,7 @@
 #include <stdint.h>
 
 #include <yeptris/api.h> /* YEPTRIS_CT_ASSERT (the layout gates) */
+#include <yeptris/tape.h> /* yeptris_json_tape (dom_from_tape) */ /* YEPTRIS_CT_ASSERT (the layout gates) */
 
 #include "../common/simd_text.h"
 
@@ -246,6 +247,15 @@ void yep_mut_set_depths(yep_dom* d, uint32_t id, uint16_t depth);
  * strictly-validated span [open, close] directly through the DOM's own
  * placement/link/anchor laws — node-for-node identical to the event
  * path (the flow-direct-diff ctest pins it). 1 = built, <0 = abort. */
+/* dom_from_tape — the lazy-DOM seam (#342 slice 1): builds the node
+ * tree from the tape's records, mirroring dom_on_flow_build's arms
+ * (borrowed spans for clean strings, an arena unescape for escaped
+ * ones, typed literals by kind). The records are pre-validated, so
+ * the walk is placement only. Returns 0, or -1 (allocation/depth/an
+ * unexpected record). STRICT tapes only — YEP_T_NUM (the lenient
+ * route's deferred numbers) is rejected. */
+int dom_from_tape(yep_dom* d, const yeptris_json_tape* t);
+
 int dom_on_flow_build(void* ctx, const char* p, size_t open, size_t len, uint32_t line,
                       size_t line_start, yep_view anchor, yep_view tag, uint32_t anchor_id,
                       int max_depth, size_t* close);

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

@@ -13,6 +13,7 @@
 #include <string.h>
 
 #include <yeptris/schema.h>
+#include <yeptris/values.h> /* YeptrisValue: ST_ANY records (#238) */
 
 #include "dom/dom.h"
 #include "memory/allocator.h"
@@ -27,7 +28,9 @@ typedef struct {
     const yep_dom* dom;
     int oom;
     int overflow;
-    int type_mismatch; /* node index */
+    int type_mismatch;  /* node index */
+    uint32_t* seen_map; /* per-node: the mapping instance that last
+                         * emitted — YEP_SF_FIRST_WINS skips a repeat */
 } yep_schema_ctx;
 
 static int col_put(yep_schema_ctx* c, uint32_t node, const void* rec, size_t size) {
@@ -84,6 +87,56 @@ static int emit_scalar(yep_schema_ctx* c, uint32_t node, uint32_t at) {
     case YEP_ST_NULL:
         col_put(c, node, &(uint8_t){0}, 0);
         return 1;
+    case YEP_ST_ANY: {
+        /* the resolver's verdict, verbatim: a YeptrisValue record
+         * (#238's headroom) — kind/tag_id from the node, the span
+         * borrowed, and the numeric payload converted when the
+         * verdict says so (the values-drain's conversion, DOM-side) */
+        YeptrisValue r = {0, 0, 0, 0, 0, 0, 0};
+        r.tag_id = n->tag_id;
+        r.off = (uint32_t)((const char*)v.p - c->dom->input_base);
+        r.len = v.len;
+        switch (n->tag_id) {
+        case YEPTRIS_TAG_NULL:
+            r.kind = YEP_V_NULL;
+            break;
+        case YEPTRIS_TAG_BOOL: {
+            r.kind = YEP_V_BOOL;
+            r.b = (uint8_t)(v.len > 0 && (v.p[0] == 't' || v.p[0] == 'T' || v.p[0] == 'y' ||
+                                          v.p[0] == 'Y' || v.p[0] == 'o' || v.p[0] == '1'));
+            break;
+        }
+        case YEPTRIS_TAG_INT:
+        case YEPTRIS_TAG_FLOAT: {
+            int64_t iv = 0;
+            double dv = 0;
+            int shape = 0;
+            size_t end = 0;
+            if (v.len != 0 && v.p != NULL &&
+                yep_json_number_scan(v.p, v.len, &end, &shape, &iv, &dv) != 0 && end == v.len) {
+                if (n->tag_id == YEPTRIS_TAG_INT) {
+                    r.kind = YEP_V_INT;
+                    r.p = (uint64_t)iv;
+                } else {
+                    r.kind = YEP_V_FLOAT;
+                    double fd = shape == 0 ? (double)iv : dv;
+                    memcpy(&r.p, &fd, sizeof(fd));
+                }
+            } else {
+                r.kind = YEP_V_STR; /* the resolver said number, the
+                                      bytes disagree: keep the span */
+            }
+            break;
+        }
+        case YEPTRIS_TAG_TIMESTAMP:
+            r.kind = YEP_V_TIMESTAMP;
+            break;
+        default:
+            r.kind = YEP_V_STR;
+            break;
+        }
+        return col_put(c, node, &r, sizeof(r));
+    }
     default:
         return -1;
     }
@@ -140,10 +193,17 @@ static int emit(yep_schema_ctx* c, uint32_t node, uint32_t at) {
                 size_t wl = strlen(cd->wire_name ? cd->wire_name : "");
                 if (cd->wire_name != NULL && key.len == wl &&
                     memcmp(key.p, cd->wire_name, wl) == 0) {
+                    if ((cd->flags & YEP_SF_FIRST_WINS) && c->seen_map != NULL &&
+                        c->seen_map[ci] == at + 1) {
+                        break; /* a repeat within THIS mapping: first wins */
+                    }
                     int rc = emit(c, ci, val);
                     if (rc != 1) {
                         return rc;
                     }
+                    if ((cd->flags & YEP_SF_FIRST_WINS) && c->seen_map != NULL) {
+                        c->seen_map[ci] = at + 1;
+                    }
                     break;
                 }
             }
@@ -178,6 +238,7 @@ YEPTRIS_API YeptrisStatus yeptris_schema_load(const char* source, size_t len, Ye
     const yep_allocator* sys = yep_system_allocator();
     yep_engine* eng = yep_engine_create(sys);
     yep_dom* dom = yep_dom_create(sys);
+    uint32_t* seen_map_ptr = NULL;
     YeptrisStatus st = YEPTRIS_OK;
     yep_sink sink = {.on_event = yep_dom_on_event,
                      .ctx = dom,
@@ -194,6 +255,9 @@ YEPTRIS_API YeptrisStatus yeptris_schema_load(const char* source, size_t len, Ye
     }
     if (schema == YEPTRIS_SCHEMA_11_COMPAT) {
         yep_engine_set_resolver(eng, yep_resolver_compat11());
+        dom->resolver = yep_resolver_compat11(); /* the DOM's direct
+                                  builders resolve their own tag_ids —
+                                  ST_ANY reads the NODE's verdict */
     }
     dom->input_base = source;
     dom->input_len = len;
@@ -204,7 +268,12 @@ YEPTRIS_API YeptrisStatus yeptris_schema_load(const char* source, size_t len, Ye
     }
 
     {
-        yep_schema_ctx c = {desc, desc_len, cols, dom, 0, 0, -1};
+        uint32_t* seen = seen_map_ptr = calloc(desc_len, sizeof(uint32_t));
+        if (seen == NULL) {
+            st = YEPTRIS_ERROR_MEMORY;
+            goto out;
+        }
+        yep_schema_ctx c = {desc, desc_len, cols, dom, 0, 0, -1, seen};
         int rc = emit(&c, 0, dom->docs[0]);
         if (rc < 0 && c.type_mismatch >= 0) {
             yep_error_set(yep_error_tls(), YEP_ERR_UNEXPECTED, 0, 0, (uint32_t)c.type_mismatch,
@@ -232,6 +301,7 @@ YEPTRIS_API YeptrisStatus yeptris_schema_load(const char* source, size_t len, Ye
     }
 
 out:
+    free(seen_map_ptr);
     yep_dom_destroy(dom);
     yep_engine_destroy(eng);
     return st;

metadata

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