yeptris 0.6.38.0-aarch64-linux → 0.6.41.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12be0e0b7764d4cd5e242c24b21d7a5e73c79b300ac5e96fc743973fb24221b5
-  data.tar.gz: ed2143a6740e74851d19cb0fea5f777604c80d6674944b65ec3fd80a10c9ec24
+  metadata.gz: 5353bd36130f48f70c8825b21e60564dafc3078e1702e186e00389be89ad2bb0
+  data.tar.gz: f1ca7bf67a3e99b23339e5d60a4a5331c60aa859d9ad49208cfe74a5236bc61a
 SHA512:
-  metadata.gz: 4c96597face49b7becc4603018e7123cc8967e78c41b475ec5b3ce5d231952ef7480f308b472899ca814da17c8210cf50d88cc24858d13be927674ae75eb9d9f
-  data.tar.gz: efd338dd2e4d7fed685fbf535de38e859cdbbe18348bd9edf4234ae5460e66b9772996e2b4cb78d1a8b1fa6fdd6ac8e3f8b8c686a025ad6a959770c1da1d8cdf
+  metadata.gz: 72ee0c7302cfe878192a677b793836ed879039e783624f323ab54c5a5a11e2e37d82cedd2f3635f3da6830e71c9967cbc3a2737055f2677cbc08fa82a9dad453
+  data.tar.gz: 94add9c22c40c61de42fa34e8d2bb359475b20f8c270cc3a57c120594a237e28857bfe44202709f7b2f3fee7341fd887b511c6f09d002fb963bc1971675b35e8

data/ext/yeptris_native/extconf.rb

@@ -1,47 +1,93 @@
 # frozen_string_literal: true
 
+# Builds the native JSON/CBOR materializer (yeptris-ruby#311): the
+# per-minor prebuilt bundle loads FIRST ("lib/yeptris/<minor>/native")
+# and THIS build is the fallback slot ("require 'yeptris/native'") —
+# compiled by the installing Ruby, so it is ABI-correct on every
+# minor, present and future. Installs must NEVER fail: any miss (no
+# engine binary, no headers, no usable toolchain) degrades to a no-op
+# Makefile and the FFI ladder carries the load, exactly as today.
+
 require "mkmf"
+require "fileutils"
+
+gem_root = File.expand_path("../..", __dir__)
+vendored = File.join(gem_root, "vendor", "libyeptris")
 
-# libyeptris location: YEPTRIS_LIB_PATH (file or dir), then sibling
-# checkouts. CI sets YEPTRIS_LIB_PATH (the built shared library) and
-# YEPTRIS_SRC (the C checkout) explicitly.
-lib_path = ENV["YEPTRIS_LIB_PATH"]
-candidates = []
-if lib_path
-  candidates << File.dirname(lib_path)
-  candidates << lib_path if File.directory?(lib_path)
+def write_dummy_makefile(reason)
+  File.write("Makefile", <<~MAKE)
+    all:
+    \t@echo "#{reason}"
+    install:
+    clean:
+  MAKE
 end
-candidates << File.expand_path("../../../../yeptris/build-validate/src", __dir__)
-candidates << File.expand_path("../../../../yeptris/build/src", __dir__)
-candidates << File.expand_path("../../../yeptris/build-validate/src", __dir__)
-candidates << File.expand_path("../../../yeptris/build/src", __dir__)
 
-# Source root: YEPTRIS_SRC (CI / explicit), then sibling checkouts.
+# 1. The engine binary to LINK. Order: CI/dev explicit, then the gem
+# root — platform gems vendor the prebuilt lib there, and the pure
+# gem's ext/libyeptris extconf builds it there BEFORE this extension
+# runs (rubygems builds extensions in gemspec order).
+lib = ENV["YEPTRIS_LIB_PATH"]
+lib = nil unless lib && File.file?(lib)
+lib ||= ["libyeptris.so", "libyeptris.dylib", "yeptris.dll"]
+        .map { |n| File.join(gem_root, n) }
+        .find { |f| File.exist?(f) }
+
+# 2. The engine headers: CI/dev checkout, then the vendored tree that
+# rides every gem artifact (the packaging doctrine's recompile half).
 src_roots = [ENV["YEPTRIS_SRC"]].compact
-src_roots << File.expand_path("../../../../yeptris/src", __dir__)
-src_roots << File.expand_path("../../../yeptris/src", __dir__)
+src_roots << File.join(vendored, "src")
 src_root = src_roots.find { |d| d && File.directory?(File.join(d, "include")) }
-abort "yeptris sources not found (set YEPTRIS_SRC)" unless src_root
 
-$INCFLAGS << " -I#{src_root}/include -I#{src_root}/yeptris"
-%w[build-validate/generated build/generated].each do |g|
-  d = File.join(File.dirname(src_root), g)
-  $INCFLAGS << " -I#{d}" if File.directory?(d)
-end
+# 0. The toolchain probe — the docstring's third miss (yeptris-ruby#317):
+# a toolchain-free image (the alpine musl smoke has no compiler) must
+# degrade to the no-op Makefile, not abort inside mkmf's sanity link.
+if !have_devel?
+  write_dummy_makefile("yeptris: no usable toolchain for the materializer; the FFI ladder carries the load")
+elsif lib.nil?
+  write_dummy_makefile("yeptris: no libyeptris binary for the materializer; the FFI ladder carries the load")
+elsif src_root.nil?
+  write_dummy_makefile("yeptris: no engine headers for the materializer; the FFI ladder carries the load")
+else
+  $INCFLAGS << " -I#{src_root}/include -I#{src_root}/yeptris"
+  %w[build-validate/generated build/generated].each do |g|
+    d = File.join(File.dirname(src_root), g)
+    $INCFLAGS << " -I#{d}" if File.directory?(d)
+  end
+  # the generated version.h: nothing in the materializer's include
+  # chain needs it today; generate it into the workdir so a future
+  # include cannot break installs (the vendored tree ships only .in)
+  vhin = File.join(src_root, "include", "yeptris", "version.h.in")
+  unless File.exist?(File.join(src_root, "include", "yeptris", "version.h"))
+    if File.exist?(vhin)
+      # CMakeLists sits at the engine tree's root: the vendored gem
+      # tree (vendor/libyeptris) or the CI checkout (libyeptris-src)
+      ver = File.read(File.join(File.dirname(src_root), "CMakeLists.txt"))[/project\s*\([^)]*?VERSION\s+([0-9.]+)/m, 1] || "0.0.0"
+      maj, min, pat = ver.split(".")
+      File.write("version.h", File.read(vhin)
+        .gsub("@PROJECT_VERSION_MAJOR@", maj || "0")
+        .gsub("@PROJECT_VERSION_MINOR@", min || "0")
+        .gsub("@PROJECT_VERSION_PATCH@", pat || "0")
+        .gsub("@PROJECT_VERSION@", ver))
+      $INCFLAGS << " -I."
+    end
+  end
+
+  libdir = File.dirname(lib)
+  $LIBPATH << libdir
+  # the bundle must find libyeptris at require time; the gem root is
+  # stable within an installation
+  $LDFLAGS << " -Wl,-rpath,#{libdir}" if RUBY_PLATFORM =~ /linux|darwin/
 
-libdir = candidates.find do |d|
-  d && File.directory?(d) && Dir[File.join(d, "libyeptris*.{dylib,so,dll}")].any?
+  if have_library("yeptris", "yep_json_string") && have_library("yeptris", "yeptris_visit_json")
+    # Windows resolves DLL dependencies beside the loading module —
+    # install the dll beside the built bundle
+    if RUBY_PLATFORM =~ /mswin|mingw/ && File.dirname(lib) != gem_root
+      ($INSTALLFILES ||= []) << [lib, "$(RUBYARCHDIR)/yeptris"]
+    end
+    $CFLAGS << " -O3 -fvisibility=hidden" unless RUBY_PLATFORM =~ /mswin|mingw/
+    create_makefile("yeptris/native")
+  else
+    write_dummy_makefile("yeptris: materializer link probe failed; the FFI ladder carries the load")
+  end
 end
-abort "libyeptris not found (set YEPTRIS_LIB_PATH)" unless libdir
-
-$LIBPATH << libdir
-# Platform gems bake a RELATIVE rpath so the bundle finds the
-  # vendored libyeptris next to itself; absolute build-time paths
-  # would dangle on user machines.
-  rpath = ENV["YEPTRIS_RPATH"] || libdir
-  $LDFLAGS << " -Wl,-rpath,#{rpath}" if RUBY_PLATFORM =~ /linux|darwin/
-have_library("yeptris", "yep_json_string") or abort "yep_json_string not exported — rebuild libyeptris"
-have_library("yeptris", "yeptris_visit_json") or abort "yeptris_visit_json missing"
-
-$CFLAGS << " -O3 -fvisibility=hidden" unless RUBY_PLATFORM =~ /mswin|mingw/
-create_makefile("yeptris/native")

data/ext/yeptris_native/json_ruby.c

@@ -63,7 +63,18 @@ static int yep_cache_mode = YEP_CACHE_ON;
  * rb_ary_new() so 3-element arrays stay EMBEDDED in the RVALUE, and
  * bulk-path hashes get exact capacity from the counted pairs. */
 enum { YEP_SHAPE_PRE = 0, YEP_SHAPE_NATURAL = 1 };
-static int yep_shape_mode = YEP_SHAPE_PRE;
+/* Default per arch (the #310 arm64 referee matrix, 24 cells over the
+ * json-users-shaped corpus): NATURAL — rb_ary_new() keeps 3-element
+ * arrays embedded in the RVALUE instead of forcing heap buffers, and
+ * it won EVERY cell (1.00-1.04x vs pre's 1.10-1.22x vs JSON.parse).
+ * x86 keeps PRE until its referee says otherwise (the GATE judges the
+ * per-arch default on CI). */
+#if defined(__aarch64__) || defined(__arm__) || defined(__ARMEL__) || defined(_M_ARM64)
+#define YEP_SHAPE_DEFAULT YEP_SHAPE_NATURAL
+#else
+#define YEP_SHAPE_DEFAULT YEP_SHAPE_PRE
+#endif
+static int yep_shape_mode = YEP_SHAPE_DEFAULT;
 
 static uint64_t jr_hash(const char* sp, long sl) {
     /* 8-byte-prefix key (the leptris nametab trick): one safe load

data/ext/yeptris_native/version.h

@@ -0,0 +1,29 @@
+/* version.h — generated from the CMake project VERSION.
+ *
+ * CMakeLists.txt project(yeptris VERSION ...) is the single source of truth;
+ * scripts/bump-version.sh syncs vcpkg.json and CHANGELOG.md from it. Never
+ * hand-edit the generated file (it lives in the build tree).
+ */
+#ifndef YEPTRIS_VERSION_H
+#define YEPTRIS_VERSION_H
+
+#include <yeptris/api.h>
+
+#define YEPTRIS_VERSION_MAJOR 0
+#define YEPTRIS_VERSION_MINOR 6
+#define YEPTRIS_VERSION_PATCH 41
+#define YEPTRIS_VERSION_STRING "0.6.41"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Returns the library version string ("major.minor.patch").
+ * Memory: static storage; valid for the lifetime of the process. */
+YEPTRIS_API const char* yeptris_version(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_VERSION_H */

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

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

@@ -55,6 +55,19 @@ YEPTRIS_API char* yeptris_serialize_ex(YeptrisDocument doc, const yeptris_emit_o
  * returned. Returns 0 on a NULL document. */
 YEPTRIS_API size_t yeptris_serialize_into(YeptrisDocument doc, char* buf, size_t cap);
 
+/* Trusted-cap emission (#352): ONE write pass into the caller's
+ * fixed buffer — no sizing pass, no per-call allocation. Returns the
+ * byte count written when ret < cap (the document is complete and
+ * NUL-terminated at buf[ret]); when ret >= cap the output did not
+ * fit — buf holds a partial document and ret is the exact total the
+ * document needs (re-call with cap >= ret + 1; the retry writes
+ * identical bytes). opts == NULL selects the fidelity mode. Returns 0
+ * on a NULL document or buffer (use yeptris_serialize_into for the
+ * measure-only form). */
+YEPTRIS_API size_t yeptris_serialize_into_trusted(YeptrisDocument doc,
+                                                  const yeptris_emit_options* opts, char* buf,
+                                                  size_t cap);
+
 /* Streaming emission (13C): bytes are delivered in chunks to sink as
  * the walk proceeds — memory bounded by the largest scalar, never the
  * document. Returns the total byte count, or 0 on a NULL argument or

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

@@ -44,6 +44,7 @@ YEPTRIS_API size_t yeptris_serialize_into_ex(YeptrisDocument handle,
     em.w.cap = 0;
     em.w.grow = 0;
     em.w.oom = 0;
+    em.w.bounded = 0;
     em.doc = (const yeptris_document*)handle;
     if (yep_doc_dom((yeptris_document*)handle) == NULL) { /* #342 lazy */
         return 0;
@@ -97,6 +98,69 @@ YEPTRIS_API size_t yeptris_serialize_into_ex(YeptrisDocument handle,
     return wrote;
 }
 
+YEPTRIS_API size_t yeptris_serialize_into_trusted(YeptrisDocument handle,
+                                                  const yeptris_emit_options* opts, char* buf,
+                                                  size_t cap) {
+    if (handle == NULL || buf == NULL || cap == 0) {
+        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.w.bounded = 0;
+    em.doc = (const yeptris_document*)handle;
+    if (yep_doc_dom((yeptris_document*)handle) == NULL) { /* #342 lazy */
+        return 0;
+    }
+    em.w.p = buf;
+    em.w.last = 0;
+    em.w.force_flow = 0;
+    em.w.in_flow = 0;
+    em.w.flow_item = 0;
+    em.w.unserializable = 0;
+    em.w.canonical = opts_canonical(opts);
+    em.w.explicit_doc_start = opts_doc_marker(opts);
+    em.w.json = 0;
+    em.w.json_compact = 0;
+    em.w.json_pretty = 0;
+    em.w.pretty_depth = 0;
+    em.w.best_width = opts_width(opts);
+    em.w.col = 0;
+    em.w.sv_input = ((const yeptris_document*)handle)->dom->input_base;
+    em.w.sv_arena = ((const yeptris_document*)handle)->dom->str;
+    em.w.sink = NULL;
+    em.w.watermark = 0;
+    em.w.sink_aborted = 0;
+    em.w.flushed = 0;
+    memset(&em.canon_names, 0, sizeof(em.canon_names));
+    if (em.w.canonical && !yep_nametab_init(&em.canon_names, yep_system_allocator())) {
+        return 0;
+    }
+    /* #352: ONE bounded wet pass — no memo, no dry run (the emit-split
+     * table's 2p/1p column priced the dry pass at ~0.55x). Routes derive
+     * on demand (the streaming route's bytes); an oversized write sets
+     * oom and the pass keeps counting, so the exact size falls out of
+     * the same walk and the retry writes identical bytes. */
+    em.w.cap = cap;
+    em.w.grow = 1;
+    em.w.bounded = 1;
+    size_t wrote = yep_emit_run(&em, 0);
+    em.w.bounded = 0;
+    int fit = !em.w.oom && !em.w.unserializable;
+    size_t ret = fit ? wrote : em.w.len;
+    if (em.canon_names.sys != NULL) {
+        yep_nametab_free(&em.canon_names);
+    }
+    if (!fit) {
+        return ret; /* ret >= cap: buf holds a partial document */
+    }
+    buf[wrote] = '\0';
+    return ret; /* ret < cap: the document is complete */
+}
+
 YEPTRIS_API void yeptris_free(void* p) {
     free(p);
 }
@@ -112,6 +176,7 @@ YEPTRIS_API char* yeptris_serialize_ex(YeptrisDocument handle, const yeptris_emi
     em.w.cap = 0;
     em.w.grow = 0;
     em.w.oom = 0;
+    em.w.bounded = 0;
     em.doc = (const yeptris_document*)handle;
     if (yep_doc_dom((yeptris_document*)handle) == NULL) { /* #342 lazy */
         return NULL;
@@ -199,6 +264,7 @@ YEPTRIS_API char* yeptris_serialize_json(YeptrisDocument handle, size_t* len) {
     em.w.cap = 0;
     em.w.grow = 0;
     em.w.oom = 0;
+    em.w.bounded = 0;
     em.doc = (const yeptris_document*)handle;
     if (yep_doc_dom((yeptris_document*)handle) == NULL) { /* #342 lazy */
         return NULL;
@@ -260,6 +326,7 @@ YEPTRIS_API char* yeptris_serialize_json_ex(YeptrisDocument handle, size_t* len,
     em.w.cap = 0;
     em.w.grow = 0;
     em.w.oom = 0;
+    em.w.bounded = 0;
     em.doc = (const yeptris_document*)handle;
     if (yep_doc_dom((yeptris_document*)handle) == NULL) { /* #342 lazy */
         return NULL;
@@ -326,6 +393,7 @@ char* yep_serialize_json_compact(const yeptris_document* doc, size_t* len) {
     em.w.cap = 0;
     em.w.grow = 0;
     em.w.oom = 0;
+    em.w.bounded = 0;
     em.doc = doc;
     em.w.p = NULL;
     em.w.last = 0;
@@ -389,6 +457,7 @@ char* yep_serialize_json_pretty_ex(const yeptris_document* doc, size_t* len, con
     em.w.cap = 0;
     em.w.grow = 0;
     em.w.oom = 0;
+    em.w.bounded = 0;
     em.doc = doc;
     em.w.p = NULL;
     em.w.last = 0;
@@ -459,6 +528,7 @@ YEPTRIS_API size_t yeptris_serialize_stream(YeptrisDocument handle,
     em.w.cap = 0;
     em.w.grow = 0;
     em.w.oom = 0;
+    em.w.bounded = 0;
     em.doc = (const yeptris_document*)handle;
     if (yep_doc_dom((yeptris_document*)handle) == NULL) { /* #342 lazy */
         return 0;

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

@@ -99,7 +99,11 @@ static void wr_put(yep_writer* w, const char* p, uint32_t n) {
      * first byte of the next heap block's header (the #182 flake:
      * corrupt deterministic, detected later, timing-varying) */
     if (w->grow && w->len + n + 1 > w->cap) {
-        wr_grow(w, n);
+        if (w->bounded) {
+            w->oom = 1; /* keep counting: the trusted caller reads the size */
+        } else {
+            wr_grow(w, n);
+        }
     }
     if (w->oom) {
         w->len += n; /* keep counting: the caller fails on oom */
@@ -122,7 +126,11 @@ static void wr_byte(yep_writer* w, char c) {
         return;
     }
     if (w->grow && w->len + 2 > w->cap) { /* +1 write, +1 terminator */
-        wr_grow(w, 1);
+        if (w->bounded) {
+            w->oom = 1; /* keep counting: the trusted caller reads the size */
+        } else {
+            wr_grow(w, 1);
+        }
     }
     if (w->oom) {
         w->len++;
@@ -346,37 +354,13 @@ static void emit_literal(yep_writer* w, const yep_dnode* n, int parent_col) {
             wr_indent(w, pad);
         }
     }
-    /* The reader swallows the own break of a WHITESPACE-ONLY
-     * more-indented last line ("|+\n:\n \t\n\n\n" reads trail=2), so
-     * the spelling needs one extra break there -- written N reads N-1
-     * (the nightly's round 32, crash-90c98918: pass1
-     * "|+\n  :\n   \t\n\n" re-parsed one break short and the second
-     * pass emitted clip). A regular last line reads 1:1. */
-    uint32_t ls = body;
-    while (ls > 0 && p[ls - 1] != '\n') {
-        ls--;
-    }
-    int tab_last = 0;
-    int ws_last = 1;
-    for (uint32_t i = ls; i < body; i++) {
-        if (p[i] == '\t') {
-            tab_last = 1;
-        } else if (p[i] != ' ') {
-            ws_last = 0;
-            break;
-        }
-    }
-    /* the reader swallows the own break of a whitespace-only last line
-     * that carries a TAB (the tab-indent law shifts the line's content
-     * start): "|+\n:\n \t\n\n\n" reads trail=2 where a spaces-only
-     * line reads 1:1 (the nightly's round 32, crash-90c98918: pass1
-     * "|+\n  :\n   \t\n\n" re-parsed one break short and the second
-     * pass emitted clip). One extra break spells the tab case — and
-     * ONLY that case: a CONTENT last line that merely carries a tab
-     * ("|+\n \t:\n..." — the round-33 composite, crash-306b67eb)
-     * reads its own break 1:1, and the extra break made the value
-     * GROW one break per pass. */
-    for (uint32_t i = 0; i < trail + ((tab_last && ws_last) ? 1 : 0); i++) {
+    /* The keep spelling writes exactly the parsed trailing breaks:
+     * written N reads N. (The round-32 extra break for tab-carrying
+     * ws-only last lines compensated a READER bug -- the tab-content
+     * arm consumed its line's own break without counting it toward
+     * trailing -- and the reader counts it now; the compensation made
+     * every pass GROW one break.) */
+    for (uint32_t i = 0; i < trail; i++) {
         wr_byte(w, '\n');
     }
 }
@@ -688,22 +672,55 @@ static void wr_anchor_check(yep_writer* w, const yep_view* name) {
     }
 }
 
+/* The anchor-name spell laws, shared by every anchor write path (the
+ * node lead AND the line-tail props: the round-45 bonus catch -- a
+ * PS-named anchor on a SEQ spelled raw through emit_props_tail and
+ * the re-parse died on the normalized break). Returns nonzero when
+ * the serialize must fail. */
+static int anchor_name_unspellable(yep_writer* w, const yep_dnode* n) {
+    yep_view chk = wv(w, n->anchor);
+    if (chk.len == 0) {
+        return 0;
+    }
+    if (chk.p[chk.len - 1] == ':') {
+        /* a SCALAR keeps riding raw only when it spells INLINE
+         * ("k: &n: v" is byte-stable); a BLOCK-style spell puts the
+         * header where the separator should be ("&: |" -- the
+         * nightly's round 44, crash-07ad9ecc) -- there is no spell:
+         * fail the serialize */
+        if (n->kind != 0 || n->style == 4 || n->style == 5) {
+            w->unserializable = 1;
+            return 1;
+        }
+    }
+    /* a NORMALIZE-SUBJECT byte (LS/PS raw, NEL, or a hard break)
+     * re-reads as a folded break: pass2 sees a broken/empty name and
+     * dies. YAML has no quoted anchor names: fail the serialize. */
+    for (size_t ci = 0; ci < chk.len; ci++) {
+        unsigned char cb = (unsigned char)chk.p[ci];
+        if (cb == '\n' || cb == '\r') {
+            w->unserializable = 1;
+            return 1;
+        }
+        if (cb == 0xC2 && ci + 1 < chk.len && (unsigned char)chk.p[ci + 1] == 0x85) {
+            w->unserializable = 1; /* NEL */
+            return 1;
+        }
+        if (cb == 0xE2 && ci + 2 < chk.len && (unsigned char)chk.p[ci + 1] == 0x80 &&
+            ((unsigned char)chk.p[ci + 2] & 0xFE) == 0xA8) {
+            w->unserializable = 1; /* LS/PS */
+            return 1;
+        }
+    }
+    return 0;
+}
+
 static void emit_anchor_ex(yep_emitter* em, const yep_dnode* n) {
     yep_writer* w = &em->w;
     if (n->anchor.len == 0) {
         return;
     }
-    /* A name ending in ':' rides or separates context-dependently
-     * (2SXE): spelled directly before a collection ("&: [[]]", the
-     * nightly's round 31, crash-66a513ea; "k: &: [[1]]" fails its own
-     * re-parse the same way) every spelling re-lexes differently --
-     * the riding/yield law reads the colon as the key indicator at
-     * the follower, so the tree changes or the parse dies. A scalar
-     * node keeps riding raw ("k: &n: v" round-trips byte-stably).
-     * There is no spell for the collection form: fail the serialize. */
-    yep_view chk = wv(w, n->anchor);
-    if (n->kind != 0 && chk.len > 0 && chk.p[chk.len - 1] == ':') {
-        w->unserializable = 1;
+    if (anchor_name_unspellable(w, n)) {
         return;
     }
     wr_byte(w, '&');
@@ -875,6 +892,9 @@ static void emit_props_tail(yep_writer* w, const yep_dnode* n) {
         wr_tag_token(w, &tdec2);
     }
     if (n->anchor.len > 0) {
+        if (anchor_name_unspellable(w, n)) {
+            return;
+        }
         wr_byte(w, ' ');
         yep_view adec2 = wv(w, n->anchor);
         wr_anchor_check(w, &adec2);
@@ -1069,7 +1089,11 @@ static void emit_block_map(yep_emitter* em, uint32_t id, int content_col) {
                     w->len += total;
                 } else {
                     if (w->grow && w->len + total + 1 > w->cap) {
-                        wr_grow(w, total);
+                        if (w->bounded) {
+                            w->oom = 1; /* keep counting: the trusted caller reads the size */
+                        } else {
+                            wr_grow(w, total);
+                        }
                     }
                     if (w->oom) {
                         w->len += total; /* keep counting: the caller fails on oom */

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

@@ -57,6 +57,9 @@ typedef struct yep_writer {
     size_t cap;
     int grow;
     int oom;
+    int bounded;        /* #352: caller-owned fixed buffer — an oversized write
+                           sets oom and keeps counting (the needed size falls
+                           out of the same pass); wr_grow is never called */
     int in_flow;        /* scalars inside flow collections: plain must drop
                            ',', '[', ']', '{', '}' — flow terminators */
     int flow_item;      /* the NEXT scalar is a flow-SEQ item: a null must

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

@@ -918,7 +918,27 @@ static int e_block_scalar(yep_engine* e, yep_event* ev, int parent_col) {
                     saw_content = 1;
                     pending_breaks = 0;
                     trailing_breaks = 0;
-                    e_line_done(e, li.end);
+                    /* the line's OWN break counts toward trailing (the
+                     * content-line arm and the spaces-past-indent arm
+                     * scan it below): consuming it silently made keep
+                     * spell one break short whenever a tab-carrying
+                     * content line ENDED the block ("|+\n\n >\t\n
+                     *   \t \n" — libyaml keeps the final break, the
+                     * nightly's round 37) */
+                    {
+                        size_t at = li.end;
+                        size_t br = yep_scan_break_len(e->p, e->len, at);
+                        if (br > 0) {
+                            trailing_breaks = 1;
+                            e->pos = at + br;
+                            e->line++;
+                            e->line_start = e->pos;
+                            e->li_cache_line = 0;
+                            e->shape_cache_line = 0;
+                        } else {
+                            e->pos = at;
+                        }
+                    }
                     continue;
                 }
             }
@@ -1289,15 +1309,29 @@ static void e_props(yep_engine* e, yep_view* anchor, yep_view* tag) {
              * re-lexes as the key indicator and the existing colon
              * arm builds the anchored null key. */
             if (e->p[e->pos - 1] == ':') {
-                /* the follower scan crosses blanks AND breaks: the
-                 * pair separator at line end still opens the value on
-                 * the next line ("&k:\n {\n}" — the nightly's round
-                 * 31, crash-c2232e17 — rode the colon and DROPPED the
-                 * flow map outright) */
+                /* the follower scan crosses blanks, breaks AND
+                 * comments: the pair separator at line end still opens
+                 * the value on a later line ("&k:\n {\n}" — the
+                 * nightly's round 31, crash-c2232e17 — rode the colon
+                 * and DROPPED the flow map; "&: #c\n|\nA" — round
+                 * 32's crash-d580b467 — stopped at the comment, rode
+                 * the colon into the anchor name and pass1/pass2
+                 * spelled different trees). A comment is
+                 * blank-equivalent here: skip it to its break and keep
+                 * scanning. */
                 size_t t = e->pos;
-                while (t < e->len &&
-                       (e->p[t] == ' ' || e->p[t] == '\t' || e->p[t] == '\n' || e->p[t] == '\r')) {
-                    t++;
+                for (;;) {
+                    while (t < e->len && (e->p[t] == ' ' || e->p[t] == '\t' || e->p[t] == '\n' ||
+                                          e->p[t] == '\r')) {
+                        t++;
+                    }
+                    if (t < e->len && e->p[t] == '#') {
+                        while (t < e->len && e->p[t] != '\n' && e->p[t] != '\r') {
+                            t++;
+                        }
+                        continue;
+                    }
+                    break;
                 }
                 if (t < e->len &&
                     (e->p[t] == '[' || e->p[t] == '{' || e->p[t] == '|' || e->p[t] == '>')) {
@@ -2172,8 +2206,11 @@ static void e_flow_frame_init(void* stv, int idx, int kind, int pending_key) {
         uint8_t pair_q; /* the pair opened on an explicit '?': its
                          * JSON-style ':' separator is still ahead */
         uint8_t pair_wrap;
-        uint8_t q_coll;   /* seq: an explicit '?' key collection awaits completion */
-        uint8_t key_coll; /* map: the nested collection opened in key position */
+        uint8_t q_coll;        /* seq: an explicit '?' key collection awaits completion */
+        uint8_t q_empty_value; /* seq: the '?' empty-key pair — 1: opened,
+                                * 2: its value state (the entry comma was
+                                * consumed inside the pair, yeptris#741) */
+        uint8_t key_coll;      /* map: the nested collection opened in key position */
         int32_t buf_from;
         uint32_t entry_line;
         uint32_t entries;
@@ -2189,6 +2226,7 @@ static void e_flow_frame_init(void* stv, int idx, int kind, int pending_key) {
     st[idx].pair_q = 0;
     st[idx].pair_wrap = 0;
     st[idx].q_coll = 0;
+    st[idx].q_empty_value = 0;
     st[idx].buf_from = -1;
     st[idx].entry_line = 0;
     st[idx].entries = 0;
@@ -2196,20 +2234,21 @@ static void e_flow_frame_init(void* stv, int idx, int kind, int pending_key) {
 
 static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_id) {
     struct {
-        uint8_t kind;        /* 0 seq, 1 map */
-        uint8_t pending_key; /* map: 1 key seen awaiting ':' value; 2 key emitted w/o ':' */
-        uint8_t sep;         /* a ',' was consumed and no entry followed yet */
-        uint8_t just_closed; /* a nested collection closed here (key candidate) */
-        uint8_t pair_open;   /* seq: a buffered single-pair awaits its MAP_END */
-        uint8_t pair_value;  /* seq: the open pair already has its value */
-        uint8_t pair_q;      /* seq: the pair opened on an explicit '?':
-                              * its JSON-style ':' separator is still ahead */
-        uint8_t pair_wrap;   /* map frame pushed as a seq single-pair */
-        uint8_t q_coll;      /* seq: an explicit '?' key collection awaits completion */
-        uint8_t key_coll;    /* map: a nested collection opened in key position */
-        int32_t buf_from;    /* seq: entry events buffered from this index */
-        uint32_t entry_line; /* seq: line where the buffered entry ended */
-        uint32_t entries;    /* completed entries (for trailing-comma detection) */
+        uint8_t kind;          /* 0 seq, 1 map */
+        uint8_t pending_key;   /* map: 1 key seen awaiting ':' value; 2 key emitted w/o ':' */
+        uint8_t sep;           /* a ',' was consumed and no entry followed yet */
+        uint8_t just_closed;   /* a nested collection closed here (key candidate) */
+        uint8_t pair_open;     /* seq: a buffered single-pair awaits its MAP_END */
+        uint8_t pair_value;    /* seq: the open pair already has its value */
+        uint8_t pair_q;        /* seq: the pair opened on an explicit '?':
+                                * its JSON-style ':' separator is still ahead */
+        uint8_t pair_wrap;     /* map frame pushed as a seq single-pair */
+        uint8_t q_coll;        /* seq: an explicit '?' key collection awaits completion */
+        uint8_t q_empty_value; /* seq: the '?' empty-key pair's state (#741) */
+        uint8_t key_coll;      /* map: a nested collection opened in key position */
+        int32_t buf_from;      /* seq: entry events buffered from this index */
+        uint32_t entry_line;   /* seq: line where the buffered entry ended */
+        uint32_t entries;      /* completed entries (for trailing-comma detection) */
     } st[YEP_MAX_DEPTH];
     int n = 0;
 
@@ -2249,6 +2288,7 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
         }
         int keyish = (st[n - 1].kind == 1 && st[n - 1].pending_key == 0);
         int q_key = 0;
+        int q_empty_key = 0; /* the '?' synthesized a null key (#741) */
         int rc;
         if (e_flow_ws(e) != 0) {
             return -1;
@@ -2278,6 +2318,10 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                 !(e->p[n2] == ' ' || e->p[n2] == '\t' || e->p[n2] == '\n' || e->p[n2] == '\r' ||
                   yep_ct_is((unsigned char)e->p[n2], YEP_CT_FLOW_IND))) {
                 st[n - 1].pair_q = 0;
+                /* yeptris#741: the consumed ':' is the pair's VALUE
+                 * indicator — the '?' empty-key pair's value state ends
+                 * here or the value node trips the entry guard */
+                st[n - 1].q_empty_value = 0;
                 e->pos++;
                 continue;
             }
@@ -2305,6 +2349,15 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
              * in a sequence a ':'-led token is a new plain, so it errors */
             return e_fail(e, YEP_ERR_UNEXPECTED, e->pos);
         }
+        if (st[n - 1].kind == 0 && st[n - 1].q_empty_value == 2 && e->pos < e->len &&
+            e->p[e->pos] != ',' && e->p[e->pos] != ']' && e->p[e->pos] != '}' &&
+            e->p[e->pos] != ':') {
+            /* yeptris#741: a node in the '?' empty-key pair's value
+             * state — ENTRY_MAPPING_VALUE wants VALUE/ENTRY/END only
+             * ("[?, a]" is the libyaml "did not find expected ',' or
+             * ']'" error) */
+            return e_fail(e, YEP_ERR_UNEXPECTED, e->pos);
+        }
         if (e->pos < e->len && e->p[e->pos] == '?' &&
             (e->pos + 1 >= e->len || e->p[e->pos + 1] == ' ' || e->p[e->pos + 1] == '\t' ||
              e->p[e->pos + 1] == '\n' || e->p[e->pos + 1] == '\r' ||
@@ -2328,6 +2381,7 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                 ev.col = e_col(e, e->pos) + 1;
                 rc = 1;
                 q_key = 1;
+                q_empty_key = (st[n - 1].kind == 0);
             } else {
                 rc = e_flow_node(e, &ev, keyish);
                 q_key = 1;
@@ -2354,10 +2408,15 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                     st[n - 1].q_coll = 1;
                 }
             }
-            if (!q_key) {
+            if (!q_key && st[n - 1].pair_open) {
                 /* a VALUE collection completes the pending pair; a KEY
                  * collection must not (its pair completes at ':' or the
-                 * boundary with a null value) */
+                 * boundary with a null value). The gate is pair_open:
+                 * in a SEQUENCE a plain collection entry has no pair,
+                 * and the unguarded write planted a stale pair_value=1
+                 * that a LATER '?'-opened pair wrap inherited -- its
+                 * comma flush then skipped the implicit null
+                 * (crash-8106600e, "[... , ? 20:50 , ...]"). */
                 st[n - 1].pair_value = 1;
             }
             unsigned char oc = (unsigned char)e->p[e->pos];
@@ -2536,6 +2595,9 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                     if (emit_now(e, &ev) != 0) {
                         return -2;
                     }
+                    if (q_empty_key) {
+                        st[n - 1].q_empty_value = 1;
+                    }
                     continue;
                 }
             }
@@ -2570,6 +2632,18 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
         unsigned char c = (unsigned char)e->p[e->pos];
         if (c == ',') {
             e->pos++;
+            if (st[n - 1].kind == 0 && st[n - 1].pair_open && st[n - 1].pair_q &&
+                !st[n - 1].pair_value && st[n - 1].q_empty_value == 1) {
+                /* yeptris#741: the '?' empty-key pair's first comma is
+                 * the entry separator libyaml's ENTRY_MAPPING_KEY
+                 * consumed to reach its VALUE state — the pair stays
+                 * open and awaits ':' (value), ',' (empty value +
+                 * close), or ']' (empty value + close). Closing here
+                 * spilled the following ': x' into a second entry
+                 * ("[? ,: x , a]" read as two maps). */
+                st[n - 1].q_empty_value = 2;
+                continue;
+            }
             if (st[n - 1].q_coll && st[n - 1].buf_from >= 0) {
                 int32_t bf0 = st[n - 1].buf_from;
                 st[n - 1].buf_from = -1;
@@ -2604,6 +2678,7 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                 st[n - 1].pair_open = 0;
                 st[n - 1].pair_value = 0;
                 st[n - 1].pair_q = 0;
+                st[n - 1].q_empty_value = 0;
             }
             if (st[n - 1].buf_from >= 0) {
                 st[n - 1].buf_from = -1;
@@ -2737,6 +2812,7 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                 }
                 st[n - 1].pair_open = 0;
                 st[n - 1].pair_value = 0;
+                st[n - 1].q_empty_value = 0;
             }
             if (st[n - 1].buf_from >= 0) {
                 st[n - 1].buf_from = -1;
@@ -2835,7 +2911,8 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                     }
                 }
                 if (was_empty) {
-                    yep_event kv; /* "[ : v" — the empty key */
+                    yep_event kv; /* "[ : v" — the empty key (CFD4,
+                                   * ledgered suite-VALID) */
                     e_event_init(&kv, YEP_EV_SCALAR);
                     kv.implicit = 1;
                     if (emit_now(e, &kv) != 0) {
@@ -2852,13 +2929,52 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                 continue; /* value next */
             }
             if (st[n - 1].kind == 0 && n >= 1) {
+                if (st[n - 1].pair_open && st[n - 1].q_empty_value == 2) {
+                    /* yeptris#741: the ':' after the '?' empty-key
+                     * pair's comma completes THE SAME pair (the pair's
+                     * VALUE indicator), not a new entry */
+                    size_t p2 = e->pos; /* the ':' byte is already consumed */
+                    while (p2 < e->len && (e->p[p2] == ' ' || e->p[p2] == '\t')) {
+                        p2++;
+                    }
+                    if (p2 < e->len && (e->p[p2] == ',' || e->p[p2] == ']' || e->p[p2] == '}')) {
+                        /* empty value at the closer: the pair closes
+                         * here; the closer dispatches as the separator */
+                        yep_event nv;
+                        e_event_init(&nv, YEP_EV_SCALAR);
+                        nv.implicit = 1;
+                        nv.style = YEP_STYLE_PLAIN;
+                        if (emit_now(e, &nv) != 0) {
+                            return -2;
+                        }
+                        yep_event mk;
+                        e_event_init(&mk, YEP_EV_MAP_END);
+                        if (emit_now(e, &mk) != 0) {
+                            return -2;
+                        }
+                        st[n - 1].pair_open = 0;
+                        st[n - 1].pair_value = 0;
+                        st[n - 1].pair_q = 0;
+                        st[n - 1].q_empty_value = 0;
+                        st[n - 1].sep = 1;
+                        st[n - 1].just_closed = 0;
+                        e->pos = p2;
+                        continue;
+                    }
+                    st[n - 1].q_empty_value = 0;
+                    e->pos++;
+                    continue;
+                }
                 if (st[n - 1].pair_open) {
                     /* "[s: : v]" — ':' in the open pair's value slot
                      * is not node content (libyaml: "did not find
                      * expected node content") */
                     return e_fail(e, YEP_ERR_UNEXPECTED, e->pos);
                 }
-                /* '[ : v' — single-pair mapping with an empty key */
+                /* '[ : v' — single-pair mapping with an empty key
+                 * (CFD4, ledgered suite-VALID: the suite's tree parses
+                 * the bare-colon entry; libyaml's rejection is the
+                 * ledgered deviation) */
                 if (n >= e->max_depth) {
                     return e_fail(e, YEP_ERR_DEPTH, e->pos);
                 }
@@ -4174,6 +4290,15 @@ static yep_norm_tok norm_step(yep_norm_ctx* c, const char* p, size_t len, size_t
                        p[i + 3] == '\r'));
         if (rescue) {
             c->quote = 0;
+            /* the marker is an unconditional document boundary (the
+             * parser's own law) and the parser's post-cut reset wipes
+             * the flow state; the walk must too, or a flow opened in
+             * an EARLIER document re-lexes the next document's spaces
+             * as token starts ("1,\"\n--- 2[\"\n--- T \"<LS>" --
+             * whole kept the LS raw inside the phantom quote while
+             * every chunked window folded it; the nightly's round 35,
+             * crash-ef534bdf) */
+            c->in_flow = 0;
         } else {
             /* NEL folds inside quotes too; LS/PS stay raw content — but
              * every break still arms the line-start state, or a col-0
@@ -4308,6 +4433,9 @@ static yep_norm_tok norm_step(yep_norm_ctx* c, const char* p, size_t len, size_t
         if (marker || (p[k] == '%' && ind == 0 && c->bs_content) ||
             (!marker && c->bs_indent != (uint32_t)-1 && ind <= (uint32_t)c->bs_indent)) {
             c->bs_open = 0; /* the fold ends: this line processes normally */
+            if (marker) {
+                c->in_flow = 0; /* markers are unconditional boundaries */
+            }
         } else {
             size_t e = k;
             while (e < len && p[e] != '\n') {
@@ -4358,10 +4486,13 @@ static yep_norm_tok norm_step(yep_norm_ctx* c, const char* p, size_t len, size_t
     }
     /* the doc-inline twin ("--- |"): the node hangs off the document,
      * so only a later marker ends its fold (col-0 lines are content) */
-    if (line_start && c->in_flow == 0 && !c->bs_open && ch == '-' && i + 2 < len &&
-        p[i + 1] == '-' && p[i + 2] == '-' &&
+    if (!c->bs_open && ch == '-' && i + 2 < len && p[i + 1] == '-' && p[i + 2] == '-' &&
         (i + 3 >= len || p[i + 3] == ' ' || p[i + 3] == '\t' || p[i + 3] == '\n' ||
-         p[i + 3] == '\r')) {
+         p[i + 3] == '\r') &&
+        (c->at_break || i == 0)) {
+        c->in_flow = 0; /* the marker bounds the document even when the
+                         * walk still believes a flow is open (the same
+                         * round-35 law as the in-quote rescue) */
         size_t k = i + 3;
         while (k < len && (p[k] == ' ' || p[k] == '\t')) {
             k++;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.38.0
+  version: 0.6.41.0
 platform: aarch64-linux
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-23 00:00:00.000000000 Z
+date: 2026-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -39,6 +39,7 @@ files:
 - ext/yeptris_native/cbor_ruby.c
 - ext/yeptris_native/extconf.rb
 - ext/yeptris_native/json_ruby.c
+- ext/yeptris_native/version.h
 - ext/yeptris_native/yeptris_native.c
 - lib/yeptris.rb
 - lib/yeptris/3.3/native.so