yeptris 0.6.42.0 → 0.6.43.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7cda6785f823f016de5e8fedc14d17037af6e79edd697d801172adf5a81142d
-  data.tar.gz: 7a0d69532d73b0300286f47e9512c51511aa79f82a25c0014ad10dae0b9b509f
+  metadata.gz: 5fe6c4145817f5a8c4dd753ea92f523a41ebcef08ae6fc17cf12a4be8d5fcc7e
+  data.tar.gz: 46989aada81d5d8cb75ea73d51af0be671326041fec93ca03ba2184fb98fc0f0
 SHA512:
-  metadata.gz: da390e1cab7318047c491e1230398a248d7a55517ef6effec0100912a284ddd6ff35ee78f8a6a8c3c7fe3ecd7dffe952b67ff8fe3bd4748f1d50dd95b4b267e6
-  data.tar.gz: 9bb34364236adc7dab714d3020efca49ddac8b986baa9d71041efc13151a35f9bde8788e92cd80fbefd38d07b62e4e972ca3b1bdccebb9719c8e40d93c7521bf
+  metadata.gz: a896a1a0a23c9ab475f1dd642e44cc0dd30288416da97f67b2b6d037957c70cee08e3c37b6e76d09b21ba71884f87759cf460536d5033e988ea1b4cdd299b7d4
+  data.tar.gz: 8838bb5ee6f826da3ecb17316c328cf53ecd690e89f927a7c579b04ac62d17e31ca23e7bf0fcfe7d3ecd17e020223021d9638fa095c1aff4967db128ec552746

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

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

@@ -66,6 +66,8 @@ static void wr_col_update(yep_writer* w, const char* p, uint32_t n) {
     w->col += (int)n;
 }
 
+static void wr_reserve(yep_writer* w, size_t need);
+
 static void wr_grow(yep_writer* w, size_t need) {
     if (w->oom || w->p == NULL) {
         w->oom = w->p == NULL;
@@ -98,20 +100,53 @@ static void wr_put(yep_writer* w, const char* p, uint32_t n) {
      * (len + n == cap) put that NUL one byte past the buffer — the
      * 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) {
-        if (w->bounded) {
-            w->oom = 1; /* keep counting: the trusted caller reads the size */
-        } else {
-            wr_grow(w, n);
+    if (w->reserve < (size_t)n) {
+        wr_reserve(w, n);
+        if (w->oom) {
+            w->len += n; /* keep counting: the caller fails on oom */
+            return;
         }
     }
-    if (w->oom) {
-        w->len += n; /* keep counting: the caller fails on oom */
-        return;
+    if ((size_t)n <= w->reserve) {
+        w->reserve -= n;
+    } else {
+        w->reserve = 0; /* grow=0 trusts the count: the write rides past
+                         * the bookkeeping exactly as before */
     }
     memcpy(w->p + w->len, p, n);
     w->len += n;
+}
+
+/* #739 lane 1: refill the writable reservation. The grow and flush
+ * checks move from every byte to every refill; the watermark law is
+ * unchanged in spirit (append-only output — any crossing is a safe
+ * cut, a sink just sees chunks up to one reserve past the mark).
+ * ONLY the growing routes hold a reservation: the caller-buffer and
+ * trusted-count routes keep cap bookkeeping that is not the writer's
+ * to reason about (several set cap=0), so their writes stay exactly
+ * the old per-call trust. */
+static void wr_reserve(yep_writer* w, size_t need) {
+    /* the FLUSH runs for every route: the fixed-window streaming route
+     * (grow=0) has no reservation, so this refill path is its ONLY
+     * flush point -- skipping it let len ride to cap and the next
+     * write landed past the window (ASan: heap-buffer-overflow WRITE
+     * of size 2 exactly 0 bytes after the 128K region; ubuntu's
+     * allocator freed-corrupted, macOS's slack absorbed it). */
     wr_maybe_flush(w);
+    if (!w->grow || w->bounded) {
+        w->reserve = 0;
+        return;
+    }
+    if (w->oom) {
+        return;
+    }
+    if (w->len + need + 1 > w->cap) { /* +1: the terminator */
+        wr_grow(w, need);
+        if (w->oom) {
+            return;
+        }
+    }
+    w->reserve = w->cap - w->len - 1;
 }
 
 static void wr_byte(yep_writer* w, char c) {
@@ -125,20 +160,17 @@ static void wr_byte(yep_writer* w, char c) {
         w->len++;
         return;
     }
-    if (w->grow && w->len + 2 > w->cap) { /* +1 write, +1 terminator */
-        if (w->bounded) {
-            w->oom = 1; /* keep counting: the trusted caller reads the size */
-        } else {
-            wr_grow(w, 1);
+    if (w->reserve == 0) {
+        wr_reserve(w, 1);
+        if (w->oom) {
+            w->len++;
+            return;
         }
     }
-    if (w->oom) {
-        w->len++;
-        return;
+    if (w->reserve > 0) {
+        w->reserve--; /* grow=0 routes keep it at 0: per-call trust */
     }
-    w->p[w->len] = c;
-    w->len++;
-    wr_maybe_flush(w);
+    w->p[w->len++] = c;
 }
 
 static void wr_indent(yep_writer* w, int depth) {
@@ -299,21 +331,34 @@ static void emit_dq_json(yep_writer* w, const char* p, uint32_t n) {
         NULL, "\\f", "\\r", NULL, NULL, NULL, NULL, NULL, NULL,  NULL,  NULL,
         NULL, NULL,  NULL,  NULL, NULL, NULL, NULL, NULL, NULL,  NULL,
     };
+    static const char hd[] = "0123456789abcdef";
+    /* run-batched (the #352 emit_dq shape): clean spans ride one
+     * wr_put each — per-byte wr_byte calls were 14% of the json
+     * write lane's leaf samples (yeptris#739) */
+    uint32_t run = 0;
     for (uint32_t i = 0; i < n; i++) {
         unsigned char c = (unsigned char)p[i];
+        if (c >= 0x20 && c != '"' && c != '\\') {
+            run++;
+            continue;
+        }
+        if (run) {
+            wr_put(w, p + i - run, run);
+            run = 0;
+        }
         if (c < 32 && named[c] != NULL) {
             wr_put(w, named[c], 2);
         } else if (c == '"' || c == '\\') {
             wr_byte(w, '\\');
             wr_byte(w, (char)c);
-        } else if (c < 0x20) {
-            static const char hd[] = "0123456789abcdef";
+        } else {
             char hex[6] = {'\\', 'u', '0', '0', hd[(c >> 4) & 0xf], hd[c & 0xf]};
             wr_put(w, hex, 6);
-        } else {
-            wr_byte(w, (char)c);
         }
     }
+    if (run) {
+        wr_put(w, p + n - run, run);
+    }
     wr_byte(w, '"');
 }
 
@@ -1101,6 +1146,9 @@ static void emit_block_map(yep_emitter* em, uint32_t id, int content_col) {
                     if (w->oom) {
                         w->len += total; /* keep counting: the caller fails on oom */
                     } else {
+                        /* the fused write bypasses wr_put/wr_byte: keep
+                         * the reservation honest (the #739 lane-1 law) */
+                        w->reserve = (size_t)total <= w->reserve ? w->reserve - (size_t)total : 0;
                         char* q = w->p + w->len;
                         if (nl) {
                             *q++ = '\n';
@@ -1360,6 +1408,7 @@ size_t yep_emit_run(yep_emitter* em, int dry) {
     const yep_dom* d = em->doc->dom;
     w->dry = dry;
     w->len = 0;
+    w->reserve = 0;
     w->last = 0;
     w->force_flow = 0;
     w->flushed = 0;

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

@@ -57,9 +57,13 @@ 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 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 */
+    /* #739 lane 1: writable bytes guaranteed at w->p + w->len. The
+     * grow/flush checks run once per refill instead of once per byte;
+     * 0 at run entry and whenever the guarantee lapses. */
+    size_t reserve;
     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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.42.0
+  version: 0.6.43.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-24 00:00:00.000000000 Z
+date: 2026-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi