yeptris 0.6.33.2-aarch64-linux → 0.6.34.2-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f539306a31099d38b0040d34986abe9aecaf7f4f7950f78fbd828002d0d186d
-  data.tar.gz: a325b02fec0989a9d21ee8615c7993d05e9a9b2f7062a64560656a4699160109
+  metadata.gz: 35e1c278d17a938cfdf797f05231844362cd5eff838dcc07f7f6626ac6b0615a
+  data.tar.gz: f0a05034530c91ccde139ba2c64c1deb88ded39a752e1e281480499b1f6c1052
 SHA512:
-  metadata.gz: 0ac10a304643b6fa2dd77979974b0809c6032c8918a9c9a9e192667e479338f0b037a45f1c240e20dccb110f354d46854c3cde5414d14a861a9577b353baba83
-  data.tar.gz: 1ba4bb2d25f6c2cbca95360336b8a8827533dace201394f8f92c2cea6395743bee00613963aa650ea2e9cafdc4ff647e7a5db4b251b25086a85491bfee6c6349
+  metadata.gz: 43f40a6018a4663aeca90017a7bf631dfa4f8acebd324463711a4103a4f9435e884cec06512ab4ca1570bde1efe108097443c5ad4e5b16b94458d0f0fbaead46
+  data.tar.gz: 3f117e473a8100ed25ff2253ddd38cabca9c945545d0af67011ff2ae016d22ac72b6f61e5d68e629e21489f29cc169a9cdecdc08a33e44794c39e181a11944ac

data/lib/yeptris/json.rb

@@ -45,7 +45,14 @@ module Yeptris
       # 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
+      # STRICT_DUPLICATE_KEYS rides the flags: json >= 3's default
+      # contract raises on duplicates. The flags were hardcoded to 0
+      # here, so every lane without the native ext (windows-latest has
+      # none) answered last-wins under json >= 3 — found by canon's
+      # dependent CI, whose parity pin now names the lane.
+      return marshal_engine(
+        source, STRICT_DUPLICATE_KEYS ? ::Yeptris::FFI::MARSHAL_STRICT_DUP_KEYS : 0
+      ) if ::Yeptris::FFI::MARSHAL_STRICT_DUP
       tape_engine(source)
     end
 

data/lib/yeptris/yaml.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+# The BulkBuilder's `when Date` must not depend on the caller loading
+# stdlib's date (issue #289: a clean `require "yeptris"` raised NameError
+# before the DumpError branch could run). Psych requires date the same way.
+require "date"
+
 # Self-sufficient (issue #95): the neutral surface is a valid entry
 # point on its own — lutaml-model requires exactly this file.
 require "yeptris"

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.2".freeze
+  VERSION = "0.6.34.2".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.2
+  version: 0.6.34.2
 platform: aarch64-linux
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-20 00:00:00.000000000 Z
+date: 2026-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -126,6 +126,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