yeptris 0.6.10.1 → 0.6.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 911e4f9b49027d9a90c269d485980d025040866830e8138d6dbb7e573e6e49ca
-  data.tar.gz: c48b0a777f5e7f7f3771bdb44661f7a5d3f11e3713895b3d0029847ce56cb7ef
+  metadata.gz: ffeaeb76cbc3a0a575cf5fce09e5ceff42ae233fa38125c4fb575eb15c2aafab
+  data.tar.gz: d6667ffc31e29fd13f97d7bd5378b6a3611c39f849f7a69075d9e90c6e262df6
 SHA512:
-  metadata.gz: cf0d8e4fb6c0833b3a1232293cc55ce4e51e4a88af05b84eee940288c197eaf2c837c3f75382cdcb643a64680869e314ae09b3076b711953cd40cd244535aedb
-  data.tar.gz: 3276f1b2af11b03a225b0b52bc7bc38982c38a65fe50b3890ab7a02d9d8c202a7e2703efc8879b8d96e9f51483e01115961c263fc89093acf01733ca71f0d454
+  metadata.gz: 52298af429a38b41b55adf972d89156e5c214367debc1ccf618fd8e1a438414004861c8b6a7e9a1cc1e5235c68ba07a734ae580da668b3b7751b708102c9d46c
+  data.tar.gz: c40301fda3424c9ef0d3d314a71dbf05b9a50af488c12b470f14cb8523912416ceb762de6e73ca6b44a97ac04b549d565113b688333320dabe9f3a2861895e50

data/lib/yeptris/ffi.rb

@@ -337,6 +337,7 @@ module Yeptris
     TAG_BOOL = 3
     TAG_NULL = 4
     TAG_TIMESTAMP = 5
+    TAG_BINARY = 8
 
     # the schema-descriptor API (issue #238; TODO.restructure/83)
     DESC_ABI = 1

data/lib/yeptris/materializer.rb

@@ -37,6 +37,7 @@ module Yeptris
     TAG_BOOL = Yeptris::FFI::TAG_BOOL
     TAG_NULL = Yeptris::FFI::TAG_NULL
     TAG_TIMESTAMP = Yeptris::FFI::TAG_TIMESTAMP
+  TAG_BINARY = Yeptris::FFI::TAG_BINARY
     TAG_MERGE = 9 # YEPTRIS_TAG_MERGE (resolve.h): a plain '<<' key
 
     INF_WORDS = {
@@ -152,6 +153,8 @@ module Yeptris
           float_or_string(value)
         when TAG_TIMESTAMP
           parse_timestamp(value)
+        when TAG_BINARY
+          value.unpack1("m") # psych to_ruby: !binary -> decode64, ASCII-8BIT (#168)
         else
           value
         end

data/lib/yeptris/node.rb

@@ -121,6 +121,7 @@ class Yeptris::Node
     Yeptris::FFI::TAG_BOOL => :bool,
     Yeptris::FFI::TAG_NULL => :null,
     Yeptris::FFI::TAG_TIMESTAMP => :timestamp,
+    Yeptris::FFI::TAG_BINARY => :binary,
   }.freeze
 
   def tag_id
@@ -351,6 +352,7 @@ class Yeptris::Node
         to_f
       end
     when :timestamp then ::Yeptris::Materializer.parse_timestamp(value)
+    when :binary then value.unpack1("m") # ASCII-8BIT bytes (#168)
     else
       # beyond int64 the C resolver leaves plain scalars :str; Psych
       # materializes Integer (issue #31) — rebuild from the text

data/lib/yeptris/psych/drop_in.rb

@@ -22,6 +22,27 @@ end
 Object.class_eval { remove_const(:Psych) } if defined?(::Psych) && !::Psych.equal?(Yeptris::Psych)
 ::Psych = Yeptris::Psych
 
+# #167: third-party gems feature-gate on Psych::VERSION at require
+# time (mechanize 2.14.1's cookie-jar reads it in a class body). The
+# face reports the STDLIB version it replaces: ORIGINAL's when psych
+# was preloaded, else the default-gem spec's version (local lookup —
+# requiring stdlib psych post-rebind is censored by the header).
+unless Yeptris::Psych.const_defined?(:VERSION, false)
+  version =
+    if Yeptris::Psych.const_defined?(:ORIGINAL, false)
+      Yeptris::Psych::ORIGINAL::VERSION
+    else
+      spec = begin
+        ::Gem.loaded_specs["psych"] ||
+          ::Gem::Specification.find_by_name("psych", ::Gem::Requirement.default)
+      rescue ::StandardError, ::Gem::Exception, ::LoadError
+        nil
+      end
+      spec&.version&.to_s
+    end
+  Yeptris::Psych.const_set(:VERSION, version) if version
+end
+
 # yaml-first boot order: ::YAML still references the ORIGINAL stdlib
 # module object, whose singleton methods route through stdlib's parse
 # stream — the UTF-8 tagging (and every other normalization) never

data/lib/yeptris/psych.rb

@@ -165,7 +165,18 @@ module Yeptris
       def force_utf8_scalars(obj)
         case obj
         when ::String
-          obj.force_encoding(::Encoding::UTF_8) if obj.encoding == ::Encoding::ASCII_8BIT && !obj.ascii_only?
+          # valid_encoding? on an ASCII-8BIT string is ALWAYS true
+          # (it is bytes) — the discriminator is whether the bytes
+          # READ as UTF-8: #135's case (UTF-8 scalars the C side
+          # materialized as BINARY) re-tags; DECODED !binary bytes
+          # that are not UTF-8 stay BINARY (#168). Binary content that
+          # happens to be valid UTF-8 re-tags — noted divergence from
+          # stdlib, which keeps BINARY; real payloads (zips, bodies)
+          # never are.
+          if obj.encoding == ::Encoding::ASCII_8BIT && !obj.ascii_only?
+            probe = obj.dup.force_encoding(::Encoding::UTF_8)
+            obj.force_encoding(::Encoding::UTF_8) if probe.valid_encoding?
+          end
           obj
         when ::Hash
           obj.each { |k, v| force_utf8_scalars(k); force_utf8_scalars(v) }
@@ -307,7 +318,9 @@ module Yeptris
         when :scalar, :mapping, :sequence
           tag = node.tag
           unless tag.nil?
-            name = tag.split(":").last
+            # both tag spellings pass: the URI form's last segment and
+            # the short "!binary" shorthand (#168's cassettes carry it)
+            name = tag.split(":").last.sub(/\A!/, "")
             unless %w[str int float bool null timestamp seq map merge value
                       binary].include?(name)
               raise DisallowedClass, name

data/lib/yeptris/yaml.rb

@@ -192,7 +192,19 @@ module Yeptris
             obj.each { |e| place(e, emit, blob, off, seen) }
             emit.call(STOP, 0, 0, 0)
           end
-        when String then scalar(obj, STYLE_BY_NAME[string_style(obj)], emit, blob, off)
+        when String
+          if obj.encoding == ::Encoding::ASCII_8BIT && !obj.ascii_only?
+            # #168: psych visit_String's binary branch — strict base64
+            # + the short !binary tag + literal style (Builder
+            # build_string carries the same branch; the tagged-literal
+            # writer keeps the block form)
+            scalar([obj].pack("m0"), STYLE_LIT, emit, blob, off)
+            emit.call(BUILD_TAG, 0, off[0], 7)
+            blob << "!binary"
+            off[0] += 7
+          else
+            scalar(obj, STYLE_BY_NAME[string_style(obj)], emit, blob, off)
+          end
         when Symbol then scalar(":#{obj}", STYLE_PLAIN, emit, blob, off)
         when Integer then scalar(obj.to_s, STYLE_PLAIN, emit, blob, off)
         when Float then scalar(float_text(obj), STYLE_PLAIN, emit, blob, off)
@@ -351,6 +363,17 @@ module Yeptris
       # visit_String matrix) serves both builders; this side carries
       # the style onto the per-node DOM.
       def build_string(doc, s)
+        # psych 5.5 visit_String's binary branch, verbatim: an
+        # ASCII-8BIT string with non-ASCII bytes emits as strict base64
+        # (pack('m0'), never wrapped) under the short !binary tag with
+        # literal style — the writer keeps the block form for tagged
+        # literals (#168). BOTH dump paths converge here (the top-level
+        # scalar fast route and the YAMLTree visitor).
+        if s.encoding == ::Encoding::ASCII_8BIT && !s.ascii_only?
+          bin = new_scalar(doc, [s].pack("m0"), :force_lit)
+          bin.set_tag("!binary")
+          return bin
+        end
         case BulkBuilder.string_style(s)
         when :single then new_scalar(doc, s, :force_str_sq)
         when :double then new_scalar(doc, s, :force_str)

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

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

@@ -221,12 +221,16 @@ YEPTRIS_API YeptrisStatus yeptris_document_build(YeptrisDocument handle,
     int depth = 0;
     uint32_t root = UINT32_MAX;
     uint32_t root_closed = 0;
+    uint32_t root_tagged = 0;          /* one trailing TAG on the closed root (#168) */
     uint32_t pending_key = UINT32_MAX; /* map frame's buffered key */
     uint32_t last_id = UINT32_MAX;     /* TAG applies here (#300) */
     YeptrisStatus rc = YEPTRIS_OK;
     for (size_t i = 0; i < count && rc == YEPTRIS_OK; i++) {
         const YeptrisBuildEntry* e = &entries[i];
-        if (root_closed) {
+        /* A closed SCALAR root admits exactly one trailing TAG —
+         * psych's binary root is `--- !binary |-` (#168); everything
+         * after (more ops, a second tag) still rejects */
+        if (root_closed && !(e->op == YEPTRIS_BUILD_TAG && !root_tagged && last_id == root)) {
             rc = YEPTRIS_ERROR_PARSE; /* the document ended; more entries */
             break;
         }
@@ -283,6 +287,7 @@ YEPTRIS_API YeptrisStatus yeptris_document_build(YeptrisDocument handle,
                 rc = YEPTRIS_ERROR_MEMORY;
                 break;
             }
+            root_tagged = root_closed;
             continue;
         default:
             rc = YEPTRIS_ERROR_PARSE; /* unknown op */

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

@@ -480,17 +480,11 @@ yep_dom* yep_dom_create(const yep_allocator* sys) {
     memset(d, 0, sizeof(*d));
     d->sys = sys;
     d->pool = pool;
-    d->handles = yep_hpool_create(sys);
-    if (d->handles == NULL) {
-        yep_pool_destroy(pool);
-        yep_free(sys, d);
-        return NULL;
-    }
+    /* #157: the handle pool is lazy — two allocations and a mutex per
+     * document that decode-only consumers (CBOR load, serialize, free)
+     * never touch; yep_dom_handles() materializes it on first use */
+    d->handles = NULL;
     if (yep_mutex_init(&d->midx.mu) != 0) {
-        yep_free(d->sys, d->anchor_nodes);
-        yep_free(d->sys, d->mut_att);
-        yep_free(d->sys, d->mut_depth);
-        yep_hpool_destroy(d->handles);
         yep_pool_destroy(pool);
         yep_free(sys, d);
         return NULL;
@@ -499,6 +493,25 @@ yep_dom* yep_dom_create(const yep_allocator* sys) {
     return d;
 }
 
+/* Lazy handle pool, mirroring the map-index's discipline (mapindex.c):
+ * EVERY access rides the dom's lazy-init mutex — read-only sharing
+ * means multiple threads may race the FIRST handle creation on a
+ * shared document (Threads.ReadOnlySharing; the TSAN catch on the
+ * first cut). The uncontended lock costs less than the hpool's own
+ * per-allocation lock that follows. */
+struct yep_hpool* yep_dom_handles(yep_dom* d) {
+    if (d == NULL || !d->midx.mu_ready) {
+        return NULL;
+    }
+    yep_mutex_lock(&d->midx.mu);
+    if (d->handles == NULL) {
+        d->handles = yep_hpool_create(d->sys);
+    }
+    struct yep_hpool* h = d->handles;
+    yep_mutex_unlock(&d->midx.mu);
+    return h;
+}
+
 void yep_dom_destroy(yep_dom* d) {
     if (d == NULL) {
         return;

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

@@ -197,6 +197,8 @@ void dom_mut_set_depth(yep_dom* d, uint32_t id, uint16_t depth);
 
 /* thread-safe handle arena (see hpool.c) */
 struct yep_hpool* yep_hpool_create(const yep_allocator* sys);
+/* Lazy handle-pool acquisition (#157): NULL dom or OOM stays NULL. */
+struct yep_hpool* yep_dom_handles(yep_dom* d);
 void yep_hpool_destroy(struct yep_hpool* p);
 void* yep_hpool_alloc(struct yep_hpool* p, size_t size, size_t align);
 

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

@@ -39,6 +39,11 @@ YEPTRIS_API size_t yeptris_serialize_into_ex(YeptrisDocument handle,
         return 0;
     }
     yep_emitter em;
+    em.w.sc_dec = NULL;
+    em.w.sc_i = 0;
+    em.w.cap = 0;
+    em.w.grow = 0;
+    em.w.oom = 0;
     em.doc = (const yeptris_document*)handle;
     em.w.p = NULL;
     em.w.last = 0;
@@ -60,13 +65,20 @@ YEPTRIS_API size_t yeptris_serialize_into_ex(YeptrisDocument handle,
     if (!yep_nametab_init(&em.canon_names, yep_system_allocator())) {
         return 0;
     }
+    em.w.sc_dec = (uint8_t*)malloc(em.doc->dom->ncount > 0 ? em.doc->dom->ncount : 1);
+    if (em.w.sc_dec == NULL) {
+        yep_nametab_free(&em.canon_names);
+        return 0;
+    }
     size_t need = yep_emit_run(&em, 1);
     if (buf == NULL || cap < need + 1) {
+        free(em.w.sc_dec);
         yep_nametab_free(&em.canon_names);
         return need;
     }
     em.w.p = buf;
     size_t wrote = yep_emit_run(&em, 0);
+    free(em.w.sc_dec);
     yep_nametab_free(&em.canon_names);
     buf[wrote] = '\0';
     return wrote;
@@ -82,6 +94,11 @@ YEPTRIS_API char* yeptris_serialize_ex(YeptrisDocument handle, const yeptris_emi
         return NULL;
     }
     yep_emitter em;
+    em.w.sc_dec = NULL;
+    em.w.sc_i = 0;
+    em.w.cap = 0;
+    em.w.grow = 0;
+    em.w.oom = 0;
     em.doc = (const yeptris_document*)handle;
     em.w.p = NULL;
     em.w.last = 0;
@@ -103,13 +120,41 @@ YEPTRIS_API char* yeptris_serialize_ex(YeptrisDocument handle, const yeptris_emi
     if (!yep_nametab_init(&em.canon_names, yep_system_allocator())) {
         return NULL;
     }
-    size_t need = yep_emit_run(&em, 1);
-    char* out = malloc(need + 1);
+    /* #352 slice 2: ONE wet pass into a growable buffer — the dry
+     * exact-sizing pass measured 0.54-0.73x of this route on CI-fresh
+     * runners (the emit-split table's 2p/1p column). The estimate
+     * starts at the input size (+64) and doubles on demand; a final
+     * shrink-to-fit keeps the returned allocation tight. No dry pass,
+     * so no decisions table. */
+    size_t est = em.doc->dom->input_len + 64;
+    if (est < 256) {
+        est = 256;
+    }
+    char* out = (char*)malloc(est);
     if (out == NULL) {
+        yep_nametab_free(&em.canon_names);
         return NULL;
     }
     em.w.p = out;
+    em.w.cap = est;
+    em.w.grow = 1;
     size_t wrote = yep_emit_run(&em, 0);
+    em.w.grow = 0;
+    /* wr_grow reallocs through w->p — the local `out` is stale after
+     * any growth; every post-run touch goes through the writer's
+     * pointer (the first round's abort was exactly this aliasing) */
+    out = em.w.p;
+    if (em.w.oom) {
+        free(out);
+        yep_nametab_free(&em.canon_names);
+        return NULL;
+    }
+    if (wrote + 1 < em.w.cap) {
+        char* tight = (char*)realloc(out, wrote + 1);
+        if (tight != NULL) {
+            out = tight;
+        }
+    }
     yep_nametab_free(&em.canon_names);
     out[wrote] = '\0';
     if (len != NULL) {
@@ -123,6 +168,11 @@ YEPTRIS_API char* yeptris_serialize_json(YeptrisDocument handle, size_t* len) {
         return NULL;
     }
     yep_emitter em;
+    em.w.sc_dec = NULL;
+    em.w.sc_i = 0;
+    em.w.cap = 0;
+    em.w.grow = 0;
+    em.w.oom = 0;
     em.doc = (const yeptris_document*)handle;
     em.w.p = NULL;
     em.w.last = 0;
@@ -168,6 +218,11 @@ YEPTRIS_API char* yeptris_serialize_json_ex(YeptrisDocument handle, size_t* len,
         return NULL;
     }
     yep_emitter em;
+    em.w.sc_dec = NULL;
+    em.w.sc_i = 0;
+    em.w.cap = 0;
+    em.w.grow = 0;
+    em.w.oom = 0;
     em.doc = (const yeptris_document*)handle;
     em.w.p = NULL;
     em.w.last = 0;
@@ -210,6 +265,11 @@ char* yep_serialize_json_compact(const yeptris_document* doc, size_t* len) {
         return NULL;
     }
     yep_emitter em;
+    em.w.sc_dec = NULL;
+    em.w.sc_i = 0;
+    em.w.cap = 0;
+    em.w.grow = 0;
+    em.w.oom = 0;
     em.doc = doc;
     em.w.p = NULL;
     em.w.last = 0;
@@ -252,6 +312,11 @@ char* yep_serialize_json_pretty(const yeptris_document* doc, size_t* len) {
         return NULL;
     }
     yep_emitter em;
+    em.w.sc_dec = NULL;
+    em.w.sc_i = 0;
+    em.w.cap = 0;
+    em.w.grow = 0;
+    em.w.oom = 0;
     em.doc = doc;
     em.w.p = NULL;
     em.w.last = 0;
@@ -307,6 +372,11 @@ YEPTRIS_API size_t yeptris_serialize_stream(YeptrisDocument handle,
         return 0;
     }
     yep_emitter em;
+    em.w.sc_dec = NULL;
+    em.w.sc_i = 0;
+    em.w.cap = 0;
+    em.w.grow = 0;
+    em.w.oom = 0;
     em.doc = (const yeptris_document*)handle;
     em.w.p = NULL;
     em.w.last = 0;

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

@@ -64,6 +64,24 @@ static void wr_col_update(yep_writer* w, const char* p, uint32_t n) {
     w->col += (int)n;
 }
 
+static void wr_grow(yep_writer* w, size_t need) {
+    if (w->oom || w->p == NULL) {
+        w->oom = w->p == NULL;
+        return;
+    }
+    size_t want = w->len + need + 1;
+    if (want < w->cap * 2) {
+        want = w->cap * 2;
+    }
+    char* np = (char*)realloc(w->p, want);
+    if (np == NULL) {
+        w->oom = 1;
+        return;
+    }
+    w->p = np;
+    w->cap = want;
+}
+
 static void wr_put(yep_writer* w, const char* p, uint32_t n) {
     if (n > 0) {
         w->last = p[n - 1];
@@ -73,6 +91,13 @@ static void wr_put(yep_writer* w, const char* p, uint32_t n) {
         w->len += n;
         return;
     }
+    if (w->grow && w->len + n > w->cap) {
+        wr_grow(w, n);
+    }
+    if (w->oom) {
+        w->len += n; /* keep counting: the caller fails on oom */
+        return;
+    }
     memcpy(w->p + w->len, p, n);
     w->len += n;
     wr_maybe_flush(w);
@@ -89,6 +114,13 @@ static void wr_byte(yep_writer* w, char c) {
         w->len++;
         return;
     }
+    if (w->grow && w->len + 1 > w->cap) {
+        wr_grow(w, 1);
+    }
+    if (w->oom) {
+        w->len++;
+        return;
+    }
     w->p[w->len] = c;
     w->len++;
     wr_maybe_flush(w);
@@ -275,21 +307,17 @@ static void emit_canonical_scalar(yep_writer* w, const yep_dnode* n) {
     }
 }
 
-static void emit_scalar(yep_writer* w, const yep_dnode* n, int parent_col, int as_key) {
-    yep_view vdec = wv(w, n->value);
-    const char* p = (const char*)vdec.p;
-    uint32_t len = vdec.len;
-    if (w->canonical || w->json) {
-        emit_canonical_scalar(w, n);
-        return;
-    }
-    /* p may be NULL for an empty view; memchr(NULL, .., 0) is UB by
-     * the nonnull attribute even though it reads nothing */
+/* The fidelity-mode emission route for one scalar (#352): the dry
+ * pass derives it exactly once; the wet pass consumes the recorded
+ * byte and skips the multiline/blockable/safety analysis entirely. */
+enum { YEP_SC_NOTHING = 0, YEP_SC_PLAIN, YEP_SC_SQ, YEP_SC_DQ, YEP_SC_LITERAL };
+#define YEP_SC_MEMO_MIN 32u /* bytes; derive-below, memoize-above */
+
+static uint8_t sc_route(yep_writer* w, const char* p, uint32_t len, int as_key, uint8_t sty_in,
+                        int has_tag) {
     int multiline = (len > 0 && memchr(p, '\n', len) != NULL);
     int blockable = 0;
     if (multiline && !as_key) {
-        /* A block whose body is all whitespace parses back empty, and a
-         * raw CR re-parses as a break — both emit double-quoted. */
         int allws = 1;
         int has_cr = 0;
         for (uint32_t i = 0; i < len; i++) {
@@ -302,68 +330,95 @@ static void emit_scalar(yep_writer* w, const yep_dnode* n, int parent_col, int a
         }
         blockable = !allws && !has_cr;
     }
-    int sty = n->style;
+    uint8_t sty = sty_in;
     if (sty == 4 || sty == 5) {
         if (multiline && as_key) {
-            emit_dq(w, p, len); /* keys stay inline: no block scalars */
-            return;
+            return YEP_SC_DQ;
         }
         if (multiline && blockable) {
-            emit_literal(w, n, parent_col);
-            return;
+            return YEP_SC_LITERAL;
         }
         if (multiline) {
-            emit_dq(w, p, len);
-            return;
+            return YEP_SC_DQ;
         }
         if (len == 0) {
-            emit_dq(w, p, len); /* an explicitly-empty block scalar is
-                                   the empty STRING — a bare empty would
-                                   re-read as null (2G84#3, K858) */
-            return;
+            return YEP_SC_DQ;
+        }
+        /* A TAGGED block scalar keeps the block form even single-line
+         * (psych's !binary emits `!binary |-` + one base64 line; an
+         * untagged single-line literal re-emits plain — libyaml parity,
+         * the #290 family) */
+        if (has_tag) {
+            return YEP_SC_LITERAL;
         }
-        sty = 1; /* a chomp-stripped block is plain bytes: re-emit plain */
+        sty = 1;
     }
     switch (sty) {
-    case 1: /* plain */
+    case 1:
         if (len == 0) {
-            if (as_key) {
-                emit_dq(w, p, len); /* empty keys must stay visible */
-            }
-            break; /* an empty plain value emits as nothing (libyaml's
-                       null rendering, issue #290) */
+            return as_key ? YEP_SC_DQ : YEP_SC_NOTHING;
         }
-        if ((as_key ? yep_style_plain_key_safe(p, len) : yep_style_plain_safe(p, len))) {
-            wr_put(w, p, len);
-        } else if (!multiline) {
-            /* libyaml parity: a scalar that must be quoted but needs no
-             * escapes (digit-leading strings like "5014", indicator
-             * leads) single-quotes — double quotes are for text that
-             * actually requires escapes (issue #95's matrix) */
-            int clean = 1;
+        if (as_key ? yep_style_plain_key_safe(p, len) : yep_style_plain_safe(p, len)) {
+            return YEP_SC_PLAIN;
+        }
+        if (!multiline) {
             for (uint32_t i = 0; i < len; i++) {
                 if ((unsigned char)p[i] < 0x20 || (unsigned char)p[i] == 0x7f) {
-                    clean = 0;
-                    break;
+                    return YEP_SC_DQ;
                 }
             }
-            if (clean) {
-                emit_sq(w, p, len);
-            } else {
-                emit_dq(w, p, len);
-            }
-        } else {
-            emit_dq(w, p, len);
+            return YEP_SC_SQ;
         }
-        break;
-    case 2: /* single */
-        if (!multiline) {
-            emit_sq(w, p, len);
+        return YEP_SC_DQ;
+    case 2:
+        return multiline ? YEP_SC_DQ : YEP_SC_SQ;
+    default:
+        return YEP_SC_DQ;
+    }
+}
+
+static void emit_scalar(yep_writer* w, const yep_dnode* n, int parent_col, int as_key) {
+    yep_view vdec = wv(w, n->value);
+    const char* p = (const char*)vdec.p;
+    uint32_t len = vdec.len;
+    if (w->canonical || w->json) {
+        emit_canonical_scalar(w, n);
+        return;
+    }
+    (void)0;
+    uint8_t route;
+    /* The memo pays only for LONG scalars: the derive cost scales with
+     * len (safety walk, quote scans) while the memo is a fixed store +
+     * cold load — on the short scalars of table-shaped documents the
+     * memo measured SLOWER than re-deriving (the #357 first artifact:
+     * json-users -36%, scalar-heavy +24%). Below the threshold both
+     * passes derive; the consumption-order index covers only the
+     * memoized long scalars, in visit order either way. */
+    if (w->sc_dec != NULL && len >= YEP_SC_MEMO_MIN) {
+        if (w->dry) {
+            route = sc_route(w, p, len, as_key, n->style, n->tag.len > 0);
+            w->sc_dec[w->sc_i] = route;
         } else {
-            emit_dq(w, p, len);
+            route = w->sc_dec[w->sc_i];
         }
+        w->sc_i++;
+    } else {
+        route = sc_route(w, p, len, as_key, n->style, n->tag.len > 0);
+    }
+    switch (route) {
+    case YEP_SC_NOTHING:
+        break; /* an empty plain value emits as nothing (libyaml's null
+                  rendering, issue #290) */
+    case YEP_SC_PLAIN:
+        wr_put(w, p, len);
+        break;
+    case YEP_SC_SQ:
+        emit_sq(w, p, len);
+        break;
+    case YEP_SC_LITERAL:
+        emit_literal(w, n, parent_col);
         break;
-    default: /* double, literal-as-key, folded-as-key, any */
+    default:
         emit_dq(w, p, len);
         break;
     }
@@ -694,6 +749,7 @@ size_t yep_emit_run(yep_emitter* em, int dry) {
     w->flushed = 0;
     w->sink_aborted = 0;
     w->col = 0;
+    w->sc_i = 0;
     yep_nametab_clear(&em->canon_names);
     if (w->json) {
         /* JSON has no multi-document streams and no document marker */

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

@@ -40,6 +40,21 @@ typedef struct yep_writer {
     int col;                                    /* current output column (wr_* maintains) */
     const char* sv_input;                       /* compact-view decode bases (dom regions) */
     const char* sv_arena;
+    /* #352: per-scalar route decisions, derived once in the dry
+     * sizing pass and consumed by the wet write pass (one byte per
+     * scalar, indexed by consumption order; NULL = derive per pass) */
+    uint8_t* sc_dec;
+    uint32_t sc_i;
+    /* #352 slice 2: the growable single-pass route — the exact-sizing
+     * dry pass measured 0.54-0.73x of the one-pass stream route on
+     * CI-fresh runners, so serialize_ex writes wet into a buffer that
+     * doubles on demand (cap/grow), like the streaming window. The
+     * fixed-buffer routes keep grow=0 and today's trust-the-count
+     * behavior. oom marks a failed growth: writes stop touching memory
+     * but the byte count keeps running so callers can fail cleanly. */
+    size_t cap;
+    int grow;
+    int oom;
 } yep_writer;
 
 typedef struct yep_emitter {

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

@@ -40,6 +40,7 @@
 
 #include <yeptris/error.h>
 #include <yeptris/marshal.h>
+#include <yeptris/resolve.h> /* YEPTRIS_TAG_BINARY (#168) */
 
 typedef struct {
     const char* name; /* into the value arena */
@@ -487,6 +488,9 @@ static int pre_scan(const yep_value_ctx* c, uint64_t** counts_out, size_t* nopen
         case YEP_V_TIMESTAMP:
             return -2;
         case YEP_V_STR:
+            if (vals[i].tag_id == YEPTRIS_TAG_BINARY) {
+                return -2; /* !binary: the walk base64-decodes (#168) */
+            }
             if (vals[i].is_key == 1 && vals[i].len == 2 && c->arena[vals[i].off] == '<' &&
                 c->arena[vals[i].off + 1] == '<') {
                 return -2; /* merge key: the walk resolves these */

data/vendor/libyeptris/src/yeptris/memory/pool.c

@@ -45,6 +45,15 @@ void* yep_pool_alloc(yep_pool* pool, size_t size, size_t align) {
     }
 
     yep_block* b = pool->head;
+    if (b == NULL) { /* the lazy first block (#157) */
+        b = yep_block_new(pool->sys, pool->block_size);
+        if (b == NULL) {
+            return NULL;
+        }
+        b->next = NULL;
+        pool->head = b;
+        pool->blocks = 1;
+    }
     uintptr_t base = (uintptr_t)b + sizeof(yep_block);
     uintptr_t start = yep_round_up(base + b->used, align);
 
@@ -88,12 +97,10 @@ yep_pool* yep_pool_create(const yep_allocator* sys, size_t block_size) {
     }
     p->sys = sys;
     p->block_size = block_size;
-    p->head = yep_block_new(sys, block_size);
-    p->blocks = 1;
-    if (p->head == NULL) {
-        yep_free(sys, p);
-        return NULL;
-    }
+    /* #157: the first block is lazy — one fewer eager allocation per
+     * document; pool_alloc materializes it on first use */
+    p->head = NULL;
+    p->blocks = 0;
     return p;
 }
 

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

@@ -27,6 +27,7 @@
 #include "resolve/resolver.h"
 #include "scan/json.h"
 #include "scan/scan.h"
+#include <yeptris/resolve.h> /* YEPTRIS_TAG_* names (#168) */
 
 #define YEP_MAX_DEPTH 1000
 #define YEP_MAX_FOLD_LINES 8192
@@ -158,7 +159,15 @@ static int emit_now(yep_engine* e, const yep_event* ev) {
         /* Resolution happens exactly here: every scalar path flows
          * through this choke point (the resolver is the typing SSOT) */
         if (ev->tag.len > 0) {
-            ((yep_event*)ev)->tag_id = yep_tag_from_uri((const char*)ev->tag.p, ev->tag.len);
+            yep_tag_id tid = yep_tag_from_uri((const char*)ev->tag.p, ev->tag.len);
+            /* psych's own dumped form is the LOCAL !binary shorthand,
+             * and stdlib to_ruby accepts it beside the core URI (#168)
+             * — compat schemas resolve it to BINARY as well */
+            if (tid == YEPTRIS_TAG_CUSTOM && ev->tag.len == 7 &&
+                memcmp(ev->tag.p, "!binary", 7) == 0 && e->resolver == yep_resolver_compat11()) {
+                tid = YEPTRIS_TAG_BINARY;
+            }
+            ((yep_event*)ev)->tag_id = tid;
         } else if (ev->implicit && e->resolver != NULL) {
             ((yep_event*)ev)->tag_id = e->resolver->resolve(
                 e->resolver->ctx, (const char*)ev->value.p, (uint32_t)ev->value.len);

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

@@ -375,7 +375,7 @@ YEPTRIS_API size_t yeptris_document_count(YeptrisDocument handle) {
 }
 
 yeptris_node* yep_handle_new(yeptris_document* doc, uint32_t id) {
-    yeptris_node* n = yep_hpool_alloc(doc->dom->handles, sizeof(yeptris_node), 16);
+    yeptris_node* n = yep_hpool_alloc(yep_dom_handles(doc->dom), sizeof(yeptris_node), 16);
     if (n == NULL) {
         return NULL;
     }
@@ -552,7 +552,7 @@ static YeptrisNode wrap(yeptris_node* base, uint32_t id) {
     /* Handles live in the document's thread-safe arena: one
      * document_free reclaims every handle ever handed out (zero-leak
      * contract) while read-only sharing stays safe (TODO.impl/19) */
-    yeptris_node* n = yep_hpool_alloc(base->doc->dom->handles, sizeof(yeptris_node), 16);
+    yeptris_node* n = yep_hpool_alloc(yep_dom_handles(base->doc->dom), sizeof(yeptris_node), 16);
     if (n == NULL) {
         return NULL;
     }

metadata

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