yeptris 0.6.16.2-powerpc64le-linux → 0.6.17.1-powerpc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8affd114cd9f63e7079742015b2b34872af58c930cb5ba37dc7dc915fe4780b1
-  data.tar.gz: 9528ac190d2a6bb9f0182858a650bb31f5315767e8220cf59fa936f04d1d62c3
+  metadata.gz: 36cb17a206c740954fafe1ce7b1fcbb6f94a47179e22beeee390498d20b1d07f
+  data.tar.gz: 8db951649c7030a30d94fdbba0778fefef872d222ed479a83d459a1c0a36cfd9
 SHA512:
-  metadata.gz: c21f7c752192b87e5aa6a3a1089359f72cf577a876f3b5cd1653a7c1c7e9a216b4c5bf0d964c64f32c29815d851d616870b4a1b78990d2344f9127650c5b2000
-  data.tar.gz: 37cf8d32c00a99dc09c9fccb59b9551e514946680e7fae0eae199c0d66a7552b957b547968e9f60f339e3f94765f1851b47212eb869b4572d0173fd4bc68ba49
+  metadata.gz: 19b0c83147c2c5f0882efb9bc32bedd6be9c7c8d80b50c86b985f36ddc6fe0d051b31c7a0795ee9340cf47dab64825072d0012d1dede882ad8497f24dbb45e85
+  data.tar.gz: 3146be4e5e094c747fa2bb0335bba6bf35a7fdee4190428d6883341f8003f472a50505e63d60c6ba59428031e7204cb70f64a1e169d2dc1932abc0604c3bc06a

data/ext/yeptris_native/cbor_ruby.c

@@ -25,102 +25,144 @@ static VALUE cr_key_str(const char* p, size_t len) {
     return rb_enc_interned_str(p, (long)len, cr_utf8_enc);
 }
 
+#include "cbor/sink.h"
 #include "dom/dom.h"
 #include "doc.h" /* the public YeptrisDocument wrapper: ->dom */
 #include <yeptris/cbor.h>
 #include <yeptris/dom.h>
 #include <yeptris/resolve.h>
 
-static const char* cr_view(const yep_dom* d, yep_sview sv, uint32_t* len) {
-    *len = sv.len;
-    if (sv.len == 0) {
-        return "";
-    }
-    return (sv.off & YEP_SV_INPUT) ? (d->str + (sv.off & YEP_SV_OFF)) : (d->input_base + sv.off);
+/* ---- the VALUE sink (#157): bytes -> VALUE in ONE pass ----
+ *
+ * The decode grammar drives; these callbacks build the same VALUEs
+ * the old DOM + cr_walk pair produced (verified by the binding's
+ * differential suite): nil/true/false by tag, ints via LL2NUM (the
+ * INT64_MIN text parity wart kept), floats via DBL2NUM (no
+ * text round trip), strings copied utf8 (byte strings today ride the
+ * same utf8 String), map keys interned (values never are).
+ *
+ * GC: the container stack is a Ruby array (every VALUE reachable);
+ * the input buffer is read directly, so decode runs with GC disabled
+ * (the caller's String may move otherwise — the #160 bus error). */
+
+struct rv_ctx {
+    VALUE stack; /* [.., container, (pending-key)?] */
+    VALUE root;  /* Qnil until the top item closes */
+};
+
+static VALUE rv_top(const struct rv_ctx* c) {
+    long n = RARRAY_LEN(c->stack);
+    return n > 0 ? rb_ary_entry(c->stack, n - 1) : Qnil;
 }
 
-static VALUE cr_scalar(const yep_dom* d, const yep_dnode* n) {
-    uint32_t len = 0;
-    const char* p = cr_view(d, n->value, &len);
-    switch (n->tag_id) {
-    case YEPTRIS_TAG_NULL:
-        return Qnil;
-    case YEPTRIS_TAG_BOOL:
-        if (len == 1) { /* Psych: "y"/"n" stay Strings */
-            return rb_utf8_str_new(p, len);
-        }
-        return (len == 4 && memcmp(p, "true", 4) == 0) ? Qtrue : Qfalse;
-    case YEPTRIS_TAG_INT: {
-        char buf[32];
-        size_t cp = len < sizeof(buf) - 1 ? len : sizeof(buf) - 1;
-        memcpy(buf, p, cp);
-        buf[cp] = '\0';
-        char* end = NULL;
-        long long v = strtoll(buf, &end, 10);
-        if (end != buf && *end == '\0' && end == buf + len && v > INT64_MIN) {
-            return LL2NUM(v);
-        }
-        return rb_utf8_str_new(p, len); /* int_or_string's fallback */
+static VALUE rv_attach(struct rv_ctx* c, VALUE v) {
+    VALUE top = rv_top(c);
+    if (RB_TYPE_P(top, T_ARRAY)) {
+        rb_ary_push(top, v);
+        return v;
     }
-    case YEPTRIS_TAG_FLOAT: {
-        char buf[64];
-        size_t cp = len < sizeof(buf) - 1 ? len : sizeof(buf) - 1;
-        memcpy(buf, p, cp);
-        buf[cp] = '\0';
-        char* end = NULL;
-        double v = strtod(buf, &end);
-        if (end != buf && end != buf + len) {
-            return rb_utf8_str_new(p, len); /* float_or_string's fallback */
-        }
-        return DBL2NUM(v);
+    if (RB_TYPE_P(top, T_HASH)) {
+        rb_ary_push(c->stack, v); /* becomes the pending key */
+        return v;
     }
-    default:
-        return rb_utf8_str_new(p, len);
+    /* a pending key: pop it, land v in the map */
+    VALUE k = rb_ary_pop(c->stack);
+    VALUE map = rv_top(c);
+    if (RB_TYPE_P(map, T_HASH)) {
+        rb_hash_aset(map, k, v);
+        return v;
     }
+    /* the stack emptied: v is the root */
+    c->root = v;
+    return v;
 }
 
-static VALUE cr_walk(const yep_dom* d, uint32_t id) {
-    const yep_dnode* n = &d->nodes[id];
-    switch (n->kind) {
-    case YEP_DOM_SCALAR:
-        return cr_scalar(d, n);
-    case YEP_DOM_SEQUENCE: {
-        long cnt = (long)n->count;
-        VALUE a = rb_ary_new_capa(cnt);
-        uint32_t c = n->first_child;
-        for (long i = 0; i < cnt && c != UINT32_MAX; i++) {
-            rb_ary_push(a, cr_walk(d, c));
-            c = d->nodes[c].next_sibling;
-        }
-        return a;
+static int rv_text(void* ctx, const char* s, uint32_t n, uint8_t tag_id, int is_key,
+                   const char* tag, uint32_t tag_len) {
+    (void)tag;
+    (void)tag_len;
+    struct rv_ctx* c = ctx;
+    VALUE v;
+    switch (tag_id) {
+    case YEPTRIS_TAG_NULL:
+        v = Qnil;
+        break;
+    case YEPTRIS_TAG_BOOL:
+        v = (n == 4 && memcmp(s, "true", 4) == 0) ? Qtrue : Qfalse;
+        break;
+    default: /* rendered text (diagnostics, simple(N), key ints) */
+        v = rb_utf8_str_new(s, (long)n);
+        break;
     }
-    case YEP_DOM_MAPPING: {
-        long pairs = (long)(n->count / 2);
-        VALUE h = HASH_NEW_CAPA(pairs);
-        uint32_t c = n->first_child;
-        for (long i = 0; i < pairs && c != UINT32_MAX; i++) {
-            VALUE k;
-            const yep_dnode* kn = &d->nodes[c];
-            if (kn->kind == YEP_DOM_SCALAR && kn->tag_id == YEPTRIS_TAG_STR) {
-                uint32_t klen = 0;
-                const char* kp = cr_view(d, kn->value, &klen);
-                k = cr_key_str(kp, klen);
-                c = kn->next_sibling;
-            } else {
-                k = cr_walk(d, c);
-                c = d->nodes[c].next_sibling;
-            }
-            VALUE v = (c != UINT32_MAX) ? cr_walk(d, c) : Qnil;
-            if (c != UINT32_MAX) {
-                c = d->nodes[c].next_sibling;
-            }
-            rb_hash_aset(h, k, v);
-        }
-        return h;
+    (void)is_key;
+    rv_attach(c, v);
+    return 1;
+}
+
+static int rv_int(void* ctx, int negative, uint64_t mag, int is_key, const char* tag,
+                  uint32_t tag_len) {
+    (void)tag;
+    (void)tag_len;
+    struct rv_ctx* c = ctx;
+    VALUE v;
+    if (negative && mag == (uint64_t)1 << 63) {
+        /* parity: the DOM path's strtoll guard renders INT64_MIN a
+         * String today; the differential suite pins it */
+        v = rb_utf8_str_new("-9223372036854775808", 20);
+    } else {
+        v = LL2NUM(negative ? -(int64_t)mag : (int64_t)mag);
     }
-    default: /* ALIAS: CBOR decode never produces one */
-        return Qnil;
+    rv_attach(c, v);
+    return 1;
+}
+
+static int rv_float(void* ctx, double dv, int is_key, const char* tag, uint32_t tag_len) {
+    (void)is_key;
+    (void)tag;
+    (void)tag_len;
+    rv_attach(ctx, DBL2NUM(dv));
+    return 1;
+}
+
+static int rv_str(void* ctx, const unsigned char* p, uint32_t n, int borrowed, int is_key,
+                  const char* tag, uint32_t tag_len) {
+    (void)borrowed;
+    (void)tag;
+    (void)tag_len;
+    struct rv_ctx* c = ctx;
+    VALUE v = is_key ? rb_enc_interned_str((const char*)p, (long)n, cr_utf8_enc)
+                     : rb_utf8_str_new((const char*)p, (long)n);
+    rv_attach(c, v);
+    return 1;
+}
+
+static int rv_bytes(void* ctx, const unsigned char* p, uint32_t n, int borrowed, int is_key,
+                    const char* tag, uint32_t tag_len) {
+    /* parity: byte strings ride the same utf8 String today */
+    return rv_str(ctx, p, n, borrowed, is_key, tag, tag_len);
+}
+
+static int rv_open(void* ctx, int is_map, uint64_t cap, const char* tag, uint32_t tag_len) {
+    (void)tag;
+    (void)tag_len;
+    struct rv_ctx* c = ctx;
+    VALUE v;
+    if (is_map) {
+        v = (cap != UINT64_MAX && cap / 2 <= 4096) ? HASH_NEW_CAPA((long)(cap / 2))
+                                                   : rb_hash_new();
+    } else {
+        v = (cap != UINT64_MAX && cap <= 8192) ? rb_ary_new_capa((long)cap) : rb_ary_new();
     }
+    rb_ary_push(c->stack, v);
+    return 1;
+}
+
+static int rv_close(void* ctx, int is_map) {
+    (void)is_map;
+    struct rv_ctx* c = ctx;
+    VALUE v = rb_ary_pop(c->stack);
+    rv_attach(c, v);
+    return 1;
 }
 
 VALUE yep_rb_cbor_load(const char* p, size_t len, int strict) {
@@ -128,27 +170,24 @@ VALUE yep_rb_cbor_load(const char* p, size_t len, int strict) {
         cr_utf8_enc = rb_utf8_encoding();
     }
     YeptrisStatus st = YEPTRIS_OK;
-    /* the DOM borrows the input buffer zero-copy; the walk ALLOCATES,
-     * and a GC compaction mid-walk moves the caller's String — the
-     * borrowed base dangles (the #160 CI bus error on 3.2/linux).
-     * Same discipline as the JSON walk: GC off across decode+walk */
+    /* the decoder reads the caller's buffer directly; GC off across
+     * the pass (a compaction would move the String under p — the
+     * #160 bus error) */
     VALUE gc_on = rb_gc_disable();
-    /* YeptrisDocument is a WRAPPER (doc.h) — ->dom is the tree; a raw
-     * yep_dom* cast read the wrapper's fields as the dom (the CI
-     * segfaults: docs at the wrong offset) */
-    yeptris_document* doc = (yeptris_document*)yeptris_cbor_decode(
-        p, len, strict ? YEPTRIS_CBOR_STRICT : 0, &st);
-    yep_dom* d = (doc != NULL) ? doc->dom : NULL;
-    if (d == NULL) {
-        if (RTEST(gc_on)) {
-            rb_gc_enable();
-        }
-        return Qundef;
-    }
-    VALUE v = (d->dcount > 0 && d->docs[0] != UINT32_MAX) ? cr_walk(d, d->docs[0]) : Qnil;
-    yeptris_document_free((YeptrisDocument)doc);
+    struct rv_ctx ctx;
+    ctx.stack = rb_ary_new();
+    ctx.root = Qnil;
+    static const yep_cbor_sink RV_SINK = {
+        NULL, rv_text, rv_int, rv_float, rv_str, rv_bytes, rv_open, rv_close,
+    };
+    yep_cbor_sink sink = RV_SINK;
+    sink.ctx = &ctx;
+    st = yep_cbor_decode_gen((const unsigned char*)p, len, strict, NULL, &sink);
     if (RTEST(gc_on)) {
         rb_gc_enable();
     }
-    return v;
+    if (st != YEPTRIS_OK) {
+        return Qundef;
+    }
+    return ctx.root;
 }

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.16.2".freeze
+  VERSION = "0.6.17.1".freeze
   # The error hierarchy lives in THIS file (the parent namespace's
   # own file): nested constants do not trigger a parent-constant
   # autoload, and the law forbids internal requires — defining the

data/vendor/libyeptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(yeptris
-    VERSION 0.6.16
+    VERSION 0.6.17
     DESCRIPTION "Ultra-fast YAML 1.2 parser, emitter and streamer in C"
     LANGUAGES C CXX
 )

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

@@ -65,7 +65,9 @@ enum {
                                     (default: last, as at parse) */
 };
 
-/* One plan node. 32 bytes, ABI-pinned. */
+/* One plan node. ABI-pinned: a pointer plus 16 fixed-width bytes —
+ * 24 on LP64, 20 on 32-bit (the hosts' FFI mirrors size :pointer
+ * per-process, so the layout contract is the POINTER plus the tail). */
 typedef struct yeptris_desc_node {
     const char* wire_name; /* mapping key to match (NULL: the root) */
     uint8_t kind;          /* YEP_SK_* */
@@ -77,7 +79,7 @@ typedef struct yeptris_desc_node {
     uint32_t reserved;     /* must be 0 (ABI headroom) */
 } yeptris_desc_node;
 
-YEPTRIS_CT_ASSERT(sizeof(yeptris_desc_node) == 24);
+YEPTRIS_CT_ASSERT(sizeof(yeptris_desc_node) == sizeof(const char*) + 16);
 
 /* One column's output. Caller allocates the payload array (sized by
  * expectation); the call fills it and sets count. No per-value FFI:

data/vendor/libyeptris/src/yeptris/cbor/decode.c

@@ -27,6 +27,8 @@
 #include <math.h>
 #include <string.h>
 
+#include <stdlib.h>
+
 #include <yeptris/cbor.h>
 #include <yeptris/resolve.h>
 
@@ -37,29 +39,41 @@
 #include "../memory/allocator.h"
 #include "../parse/events.h"
 #include "doc.h"
+#include "sink.h"
 
 #define YEP_CBOR_INDEF UINT64_MAX
 #define YEP_CBOR_MAX_ARG_BYTES 8
 
 typedef struct {
-    uint64_t rem; /* items left; maps count 2*pairs; INDEF = until break */
+    uint64_t rem;      /* items left; maps count 2*pairs; INDEF = until break */
+    uint64_t consumed; /* items landed (the key/value parity) */
     uint8_t is_map;
 } yep_cframe;
 
+#define YEP_CBOR_TAGBUF                                                                            \
+    512 /* a semantic-tag chain over ~23 links is                                                  \
+         * pathological; the arena form had no cap,                                                \
+         * the stack form does (documented) */
+
 typedef struct {
-    yep_dom* d;
+    yep_dom* d; /* the DOM sink's ctx (NULL for pure sinks) */
     const unsigned char* p;
     size_t len;
     size_t i;
     int strict;
     YeptrisStatus status;
-    /* pending tag chain: tag numbers arrive before their content and
-     * render into the arena as "N N N" (outermost first — the encoder
-     * splits it back); the span attaches to the next data item */
-    yep_sview pending_tag;
-    int have_pending;
+    /* the pending semantic-tag chain, text form ("N N N", outermost
+     * first — the next item's writer consumes it) */
+    char tagbuf[YEP_CBOR_TAGBUF];
+    uint32_t taglen;
+    /* indefinite-string accumulation (chunk framing is the grammar's;
+     * the finished span goes to one str/bytes callback) */
+    unsigned char* ibuf;
+    size_t icap;
+    uint32_t ilen;
+    const yep_cbor_sink* s;
     yep_cframe frame[YEP_DOM_MAX_DEPTH];
-    int depth; /* == d->depth by construction */
+    int depth;
 } yep_cdec;
 
 static void cbor_fail(yep_cdec* c, yep_err_code code, const char* msg) {
@@ -146,116 +160,74 @@ static double cbor_half(uint16_t h) {
     return (h & 0x8000u) != 0 ? -val : val;
 }
 
-/* Scalar from arena text (numbers, diagnostics, literals). */
-static uint32_t cbor_text_node(yep_cdec* c, const char* text, uint32_t n, uint8_t tag_id) {
-    yep_view tag_v;
-    const yep_view* tag = NULL;
-    if (c->have_pending) {
-        /* the pending chain lives in the DOM arena (offsets, not
-         * pointers — the arena reallocs as it grows) */
-        tag_v.p = c->d->str + (c->pending_tag.off & YEP_SV_OFF);
-        tag_v.len = c->pending_tag.len;
-        tag = &tag_v;
-        c->have_pending = 0;
-    }
-    uint32_t id = dom_open_node(c->d, YEP_DOM_SCALAR, tag, NULL, 0, YEP_STYLE_PLAIN, 1, 0);
-    if (id == UINT32_MAX) {
-        c->status = YEPTRIS_ERROR_MEMORY;
-        return UINT32_MAX;
-    }
-    yep_dnode* node = &c->d->nodes[id];
-    char* dst = yep_dom_str_tail(c->d, n);
-    if (dst == NULL) {
-        c->status = YEPTRIS_ERROR_MEMORY;
-        return UINT32_MAX;
-    }
-    memcpy(dst, text, n);
-    node->value = yep_dom_str_commit(c->d, n);
-    node->tag_id = tag_id;
-    if (dom_place(c->d, id) != 0) {
-        c->status = YEPTRIS_ERROR_MEMORY;
-        return UINT32_MAX;
+/* The pending semantic-tag chain, consumed by the next writer. */
+static const char* cbor_take_tag(yep_cdec* c, uint32_t* len) {
+    if (c->taglen == 0) {
+        *len = 0;
+        return NULL;
     }
-    return id;
+    *len = c->taglen;
+    c->taglen = 0;
+    return c->tagbuf;
 }
 
-/* Scalar borrowing the input (definite strings, bignum byte strings). */
-static uint32_t cbor_span_node(yep_cdec* c, const unsigned char* p, uint32_t n) {
-    yep_view tag_v;
-    const yep_view* tag = NULL;
-    if (c->have_pending) {
-        tag_v.p = c->d->str + (c->pending_tag.off & YEP_SV_OFF);
-        tag_v.len = c->pending_tag.len;
-        tag = &tag_v;
-        c->have_pending = 0;
-    }
-    uint32_t id = dom_open_node(c->d, YEP_DOM_SCALAR, tag, NULL, 0, YEP_STYLE_DOUBLE_QUOTED, 0, 0);
-    if (id == UINT32_MAX) {
+/* Rendered text (numbers-as-text, literals, diagnostics). */
+static uint32_t cbor_text_node(yep_cdec* c, const char* text, uint32_t n, uint8_t tag_id,
+                               int is_key) {
+    uint32_t tag_len;
+    const char* tag = cbor_take_tag(c, &tag_len);
+    if (!c->s->text(c->s->ctx, text, n, tag_id, is_key, tag, tag_len)) {
         c->status = YEPTRIS_ERROR_MEMORY;
         return UINT32_MAX;
     }
-    yep_dnode* node = &c->d->nodes[id];
-    node->value.off = (uint32_t)((const char*)p - c->d->input_base);
-    node->value.len = n;
-    if (dom_place(c->d, id) != 0) {
+    return 0; /* item identity is the sink's business */
+}
+
+/* Definite string (mt2 -> bytes_val, mt3 -> str_val), borrowing the input. */
+static uint32_t cbor_span_node(yep_cdec* c, const unsigned char* p, uint32_t n, uint8_t mt,
+                               int is_key) {
+    uint32_t tag_len;
+    const char* tag = cbor_take_tag(c, &tag_len);
+    int ok = (mt == 2) ? c->s->bytes_val(c->s->ctx, p, n, 1, is_key, tag, tag_len)
+                       : c->s->str_val(c->s->ctx, p, n, 1, is_key, tag, tag_len);
+    if (!ok) {
         c->status = YEPTRIS_ERROR_MEMORY;
         return UINT32_MAX;
     }
-    return id;
+    return 0;
 }
 
-static int cbor_open(yep_cdec* c, int is_map) {
+static int cbor_open(yep_cdec* c, int is_map, uint64_t cap) {
     if (c->depth >= YEP_DOM_MAX_DEPTH) {
         yep_error_set(yep_error_tls(), YEP_ERR_UNEXPECTED, 0, 0, c->i,
                       "CBOR nesting exceeds the depth guard at byte %zu", c->i);
         c->status = YEPTRIS_ERROR_DEPTH;
         return 0;
     }
-    yep_view tag_v;
-    const yep_view* tag = NULL;
-    if (c->have_pending) {
-        tag_v.p = c->d->str + (c->pending_tag.off & YEP_SV_OFF);
-        tag_v.len = c->pending_tag.len;
-        tag = &tag_v;
-        c->have_pending = 0;
-    }
-    uint32_t id =
-        dom_open_node(c->d, is_map ? YEP_DOM_MAPPING : YEP_DOM_SEQUENCE, tag, NULL, 0, 0, 0, 1);
-    if (id == UINT32_MAX) {
+    uint32_t tag_len;
+    const char* tag = cbor_take_tag(c, &tag_len);
+    if (!c->s->open(c->s->ctx, is_map, cap, tag, tag_len)) {
         c->status = YEPTRIS_ERROR_MEMORY;
         return 0;
     }
-    if (dom_place(c->d, id) != 0) {
-        c->status = YEPTRIS_ERROR_MEMORY;
-        return 0;
-    }
-    c->d->map_pending_key[c->d->depth] = 0;
-    c->d->stack[c->d->depth++] = id;
-    c->depth++; /* the frame mirrors the DOM's stack one-to-one */
+    /* a sibling at this depth may have left state behind */
+    c->frame[c->depth].consumed = 0;
+    c->depth++;
     return 1;
 }
 
 static int cbor_note_tag(yep_cdec* c, uint64_t tag) {
-    char buf[24];
-    uint32_t n = 0;
-    if (c->have_pending) {
-        buf[n++] = ' '; /* separator between chain links */
-    }
-    n += cbor_u64dec(tag, buf + n);
-    char* dst = yep_dom_str_tail(c->d, n);
-    if (dst == NULL) {
-        c->status = YEPTRIS_ERROR_MEMORY;
+    if (c->taglen + 1 + 20 > sizeof c->tagbuf) {
+        yep_error_set(yep_error_tls(), YEP_ERR_UNEXPECTED, 0, 0, c->i,
+                      "semantic-tag chain exceeds %u bytes at byte %zu", (unsigned)sizeof c->tagbuf,
+                      c->i);
+        c->status = YEPTRIS_ERROR_PARSE;
         return 0;
     }
-    yep_sview piece = yep_dom_str_commit(c->d, n);
-    if (!c->have_pending) {
-        c->pending_tag = piece;
-        c->pending_tag.len = 0;
-        c->have_pending = 1;
+    if (c->taglen > 0) {
+        c->tagbuf[c->taglen++] = ' '; /* separator between chain links */
     }
-    memcpy(dst, buf, n);
-    /* piece-by-piece commit keeps the chain contiguous in the arena */
-    c->pending_tag.len += n;
+    c->taglen += cbor_u64dec(tag, c->tagbuf + c->taglen);
     return 1;
 }
 
@@ -263,7 +235,6 @@ static int cbor_note_tag(yep_cdec* c, uint64_t tag) {
  * arena; text chunks validate per chunk — RFC 8949 s3.2.3's code-point
  * boundary rule makes per-chunk validity imply whole-string validity). */
 static int cbor_indef_string(yep_cdec* c, int is_text) {
-    uint32_t first = 0;
     uint32_t total = 0;
     for (;;) {
         if (c->i >= c->len) {
@@ -291,75 +262,55 @@ static int cbor_indef_string(yep_cdec* c, int is_text) {
             return 0;
         }
         if (n > 0) { /* zero-length chunks are legal, just empty */
-            char* dst = yep_dom_str_tail(c->d, (uint32_t)n);
-            if (dst == NULL) {
-                c->status = YEPTRIS_ERROR_MEMORY;
-                return 0;
-            }
-            yep_sview piece = yep_dom_str_commit(c->d, (uint32_t)n);
-            memcpy(dst, c->p + c->i, (size_t)n);
-            if (total == 0) {
-                first = piece.off;
+            if (total + n > c->icap) {
+                size_t ncap = c->icap ? c->icap * 2 : 256;
+                while (ncap < total + n) {
+                    ncap *= 2;
+                }
+                unsigned char* nib = realloc(c->ibuf, ncap);
+                if (nib == NULL) {
+                    c->status = YEPTRIS_ERROR_MEMORY;
+                    return 0;
+                }
+                c->ibuf = nib;
+                c->icap = ncap;
             }
+            memcpy(c->ibuf + total, c->p + c->i, (size_t)n);
             total += (uint32_t)n;
         }
         c->i += (size_t)n;
     }
-    /* node over the concatenated arena span */
-    yep_view tag_v;
-    const yep_view* tag = NULL;
-    if (c->have_pending) {
-        tag_v.p = c->d->str + (c->pending_tag.off & YEP_SV_OFF);
-        tag_v.len = c->pending_tag.len;
-        tag = &tag_v;
-        c->have_pending = 0;
-    }
-    uint32_t id = dom_open_node(c->d, YEP_DOM_SCALAR, tag, NULL, 0, YEP_STYLE_DOUBLE_QUOTED, 0, 0);
-    if (id == UINT32_MAX) {
-        c->status = YEPTRIS_ERROR_MEMORY;
-        return 0;
-    }
-    yep_dnode* node = &c->d->nodes[id];
-    node->value.off = first;
-    node->value.len = total;
-    if (dom_place(c->d, id) != 0) {
+    /* one value over the accumulated span */
+    uint32_t tag_len;
+    const char* tag = cbor_take_tag(c, &tag_len);
+    int ok =
+        (is_text ? c->s->str_val : c->s->bytes_val)(c->s->ctx, c->ibuf, total, 0, 0, tag, tag_len);
+    if (!ok) {
         c->status = YEPTRIS_ERROR_MEMORY;
         return 0;
     }
     return 1;
 }
 
-/* yep_json_number-style inline render: one node for a known integer. */
-static int cbor_int_node(yep_cdec* c, int negative, uint64_t mag) {
-    char buf[24];
-    uint32_t n = 0;
-    uint8_t tag_id;
-    if (negative) {
-        buf[n++] = '-';
+/* Known integer: value = negative ? -mag : mag, mag <= 2^63. */
+static int cbor_int_node(yep_cdec* c, int negative, uint64_t mag, int is_key) {
+    uint32_t tag_len;
+    const char* tag = cbor_take_tag(c, &tag_len);
+    if (!c->s->int_val(c->s->ctx, negative, mag, is_key, tag, tag_len)) {
+        c->status = YEPTRIS_ERROR_MEMORY;
+        return 0;
     }
-    n += cbor_u64dec(mag, buf + n);
-    tag_id = YEPTRIS_TAG_INT;
-    return cbor_text_node(c, buf, n, tag_id) != UINT32_MAX;
+    return 1;
 }
 
-static int cbor_float_node(yep_cdec* c, double dv) {
-    char buf[48];
-    uint32_t n;
-    uint8_t tag_id = YEPTRIS_TAG_FLOAT;
-    if (dv != dv) {
-        memcpy(buf, "NaN", 3);
-        n = 3;
-    } else if (dv > 1.7976931348623157e308) {
-        memcpy(buf, "Infinity", 8);
-        n = 8;
-    } else if (dv < -1.7976931348623157e308) {
-        memcpy(buf, "-Infinity", 9);
-        n = 9;
-    } else {
-        n = (uint32_t)yep_d2s_shortest(dv, buf);
+static int cbor_float_node(yep_cdec* c, double dv, int is_key) {
+    uint32_t tag_len;
+    const char* tag = cbor_take_tag(c, &tag_len);
+    if (!c->s->float_val(c->s->ctx, dv, is_key, tag, tag_len)) {
+        c->status = YEPTRIS_ERROR_MEMORY;
+        return 0;
     }
-    (void)tag_id;
-    return cbor_text_node(c, buf, n, YEPTRIS_TAG_FLOAT) != UINT32_MAX;
+    return 1;
 }
 
 /* The diagnostic renderer for lenient-mode non-string SCALAR map keys
@@ -408,9 +359,9 @@ static int cbor_key_diag(yep_cdec* c, uint8_t mt, uint64_t val, double dv) {
         }
         break;
     default:
-        return cbor_float_node(c, dv); /* floats: the shortest text */
+        return cbor_float_node(c, dv, 1); /* floats: the shortest text */
     }
-    return cbor_text_node(c, buf, n, 0) != UINT32_MAX;
+    return cbor_text_node(c, buf, n, 0, 1) != UINT32_MAX;
 }
 
 /* Decodes ONE data item (scalar: creates+places the node; container:
@@ -425,9 +376,10 @@ static int cbor_item(yep_cdec* c) {
     uint8_t ai = ib & 0x1F;
 
     /* the map-key position decides representation before the item is
-     * built (the DOM pairs whatever node lands there) */
+     * built: even items consumed = key, odd = value (the frame's own
+     * parity — the DOM's placement machine tracks its own copy) */
     int key_slot = 0;
-    if (c->depth > 0 && c->frame[c->depth - 1].is_map && !c->d->map_pending_key[c->d->depth - 1]) {
+    if (c->depth > 0 && c->frame[c->depth - 1].is_map && c->frame[c->depth - 1].consumed % 2 == 0) {
         key_slot = 1;
     }
 
@@ -444,7 +396,7 @@ static int cbor_item(yep_cdec* c) {
             if (key_slot) {
                 CBOR_REJECT("structure as map key");
             }
-            if (!cbor_open(c, 0)) {
+            if (!cbor_open(c, 0, YEP_CBOR_INDEF)) {
                 return 0;
             }
             c->frame[c->depth - 1].rem = YEP_CBOR_INDEF;
@@ -454,7 +406,7 @@ static int cbor_item(yep_cdec* c) {
             if (key_slot) {
                 CBOR_REJECT("structure as map key");
             }
-            if (!cbor_open(c, 1)) {
+            if (!cbor_open(c, 1, YEP_CBOR_INDEF)) {
                 return 0;
             }
             c->frame[c->depth - 1].rem = YEP_CBOR_INDEF;
@@ -482,9 +434,9 @@ static int cbor_item(yep_cdec* c) {
             return cbor_key_diag(c, 0, arg, 0) ? 1 : 0;
         }
         if (arg <= (uint64_t)INT64_MAX) {
-            return cbor_int_node(c, 0, arg) ? 1 : 0;
+            return cbor_int_node(c, 0, arg, key_slot) ? 1 : 0;
         }
-        return cbor_float_node(c, (double)arg) ? 1 : 0;
+        return cbor_float_node(c, (double)arg, key_slot) ? 1 : 0;
     }
     case 1: {
         if (key_slot && c->strict) {
@@ -495,9 +447,9 @@ static int cbor_item(yep_cdec* c) {
         }
         if (arg <= (uint64_t)INT64_MAX + 1) { /* -1-2^63 == INT64_MIN */
             uint64_t mag = arg + 1;
-            return cbor_int_node(c, 1, mag) ? 1 : 0;
+            return cbor_int_node(c, 1, mag, key_slot) ? 1 : 0;
         }
-        return cbor_float_node(c, -((double)arg + 1.0)) ? 1 : 0;
+        return cbor_float_node(c, -((double)arg + 1.0), key_slot) ? 1 : 0;
     }
     case 2:
     case 3: {
@@ -518,7 +470,7 @@ static int cbor_item(yep_cdec* c) {
             c->i += (size_t)arg;
             return ok ? 1 : 0;
         }
-        uint32_t id = cbor_span_node(c, c->p + c->i, (uint32_t)arg);
+        uint32_t id = cbor_span_node(c, c->p + c->i, (uint32_t)arg, (uint8_t)mt, key_slot);
         c->i += (size_t)arg;
         return id != UINT32_MAX ? 1 : 0;
     }
@@ -529,7 +481,7 @@ static int cbor_item(yep_cdec* c) {
         if (arg > c->len - c->i) { /* every item consumes >= 1 byte */
             CBOR_REJECT("array overruns the input");
         }
-        if (!cbor_open(c, 0)) {
+        if (!cbor_open(c, 0, arg)) {
             return 0;
         }
         c->frame[c->depth - 1].rem = arg;
@@ -543,7 +495,7 @@ static int cbor_item(yep_cdec* c) {
         if (arg > (c->len - c->i) / 2) { /* pairs need 2 items each */
             CBOR_REJECT("map overruns the input");
         }
-        if (!cbor_open(c, 1)) {
+        if (!cbor_open(c, 1, arg * 2)) {
             return 0;
         }
         c->frame[c->depth - 1].rem = arg * 2;
@@ -566,22 +518,22 @@ static int cbor_item(yep_cdec* c) {
         if (key_slot) {
             return cbor_key_diag(c, 7, 20, 0) ? 1 : 0;
         }
-        return cbor_text_node(c, "false", 5, YEPTRIS_TAG_BOOL) != UINT32_MAX ? 1 : 0;
+        return cbor_text_node(c, "false", 5, YEPTRIS_TAG_BOOL, key_slot) != UINT32_MAX ? 1 : 0;
     case 21:
         if (key_slot) {
             return cbor_key_diag(c, 7, 21, 0) ? 1 : 0;
         }
-        return cbor_text_node(c, "true", 4, YEPTRIS_TAG_BOOL) != UINT32_MAX ? 1 : 0;
+        return cbor_text_node(c, "true", 4, YEPTRIS_TAG_BOOL, key_slot) != UINT32_MAX ? 1 : 0;
     case 22:
         if (key_slot) {
             return cbor_key_diag(c, 7, 22, 0) ? 1 : 0;
         }
-        return cbor_text_node(c, "null", 4, YEPTRIS_TAG_NULL) != UINT32_MAX ? 1 : 0;
+        return cbor_text_node(c, "null", 4, YEPTRIS_TAG_NULL, key_slot) != UINT32_MAX ? 1 : 0;
     case 23:
         if (key_slot) {
             return cbor_key_diag(c, 7, 23, 0) ? 1 : 0;
         }
-        return cbor_text_node(c, "undefined", 9, 0) != UINT32_MAX ? 1 : 0;
+        return cbor_text_node(c, "undefined", 9, 0, key_slot) != UINT32_MAX ? 1 : 0;
     case 24: {
         if (c->len - c->i < 1) {
             CBOR_REJECT("truncated simple value");
@@ -597,7 +549,7 @@ static int cbor_item(yep_cdec* c) {
         memcpy(buf, "simple(", 7);
         uint32_t n = 7 + cbor_u64dec(v, buf + 7);
         buf[n++] = ')';
-        return cbor_text_node(c, buf, n, 0) != UINT32_MAX ? 1 : 0;
+        return cbor_text_node(c, buf, n, 0, key_slot) != UINT32_MAX ? 1 : 0;
     }
     case 25: {
         if (c->len - c->i < 2) {
@@ -641,7 +593,7 @@ static int cbor_item(yep_cdec* c) {
             memcpy(buf, "simple(", 7);
             uint32_t n = 7 + cbor_u64dec(ai, buf + 7);
             buf[n++] = ')';
-            return cbor_text_node(c, buf, n, 0) != UINT32_MAX ? 1 : 0;
+            return cbor_text_node(c, buf, n, 0, key_slot) != UINT32_MAX ? 1 : 0;
         }
         CBOR_REJECT("reserved additional information");
     }
@@ -652,34 +604,191 @@ static int cbor_item(yep_cdec* c) {
     if (key_slot) {
         return cbor_key_diag(c, 8, 0, dv) ? 1 : 0;
     }
-    return cbor_float_node(c, dv) ? 1 : 0;
+    return cbor_float_node(c, dv, key_slot) ? 1 : 0;
 }
 
-int yep_cbor_decode_dom(yep_dom* d, const unsigned char* p, size_t len, int strict,
-                        size_t* consumed) {
+/* The DOM sink: the yeptris_cbor_decode public path. Each impl is the
+ * pre-sink writer, byte for byte (the differential suite pins it). */
+
+static int dom_sink_text(void* dp, const char* s, uint32_t n, uint8_t tag_id, int is_key,
+                         const char* tag, uint32_t tag_len) {
+    yep_dom* d = dp;
+    (void)is_key;
+    yep_view tag_v;
+    const yep_view* tagp = NULL;
+    if (tag != NULL) {
+        char* dst = yep_dom_str_tail(d, tag_len);
+        if (dst == NULL) {
+            return 0;
+        }
+        memcpy(dst, tag, tag_len);
+        yep_sview piece = yep_dom_str_commit(d, tag_len);
+        tag_v.p = d->str + (piece.off & YEP_SV_OFF);
+        tag_v.len = tag_len;
+        tagp = &tag_v;
+    }
+    uint32_t id = dom_open_node(d, YEP_DOM_SCALAR, tagp, NULL, 0, YEP_STYLE_PLAIN, 1, 0);
+    if (id == UINT32_MAX) {
+        return 0;
+    }
+    yep_dnode* node = &d->nodes[id];
+    char* dst = yep_dom_str_tail(d, n);
+    if (dst == NULL) {
+        return 0;
+    }
+    memcpy(dst, s, n);
+    node->value = yep_dom_str_commit(d, n);
+    node->tag_id = tag_id;
+    return dom_place(d, id) == 0;
+}
+
+static int dom_sink_span(void* dp, const unsigned char* p, uint32_t n, int borrowed, int is_key,
+                         const char* tag, uint32_t tag_len) {
+    yep_dom* d = dp;
+    (void)is_key;
+    (void)borrowed; /* 0 rides the scratch buffer: still copied to the arena */
+    yep_view tag_v;
+    const yep_view* tagp = NULL;
+    if (tag != NULL) {
+        char* dst = yep_dom_str_tail(d, tag_len);
+        if (dst == NULL) {
+            return 0;
+        }
+        memcpy(dst, tag, tag_len);
+        yep_sview piece = yep_dom_str_commit(d, tag_len);
+        tag_v.p = d->str + (piece.off & YEP_SV_OFF);
+        tag_v.len = tag_len;
+        tagp = &tag_v;
+    }
+    uint32_t id = dom_open_node(d, YEP_DOM_SCALAR, tagp, NULL, 0, YEP_STYLE_DOUBLE_QUOTED, 0, 0);
+    if (id == UINT32_MAX) {
+        return 0;
+    }
+    yep_dnode* node = &d->nodes[id];
+    if (borrowed) {
+        node->value.off = (uint32_t)((const char*)p - d->input_base);
+        node->value.len = n;
+    } else if (n > 0) { /* the empty indefinite string needs no arena */
+        char* dst = yep_dom_str_tail(d, n);
+        if (dst == NULL) {
+            return 0;
+        }
+        memcpy(dst, p, n);
+        node->value = yep_dom_str_commit(d, n);
+    }
+    return dom_place(d, id) == 0;
+}
+
+static int dom_sink_str(void* dp, const unsigned char* p, uint32_t n, int borrowed, int is_key,
+                        const char* tag, uint32_t tag_len) {
+    return dom_sink_span(dp, p, n, borrowed, is_key, tag, tag_len);
+}
+
+static int dom_sink_bytes(void* dp, const unsigned char* p, uint32_t n, int borrowed, int is_key,
+                          const char* tag, uint32_t tag_len) {
+    return dom_sink_span(dp, p, n, borrowed, is_key, tag, tag_len);
+}
+
+static int dom_sink_open(void* dp, int is_map, uint64_t cap, const char* tag, uint32_t tag_len) {
+    yep_dom* d = dp;
+    (void)cap;
+    yep_view tag_v;
+    const yep_view* tagp = NULL;
+    if (tag != NULL) {
+        char* dst = yep_dom_str_tail(d, tag_len);
+        if (dst == NULL) {
+            return 0;
+        }
+        memcpy(dst, tag, tag_len);
+        yep_sview piece = yep_dom_str_commit(d, tag_len);
+        tag_v.p = d->str + (piece.off & YEP_SV_OFF);
+        tag_v.len = tag_len;
+        tagp = &tag_v;
+    }
+    uint32_t id =
+        dom_open_node(d, is_map ? YEP_DOM_MAPPING : YEP_DOM_SEQUENCE, tagp, NULL, 0, 0, 0, 1);
+    if (id == UINT32_MAX) {
+        return 0;
+    }
+    if (dom_place(d, id) != 0) {
+        return 0;
+    }
+    d->map_pending_key[d->depth] = 0;
+    d->stack[d->depth++] = id;
+    return 1;
+}
+
+static int dom_sink_close(void* dp, int is_map) {
+    yep_dom* d = dp;
+    (void)is_map;
+    d->depth--;
+    return 1;
+}
+
+static int dom_sink_int(void* dp, int negative, uint64_t mag, int is_key, const char* tag,
+                        uint32_t tag_len) {
+    char buf[24];
+    uint32_t n = 0;
+    if (negative) {
+        buf[n++] = '-';
+    }
+    n += cbor_u64dec(mag, buf + n);
+    return dom_sink_text(dp, buf, n, YEPTRIS_TAG_INT, is_key, tag, tag_len);
+}
+
+static int dom_sink_float(void* dp, double dv, int is_key, const char* tag, uint32_t tag_len) {
+    char buf[48];
+    (void)is_key;
+    uint32_t n;
+    if (dv != dv) {
+        memcpy(buf, "NaN", 3);
+        n = 3;
+    } else if (dv > 1.7976931348623157e308) {
+        memcpy(buf, "Infinity", 8);
+        n = 8;
+    } else if (dv < -1.7976931348623157e308) {
+        memcpy(buf, "-Infinity", 9);
+        n = 9;
+    } else {
+        n = (uint32_t)yep_d2s_shortest(dv, buf);
+    }
+    return dom_sink_text(dp, buf, n, YEPTRIS_TAG_FLOAT, is_key, tag, tag_len);
+}
+
+static const yep_cbor_sink yep_cbor_dom_sink_impl = {
+    NULL,         dom_sink_text,  dom_sink_int,  dom_sink_float,
+    dom_sink_str, dom_sink_bytes, dom_sink_open, dom_sink_close,
+};
+
+int yep_cbor_decode_gen(const unsigned char* p, size_t len, int strict, size_t* consumed,
+                        const yep_cbor_sink* sink) {
     yep_cdec c;
     memset(&c, 0, sizeof(c));
-    c.d = d;
+    c.s = sink;
     c.p = p;
     c.len = len;
     c.strict = strict;
     c.status = YEPTRIS_OK;
     int done_top = 0; /* the ONE top-level item is done (tags never count) */
+    int rc;
     for (;;) {
         if (c.depth == 0) {
             if (done_top) { /* the root closed; one data item per call */
                 if (c.i != len && consumed == NULL) {
                     cbor_fail(&c, YEP_ERR_UNEXPECTED, "trailing bytes after the data item");
-                    return YEPTRIS_ERROR_PARSE;
+                    rc = YEPTRIS_ERROR_PARSE;
+                    goto done;
                 }
                 if (consumed != NULL) {
                     *consumed = c.i;
                 }
-                return YEPTRIS_OK;
+                rc = YEPTRIS_OK;
+                goto done;
             }
             int st = cbor_item(&c);
             if (st == 0) {
-                return (int)c.status;
+                rc = (int)c.status;
+                goto done;
             }
             if (st == 2) {
                 continue; /* tag chain: the content item follows */
@@ -689,19 +798,26 @@ int yep_cbor_decode_dom(yep_dom* d, const unsigned char* p, size_t len, int stri
         }
         yep_cframe* fr = &c.frame[c.depth - 1];
         if (fr->rem == 0) { /* definite container complete */
-            c.d->depth--;
+            if (!c.s->close(c.s->ctx, fr->is_map)) {
+                rc = YEPTRIS_ERROR_MEMORY;
+                goto done;
+            }
             c.depth--;
             continue;
         }
         if (fr->rem == YEP_CBOR_INDEF) {
             if (c.i < c.len && c.p[c.i] == 0xFF) {
-                if (fr->is_map && c.d->map_pending_key[c.d->depth - 1]) {
+                if (fr->is_map && fr->consumed % 2 == 1) {
                     cbor_fail(&c, YEP_ERR_UNEXPECTED,
                               "break in a map value position (odd item count)");
-                    return YEPTRIS_ERROR_PARSE;
+                    rc = YEPTRIS_ERROR_PARSE;
+                    goto done;
                 }
                 c.i++;
-                c.d->depth--;
+                if (!c.s->close(c.s->ctx, fr->is_map)) {
+                    rc = YEPTRIS_ERROR_MEMORY;
+                    goto done;
+                }
                 c.depth--;
                 continue;
             }
@@ -709,16 +825,33 @@ int yep_cbor_decode_dom(yep_dom* d, const unsigned char* p, size_t len, int stri
         size_t parent = (size_t)(c.depth - 1);
         int st = cbor_item(&c);
         if (st == 0) {
-            return (int)c.status;
+            rc = (int)c.status;
+            goto done;
         }
         if (st == 2) {
             continue; /* tags never consume a container slot */
         }
+        c.frame[parent].consumed++;
         if (c.frame[parent].rem != YEP_CBOR_INDEF) {
             c.frame[parent].rem--;
             /* one item (scalar, or a container now open) consumed a parent slot */
         }
     }
+done:
+    free(c.ibuf);
+    return rc;
+}
+
+int yep_cbor_decode_dom_sink(void* dp, const unsigned char* p, size_t len, int strict,
+                             size_t* consumed) {
+    yep_cbor_sink s = yep_cbor_dom_sink_impl;
+    s.ctx = dp;
+    return yep_cbor_decode_gen(p, len, strict, consumed, &s);
+}
+
+int yep_cbor_decode_dom(yep_dom* d, const unsigned char* p, size_t len, int strict,
+                        size_t* consumed) {
+    return yep_cbor_decode_dom_sink(d, p, len, strict, consumed);
 }
 
 static YeptrisDocument cbor_wrap(yep_dom* dom, const void* buf, const yep_allocator* sys) {

data/vendor/libyeptris/src/yeptris/cbor/sink.h

@@ -0,0 +1,58 @@
+/* sink.h — the CBOR decode seam (#157).
+ *
+ * The grammar loop (decode.c's cbor_item machinery) is the single
+ * source of CBOR semantics; a sink implements the item constructors
+ * on top of it. Two sinks exist: the DOM builder (the default, the
+ * yeptris_cbor_decode public path) and the native ext's VALUE builder
+ * (one pass, no intermediate). Sinks receive the resolver's tag_id
+ * and the pending semantic-tag chain in its text form ("N N N",
+ * outermost first — NULL when the item carries no chain).
+ */
+#ifndef YEP_CBOR_SINK_H
+#define YEP_CBOR_SINK_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <yeptris/api.h> /* YEPTRIS_API (the ext links these) */
+
+typedef struct yep_cbor_sink {
+    void* ctx;
+    /* All callbacks return 0 on sink failure (the decoder reports
+     * MEMORY). They may raise through host languages (longjmp): the
+     * decoder owns no host-managed state across them except the
+     * indefinite buffer, which its own exit paths free. */
+    /* is_key: 1 = the item lands in the enclosing map's key slot
+     * (sinks key-intern strings; the DOM ignores it). Rendered text:
+     * numbers-as-text, false/true/null/undefined, simple(N) — the
+     * exact bytes the DOM path stores. */
+    int (*text)(void* ctx, const char* s, uint32_t n, uint8_t tag_id, int is_key, const char* tag,
+                uint32_t tag_len);
+    /* Known integers: value = negative ? -(mag) : mag, mag <= 2^63. */
+    int (*int_val)(void* ctx, int negative, uint64_t mag, int is_key, const char* tag,
+                   uint32_t tag_len);
+    int (*float_val)(void* ctx, double dv, int is_key, const char* tag, uint32_t tag_len);
+    /* Strings. borrowed: 1 = p is the input (a sink may record the
+     * offset), 0 = the decoder's scratch buffer (copy or take it). */
+    int (*str_val)(void* ctx, const unsigned char* p, uint32_t n, int borrowed, int is_key,
+                   const char* tag, uint32_t tag_len);
+    int (*bytes_val)(void* ctx, const unsigned char* p, uint32_t n, int borrowed, int is_key,
+                     const char* tag, uint32_t tag_len);
+    /* Containers. cap: expected item count (maps: pairs*2), UINT64_MAX
+     * for indefinite. close fires for BOTH the definite-complete and
+     * the break paths, after the last child. */
+    int (*open)(void* ctx, int is_map, uint64_t cap, const char* tag, uint32_t tag_len);
+    int (*close)(void* ctx, int is_map);
+} yep_cbor_sink;
+
+/* The generic engine: the grammar, driving `sink`. Same reject/
+ * encoding/depth semantics as the DOM entry. */
+YEPTRIS_API int yep_cbor_decode_gen(const unsigned char* p, size_t len, int strict,
+                                    size_t* consumed, const yep_cbor_sink* sink);
+
+/* The DOM sink: pairs yep_cbor_decode_gen with a yep_dom* (the
+ * yep_cbor_decode_dom public path's driver; d is a yep_dom*). */
+YEPTRIS_API int yep_cbor_decode_dom_sink(void* d, const unsigned char* p, size_t len, int strict,
+                                         size_t* consumed);
+
+#endif /* YEP_CBOR_SINK_H */

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

@@ -134,8 +134,17 @@ static void wr_indent(yep_writer* w, int depth) {
 
 static void emit_dq(yep_writer* w, const char* p, uint32_t n) {
     wr_byte(w, '"');
+    uint32_t run = 0;
     for (uint32_t i = 0; i < n; i++) {
         unsigned char c = (unsigned char)p[i];
+        if (c >= 0x20 && c != '"' && c != '\\' && c != 0x7f) {
+            run++;
+            continue;
+        }
+        if (run) {
+            wr_put(w, p + i - run, run);
+            run = 0;
+        }
         if (c == '"' || c == '\\') {
             wr_byte(w, '\\');
             wr_byte(w, (char)c);
@@ -161,10 +170,11 @@ static void emit_dq(yep_writer* w, const char* p, uint32_t n) {
                 char hex[4] = {'\\', 'x', hd[(c >> 4) & 0xf], hd[c & 0xf]};
                 wr_put(w, hex, 4);
             }
-        } else {
-            wr_byte(w, (char)c);
         }
     }
+    if (run) {
+        wr_put(w, p + n - run, run);
+    }
     wr_byte(w, '"');
 }
 
@@ -315,6 +325,10 @@ enum { YEP_SC_NOTHING = 0, YEP_SC_PLAIN, YEP_SC_SQ, YEP_SC_DQ, YEP_SC_LITERAL };
 
 static uint8_t sc_route(yep_writer* w, const char* p, uint32_t len, int as_key, uint8_t sty_in,
                         int has_tag) {
+    if ((sty_in == 1) && len > 0 &&
+        (as_key ? yep_style_plain_key_safe(p, len) : yep_style_plain_safe(p, len))) {
+        return YEP_SC_PLAIN; /* plain-safe implies no breaks: memchr skipped */
+    }
     int multiline = (len > 0 && memchr(p, '\n', len) != NULL);
     int blockable = 0;
     if (multiline && !as_key) {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.16.2
+  version: 0.6.17.1
 platform: powerpc64le-linux
 authors:
 - Ribose Inc.
@@ -91,6 +91,7 @@ files:
 - vendor/libyeptris/src/yeptris/cbor/cbor.h
 - vendor/libyeptris/src/yeptris/cbor/decode.c
 - vendor/libyeptris/src/yeptris/cbor/encode.c
+- vendor/libyeptris/src/yeptris/cbor/sink.h
 - vendor/libyeptris/src/yeptris/common/chartype.c
 - vendor/libyeptris/src/yeptris/common/chartype.h
 - vendor/libyeptris/src/yeptris/common/cpu.c