yeptris 0.6.16.1 → 0.6.16.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36b4d1444bde48fba47b0fd89851f5ebe8cd7a666c7e3faa8652caf4bb37a60f
-  data.tar.gz: 7f113394e8f82d502425610637641716af695a835ba01f6ce5e611c5073c6d55
+  metadata.gz: f6b3f2406ea8b763cfa7bd0d0a36ea30ba7bb80c8322c6ebe5fd8300725e47d2
+  data.tar.gz: 9a500939ce7f65be9219acc0a44c62819ddd09f4f64486177065681b8490e686
 SHA512:
-  metadata.gz: cec260d2c0b2c10d152336d0809eca8d9d15c4fc8e52ddac94fa01b8850c3f59cebb74f0ddd78b48f751ce9fb6a1f74e6f9646d81a237144645810949c93b7a0
-  data.tar.gz: efa7dbc2609e25b0d25bb0d93c7d877223808d88343299e7dfd60ed9442eb31806347a4aa1f255452bfc219af2a5d4c34b66f5d50346d839de59ee256dafe0da
+  metadata.gz: 6c4eeced42673cb9613462d239f6427bdb1190e14b0a733976e3bd9c17ee061a4fe7fb5f14ace52ea05242b186410570b8d44f1fc5bbc2ab2aacbcd65188d7ef
+  data.tar.gz: 5b84d8229ff419ab0c04fba154088775776ed5f70f4e6be5a9939e9b495e61ac82656a1bf0d7cbddbdf55ae9c1ba1912c44fc2af5b22e16d40a432e71009b185

data/ext/yeptris_native/yeptris_native.c

@@ -423,8 +423,51 @@ static VALUE native_gc_mode_set(VALUE self, VALUE mode) {
     return mode;
 }
 
+/* ABI-drift self-check (the #157-audit silent-nil class): the bundle
+ * is compiled against a specific yep_dom layout; engine drift makes
+ * the walkers read fields at stale offsets — cbor_load returned NIL
+ * on valid CBOR in the dev-checkout audit, with no error anywhere.
+ * Both walkers must round-trip a known document at load, or Init
+ * raises LoadError: lib/yeptris.rb's existing rescue falls back to
+ * the FFI ladder (loudly), and the stale bundle never answers with
+ * garbage. Runs inside rb_protect so a drifted walk raises instead of
+ * crashing the load. */
+static VALUE native_self_check_body(VALUE unused) {
+    /* JSON: {"a"=>[1, 2.5, "x", true, nil]} */
+    const char* json = "{\"a\":[1,2.5,\"x\",true,null]}";
+    VALUE j = yep_rb_parse_json(json, strlen(json), 0);
+    if (j == Qundef || !RB_TYPE_P(j, T_HASH)) return Qfalse;
+    VALUE a = rb_hash_lookup(j, rb_str_new_cstr("a"));
+    if (!RB_TYPE_P(a, T_ARRAY) || RARRAY_LEN(a) != 5) return Qfalse;
+    if (!RB_INTEGER_TYPE_P(rb_ary_entry(a, 0))) return Qfalse;
+    if (!RB_FLOAT_TYPE_P(rb_ary_entry(a, 1))) return Qfalse;
+    if (!RB_TYPE_P(rb_ary_entry(a, 2), T_STRING)) return Qfalse;
+    if (rb_ary_entry(a, 3) != Qtrue || !NIL_P(rb_ary_entry(a, 4))) return Qfalse;
+
+    /* CBOR: A1 61 6B 01 = {"k" => 1} (canonical, hand-encoded) */
+    const char cbor[] = "\xA1\x61\x6B\x01";
+    VALUE c = yep_rb_cbor_load(cbor, sizeof(cbor) - 1, 0);
+    if (c == Qundef || !RB_TYPE_P(c, T_HASH)) return Qfalse;
+    VALUE one = rb_hash_lookup(c, rb_str_new_cstr("k"));
+    if (!RB_INTEGER_TYPE_P(one) || !rb_eql(one, INT2FIX(1))) return Qfalse;
+    return Qtrue;
+}
+
+static void native_self_check(void) {
+    int state = 0;
+    VALUE ok = rb_protect(native_self_check_body, Qnil, &state);
+    if (state != 0 || ok != Qtrue) {
+        if (state != 0) rb_set_errinfo(Qnil);
+        rb_raise(rb_eLoadError,
+                 "yeptris: native materializer failed its ABI self-check "
+                 "(stale build against a drifted engine?) — refusing to "
+                 "register; the FFI ladder will carry the load");
+    }
+}
+
 RUBY_FUNC_EXPORTED void Init_native(void) {
     utf8_enc = rb_utf8_encoding();
+    native_self_check();
     VALUE mYep = rb_define_module("Yeptris");
     VALUE mNat = rb_define_module_under(mYep, "Native");
     rb_define_singleton_method(mNat, "load_json", native_load_json, -1);

data/lib/yeptris/json.rb

@@ -119,7 +119,7 @@ module Yeptris
       end
     end
 
-    def walk_tape(src, tape)
+    def walk_tape(src, tape, strict_dup = STRICT_DUPLICATE_KEYS)
       n = tape[:count]
       kinds = tape[:kinds].read_bytes(n).unpack("C*")
       offs = tape[:offs].read_bytes(n * 4).unpack("V*")
@@ -139,7 +139,7 @@ module Yeptris
 
       docs = [nil] # record 0 (DOC) pre-consumed — the root's slot
       stack = []
-      key_sets = STRICT_DUPLICATE_KEYS ? [{}] : nil
+      key_sets = strict_dup ? [{}] : nil
       pending_key = nil
       i = 1
       while i < n
@@ -152,8 +152,12 @@ module Yeptris
           place(docs, stack, pending_key) { {} }
           pending_key = nil
         when T_CLOSE
+          # Key frames are pushed per MAP_OPEN — an ARRAY close must
+          # not pop the enclosing map's frame (issue found by ea's CI:
+          # {"a":[1],"b":[2],"c":[3]} exhausted the frames and the next
+          # map key hit key_sets.last.key? on nil under strict mode).
+          key_sets&.pop if stack.last.is_a?(Hash)
           stack.pop
-          key_sets&.pop
         when T_STR
           # empty-string literals are frozen+shared since Ruby 3.4
           # (and `+""` binds after the method chain anyway), so the
@@ -256,8 +260,8 @@ module Yeptris
           place(docs, stack, pending_key) { {} }
           pending_key = nil
         when ValueML::CLOSE
+          key_sets&.pop if stack.last.is_a?(Hash)
           stack.pop
-          key_sets&.pop
         when ValueML::V_STR
           text = arena.byteslice(offs[i], lens[i])
           if ikeys[i] == 1 && !stack.empty? && stack.last.is_a?(Hash)

data/lib/yeptris/psych/class_loader.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Yeptris
+  module Psych
+    # The minimal ClassLoader face the ScalarScanner port drives
+    # (stdlib's loader resolves through the class hierarchy; the
+    # scanner only needs the date class and symbolize).
+    class ClassLoader
+      def date
+        Date
+      end
+
+      def symbolize str
+        str.to_sym
+      end
+
+      def load name
+        Object.const_get(name)
+      end
+    end
+  end
+end

data/lib/yeptris/psych/scalar_scanner.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Yeptris
+  module Psych
+    ###
+    # Scan scalars for built in types — the stdlib Psych::ScalarScanner
+    # port (#179): same regexes, same precedence, same edge verdicts.
+    # The load path types through the C resolver; this class is the
+    # standalone API stdlib code (and Psych's own tests) drive directly.
+    class ScalarScanner
+      # Taken from http://yaml.org/type/timestamp.html
+      TIME = /^-?\d{4}-\d{1,2}-\d{1,2}(?:[Tt]|\s+)\d{1,2}:\d\d:\d\d(?:\.\d*)?(?:\s*(?:Z|[-+]\d{1,2}:?(?:\d\d)?))?$/
+
+      # Taken from http://yaml.org/type/float.html
+      # Base 60, [-+]inf and NaN are handled separately
+      FLOAT = /^(?:[-+]?([0-9][0-9_,]*)?\.[0-9]*([eE][-+][0-9]+)?(?# base 10))$/x
+
+      # Taken from http://yaml.org/type/int.html and modified to ensure at least one numerical symbol exists
+      INTEGER_STRICT = /^(?:[-+]?0b[_]*[0-1][0-1_]*             (?# base 2)
+                           |[-+]?0[_]*[0-7][0-7_]*              (?# base 8)
+                           |[-+]?(0|[1-9][0-9_]*)               (?# base 10)
+                           |[-+]?0x[_]*[0-9a-fA-F][0-9a-fA-F_]* (?# base 16))$/x
+
+      # Same as above, but allows commas.
+      # Not to YML spec, but kept for backwards compatibility
+      INTEGER_LEGACY = /^(?:[-+]?0b[_,]*[0-1][0-1_,]*                (?# base 2)
+                           |[-+]?0[_,]*[0-7][0-7_,]*                 (?# base 8)
+                           |[-+]?(?:0|[1-9](?:[0-9]|,[0-9]|_[0-9])*) (?# base 10)
+                           |[-+]?0x[_,]*[0-9a-fA-F][0-9a-fA-F_,]*    (?# base 16))$/x
+
+      BOOLEAN_TRUE  = /^(yes|true|on)$/i
+      BOOLEAN_FALSE = /^(no|false|off)$/i
+
+      attr_reader :class_loader
+
+      # Create a new scanner
+      def initialize class_loader = ClassLoader, strict_integer: false, parse_symbols: true
+        @symbol_cache = {}
+        @class_loader = class_loader
+        @strict_integer = strict_integer
+        @parse_symbols = parse_symbols
+      end
+
+      # Tokenize +string+ returning the Ruby object
+      def tokenize string
+        return nil if string.empty?
+        return @symbol_cache[string] if @symbol_cache.key?(string)
+        integer_regex = @strict_integer ? INTEGER_STRICT : INTEGER_LEGACY
+        # Check for a String type, being careful not to get caught by hash keys, hex values, and
+        # special floats (e.g., -.inf).
+        if string.match?(%r{^[^\d.:-]?[[:alpha:]_\s!@#$%\^&*(){}<>|/\\~;=]+}) || string.match?(/\n/)
+          return string if string.length > 5
+
+          if string.match?(/^[^ytonf~]/i)
+            string
+          elsif string == '~' || string.match?(/^null$/i)
+            nil
+          elsif string.match?(BOOLEAN_TRUE)
+            true
+          elsif string.match?(BOOLEAN_FALSE)
+            false
+          else
+            string
+          end
+        elsif string.match?(TIME)
+          begin
+            parse_time string
+          rescue ArgumentError
+            string
+          end
+        elsif string.match?(/^\d{4}-(?:1[012]|0\d|\d)-(?:[12]\d|3[01]|0\d|\d)$/)
+          begin
+            class_loader.date.strptime(string, '%F', Date::GREGORIAN)
+          rescue ArgumentError
+            string
+          end
+        elsif string.match?(/^\+?\.inf$/i)
+          Float::INFINITY
+        elsif string.match?(/^-\.inf$/i)
+          -Float::INFINITY
+        elsif string.match?(/^\.nan$/i)
+          Float::NAN
+        elsif @parse_symbols && string.match?(/^:./)
+          if string =~ /^:(["'])(.*)\1/
+            @symbol_cache[string] = class_loader.symbolize($2.sub(/^:/, ''))
+          else
+            @symbol_cache[string] = class_loader.symbolize(string.sub(/^:/, ''))
+          end
+        elsif string.match?(/^[-+]?[0-9][0-9_]*(:[0-5]?[0-9]){1,2}$/)
+          i = 0
+          string.split(':').each_with_index do |n, e|
+            i += (n.to_i * 60**(e - 2).abs)
+          end
+          i
+        elsif string.match?(/^[-+]?[0-9][0-9_]*(:[0-5]?[0-9]){1,2}\.[0-9_]*$/)
+          i = 0
+          string.split(':').each_with_index do |n, e|
+            i += (n.to_f * 60**(e - 2).abs)
+          end
+          i
+        elsif string.match?(FLOAT)
+          if string.match?(/\A[-+]?\.\Z/)
+            string
+          else
+            Float(string.delete(',_').gsub(/\.([Ee]|$)/, '\1'))
+          end
+        elsif string.match?(integer_regex)
+          parse_int string
+        else
+          string
+        end
+      end
+
+      # Parse and return an int from +string+
+      def parse_int string
+        Integer(string.delete(',_'))
+      end
+
+      ###
+      # Parse and return a Time from +string+
+      def parse_time string
+        date, time = *(string.split(/[Tt]|\s+/, 2))
+        (yy, m, dd) = date.match(/^(-?\d{4})-(\d{1,2})-(\d{1,2})/).captures.map { |x| x.to_i }
+        md = time.match(/(\d+:\d+:\d+)(?:\.(\d*))?\s*(Z|[-+]\d+(:\d\d)?)?/)
+
+        (hh, mm, ss) = md[1].split(':').map { |x| x.to_i }
+        us = (md[2] ? Rational("0.#{md[2]}") : 0) * 1_000_000
+
+        time = Time.utc(yy, m, dd, hh, mm, ss, us)
+
+        return time if 'Z' == md[3]
+        return Time.at(time.to_i, us) unless md[3]
+
+        tz = md[3].match(/^([+\-]?\d{1,2})\:?(\d{1,2})?$/)[1..-1].compact.map { |digit| Integer(digit, 10) }
+        offset = tz.first * 3600
+
+        if offset < 0
+          offset -= ((tz[1] || 0) * 60)
+        else
+          offset += ((tz[1] || 0) * 60)
+        end
+
+        Time.new(yy, m, dd, hh, mm, ss + us / 1_000_000r, offset)
+      end
+    end
+  end
+end

data/lib/yeptris/psych.rb

@@ -22,6 +22,9 @@ require "yeptris"
 # document without materializing.
 module Yeptris
   module Psych
+    autoload :ClassLoader, "yeptris/psych/class_loader"
+    autoload :ScalarScanner, "yeptris/psych/scalar_scanner"
+
     # The tag registries (Psych's class-level API, #95 bug 4):
     # load_tags maps a serialized tag to the Class that revives it;
     # dump_tags overrides the emitted tag for a Class. Consulted by
@@ -258,18 +261,28 @@ module Yeptris
         ::Yeptris::Psych.dump(obj, io, options)
       end
 
-      def load_stream(yaml, **kwargs)
+      def load_stream(yaml, **kwargs, &block)
         # materialize each document's root directly — the stream
         # children share one C document, so their handles would all
-        # resolve to the first document's tree
+        # resolve to the first document's tree. stdlib's block form
+        # yields each loaded document's object (#179 round 4).
         doc = Yeptris::Document.parse(yaml, schema: :compat_11)
         return nil if doc.nil? # the legal empty stream
 
         begin
-          (0...doc.document_count).map { |i| doc.root(i).to_ruby }
+          docs = (0...doc.document_count).map { |i| doc.root(i).to_ruby }
         ensure
           doc.free
         end
+        docs.each { |d| block.call(d) } if block
+        docs
+      end
+
+      # safe_load_stream: stdlib's surface — the stream form of
+      # safe_load. Our load_stream is already safe-by-default
+      # (Psych 5 semantics), so this is the yielding wrapper.
+      def safe_load_stream(yaml, **kwargs, &block)
+        load_stream(yaml, **kwargs, &block)
       end
 
       # The first document's node tree (no Ruby materialization).
@@ -299,13 +312,14 @@ module Yeptris
         # handles GC-free. (The block-yielding form is tracked under
         # #179: the current implementation materializes eagerly; the
         # block is only honored as a no-op convenience.)
-        _ = block # reserved for the future yielding form (#179)
         doc = Yeptris::Document.parse(yaml, schema: :compat_11)
         return nil if doc.nil? || doc.document_count.zero?
 
         stream = Nodes::Stream.new
         (0...doc.document_count).each do |i|
-          stream.children << Nodes::Builder.document_stream_child(doc, i)
+          child = Nodes::Builder.document_stream_child(doc, i)
+          stream.children << child
+          block.call(child) if block # stdlib's yielding form (#179 round 4)
         end
         # ownership: the DOCUMENT wrapper is the sole owner — its own
         # finalizer (pointer-only closure) frees the C memory; the
@@ -450,6 +464,10 @@ module Yeptris
       # tree stay valid while the tree is reachable; a GC finalizer
       # releases the C memory when it is not.
       class Document < Node
+          # The document's root as a Ruby object (the stream-yield face).
+          def to_ruby
+            children.first&.to_ruby
+          end
         attr_reader :version, :tags
 
         def initialize(version = [], tags = {})

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.1".freeze
+  VERSION = "0.6.16.2".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/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 */

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.16.1
+  version: 0.6.16.2
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-21 00:00:00.000000000 Z
+date: 2026-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -50,11 +50,13 @@ files:
 - lib/yeptris/materializer.rb
 - lib/yeptris/node.rb
 - lib/yeptris/psych.rb
+- lib/yeptris/psych/class_loader.rb
 - lib/yeptris/psych/coder_shim.rb
 - lib/yeptris/psych/drop_in.rb
 - lib/yeptris/psych/encodable.rb
 - lib/yeptris/psych/handler.rb
 - lib/yeptris/psych/parser.rb
+- lib/yeptris/psych/scalar_scanner.rb
 - lib/yeptris/psych/visitors.rb
 - lib/yeptris/schema.rb
 - lib/yeptris/valueml.rb
@@ -89,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