yeptris 0.6.33.1 → 0.6.34.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8b675b39f6785429f94719e6181385b944307a0d0ffa4ce110e632ff6a32376
-  data.tar.gz: e9adc21e40e03957bbabc17b6a05ff14b45407d8e664cf4010f40a5696cb2369
+  metadata.gz: f0e9eb62d76c5029f2712f49649f6b8fe366a5a2c78c4d1360148ad9afa101c5
+  data.tar.gz: 81495275aea44c42938fdcb2fbbe3b693d20fc7cae24d0e575fa807436c1f870
 SHA512:
-  metadata.gz: 3321c98a84e187037ccf67af14fef2a4ea0ec2570c2d5f9ffb962ba9199959a8d1cefdbf146963cc208536cbfc575c012078548226456f3ac7f485f91a44f897
-  data.tar.gz: 255ae290f8227e62f026629a5ee69666535c0442fa167877223cbc0cbe2d9ce74398b98c75f706a370765714fe5694fc2b3b165f0539a7ffd8c5e931080092de
+  metadata.gz: 23b3e575e2cf67681d6c1d02d93d3fdc810c1f2233f80d9e81e32870fcd9c3ee204326fe8546d35dc5f1b674b8fd98a8bc1fb42e5a7a90dfe9c62f2e82b21981
+  data.tar.gz: e936ed4c8980fbe336cafb2bb7c60024099695e942adc7ccb967384b3a947f70d9f895a26ee853adecd0c1bb2deb558db3f82468a6d2adf8a1b494ca82eb5e35

data/README.adoc

@@ -5,6 +5,15 @@ https://github.com/leptris/yeptris[libyeptris] — the YAML counterpart
 of libleptris. Psych-compatible semantics, one shared library, zero
 compilation at install.
 
+Part of the yeptris program: *the best (multiple dimensions)
+YAML/JSON parser/builder ever* — conformance, performance,
+safety/hardening, API surfaces, transport correctness, and trust,
+held simultaneously, in C, Ruby, Rust, and JS. This binding is the
+most complete surface: the Psych drop-in namespace, JSON.parse
+parity with the strict duplicate-key contract, CBOR, and ValueML,
+tracking every libyeptris release in lockstep. The achievement
+program lives in the engine's PLAN.md ("The best-ever program").
+
 == Install (development)
 
 The gem loads a shared `libyeptris` — from `YEPTRIS_LIB_PATH`, a

data/ext/yeptris_native/json_ruby.c

@@ -173,9 +173,19 @@ static VALUE jr_object(jr* j) {
 }
 
 static VALUE jr_object_body(jr* j, VALUE h_pre) {
+    /* The pairs staging buffer MUST live in GC-scanned memory: pairs
+     * beyond the current one exist only there once the key/val locals
+     * are reused, so a malloc'd buffer makes them invisible to the
+     * collector — it can free them mid-parse and recycle their slots,
+     * and rb_hash_bulk_insert then inserts garbage (yeptris-ruby#279:
+     * the arm64-darwin SIGSEGV whose fault address was document text).
+     * The stack array IS scanned, so the bulk fast path is bounded at
+     * 31 pairs; beyond that the buffered pairs flush with one
+     * bulk_insert and the rest of the object rides rb_hash_aset. */
     VALUE pairs[64];
     VALUE* pv = pairs;
     size_t pcap = 64, pn = 0, heap_cap = 0;
+    int aset_rest = 0;
     for (;;) {
         jr_ws(j);
         if (j->i >= j->len || j->p[j->i] != '"') { j->err = -2; goto out; }
@@ -186,7 +196,7 @@ static VALUE jr_object_body(jr* j, VALUE h_pre) {
         j->i++;
         VALUE val = jr_value(j);
         if (j->err) goto out;
-        if (yep_ins_mode == YEP_INS_ASET || j->strict_dup) {
+        if (yep_ins_mode == YEP_INS_ASET || j->strict_dup || aset_rest) {
             VALUE h = h_pre == Qundef ? (h_pre = HASH_NEW_CAPA(8)) : h_pre;
             if (j->strict_dup && !NIL_P(rb_hash_aref(h, key))) {
                 j->err = -3;
@@ -196,15 +206,21 @@ static VALUE jr_object_body(jr* j, VALUE h_pre) {
             rb_hash_aset(h, key, val);
         } else {
             if (pn + 2 > pcap) {
-                size_t ncap = pcap * 2;
-                VALUE* nv = malloc(ncap * sizeof(VALUE));
-                if (!nv) { j->err = -1; goto out; }
-                memcpy(nv, pv, pn * sizeof(VALUE));
-                if (pv != pairs) { free(pv); heap_cap = 1; }
-                pv = nv; pcap = ncap;
+                /* buffer full: flush what is staged (no heap staging —
+                 * see the #279 note above); THIS pair and the rest of
+                 * the object ride aset — no continue here, the
+                 * delimiter scan below must still run */
+                VALUE h = (h_pre == Qundef) ? (h_pre = HASH_NEW_CAPA((long)(pn / 2) + 8)) : h_pre;
+                rb_hash_bulk_insert((long)pn, (const VALUE*)pv, h);
+                pn = 0;
+                aset_rest = 1;
+            }
+            if (aset_rest) {
+                rb_hash_aset(h_pre, key, val);
+            } else {
+                pv[pn++] = key;
+                pv[pn++] = val;
             }
-            pv[pn++] = key;
-            pv[pn++] = val;
         }
         jr_ws(j);
         if (j->i >= j->len) { j->err = -2; goto out; }
@@ -351,7 +367,17 @@ double yep_rb_scan_time(const char* p, size_t len, int n) {
 VALUE yep_rb_parse_json(const char* p, size_t len, int strict_dup) {
     jr j;
     memset(&j, 0, sizeof(j));
-    j.p = p; j.len = len; j.enc = rb_utf8_encoding();
+    /* The parse holds j.p across unbounded allocations, and the GC
+     * strategy knobs leave collection ENABLED during the window
+     * (arm64's default is none). A compaction moving the source
+     * string would dangle every j->p read after the move
+     * (yeptris-ruby#279's heap-layout-dependent SIGSEGV class), so
+     * the parse runs on a private copy: one memcpy of the input,
+     * then no Ruby object backs the cursor. */
+    char* own = malloc(len ? len : 1);
+    if (own == NULL) rb_raise(rb_eNoMemError, "yeptris native json");
+    memcpy(own, p, len);
+    j.p = own; j.len = len; j.enc = rb_utf8_encoding();
     j.strict_dup = strict_dup;
     VALUE already = Qtrue;
     if (yep_gc_mode != YEP_GC_NONE) already = rb_gc_disable();
@@ -359,6 +385,7 @@ VALUE yep_rb_parse_json(const char* p, size_t len, int strict_dup) {
     jr_ws(&j);
     if (j.i != len && j.err == 0) j.err = -2;
     free(j.scratch);
+    free(own);
     if (already == Qfalse) rb_gc_enable();
     if (yep_gc_mode == YEP_GC_START && j.err == 0) rb_gc_start();
     if (j.err == -1) rb_raise(rb_eNoMemError, "yeptris native json");
@@ -366,6 +393,11 @@ VALUE yep_rb_parse_json(const char* p, size_t len, int strict_dup) {
         rb_raise(rb_path2class("Yeptris::ParseError"), "duplicate key \"%s\" in JSON object",
                  RSTRING_PTR(j.dup_key));
     }
-    if (j.err != 0) rb_raise(rb_path2class("Yeptris::ParseError"), "native json parse failed");
+    if (j.err != 0) {
+        /* the tape engine's wording ("not strict JSON at byte N") so
+         * consumers can pin one error shape across both routes
+         * (yeptris-ruby#279's adjacent note) */
+        rb_raise(rb_path2class("Yeptris::ParseError"), "not strict JSON at byte %zu", j.i);
+    }
     return v;
 }

data/lib/yeptris/ffi.rb

@@ -228,12 +228,17 @@ module Yeptris
                     %i[pointer size_t int int pointer pointer], :int
     attach_function :yeptris_marshal_node,
                     %i[yeptris_node pointer pointer], :int
+    attach_function :yeptris_marshal_node_ex,
+                    %i[yeptris_node uint32 pointer pointer], :int
     attach_function :yeptris_marshal_free, [:pointer], :void
     # The bulk child drain (#168's quadratic): O(n) iteration for
     # #each/#each_pair. Engines without it fall back to the per-index
     # walk (correct, quadratic).
     CHILDREN_DRAIN = !(@missing ||= []).include?(:yeptris_node_children)
     MARSHAL = !(@missing ||= []).include?(:yeptris_marshal_node)
+    # the strict-dup marshal entry (engine 0.6.34+, yeptris-ruby#278):
+    # gates the JSON fallback's C route in STRICT mode
+    MARSHAL_STRICT_DUP = !(@missing ||= []).include?(:yeptris_marshal_node_ex)
 
     # bulk build (TODO.impl/15 phase D): one call raises a document
     BUILD_SCALAR = 1

data/lib/yeptris/json.rb

@@ -9,10 +9,13 @@ module Yeptris
   # keeps the Psych contract for every input (JSON-shaped included),
   # so the two never drift into each other's semantics.
   #
-  # Engines, fastest first (both exact — the parity spec runs against
+  # Engines, fastest first (all exact — the parity spec runs against
   # whichever is loaded):
   # 1. the native materializer (fused C scan → VALUE; opt-in build)
-  # 2. the record drain + strict conversion walk (always available)
+  # 2. the marshal engine (#278): strict-JSON parse + Marshal 4.8
+  #    emission + ONE core Marshal.load — all C, no per-value Ruby
+  #    (engine 0.6.34+; the strict flag follows the resolved json gem)
+  # 3. the record drain + strict conversion walk (always available)
   module JSON
     class Error < ::Yeptris::Error; end
     class ParseError < Error; end
@@ -39,9 +42,46 @@ module Yeptris
           raise ParseError, e.message
         end
       end
+      # yeptris-ruby#278: with no Ruby-version-matched native build the
+      # pure-Ruby walk measured 0.11x vs JSON.parse on real documents —
+      # the marshal engine keeps the fallback C-side end to end.
+      return marshal_engine(source, 0) if ::Yeptris::FFI::MARSHAL_STRICT_DUP
       tape_engine(source)
     end
 
+    # The marshal engine (#278): yeptris_parse_json gates the strict
+    # grammar, yeptris_marshal_node_ex writes the Ruby Marshal 4.8
+    # stream (STRICT_DUP_KEYS raising on json 3's default contract),
+    # and ONE core Marshal.load materializes the graph. Returns nil
+    # when the engine cannot serve the route (caller keeps walking);
+    # every parse/dup failure raises ParseError.
+    def marshal_engine(source, flags)
+      begin
+        gate = ::Yeptris::Document.parse_json(source)
+      rescue ::Yeptris::ParseError => e
+        raise ParseError, e.message
+      end
+      begin
+        out_p = ::FFI::MemoryPointer.new(:pointer)
+        olen_p = ::FFI::MemoryPointer.new(:size_t)
+        st = ::Yeptris::FFI.yeptris_marshal_node_ex(
+          ::Yeptris::FFI.yeptris_document_root(gate.c_ptr, 0), flags, out_p, olen_p
+        )
+        if st != ::Yeptris::FFI::OK
+          raise ParseError, ::Yeptris::FFI.last_error_message if st == ::Yeptris::FFI::ERROR_PARSE
+
+          return nil # UNSUPPORTED: merge keys et al. cannot occur in JSON
+        end
+        buf = out_p.read_pointer
+        data = buf.read_bytes(::Yeptris::FFI.read_c_size_t(olen_p))
+        data.force_encoding(Encoding::ASCII_8BIT)
+        ::Yeptris::FFI.yeptris_marshal_free(buf)
+        Marshal.load(data)
+      ensure
+        gate.free
+      end
+    end
+
     # The tape engine (issue #81): ONE call validates and materializes
     # the record stream; the walk reads four bulk columns and slices
     # strings straight out of the caller's source — no gate document,
@@ -212,6 +252,12 @@ module Yeptris
         raise ParseError, e.message
       end
       begin
+        if ::Yeptris::FFI::MARSHAL_STRICT_DUP
+          routed = marshal_engine(
+            source, STRICT_DUPLICATE_KEYS ? ::Yeptris::FFI::MARSHAL_STRICT_DUP_KEYS : 0
+          )
+          return routed unless routed.nil?
+        end
         cols = ::Yeptris::FFI::ValueColumns.new
         st = ::Yeptris::FFI.yeptris_value_drain_columns(
           source, source.bytesize, ::Yeptris::FFI::SCHEMA_12_CORE, cols

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

data/vendor/libyeptris/src/CMakeLists.txt

@@ -54,6 +54,7 @@ set(YEPTRIS_SOURCES
     yeptris/emit/emit.c
     yeptris/emit/float/print.c
     yeptris/emit/float/dragon.c
+    yeptris/emit/float/fpconv.c
 )
 
 if(YEPTRIS_WITH_CBOR)

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

@@ -43,6 +43,17 @@ YEPTRIS_API YeptrisStatus yeptris_marshal(const char* data, size_t len, YeptrisS
  * bulk path behind Node#to_ruby (one call, not one per node). */
 YEPTRIS_API YeptrisStatus yeptris_marshal_node(YeptrisNode node, char** out, size_t* out_len);
 
+#define YEPTRIS_MARSHAL_STRICT_DUP_KEYS 1u
+
+/* yeptris_marshal_node with flags. STRICT_DUP_KEYS raises
+ * YEPTRIS_ERROR_PARSE ("duplicate key in object") when any map carries
+ * the same key twice — json 3's default contract; the JSON DOM keeps
+ * both pairs, and the non-strict stream stays last-wins (json 2.x).
+ * Memory: *out is malloc'd, free with yeptris_marshal_free exactly
+ * once; on failure nothing is allocated. */
+YEPTRIS_API YeptrisStatus yeptris_marshal_node_ex(YeptrisNode node, uint32_t flags, char** out,
+                                                  size_t* out_len);
+
 YEPTRIS_API void yeptris_marshal_free(char* out);
 
 #ifdef __cplusplus

data/vendor/libyeptris/src/yeptris/emit/float/api.h

@@ -31,6 +31,11 @@ int yep_d2fixed(double d, uint32_t precision, char* buf);
 /* YAML words for non-finite values (finite input returns 0). */
 int yep_d2s_nonfinite(double d, char* buf);
 
+/* The json-gem float byte shape (grisu2 digits + fpconv emit
+ * windows, vendored in fpconv.c) for JSON-mode canonical scalars
+ * (yeptris#651). 32-byte buffer. Returns the length written. */
+int yep_d2s_json(double d, char* buf);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -0,0 +1,428 @@
+/* fpconv.c — the json-gem float byte shape (yeptris#651).
+ *
+ * Vendored from night-shift/fpconv in the variant carried by the Ruby
+ * json package (ruby/json ext/json/ext/vendor/fpconv.c), which appends
+ * ".0" to integral floats. JSON.generate on json >= 2.10 emits floats
+ * through exactly this code, so byte parity for the JSON writer
+ * (emit_canonical_scalar's JSON route) requires the same digits AND
+ * the same emit windows: grisu2 is not always-shortest, so the
+ * clean-room shortest printer cannot be reshaped to match.
+ *
+ * Boost Software License - Version 1.0 - August 17th, 2003.
+ * Permission is hereby granted, free of charge, to any person or
+ * organization obtaining a copy of this software (see
+ * https://www.boost.org/LICENSE_1_0.txt). Attribution preserved per
+ * the vendoring discipline (cf. the ryu port plan).
+ */
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "emit/float/api.h"
+
+#define npowers 87
+#define steppowers 8
+#define firstpower -348 /* 10 ^ -348 */
+
+#define expmax -32
+#define expmin -60
+
+typedef struct Fp {
+    uint64_t frac;
+    int exp;
+} Fp;
+
+static const Fp powers_ten[] = {
+    {18054884314459144840U, -1220}, {13451937075301367670U, -1193}, {10022474136428063862U, -1166},
+    {14934650266808366570U, -1140}, {11127181549972568877U, -1113}, {16580792590934885855U, -1087},
+    {12353653155963782858U, -1060}, {18408377700990114895U, -1034}, {13715310171984221708U, -1007},
+    {10218702384817765436U, -980},  {15227053142812498563U, -954},  {11345038669416679861U, -927},
+    {16905424996341287883U, -901},  {12595523146049147757U, -874},  {9384396036005875287U, -847},
+    {13983839803942852151U, -821},  {10418772551374772303U, -794},  {15525180923007089351U, -768},
+    {11567161174868858868U, -741},  {17236413322193710309U, -715},  {12842128665889583758U, -688},
+    {9568131466127621947U, -661},   {14257626930069360058U, -635},  {10622759856335341974U, -608},
+    {15829145694278690180U, -582},  {11793632577567316726U, -555},  {17573882009934360870U, -529},
+    {13093562431584567480U, -502},  {9755464219737475723U, -475},   {14536774485912137811U, -449},
+    {10830740992659433045U, -422},  {16139061738043178685U, -396},  {12024538023802026127U, -369},
+    {17917957937422433684U, -343},  {13349918974505688015U, -316},  {9946464728195732843U, -289},
+    {14821387422376473014U, -263},  {11042794154864902060U, -236},  {16455045573212060422U, -210},
+    {12259964326927110867U, -183},  {18268770466636286478U, -157},  {13611294676837538539U, -130},
+    {10141204801825835212U, -103},  {15111572745182864684U, -77},   {11258999068426240000U, -50},
+    {16777216000000000000U, -24},   {12500000000000000000U, 3},     {9313225746154785156U, 30},
+    {13877787807814456755U, 56},    {10339757656912845936U, 83},    {15407439555097886824U, 109},
+    {11479437019748901445U, 136},   {17105694144590052135U, 162},   {12744735289059618216U, 189},
+    {9495567745759798747U, 216},    {14149498560666738074U, 242},   {10542197943230523224U, 269},
+    {15709099088952724970U, 295},   {11704190886730495818U, 322},   {17440603504673385349U, 348},
+    {12994262207056124023U, 375},   {9681479787123295682U, 402},    {14426529090290212157U, 428},
+    {10748601772107342003U, 455},   {16016664761464807395U, 481},   {11933345169920330789U, 508},
+    {17782069995880619868U, 534},   {13248674568444952270U, 561},   {9871031767461413346U, 588},
+    {14708983551653345445U, 614},   {10959046745042015199U, 641},   {16330252207878254650U, 667},
+    {12166986024289022870U, 694},   {18130221999122236476U, 720},   {13508068024458167312U, 747},
+    {10064294952495520794U, 774},   {14996968138956309548U, 800},   {11173611982879273257U, 827},
+    {16649979327439178909U, 853},   {12405201291620119593U, 880},   {9242595204427927429U, 907},
+    {13772540099066387757U, 933},   {10261342003245940623U, 960},   {15290591125556738113U, 986},
+    {11392378155556871081U, 1013},  {16975966327722178521U, 1039},  {12648080533535911531U, 1066}};
+
+static Fp find_cachedpow10(int exp, int* k) {
+    const double one_log_ten = 0.30102999566398114;
+
+    int approx = (int)(-(exp + npowers) * one_log_ten);
+    int idx = (approx - firstpower) / steppowers;
+
+    while (1) {
+        int current = exp + powers_ten[idx].exp + 64;
+
+        if (current < expmin) {
+            idx++;
+            continue;
+        }
+
+        if (current > expmax) {
+            idx--;
+            continue;
+        }
+
+        *k = (firstpower + idx * steppowers);
+
+        return powers_ten[idx];
+    }
+}
+
+#define fracmask 0x000FFFFFFFFFFFFFU
+#define expmask 0x7FF0000000000000U
+#define hiddenbit 0x0010000000000000U
+#define signmask 0x8000000000000000U
+#define expbias (1023 + 52)
+
+#define absv(n) ((n) < 0 ? -(n) : (n))
+#define minv(a, b) ((a) < (b) ? (a) : (b))
+
+static const uint64_t tens[] = {10000000000000000000U,
+                                1000000000000000000U,
+                                100000000000000000U,
+                                10000000000000000U,
+                                1000000000000000U,
+                                100000000000000U,
+                                10000000000000U,
+                                1000000000000U,
+                                100000000000U,
+                                10000000000U,
+                                1000000000U,
+                                100000000U,
+                                10000000U,
+                                1000000U,
+                                100000U,
+                                10000U,
+                                1000U,
+                                100U,
+                                10U,
+                                1U};
+
+static uint64_t get_dbits(double d) {
+    union {
+        double dbl;
+        uint64_t i;
+    } dbl_bits = {d};
+
+    return dbl_bits.i;
+}
+
+static Fp build_fp(double d) {
+    uint64_t bits = get_dbits(d);
+
+    Fp fp;
+    fp.frac = bits & fracmask;
+    fp.exp = (bits & expmask) >> 52;
+
+    if (fp.exp) {
+        fp.frac += hiddenbit;
+        fp.exp -= expbias;
+
+    } else {
+        fp.exp = -expbias + 1;
+    }
+
+    return fp;
+}
+
+static void normalize(Fp* fp) {
+    while ((fp->frac & hiddenbit) == 0) {
+        fp->frac <<= 1;
+        fp->exp--;
+    }
+
+    int shift = 64 - 52 - 1;
+    fp->frac <<= shift;
+    fp->exp -= shift;
+}
+
+static void get_normalized_boundaries(Fp* fp, Fp* lower, Fp* upper) {
+    upper->frac = (fp->frac << 1) + 1;
+    upper->exp = fp->exp - 1;
+
+    while ((upper->frac & (hiddenbit << 1)) == 0) {
+        upper->frac <<= 1;
+        upper->exp--;
+    }
+
+    int u_shift = 64 - 52 - 2;
+
+    upper->frac <<= u_shift;
+    upper->exp = upper->exp - u_shift;
+
+    int l_shift = fp->frac == hiddenbit ? 2 : 1;
+
+    lower->frac = (fp->frac << l_shift) - 1;
+    lower->exp = fp->exp - l_shift;
+
+    lower->frac <<= lower->exp - upper->exp;
+    lower->exp = upper->exp;
+}
+
+static Fp multiply(Fp* a, Fp* b) {
+    const uint64_t lomask = 0x00000000FFFFFFFF;
+
+    uint64_t ah_bl = (a->frac >> 32) * (b->frac & lomask);
+    uint64_t al_bh = (a->frac & lomask) * (b->frac >> 32);
+    uint64_t al_bl = (a->frac & lomask) * (b->frac & lomask);
+    uint64_t ah_bh = (a->frac >> 32) * (b->frac >> 32);
+
+    uint64_t tmp = (ah_bl & lomask) + (al_bh & lomask) + (al_bl >> 32);
+    /* round up */
+    tmp += 1U << 31;
+
+    Fp fp = {ah_bh + (ah_bl >> 32) + (al_bh >> 32) + (tmp >> 32), a->exp + b->exp + 64};
+
+    return fp;
+}
+
+static void round_digit(char* digits, int ndigits, uint64_t delta, uint64_t rem, uint64_t kappa,
+                        uint64_t frac) {
+    while (rem < frac && delta - rem >= kappa &&
+           (rem + kappa < frac || frac - rem > rem + kappa - frac)) {
+        digits[ndigits - 1]--;
+        rem += kappa;
+    }
+}
+
+static int generate_digits(Fp* fp, Fp* upper, Fp* lower, char* digits, int* K) {
+    uint64_t wfrac = upper->frac - fp->frac;
+    uint64_t delta = upper->frac - lower->frac;
+
+    Fp one;
+    one.frac = 1ULL << -upper->exp;
+    one.exp = upper->exp;
+
+    uint64_t part1 = upper->frac >> -one.exp;
+    uint64_t part2 = upper->frac & (one.frac - 1);
+
+    int idx = 0, kappa = 10;
+    const uint64_t* divp;
+    /* 1000000000 */
+    for (divp = tens + 10; kappa > 0; divp++) {
+        uint64_t div = *divp;
+        unsigned digit = (unsigned)(part1 / div);
+
+        if (digit || idx) {
+            digits[idx++] = (char)(digit + '0');
+        }
+
+        part1 -= digit * div;
+        kappa--;
+
+        uint64_t tmp = (part1 << -one.exp) + part2;
+        if (tmp <= delta) {
+            *K += kappa;
+            round_digit(digits, idx, delta, tmp, div << -one.exp, wfrac);
+
+            return idx;
+        }
+    }
+
+    /* 10 */
+    const uint64_t* unit = tens + 18;
+
+    while (true) {
+        part2 *= 10;
+        delta *= 10;
+        kappa--;
+
+        unsigned digit = (unsigned)(part2 >> -one.exp);
+        if (digit || idx) {
+            digits[idx++] = (char)(digit + '0');
+        }
+
+        part2 &= one.frac - 1;
+        if (part2 < delta) {
+            *K += kappa;
+            round_digit(digits, idx, delta, part2, one.frac, wfrac * *unit);
+
+            return idx;
+        }
+
+        unit--;
+    }
+}
+
+static int grisu2(double d, char* digits, int* K) {
+    Fp w = build_fp(d);
+
+    Fp lower, upper;
+    get_normalized_boundaries(&w, &lower, &upper);
+
+    normalize(&w);
+
+    int k;
+    Fp cp = find_cachedpow10(upper.exp, &k);
+
+    w = multiply(&w, &cp);
+    upper = multiply(&upper, &cp);
+    lower = multiply(&lower, &cp);
+
+    lower.frac++;
+    upper.frac--;
+
+    *K = -k;
+
+    return generate_digits(&w, &upper, &lower, digits, K);
+}
+
+static int emit_digits(char* digits, int ndigits, char* dest, int K, bool neg) {
+    int exp = absv(K + ndigits - 1);
+
+    if (K >= 0 && exp < 15) {
+        memcpy(dest, digits, (size_t)ndigits);
+        memset(dest + ndigits, '0', (size_t)K);
+
+        /* add a .0 to mark this as a float. */
+        dest[ndigits + K] = '.';
+        dest[ndigits + K + 1] = '0';
+
+        return ndigits + K + 2;
+    }
+
+    /* write decimal w/o scientific notation */
+    if (K < 0 && (K > -7 || exp < 10)) {
+        int offset = ndigits - absv(K);
+        /* fp < 1.0 -> write leading zero */
+        if (offset <= 0) {
+            offset = -offset;
+            dest[0] = '0';
+            dest[1] = '.';
+            memset(dest + 2, '0', (size_t)offset);
+            memcpy(dest + offset + 2, digits, (size_t)ndigits);
+
+            return ndigits + 2 + offset;
+
+            /* fp > 1.0 */
+        } else {
+            memcpy(dest, digits, (size_t)offset);
+            dest[offset] = '.';
+            memcpy(dest + offset + 1, digits + offset, (size_t)(ndigits - offset));
+
+            return ndigits + 1;
+        }
+    }
+
+    /* write decimal w/ scientific notation */
+    ndigits = minv(ndigits, 18 - neg);
+
+    int idx = 0;
+    dest[idx++] = digits[0];
+
+    if (ndigits > 1) {
+        dest[idx++] = '.';
+        memcpy(dest + idx, digits + 1, (size_t)(ndigits - 1));
+        idx += ndigits - 1;
+    }
+
+    dest[idx++] = 'e';
+
+    char sign = K + ndigits - 1 < 0 ? '-' : '+';
+    dest[idx++] = sign;
+
+    int cent = 0;
+
+    if (exp > 99) {
+        cent = exp / 100;
+        dest[idx++] = (char)(cent + '0');
+        exp -= cent * 100;
+    }
+    if (exp > 9) {
+        int dec = exp / 10;
+        dest[idx++] = (char)(dec + '0');
+        exp -= dec * 10;
+
+    } else if (cent) {
+        dest[idx++] = '0';
+    }
+
+    dest[idx++] = (char)(exp % 10 + '0');
+
+    return idx;
+}
+
+static int filter_special(double fp, char* dest) {
+    if (fp == 0.0) {
+        dest[0] = '0';
+        dest[1] = '.';
+        dest[2] = '0';
+        return 3;
+    }
+
+    uint64_t bits = get_dbits(fp);
+
+    bool nan = (bits & expmask) == expmask;
+
+    if (!nan) {
+        return 0;
+    }
+
+    if (bits & fracmask) {
+        dest[0] = 'n';
+        dest[1] = 'a';
+        dest[2] = 'n';
+
+    } else {
+        dest[0] = 'i';
+        dest[1] = 'n';
+        dest[2] = 'f';
+    }
+
+    return 3;
+}
+
+/* Fast and accurate double to string conversion based on Florian
+ * Loitsch's Grisu-algorithm. The generated string is never longer
+ * than 32 characters and is not null terminated. Returns the number
+ * of written characters. */
+static int fpconv_dtoa(double d, char dest[32]) {
+    char digits[18];
+
+    int str_len = 0;
+    bool neg = false;
+
+    if (get_dbits(d) & signmask) {
+        dest[0] = '-';
+        str_len++;
+        neg = true;
+    }
+
+    int spec = filter_special(d, dest + str_len);
+
+    if (spec) {
+        return str_len + spec;
+    }
+
+    int K = 0;
+    int ndigits = grisu2(d, digits, &K);
+
+    str_len += emit_digits(digits, ndigits, dest + str_len, K, neg);
+
+    return str_len;
+}
+
+int yep_d2s_json(double d, char* buf) {
+    return fpconv_dtoa(d, buf);
+}

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

@@ -377,7 +377,10 @@ static void emit_canonical_scalar(yep_writer* w, const yep_dnode* n) {
             tmp[tl] = '\0';
             double d = strtod(tmp, &end);
             if (end != NULL && *end == '\0' && end != tmp) {
-                int wl = yep_d2s_shortest(d, buf);
+                /* JSON floats carry the json-gem byte shape so
+                 * JSON.generate round trips stay byte-identical
+                 * (yeptris#651); YAML keeps the shortest shape. */
+                int wl = w->json ? yep_d2s_json(d, buf) : yep_d2s_shortest(d, buf);
                 wr_put(w, buf, (uint32_t)wl);
                 return;
             }

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

@@ -656,6 +656,171 @@ static YeptrisStatus map_fail(int rc) {
     return rc == -1 ? YEPTRIS_ERROR_MEMORY : YEPTRIS_ERROR_UNSUPPORTED;
 }
 
+/* ---- strict duplicate-key pre-scan (yeptris-ruby#278) ----------------
+ *
+ * json 3 makes duplicate keys an error by DEFAULT; the marshal route
+ * must raise before any bytes are written, exactly like the native
+ * materializer's rb_hash_aref probe. One linear pass over the same
+ * records the writer consumes — the writer itself stays untouched
+ * (the dup law lives here, once). The JSON DOM keeps both pairs
+ * ("{\"a\":1,\"a\":2}" map_count=2), so the records see them; the
+ * non-strict Marshal stream stays last-wins, which is json 2.x's
+ * contract.
+ *
+ * Key identity is the record's typed payload: span kinds compare the
+ * arena bytes, the rest compare (kind, b, payload). One growable
+ * open-addressing table serves the INNERMOST open map (cleared on
+ * close) — duplicates are per-map by definition.
+ */
+
+typedef struct {
+    uint64_t p; /* 0 = empty slot (payload 0 with kind 0 cannot be a key) */
+    uint32_t off, len;
+    uint8_t kind, b;
+} dup_slot;
+
+typedef struct {
+    dup_slot* slots;
+    size_t cap; /* power of two */
+} dup_set;
+
+static uint64_t dup_hash(const dup_slot* k, const char* arena) {
+    uint64_t h = 1469598103934665603ull;
+    if (k->len != UINT32_MAX && (k->kind == YEP_V_STR || k->kind == YEP_V_TIMESTAMP ||
+                                 k->kind == YEP_V_ALIAS || k->kind == YEP_V_ANCHOR)) {
+        for (uint32_t i = 0; i < k->len; i++) {
+            h ^= (unsigned char)arena[k->off + i];
+            h *= 1099511628211ull;
+        }
+    }
+    h ^= k->kind;
+    h *= 1099511628211ull;
+    h ^= k->b;
+    h *= 1099511628211ull;
+    h ^= k->p;
+    h *= 1099511628211ull;
+    return h;
+}
+
+static int dup_eq(const dup_slot* a, const dup_slot* b, const char* arena) {
+    if (a->kind != b->kind || a->b != b->b || a->p != b->p) {
+        return 0;
+    }
+    int spanned = (a->kind == YEP_V_STR || a->kind == YEP_V_TIMESTAMP || a->kind == YEP_V_ALIAS ||
+                   a->kind == YEP_V_ANCHOR);
+    if (!spanned) {
+        return 1;
+    }
+    if (a->len != b->len) {
+        return 0;
+    }
+    return a->len == 0 || memcmp(arena + a->off, arena + b->off, a->len) == 0;
+}
+
+static int dup_set_grow(dup_set* s) {
+    size_t ncap = s->cap ? s->cap * 2 : 16;
+    dup_slot* ns = calloc(ncap, sizeof(*ns));
+    if (ns == NULL) {
+        return -1;
+    }
+    if (s->slots != NULL) {
+        free(s->slots);
+    }
+    s->slots = ns;
+    s->cap = ncap;
+    return 0;
+}
+
+/* 1 = duplicate found (TLS error set), 0 = clean, -1 = oom */
+static int strict_dup_scan(const yep_value_ctx* c) {
+    dup_set s = {NULL, 0};
+    int rc = 0;
+    const YeptrisValue* vals = c->vals;
+    for (size_t i = 0; i < c->n && rc == 0; i++) {
+        const YeptrisValue* v = &vals[i];
+        if (v->kind == YEP_V_MAP_OPEN) {
+            if (s.slots != NULL) {
+                memset(s.slots, 0, s.cap * sizeof(*s.slots)); /* innermost map only */
+            }
+            continue;
+        }
+        if (v->kind == YEP_V_CLOSE || v->is_key != 1) {
+            continue;
+        }
+        dup_slot k = {v->p, v->off, v->len, v->kind, v->b};
+        if (k.p == 0) {
+            k.p = 1; /* never aliases the empty-slot sentinel */
+        }
+        if (s.cap == 0 && dup_set_grow(&s) != 0) {
+            rc = -1;
+            break;
+        }
+        uint64_t h = dup_hash(&k, c->arena);
+        for (;;) {
+            dup_slot* slot = &s.slots[h & (s.cap - 1)];
+            if (slot->p == 0) {
+                *slot = k;
+                break;
+            }
+            if (dup_eq(slot, &k, c->arena)) {
+                yep_error_set(yep_error_tls(), YEP_ERR_UNEXPECTED, 0, 0, 0,
+                              "duplicate key in object");
+                rc = 1;
+                break;
+            }
+            h++;
+        }
+    }
+    free(s.slots);
+    return rc;
+}
+
+static int dom_subtree_tagged(const yep_dom* d, uint32_t id);
+static YeptrisStatus marshal_records(const yep_value_ctx* c, int compat, YeptrisMarshalMode mode,
+                                     int node_mode, char** out, size_t* out_len);
+
+YEPTRIS_API YeptrisStatus yeptris_marshal_node_ex(YeptrisNode node, uint32_t flags, char** out,
+                                                  size_t* out_len) {
+    if (node == NULL || out == NULL || out_len == NULL ||
+        (flags & ~YEPTRIS_MARSHAL_STRICT_DUP_KEYS) != 0) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    *out = NULL;
+    *out_len = 0;
+    yeptris_node* h = (yeptris_node*)node;
+    yep_dom* dom = yep_doc_dom(h->doc); /* #378: a lazy parse carries the
+                                         * tape — the tree materializes here */
+    if (dom == NULL) {
+        return YEPTRIS_ERROR_MEMORY; /* the lazy route's retry contract */
+    }
+    if (dom_subtree_tagged(dom, h->id) != 0) {
+        yep_error_set(yep_error_tls(), YEP_ERR_UNEXPECTED, 0, 0, 0,
+                      "marshal: explicitly tagged node not expressible; "
+                      "fall back to the value walk");
+        return YEPTRIS_ERROR_UNSUPPORTED;
+    }
+    yep_value_ctx* c = NULL;
+    if (yep_values_from_dom(dom, h->id, 0, &c) != 0) {
+        return YEPTRIS_ERROR_MEMORY;
+    }
+    if ((flags & YEPTRIS_MARSHAL_STRICT_DUP_KEYS) != 0) {
+        int drc = strict_dup_scan(c);
+        if (drc != 0) {
+            yep_value_ctx_free(c);
+            return drc < 0 ? YEPTRIS_ERROR_MEMORY : YEPTRIS_ERROR_PARSE;
+        }
+    }
+    YeptrisStatus st = marshal_records(c, h->doc->schema == YEPTRIS_SCHEMA_11_COMPAT,
+                                       YEPTRIS_MARSHAL_ALL_DOCS, 1, out, out_len);
+    if (st == YEPTRIS_ERROR_UNSUPPORTED) {
+        yep_error_set(yep_error_tls(), YEP_ERR_UNEXPECTED, 0, 0, 0,
+                      "marshal: merge key, timestamp or forward alias not expressible; "
+                      "fall back to the value walk");
+    }
+    yep_value_ctx_free(c);
+    return st;
+}
+
 static YeptrisStatus marshal_records(const yep_value_ctx* c, int compat, YeptrisMarshalMode mode,
                                      int node_mode, char** out, size_t* out_len) {
     *out = NULL;
@@ -750,36 +915,7 @@ static int dom_subtree_tagged(const yep_dom* d, uint32_t id) {
 }
 
 YEPTRIS_API YeptrisStatus yeptris_marshal_node(YeptrisNode node, char** out, size_t* out_len) {
-    if (node == NULL || out == NULL || out_len == NULL) {
-        return YEPTRIS_ERROR_ARG;
-    }
-    *out = NULL;
-    *out_len = 0;
-    yeptris_node* h = (yeptris_node*)node;
-    yep_dom* dom = yep_doc_dom(h->doc); /* #378: a lazy parse carries the
-                                         * tape — the tree materializes here */
-    if (dom == NULL) {
-        return YEPTRIS_ERROR_MEMORY; /* the lazy route's retry contract */
-    }
-    if (dom_subtree_tagged(dom, h->id) != 0) {
-        yep_error_set(yep_error_tls(), YEP_ERR_UNEXPECTED, 0, 0, 0,
-                      "marshal: explicitly tagged node not expressible; "
-                      "fall back to the value walk");
-        return YEPTRIS_ERROR_UNSUPPORTED;
-    }
-    yep_value_ctx* c = NULL;
-    if (yep_values_from_dom(dom, h->id, 0, &c) != 0) {
-        return YEPTRIS_ERROR_MEMORY;
-    }
-    YeptrisStatus st = marshal_records(c, h->doc->schema == YEPTRIS_SCHEMA_11_COMPAT,
-                                       YEPTRIS_MARSHAL_ALL_DOCS, 1, out, out_len);
-    if (st == YEPTRIS_ERROR_UNSUPPORTED) {
-        yep_error_set(yep_error_tls(), YEP_ERR_UNEXPECTED, 0, 0, 0,
-                      "marshal: merge key, timestamp or forward alias not expressible; "
-                      "fall back to the value walk");
-    }
-    yep_value_ctx_free(c);
-    return st;
+    return yeptris_marshal_node_ex(node, 0, out, out_len);
 }
 
 YEPTRIS_API void yeptris_marshal_free(char* out) {

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

@@ -3684,9 +3684,15 @@ static int e_parse_value(yep_engine* e, yep_ctx ctx, uint16_t floor_col) {
                     continue;
                 }
                 int pc_comment = (pc == '#' && (prev == ' ' || prev == '\t'));
+                /* an opening quote is node CONTENT, not a prop: the walk
+                 * must stop there ('only_props' stays 0) — walking on put
+                 * the line's ' #' inside the quoted span, read the quoted
+                 * key of the nightly's run 39223056891 ("x:\n!t \"a #b\": y")
+                 * as a comment and rejected the keyed pair */
                 if (pc == '&' || pc == '!' || pc == '<' || pc == ',' || pc == '>' ||
                     (pc != '\n' && pc != '\r' && !pc_comment &&
-                     !yep_ct_is((unsigned char)pc, YEP_CT_FLOW_IND) && pc != ':' && pc != ' ')) {
+                     !yep_ct_is((unsigned char)pc, YEP_CT_FLOW_IND) && pc != ':' && pc != ' ' &&
+                     pc != '"' && pc != '\'')) {
                     prev = pc;
                     t++;
                     continue;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.33.1
+  version: 0.6.34.1
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-19 00:00:00.000000000 Z
+date: 2026-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -123,6 +123,7 @@ files:
 - vendor/libyeptris/src/yeptris/emit/float/api.h
 - vendor/libyeptris/src/yeptris/emit/float/dragon.c
 - vendor/libyeptris/src/yeptris/emit/float/floatint.h
+- vendor/libyeptris/src/yeptris/emit/float/fpconv.c
 - vendor/libyeptris/src/yeptris/emit/float/print.c
 - vendor/libyeptris/src/yeptris/emit/style.c
 - vendor/libyeptris/src/yeptris/emit/style.h