yeptris 0.6.48.0-aarch64-linux → 0.6.50.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35fb61a844f3c216af5b507b1734b3b35ec903925bcbb17a8d2ea650fa501eaf
-  data.tar.gz: 4120fa28eef23c4d25e474030efd19c21a88d663a4db944d2e12f762673b475e
+  metadata.gz: '0782e25e15d541b7a7e5448f7c63e79e627a130946d131860133021262d15c28'
+  data.tar.gz: daf5279398e226c9ab663ab1482356938a675a7cdd84b0e872134e2f6651322f
 SHA512:
-  metadata.gz: 651d7bd9d2b054ebe3af1d2047f304e9a6aeb7e8f3c6dd0a04efb93143f2634b3ae6764d6392a783538589b45e9d6a9f4a7c979647005e565a0c3529ffc7ec7e
-  data.tar.gz: 2ea6d6b6c9c51c9cfcac877a097f4c86affd0d1af7b51b489891f1766b62880d0011c8c7054d00850315e88c919934c66faebf57dc301d9382ce806ec43ae6ef
+  metadata.gz: 423942744e7c5fbaa2c7dc4cde3f088abaf4aaacb88e4095c9e0fd0af1e3bf9774024522fcaa34d97e511ddba3b62e30a53753ee127a50ee3727f2a08fa08ca2
+  data.tar.gz: 102f3c0f8f3baa9d78ea65a3124c24c632d8f2e8940835e63c28061c81cb5b16039be3ac8c58e1751943ba3d10ef8287ee245260eb81b8a0a5b3d3a3ee63527e

data/ext/yeptris_native/version.h

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

data/lib/yeptris/cbor.rb

@@ -77,6 +77,11 @@ module Yeptris
     end
 
     def dump(obj, canonical: true)
+      # yeptris-ruby#322: the marshal face answers in one C call when
+      # the host has an exact spelling; nil routes to the tree walk
+      data = marshal_cbor_dump(obj, canonical)
+      return data if data
+
       docs = build_documents([obj])
       begin
         encode_one(docs[0], canonical)
@@ -123,6 +128,33 @@ module Yeptris
       take_buffer(::Yeptris::FFI.yeptris_cbor_encode(doc.c_ptr, opts, len_ptr), len_ptr)
     end
 
+    # yeptris-ruby#322: Marshal.dump bytes -> one CBOR item in ONE C
+    # call (yeptris_cbor_from_marshal, engine 0.6.49+). Returns nil
+    # when the route is unavailable or the host's bytes have no exact
+    # fast-path spelling (UNSUPPORTED), and the caller keeps the
+    # YAMLTree walk, which is exact by construction. Marshal-undumpable
+    # hosts raise TypeError; nil lets that walk own the DumpError
+    # contract too.
+    def marshal_cbor_dump(obj, canonical)
+      return nil unless defined?(::Yeptris::FFI::MARSHAL_CBOR) &&
+                        ::Yeptris::FFI::MARSHAL_CBOR
+      m = Marshal.dump(obj)
+      out_p = ::FFI::MemoryPointer.new(:pointer)
+      olen_p = ::FFI::MemoryPointer.new(:size_t)
+      st = ::Yeptris::FFI.yeptris_cbor_from_marshal(
+        m, m.bytesize, canonical ? CANONICAL : 0, out_p, olen_p
+      )
+      return nil unless st == ::Yeptris::FFI::OK
+      buf = out_p.read_pointer
+      return nil if buf.null?
+
+      data = buf.read_bytes(::Yeptris::FFI.read_c_size_t(olen_p))
+      ::Yeptris::FFI.yeptris_marshal_free(buf)
+      data.force_encoding(Encoding::BINARY)
+    rescue ::TypeError
+      nil
+    end
+
     # The encode convenience contract: a malloc'd buffer plus its
     # byte length — binary data, freed through the library's own free.
     def take_buffer(ptr, len_ptr)

data/lib/yeptris/ffi.rb

@@ -303,6 +303,12 @@ module Yeptris
     attach_function :yeptris_cbor_encode_sequence,
                     %i[pointer size_t uint32 pointer], :pointer
     CBOR_EX = !(@missing ||= []).include?(:yeptris_cbor_decode)
+    # yeptris-ruby#322: Marshal.dump bytes -> one CBOR item in one C
+    # call (engine 0.6.49+); MARSHAL_CBOR goes false on older libraries
+    # and CBOR.dump keeps the YAMLTree walk
+    attach_function :yeptris_cbor_from_marshal,
+                    %i[pointer size_t uint32 pointer pointer], :int
+    MARSHAL_CBOR = !(@missing ||= []).include?(:yeptris_cbor_from_marshal)
 
     # Owned char* results (serialize*): one reader, freed exactly once.
     # The release goes through yeptris_free (libyeptris's own

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

data/vendor/libyeptris/src/CMakeLists.txt

@@ -58,7 +58,8 @@ set(YEPTRIS_SOURCES
 )
 
 if(YEPTRIS_WITH_CBOR)
-    list(APPEND YEPTRIS_SOURCES yeptris/cbor/decode.c yeptris/cbor/encode.c)
+    list(APPEND YEPTRIS_SOURCES yeptris/cbor/decode.c yeptris/cbor/encode.c
+        yeptris/cbor/from_marshal.c)
 endif()
 
 # AOT SIMD TUs (TODO.impl/04): per-ISA compile flags; the TUs and the

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

@@ -94,6 +94,30 @@ YEPTRIS_API size_t yeptris_cbor_encode_into(YeptrisDocument doc, uint32_t opts,
  * byte count. */
 YEPTRIS_API void* yeptris_cbor_encode(YeptrisDocument doc, uint32_t opts, size_t* len);
 
+/* The binding's dump face (yeptris-ruby#322): Ruby Marshal 4.8 bytes
+ * IN, ONE CBOR data item OUT, one C call — the CBOR twin of
+ * yeptris_json_from_marshal (marshal.h), walked in C with no Document
+ * and no per-node host crossings. opts: YEPTRIS_CBOR_CANONICAL sorts
+ * each map's pairs by encoded-key bytes; 0 keeps insertion order.
+ *
+ * Covers the host subset the per-node route spells: nil/bool/int/
+ * float/string/array/hash, symbols (as ":name" text), 'I' wrappers,
+ * shared-object links (duplicated bytes), bignums up to four 16-bit
+ * words (inside int64 as integers, past either end as preferred
+ * floats), and the per-node route's map-key spellings (strings,
+ * symbols, integers, floats, booleans). Anything else — objects,
+ * structs, user marshal, invalid-UTF-8 strings, non-finite float text,
+ * wider bignums, nil/array/hash map keys, cycles — returns
+ * YEPTRIS_ERROR_UNSUPPORTED and the binding keeps its per-node walk.
+ *
+ * The bytes are byte-identical to yeptris_cbor_encode over the
+ * document the per-node walk builds (pinned by test_cbor_marshal.cpp).
+ * *out is malloc'd, free with yeptris_marshal_free (or free) exactly
+ * once; on failure nothing is allocated. Trailing bytes after the
+ * root are UNSUPPORTED (the stream is exactly one value). */
+YEPTRIS_API YeptrisStatus yeptris_cbor_from_marshal(const char* m, size_t m_len, uint32_t opts,
+                                                    char** out, size_t* out_len);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -31,11 +31,13 @@ YEPTRIS_API YeptrisDocument yeptris_parse_json(const char* data, size_t len, Yep
  * collections, JSON escapes, shortest floats, null/true/false words).
  * Returns a malloc'd NUL-terminated buffer (caller frees) with *len
  * (may be NULL) set, or NULL on a NULL document / allocation
- * failure / zero documents. */
+ * failure / zero documents / a document with no JSON spelling
+ * (unserializable). */
 YEPTRIS_API char* yeptris_serialize_json(YeptrisDocument doc, size_t* len);
 
 /* The compact variant: no padding spaces (JSON.generate's shape);
- * compact == 0 is byte-identical to yeptris_serialize_json. */
+ * compact == 0 is byte-identical to yeptris_serialize_json. Same
+ * NULL contract, the unserializable law included. */
 YEPTRIS_API char* yeptris_serialize_json_ex(YeptrisDocument doc, size_t* len, int compact);
 
 /* The pretty variant: JSON.pretty_generate's shape — one entry per

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

@@ -74,6 +74,11 @@ typedef struct yeptris_json_tape {
                                outlive the tape — same contract as the spans) */
     size_t _srclen;
     void* _block; /* the carved allocation base */
+    /* the >1024 simple-key verdict, settled DURING the lenient walk
+     * (one compare per map key) — the post-scan re-walk of the whole
+     * tape cost 16% of json-users parse (#739 profile, 2026-10-28) */
+    unsigned char _long_key_known;
+    unsigned char _long_key;
 } yeptris_json_tape;
 
 /* Parses strict JSON into the tape. Accepts scalar roots (a single

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

@@ -119,14 +119,36 @@ static int cbor_arg(yep_cdec* c, uint8_t ai, uint64_t* val) {
 }
 
 static uint32_t cbor_u64dec(uint64_t v, char* buf) {
+    /* two digits per divide: the per-digit %10//10 loop was the decode
+     * lane's hottest formatter (the #742 profile) — one /100 plus a
+     * table load halves the divides; the reverse pass shrinks to the
+     * pair loop */
+    static const char PAIRS[] = "00010203040506070809"
+                                "10111213141516171819"
+                                "20212223242526272829"
+                                "30313233343536373839"
+                                "40414243444546474849"
+                                "50515253545556575859"
+                                "60616263646566676869"
+                                "70717273747576777879"
+                                "80818283848586878889"
+                                "90919293949596979899";
     char tmp[20];
     uint32_t n = 0;
-    do {
-        tmp[n++] = (char)('0' + (v % 10));
-        v /= 10;
-    } while (v != 0);
+    while (v >= 100) {
+        uint32_t r = (uint32_t)(v % 100u);
+        v /= 100u;
+        tmp[n++] = PAIRS[r * 2u + 1u];
+        tmp[n++] = PAIRS[r * 2u];
+    }
+    if (v >= 10u) {
+        tmp[n++] = PAIRS[v * 2u + 1u];
+        tmp[n++] = PAIRS[v * 2u];
+    } else {
+        tmp[n++] = (char)('0' + (int)v);
+    }
     for (uint32_t k = 0; k < n; k++) {
-        buf[k] = tmp[n - 1 - k];
+        buf[k] = tmp[n - 1u - k];
     }
     return n;
 }
@@ -727,13 +749,41 @@ static int dom_sink_close(void* dp, int is_map) {
 
 static int dom_sink_int(void* dp, int negative, uint64_t mag, int is_key, const char* tag,
                         uint32_t tag_len) {
-    char buf[24];
+    /* the int path formats straight into the arena (the #742
+     * profile's 26% lane): no stack buffer, no second copy through
+     * the text sink — tail, format in place, commit */
+    (void)is_key;
+    yep_dom* d = dp;
+    yep_view tag_v;
+    const yep_view* tagp = NULL;
+    if (tag != NULL) {
+        char* tdst = yep_dom_str_tail(d, tag_len);
+        if (tdst == NULL) {
+            return 0;
+        }
+        memcpy(tdst, tag, tag_len);
+        yep_sview piece = yep_dom_str_commit(d, tag_len);
+        tag_v.p = d->str + (piece.off & YEP_SV_OFF);
+        tag_v.len = tag_len;
+        tagp = &tag_v;
+    }
+    uint32_t id = dom_open_node(d, YEP_DOM_SCALAR, tagp, NULL, 0, YEP_STYLE_PLAIN, 1, 0);
+    if (id == UINT32_MAX) {
+        return 0;
+    }
+    yep_dnode* node = &d->nodes[id];
+    char* dst = yep_dom_str_tail(d, 21); /* '-' plus twenty digits */
+    if (dst == NULL) {
+        return 0;
+    }
     uint32_t n = 0;
     if (negative) {
-        buf[n++] = '-';
+        dst[n++] = '-';
     }
-    n += cbor_u64dec(mag, buf + n);
-    return dom_sink_text(dp, buf, n, YEPTRIS_TAG_INT, is_key, tag, tag_len);
+    n += cbor_u64dec(mag, dst + n);
+    node->value = yep_dom_str_commit(d, n);
+    node->tag_id = YEPTRIS_TAG_INT;
+    return dom_place(d, id) == 0;
 }
 
 static int dom_sink_float(void* dp, double dv, int is_key, const char* tag, uint32_t tag_len) {

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

@@ -25,6 +25,7 @@
  * - aliases (YAML input) are UNSUPPORTED: the CBOR model has none
  */
 #include "cbor.h"
+#include "encode_priv.h"
 
 #include <math.h>
 #include <stdlib.h>
@@ -40,7 +41,7 @@
 
 /* ---- heads: minimal argument encoding (RFC 8949 s3) ----------------- */
 
-static size_t cbor_arg_bytes(uint64_t arg) {
+size_t yep_cbor_arg_bytes(uint64_t arg) {
     if (arg < 24)
         return 1;
     if (arg <= 0xFFull)
@@ -52,10 +53,10 @@ static size_t cbor_arg_bytes(uint64_t arg) {
     return 9;
 }
 
-static void cbor_put_head(uint8_t* out, size_t* pos, uint8_t mt, uint64_t arg) {
+void yep_cbor_put_head(uint8_t* out, size_t* pos, uint8_t mt, uint64_t arg) {
     /* payload bytes -> additional info: 1->24, 2->25, 4->26, 8->27 */
     static const uint8_t ai_of[9] = {0, 24, 25, 25, 26, 26, 26, 26, 27};
-    size_t n = cbor_arg_bytes(arg) - 1;
+    size_t n = yep_cbor_arg_bytes(arg) - 1;
     out[(*pos)++] = (uint8_t)((mt << 5) | (n == 0 ? (uint8_t)arg : ai_of[n]));
     for (size_t k = 0; k < n; k++) { /* network byte order */
         out[(*pos)++] = (uint8_t)(arg >> (8 * (n - 1 - k)));
@@ -143,7 +144,7 @@ static uint16_t cbor_d2h(double d) {
     return (uint16_t)(sign | m10);
 }
 
-static uint8_t cbor_float_width(double d) {
+uint8_t yep_cbor_float_width(double d) {
     if (d != d) {
         return 2; /* NaN: the canonical f9 7e00 (s4.2.2) */
     }
@@ -157,7 +158,7 @@ static uint8_t cbor_float_width(double d) {
     return 8;
 }
 
-static void cbor_put_float(uint8_t* out, size_t* pos, double d, uint8_t width) {
+void yep_cbor_put_float(uint8_t* out, size_t* pos, double d, uint8_t width) {
     out[(*pos)++] = (uint8_t)((7 << 5) | (width == 2 ? 25 : width == 4 ? 26 : 27));
     uint64_t bits = 0;
     if (width == 2) {
@@ -221,7 +222,7 @@ static int cbor_scalar_number(const yep_view* v, cbor_num* out) {
     }
     out->mt = 7;
     out->dval = dv;
-    out->fwidth = cbor_float_width(dv);
+    out->fwidth = yep_cbor_float_width(dv);
     return 1;
 }
 
@@ -247,17 +248,17 @@ static int cbor_bool_value(const yep_view* v) {
 /* The diagnostic round-trip (the 01 ledger): decode renders
  * undefined/simple(N) as text; encode recognizes them back. The words
  * are reserved — a literal "undefined" string encodes as the simple. */
-static int cbor_simple_of(const yep_view* v) {
-    if (v->len == 9 && memcmp(v->p, "undefined", 9) == 0) {
+int yep_cbor_simple_of(const char* p, size_t len) {
+    if (len == 9 && memcmp(p, "undefined", 9) == 0) {
         return 23;
     }
-    if (v->len > 9 && memcmp(v->p, "simple(", 7) == 0 && v->p[v->len - 1] == ')') {
+    if (len > 9 && memcmp(p, "simple(", 7) == 0 && p[len - 1] == ')') {
         uint64_t val = 0;
-        for (size_t i = 7; i + 1 < v->len; i++) {
-            if (v->p[i] < '0' || v->p[i] > '9') {
+        for (size_t i = 7; i + 1 < len; i++) {
+            if (p[i] < '0' || p[i] > '9') {
                 return -1;
             }
-            val = val * 10 + (uint64_t)(v->p[i] - '0');
+            val = val * 10 + (uint64_t)(p[i] - '0');
             if (val > 255) {
                 return -1;
             }
@@ -337,7 +338,7 @@ static uint8_t* cbor_encode_key(const yep_dom* d, const yep_dnode* key, size_t*
         goto bad;
     }
     for (int t = 0; t < ntags; t++) {
-        cbor_put_head(buf, &pos, 6, tags[t]);
+        yep_cbor_put_head(buf, &pos, 6, tags[t]);
     }
     if (key->tag_id == YEPTRIS_TAG_INT || key->tag_id == YEPTRIS_TAG_FLOAT) {
         cbor_num num;
@@ -345,13 +346,13 @@ static uint8_t* cbor_encode_key(const yep_dom* d, const yep_dnode* key, size_t*
             goto bad;
         }
         if (num.mt != 7) {
-            cbor_put_head(buf, &pos, num.mt, num.uval);
+            yep_cbor_put_head(buf, &pos, num.mt, num.uval);
         } else {
-            cbor_put_float(buf, &pos, num.dval, num.fwidth);
+            yep_cbor_put_float(buf, &pos, num.dval, num.fwidth);
         }
     } else { /* strings and diagnostics: a simple, else a text item */
         if (key->tag.len == 0) {
-            int sv = cbor_simple_of(&v);
+            int sv = yep_cbor_simple_of(v.p, v.len);
             if (sv >= 0) {
                 if (sv < 24) {
                     buf[pos++] = (uint8_t)(0xE0 | (uint8_t)sv);
@@ -363,7 +364,7 @@ static uint8_t* cbor_encode_key(const yep_dom* d, const yep_dnode* key, size_t*
                 return buf;
             }
         }
-        cbor_put_head(
+        yep_cbor_put_head(
             buf, &pos,
             v.len == 0 || yep_utf8_validate((const unsigned char*)v.p, v.len, NULL) ? 3 : 2, v.len);
         if (v.len > 0) {
@@ -498,7 +499,7 @@ static size_t cbor_size_scalar(cenc* e, const yep_dnode* n) {
         return 0;
     }
     for (int t = 0; t < ntags; t++) {
-        sz += cbor_arg_bytes(tags[t]);
+        sz += yep_cbor_arg_bytes(tags[t]);
     }
     yep_view v = yep_dom_view(d, n->value);
     switch (n->tag_id) {
@@ -510,19 +511,19 @@ static size_t cbor_size_scalar(cenc* e, const yep_dnode* n) {
             e->status = YEPTRIS_ERROR_UNSUPPORTED;
             return 0;
         }
-        return sz + (num.mt == 7 ? (size_t)(1 + num.fwidth) : cbor_arg_bytes(num.uval));
+        return sz + (num.mt == 7 ? (size_t)(1 + num.fwidth) : yep_cbor_arg_bytes(num.uval));
     }
     case YEPTRIS_TAG_BOOL:
     case YEPTRIS_TAG_NULL:
         return sz + 1;
     default: /* str: a recognized diagnostic, else a text item */
         if (n->tag.len == 0) {
-            int sv = cbor_simple_of(&v);
+            int sv = yep_cbor_simple_of(v.p, v.len);
             if (sv >= 0) {
                 return sz + ((uint32_t)sv < 24 ? 1 : 2);
             }
         }
-        return sz + cbor_arg_bytes(v.len) + v.len;
+        return sz + yep_cbor_arg_bytes(v.len) + v.len;
     }
 }
 
@@ -541,7 +542,7 @@ static size_t cbor_size_item(cenc* e, uint32_t id) {
         return 0;
     }
     for (int t = 0; t < ntags; t++) {
-        sz += cbor_arg_bytes(tags[t]);
+        sz += yep_cbor_arg_bytes(tags[t]);
     }
     if (n->kind == YEP_DOM_ALIAS) {
         e->failed = 1;
@@ -549,7 +550,7 @@ static size_t cbor_size_item(cenc* e, uint32_t id) {
         return 0;
     }
     if (n->kind == YEP_DOM_SEQUENCE) {
-        sz += cbor_arg_bytes(n->count);
+        sz += yep_cbor_arg_bytes(n->count);
         uint32_t c = n->first_child;
         for (uint32_t k = 0; k < n->count && !e->failed; k++) {
             sz += cbor_size_item(e, c);
@@ -559,7 +560,7 @@ static size_t cbor_size_item(cenc* e, uint32_t id) {
     }
     /* mapping */
     uint32_t pairs = n->count / 2;
-    sz += cbor_arg_bytes(pairs);
+    sz += yep_cbor_arg_bytes(pairs);
     /* hold the INDEX, not the pointer: sizing a child recurses into
      * nested maps whose preps REALLOC e->maps (#152 — a held cmap*
      * dangled and the next pair read walked freed memory; n>=11 of
@@ -610,9 +611,9 @@ static void cbor_write_scalar(cenc* e, const yep_dnode* n, uint8_t* out, size_t*
             return; /* pass 1 already failed on this; unreachable */
         }
         if (num.mt == 7) {
-            cbor_put_float(out, pos, num.dval, num.fwidth);
+            yep_cbor_put_float(out, pos, num.dval, num.fwidth);
         } else {
-            cbor_put_head(out, pos, num.mt, num.uval);
+            yep_cbor_put_head(out, pos, num.mt, num.uval);
         }
         return;
     }
@@ -624,7 +625,7 @@ static void cbor_write_scalar(cenc* e, const yep_dnode* n, uint8_t* out, size_t*
         return;
     default:
         if (n->tag.len == 0) {
-            int sv = cbor_simple_of(&v);
+            int sv = yep_cbor_simple_of(v.p, v.len);
             if (sv >= 0) {
                 if (sv < 24) {
                     out[(*pos)++] = (uint8_t)(0xE0 | (uint8_t)sv);
@@ -638,7 +639,7 @@ static void cbor_write_scalar(cenc* e, const yep_dnode* n, uint8_t* out, size_t*
         /* invalid UTF-8 can only have been a byte string (the 01
          * ledger: both decode to tag-str scalars) — emit mt2 so the
          * roundtrip re-decodes to the same bytes */
-        cbor_put_head(
+        yep_cbor_put_head(
             out, pos,
             v.len == 0 || yep_utf8_validate((const unsigned char*)v.p, v.len, NULL) ? 3 : 2, v.len);
         if (v.len > 0) { /* memcpy(_, NULL, 0) is UB (gcc UBSan) */
@@ -655,14 +656,14 @@ static void cbor_write_item(cenc* e, uint32_t id, uint8_t* out, size_t* pos) {
     uint64_t tags[16];
     int ntags = cbor_tag_chain(d, n, tags, 16);
     for (int t = 0; t < ntags; t++) {
-        cbor_put_head(out, pos, 6, tags[t]);
+        yep_cbor_put_head(out, pos, 6, tags[t]);
     }
     if (n->kind == YEP_DOM_SCALAR) {
         cbor_write_scalar(e, n, out, pos);
         return;
     }
     if (n->kind == YEP_DOM_SEQUENCE) {
-        cbor_put_head(out, pos, 4, n->count);
+        yep_cbor_put_head(out, pos, 4, n->count);
         uint32_t c = n->first_child;
         for (uint32_t k = 0; k < n->count; k++) {
             cbor_write_item(e, c, out, pos);
@@ -671,7 +672,7 @@ static void cbor_write_item(cenc* e, uint32_t id, uint8_t* out, size_t* pos) {
         return;
     }
     uint32_t pairs = n->count / 2;
-    cbor_put_head(out, pos, 5, pairs);
+    yep_cbor_put_head(out, pos, 5, pairs);
     cmap* cm = NULL;
     if (e->canonical && e->next_map < e->nmaps) {
         cm = &e->maps[e->next_map++]; /* walk order == build order */

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

@@ -0,0 +1,32 @@
+/* encode_priv.h — the CBOR encoder's shared kernels (internal).
+ *
+ * encode.c owns the DOM walk; from_marshal.c (the binding dump face)
+ * appends the same item bytes from a Marshal stream. The minimal-head
+ * table, the preferred-float width rule and the reserved diagnostic
+ * words are ONE law each — both writers call them from here. */
+
+#ifndef YEPTRIS_CBOR_ENCODE_PRIV_H
+#define YEPTRIS_CBOR_ENCODE_PRIV_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+/* RFC 8949 s3: the encoded size of argument arg. */
+size_t yep_cbor_arg_bytes(uint64_t arg);
+
+/* RFC 8949 s3: one head (major type + minimally encoded argument). */
+void yep_cbor_put_head(uint8_t* out, size_t* pos, uint8_t mt, uint64_t arg);
+
+/* s4.2.2: the smallest of half/single/double that round-trips. */
+uint8_t yep_cbor_float_width(double d);
+
+/* s4.2.2: one float at the requested width (NaN canonicalizes). */
+void yep_cbor_put_float(uint8_t* out, size_t* pos, double d, uint8_t width);
+
+/* The diagnostic round-trip ledger: decode renders undefined and
+ * simple(N) as text, so the encoder recognizes those words back — with
+ * the >9-byte gate that leaves single-digit simple(N) as text. Returns
+ * the simple value, or -1 when the text is not a reserved word. */
+int yep_cbor_simple_of(const char* p, size_t len);
+
+#endif /* YEPTRIS_CBOR_ENCODE_PRIV_H */