yeptris 0.6.39.1-arm-linux-eabihf → 0.6.42.0-arm-linux-eabihf

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b550d3511828de23b6a8c925382eff1d637a9c8391ab8952ef7fbfa3b2d57549
-  data.tar.gz: bbe90991005ccb7718ecd3f465fe5563b937153c5ee39d02014baed5a52b725f
+  metadata.gz: 7abcdd568d0a95540be90ecbe988bb575aa4e97d8a7bda0292dc7b578ff7ca5f
+  data.tar.gz: 834db1e48082ef9b40cc0ceda0ffcdd17a4fc1bcb5324a6ce53f09be6cc9213a
 SHA512:
-  metadata.gz: c9e5c875e40a7220c4a9183f3f000a39d169b1462e425dc37d4cc1389cc2496d52b9d53746ee4759e47d1e2cbc9eea0f4af5e3cd910e085d6d893d3082b971dd
-  data.tar.gz: 331d2e087e1dc215eb0a5a3dc7e2f8a0e2ca9755ef49e201eed2c08a04c3931653850a26cfa7cf0af88ed99b02e14a14d6f6c9e4a018712d5ccdb234245d2f81
+  metadata.gz: '039d4d530fb04d72b3afe2f67ab249137d88d3e0c275141aeffd2dd8cc15a7f686c22e6416e11d7d7ade99a5ead7a9f465c7ebbad8a87a417af8c9222e5aff23'
+  data.tar.gz: 894301188585b5318d4d6896e0c2c4e8ff6a74e2f746361294e242dbcf52fadc7481b3f1fe6061bfafe92106b841ca155df35339102da048659e0e9d7345ef2b

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 42
+#define YEPTRIS_VERSION_STRING "0.6.42"
+
+#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.39.1".freeze
+  VERSION = "0.6.42.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.39
+    VERSION 0.6.42
     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;
@@ -227,8 +293,15 @@ YEPTRIS_API char* yeptris_serialize_json(YeptrisDocument handle, size_t* len) {
     if (em.w.canonical && !yep_nametab_init(&em.canon_names, yep_system_allocator())) {
         return NULL;
     }
-    size_t need = yep_emit_run(&em, 1);
-    char* out = malloc(need + 1);
+    /* #739: ONE wet pass into a growable buffer — the dry exact-sizing
+     * pass priced ~2x on the json lane (the #352 slice-2 pattern);
+     * the estimate starts at the input size (+64) and doubles on
+     * demand, shrink-to-fit at the end. */
+    size_t est = em.doc->dom->input_len + 64;
+    if (est < 256) {
+        est = 256;
+    }
+    char* out = (char*)malloc(est);
     if (out == NULL) {
         if (em.canon_names.sys != NULL) {
             yep_nametab_free(&em.canon_names);
@@ -236,7 +309,24 @@ YEPTRIS_API char* yeptris_serialize_json(YeptrisDocument handle, size_t* len) {
         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;
+    out = em.w.p; /* wr_grow reallocs through w->p — the local is stale */
+    if (em.w.oom || em.w.unserializable) {
+        free(out);
+        if (em.canon_names.sys != NULL) {
+            yep_nametab_free(&em.canon_names);
+        }
+        return NULL;
+    }
+    if (em.w.cap - (wrote + 1) > em.w.cap / 8) {
+        char* tight = (char*)realloc(out, wrote + 1);
+        if (tight != NULL) {
+            out = tight;
+        }
+    }
     if (em.canon_names.sys != NULL) {
         yep_nametab_free(&em.canon_names);
     }
@@ -260,6 +350,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 +417,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 +481,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 +552,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);
@@ -892,6 +912,9 @@ static void emit_node(yep_emitter* em, uint32_t id, int parent_col, int as_key);
  * written). Conservative factor-4 estimate for every expandable
  * byte — overestimating only takes the (always-legal) explicit form. */
 static int key_written_over_limit(yep_writer* w, const yep_dnode* kn) {
+    if (w->json) {
+        return 0; /* JSON has no simple-key law: every key writes (#739) */
+    }
     uint64_t est = 2; /* the quotes */
     yep_view kv_ = wv(w, kn->value);
     const unsigned char* q = (const unsigned char*)kv_.p;
@@ -1069,7 +1092,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;
                 }
             }
@@ -1187,10 +1207,18 @@ static yep_view e_resolve_tag_raw(yep_engine* e, yep_view tag) {
     if (tag.len == 1 && tag.p[0] == '!') {
         return tag;
     }
-    /* longest matching handle wins */
+    /* longest matching handle wins; a redefined PRIMARY ('%TAG ! ...')
+     * cannot capture a '!!'-led tag — the secondary handle resolves
+     * through its own entry or the fixed tag:yaml.org,2002: default
+     * (spec 6.8.2.2; libyaml: "%TAG ! !p/" + "!!i" is
+     * tag:yaml.org,2002:i, the nightly's round 52, crash-763bb852) */
+    int secondary = tag.len >= 2 && tag.p[0] == '!' && tag.p[1] == '!';
     int best = -1;
     uint32_t best_len = 0;
     for (int i = 0; i < e->tagmap_n; i++) {
+        if (secondary && e->tagmap[i].handle.len == 1) {
+            continue;
+        }
         if (tag.len >= e->tagmap[i].handle.len && e->tagmap[i].handle.len > best_len &&
             memcmp(tag.p, e->tagmap[i].handle.p, e->tagmap[i].handle.len) == 0) {
             best = i;
@@ -2186,8 +2214,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;
@@ -2203,6 +2234,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;
@@ -2210,20 +2242,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;
 
@@ -2263,6 +2296,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;
@@ -2292,6 +2326,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;
             }
@@ -2319,6 +2357,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' ||
@@ -2342,6 +2389,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;
@@ -2368,10 +2416,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];
@@ -2550,6 +2603,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;
                 }
             }
@@ -2584,6 +2640,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;
@@ -2618,6 +2686,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;
@@ -2751,6 +2820,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;
@@ -2849,7 +2919,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) {
@@ -2866,13 +2937,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);
                 }
@@ -4188,6 +4298,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
@@ -4322,6 +4441,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') {
@@ -4372,10 +4494,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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.39.1
+  version: 0.6.42.0
 platform: arm-linux-eabihf
 authors:
 - Ribose Inc.
@@ -38,6 +38,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.4/native.so