yeptris 0.6.13.1 → 0.6.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5dd96eb5583028d0da7d38ee4addaf108b8a2495696aacc6f68c43117773da3
-  data.tar.gz: b489c5bfc4b41d9cb3d8b836ac4b88f62aaeab5856788412301cde79ee0dfd2f
+  metadata.gz: 0033737c829c7beb3ae83ca816033386b4fe23b53968f2b0ff40a74c97aac469
+  data.tar.gz: c27accdae4e4807500d4edbfa39228b003c70e5380de3f259bd5315dc9a2dc6f
 SHA512:
-  metadata.gz: 4d91f1cdb572d444d4f7a43aec756400375581b3fa7bb1f6bbf62e9ad134ffa392fb1a763f11daffb07ae865e4046b6379a15b7f57eec5fb72c842bb580aee52
-  data.tar.gz: 7ac70b81ca8cf423226b48f8e6422686dc6edd9593a94bc82ebc7d0470ee40a9de9f28b4bd0f4ddf1c85ee1e132156fa1d889db8a1af9a788a6f5384f60c08c6
+  metadata.gz: ca7d477d959df73f231e443f15ceef0403774129e2df0af49d94e2f926d24c380cbacf6e92d88e9488715c028de0533e93fa82ca039ee129dd13b90f4b4badd0
+  data.tar.gz: 54b35dfe9c5399157ffbbb1e33b058afbe523e36222771d000ff697ccaccd059d5b049a3383ac2fbad61086d4548d3bc23343f600311c4c8438535d2a87cc2a8

data/lib/yeptris/document.rb

@@ -26,18 +26,23 @@ class Yeptris::Document
   def self.parse(yaml, schema: :core_12, max_depth: 0)
     yaml = Yeptris.read_input(yaml)
     yaml = yaml.to_s
+    status = ::FFI::MemoryPointer.new(:int)
     doc =
       if schema == :core_12 && max_depth.zero?
-        Yeptris::FFI.yeptris_parse(yaml, yaml.bytesize, nil)
+        Yeptris::FFI.yeptris_parse(yaml, yaml.bytesize, status)
       else
         opts = Yeptris::FFI::ParseOptions.new
         opts[:schema] = schema == :compat_11 ? Yeptris::FFI::SCHEMA_11_COMPAT : Yeptris::FFI::SCHEMA_12_CORE
         opts[:max_depth] = max_depth
-        Yeptris::FFI.yeptris_parse_ex(yaml, yaml.bytesize, opts, nil)
+        Yeptris::FFI.yeptris_parse_ex(yaml, yaml.bytesize, opts, status)
       end
     if doc.null?
-      # the status out-param is skipped: the thread-local error
-      # channel carries the failure detail (measurable on small docs)
+      # NULL + OK is the legal empty stream (no documents): nil, like
+      # stdlib. The status out-param is the discriminator — the TLS
+      # error message cannot serve (a stale error from an earlier
+      # parse persists on the thread).
+      return nil if status.read_int.zero?
+
       raise Yeptris::ParseError,
             "parse failed: #{Yeptris::FFI.last_error_message}"
     end

data/lib/yeptris/ffi.rb

@@ -174,6 +174,8 @@ module Yeptris
     attach_function :yeptris_node_bool, %i[yeptris_node pointer], :yeptris_status
     attach_function :yeptris_node_seq_count, [:yeptris_node], :size_t
     attach_function :yeptris_node_seq_at, %i[yeptris_node size_t], :yeptris_node
+    attach_function :yeptris_node_children,
+                    %i[yeptris_node pointer size_t], :size_t
     attach_function :yeptris_node_map_count, [:yeptris_node], :size_t
     attach_function :yeptris_node_map_get, %i[yeptris_node pointer size_t], :yeptris_node
     attach_function :yeptris_node_map_at,
@@ -227,6 +229,10 @@ module Yeptris
     attach_function :yeptris_marshal_node,
                     %i[yeptris_node pointer pointer], :int
     attach_function :yeptris_marshal_free, [:pointer], :void
+    # The bulk child drain (#168's quadratic): O(n) iteration for
+    # #each/#each_pair. Engines without it fall back to the per-index
+    # walk (correct, quadratic).
+    CHILDREN_DRAIN = !(@missing ||= []).include?(:yeptris_node_children)
     MARSHAL = !(@missing ||= []).include?(:yeptris_marshal_node)
 
     # bulk build (TODO.impl/15 phase D): one call raises a document

data/lib/yeptris/node.rb

@@ -150,7 +150,17 @@ class Yeptris::Node
     return enum_for(:each) unless block_given?
     raise Yeptris::Error, "#each is for sequences" unless sequence?
 
-    (0...seq_count).each { |i| yield seq_at(i) }
+    if Yeptris::FFI::CHILDREN_DRAIN
+      # one bulk walk (#168): the per-index seq_at loop paid i sibling
+      # hops per element — n^2/2 over an 80k-row sequence
+      n = alive { Yeptris::FFI.yeptris_node_seq_count(@c_ptr) }
+      buf = ::FFI::MemoryPointer.new(:pointer, n)
+      alive { Yeptris::FFI.yeptris_node_children(@c_ptr, buf, n) }
+      step = buf.type_size
+      n.times { |i| yield @document.wrap_node(buf.get_pointer(i * step)) }
+    else
+      (0...seq_count).each { |i| yield seq_at(i) }
+    end
   end
 
   # ---- mapping access ----
@@ -177,13 +187,25 @@ class Yeptris::Node
     return enum_for(:each_pair) unless block_given?
     raise Yeptris::Error, "#each_pair is for mappings" unless mapping?
 
-    k = ::FFI::MemoryPointer.new(:pointer)
-    v = ::FFI::MemoryPointer.new(:pointer)
-    (0...map_count).each do |i|
-      rc = alive { Yeptris::FFI.yeptris_node_map_at(@c_ptr, i, k, v) }
-      next unless rc.zero?
+    if Yeptris::FFI::CHILDREN_DRAIN
+      # key,value interleaved in one walk — the same #168 cure
+      pairs = alive { Yeptris::FFI.yeptris_node_map_count(@c_ptr) }
+      buf = ::FFI::MemoryPointer.new(:pointer, pairs * 2)
+      alive { Yeptris::FFI.yeptris_node_children(@c_ptr, buf, pairs * 2) }
+      step = buf.type_size
+      pairs.times do |p|
+        yield @document.wrap_node(buf.get_pointer((2 * p) * step)),
+              @document.wrap_node(buf.get_pointer((2 * p + 1) * step))
+      end
+    else
+      k = ::FFI::MemoryPointer.new(:pointer)
+      v = ::FFI::MemoryPointer.new(:pointer)
+      (0...map_count).each do |i|
+        rc = alive { Yeptris::FFI.yeptris_node_map_at(@c_ptr, i, k, v) }
+        next unless rc.zero?
 
-      yield @document.wrap_node(k.read_pointer), @document.wrap_node(v.read_pointer)
+        yield @document.wrap_node(k.read_pointer), @document.wrap_node(v.read_pointer)
+      end
     end
   end
 
@@ -254,6 +276,31 @@ class Yeptris::Node
     alive { Yeptris::FFI.yeptris_node_id(@c_ptr) }
   end
 
+  # The marshal fast path (TODO.restructure/21; #178): one C call
+  # turns this subtree into Marshal 4.8 bytes — Marshal.load builds
+  # the Ruby objects in C, no per-node FFI. nil when the document
+  # carries constructs the format cannot express (merge keys,
+  # timestamps, tagged revivals): the caller walks instead. Raises
+  # ParseError on engine errors (not on the bail).
+  def marshal_fast
+    return nil unless Yeptris::FFI::MARSHAL
+
+    out_p = ::FFI::MemoryPointer.new(:pointer)
+    olen_p = ::FFI::MemoryPointer.new(:size_t)
+    st = alive { Yeptris::FFI.yeptris_marshal_node(@c_ptr, out_p, olen_p) }
+    if st == Yeptris::FFI::ERROR_UNSUPPORTED
+      nil
+    elsif st != Yeptris::FFI::OK
+      raise Yeptris::ParseError, Yeptris::FFI.last_error_message
+    else
+      bytes = out_p.read_pointer.read_bytes(olen_p.read_uint64)
+      bytes.force_encoding(Encoding::ASCII_8BIT)
+      ::Marshal.load(bytes)
+    end
+  ensure
+    Yeptris::FFI.yeptris_marshal_free(out_p.read_pointer) if out_p
+  end
+
   def to_ruby(memo = nil)
     # readonly documents memoize per node: a second materialization
     # returns the SAME object (the readonly cache is the ground truth
@@ -271,25 +318,7 @@ class Yeptris::Node
     # Falls back to the per-node FFI walk on constructs the format
     # cannot express (merge keys, timestamps) and on older builds.
     if Yeptris::FFI::MARSHAL && memo.nil?
-      result =
-        begin
-          out_p = ::FFI::MemoryPointer.new(:pointer)
-          olen_p = ::FFI::MemoryPointer.new(:size_t)
-          st = Yeptris::FFI.yeptris_marshal_node(@c_ptr, out_p, olen_p)
-          if st == Yeptris::FFI::ERROR_UNSUPPORTED
-            nil
-          elsif st != Yeptris::FFI::OK
-            raise Yeptris::ParseError, Yeptris::FFI.last_error_message
-          else
-            buf = out_p.read_pointer
-            len = olen_p.read_uint64
-            bytes = buf.read_bytes(len)
-            bytes.force_encoding(Encoding::ASCII_8BIT)
-            ::Marshal.load(bytes)
-          end
-        ensure
-          Yeptris::FFI.yeptris_marshal_free(out_p.read_pointer) if out_p
-        end
+      result = marshal_fast
       unless result.nil?
         @document.readonly_memo[node_id] = result if @document.readonly?
         return result
@@ -310,7 +339,32 @@ class Yeptris::Node
       h = {}
       memo[node_id] = h
       each_pair do |k, v|
-        h[k.to_ruby_key] = v.to_ruby(memo)
+        key = k.to_ruby_key
+        val = v.to_ruby(memo)
+        if key == "<<" && k.tag != "tag:yaml.org,2002:str"
+          # stdlib revive_hash's merge branch: the VALUE's node kind
+          # picks the arm; every merge is TypeError-guarded (a bad
+          # element keeps the whole '<<' pair literal)
+          if v.kind == :alias || v.mapping?
+            begin
+              h.merge!(val)
+            rescue ::TypeError
+              h[key] = val
+            end
+          elsif v.sequence?
+            begin
+              merged = {}
+              val.reverse_each { |e| merged.merge!(e) }
+              h.merge!(merged)
+            rescue ::TypeError
+              h[key] = val
+            end
+          else
+            h[key] = val
+          end
+        else
+          h[key] = val
+        end
       end
       h
     when :sequence
@@ -320,7 +374,11 @@ class Yeptris::Node
       a
     when :alias
       t = alias_target
-      t.nil? ? nil : t.to_ruby(memo)
+      if t.nil?
+        raise ::Yeptris::Psych::AnchorNotDefined,
+              "Unknown anchor: #{anchor}"
+      end
+      t.to_ruby(memo)
     else
       scalar_to_ruby
     end

data/lib/yeptris/psych/visitors.rb

@@ -188,6 +188,13 @@ module Yeptris
               key_node = @tree.new_scalar("", :single_quoted)
               key_node.set_tag("!")
               m.map_add_node(key_node, visit(v))
+            elsif k.is_a?(::String) && k == "<<"
+              # stdlib yaml_tree: a literal chevron key carries the
+              # explicit !!str tag (single-quoted) so it does not
+              # re-load as a merge
+              key_node = @tree.new_scalar("<<", :single_quoted)
+              key_node.set_tag("!!str")
+              m.map_add_node(key_node, visit(v))
             else
               m.map_add(key_text(k), visit(v))
             end
@@ -415,10 +422,38 @@ module Yeptris
           end
         end
 
+        # stdlib visit_hash's merge branch, verbatim in structure: the
+        # key's SHAPE decides (an explicit !!str '<<' is a literal key,
+        # not a merge), the VALUE's node kind picks the arm, and every
+        # merge is TypeError-guarded (a bad element keeps the whole
+        # '<<' pair literal — merges are all-or-nothing).
         def hash_into(h, node)
           anchors[node.anchor] = h if node.anchor
           node.children.each_slice(2) do |k, v|
-            h[visit(k)] = visit(v)
+            key = visit(k)
+            val = visit(v)
+            if key == "<<" && k.tag != "tag:yaml.org,2002:str"
+              case v
+              when ::Yeptris::Psych::Nodes::Alias, ::Yeptris::Psych::Nodes::Mapping
+                begin
+                  h.merge!(val)
+                rescue ::TypeError
+                  h[key] = val
+                end
+              when ::Yeptris::Psych::Nodes::Sequence
+                begin
+                  merged = {}
+                  val.reverse_each { |value| merged.merge!(value) }
+                  h.merge!(merged)
+                rescue ::TypeError
+                  h[key] = val
+                end
+              else
+                h[key] = val
+              end
+            else
+              h[key] = val
+            end
           end
           h
         end

data/lib/yeptris/psych.rb

@@ -91,6 +91,9 @@ module Yeptris
     # object instance exists.
     autoload :Encodable, "yeptris/psych/encodable"
     class Error < StandardError; end
+
+    # stdlib psych 5: a *foo with no matching &foo anchor
+    class AnchorNotDefined < Error; end
     # Psych's exact interface (issue #32): same constructor arity,
     # same reader set (file/line/column/offset/problem/context), same
     # message shape — drop-in consumers' rescues and constructors
@@ -143,6 +146,31 @@ module Yeptris
       # !ruby/set, encode_with/init_with, alias identity. Plain-data
       # loads should use load/safe_load (the Materializer fast path).
       def unsafe_load(yaml, **)
+        # #178: the marshal fast path. Nodes::Builder's tree is per-node
+        # FFI (kind/tag/anchor/value + a walk per container) — the whole
+        # 11 MB relaton index paid ~9.6 s there. When the document is
+        # plain data (no timestamps/merge keys/tagged revivals), ONE C
+        # call materializes the tree as Marshal bytes and Marshal.load
+        # builds the objects in C (~1 s end to end). Construct-heavy
+        # documents keep the full revival walk below, byte for byte.
+        if Yeptris::FFI::MARSHAL && ::Yeptris::Psych.domain_types.empty?
+          begin
+            doc = ::Yeptris::Document.parse(yaml, schema: :compat_11)
+            return nil if doc.nil? || doc.document_count.zero?
+
+            root = doc.root(0)
+            fast = root&.marshal_fast
+            unless fast.nil?
+              doc.free
+              return fast
+            end
+            tree = Nodes::Builder.document(doc) # ownership: the tree frees
+            return Visitors::ToRuby.visit(tree.children.first)
+          rescue ::Yeptris::ParseError => e
+            doc&.free unless doc&.freed?
+            translate_parse_error(e)
+          end
+        end
         tree = parse(yaml)
         return nil if tree.nil?
 
@@ -150,11 +178,16 @@ module Yeptris
       end
 
       def safe_load(yaml, permitted_classes: [::Date, ::Time], aliases: false, **)
-        doc = Yeptris::Document.parse(yaml, schema: :compat_11)
         begin
+          doc = Yeptris::Document.parse(yaml, schema: :compat_11)
+          return nil if doc.nil? # the legal empty stream
+
           force_utf8_scalars(walk_safe(doc.root(0), permitted_classes, aliases))
+        rescue ::Yeptris::ParseError => e
+          doc&.free unless doc&.freed?
+          translate_parse_error(e)
         ensure
-          doc.free
+          doc&.free
         end
       end
 
@@ -230,6 +263,8 @@ module Yeptris
         # children share one C document, so their handles would all
         # resolve to the first document's tree
         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 }
         ensure
@@ -238,9 +273,18 @@ module Yeptris
       end
 
       # The first document's node tree (no Ruby materialization).
+      def translate_parse_error(e)
+        # yeptris rejects *foo without &foo at PARSE time (stdlib
+        # raises at visit) — surface it as stdlib's class so
+        # consumers' rescues keep working
+        raise AnchorNotDefined, e.message if e.message.include?("undefined anchor")
+
+        raise SyntaxError.from_parse_error(e)
+      end
+
       def parse(yaml)
         doc = Yeptris::Document.parse(yaml, schema: :compat_11)
-        return nil if doc.document_count.zero?
+        return nil if doc.nil? || doc.document_count.zero?
 
         Nodes::Builder.document(doc)
       rescue Yeptris::ParseError => e
@@ -249,7 +293,7 @@ module Yeptris
 
       def parse_stream(yaml)
         doc = Yeptris::Document.parse(yaml, schema: :compat_11)
-        return nil if doc.document_count.zero?
+        return nil if doc.nil? || doc.document_count.zero?
 
         stream = Nodes::Stream.new
         (0...doc.document_count).each do |i|

data/lib/yeptris/yaml/descriptor.rb

@@ -33,6 +33,8 @@ class Yeptris::YAML::Descriptor < ::Yeptris::JSON::Descriptor
   def walk(yaml)
     src = ::Yeptris.read_input(yaml).to_s
     doc = ::Yeptris::Document.parse(src, schema: @schema)
+    return [] if doc.nil? # the legal empty stream
+
     begin
       st = ::FFI::MemoryPointer.new(:int)
       raw = ::Yeptris::FFI.yeptris_document_plan_walk(doc.c_ptr, @handle, st)

data/lib/yeptris/yaml.rb

@@ -73,7 +73,7 @@ module Yeptris
     # Parses without materializing: the first document's root Node.
     def parse(yaml, schema: :core_12)
       doc = Document.parse(yaml, schema: schema)
-      return nil if doc.document_count.zero?
+      return nil if doc.nil? || doc.document_count.zero?
 
       doc.root(0)
     end
@@ -177,6 +177,14 @@ module Yeptris
                 off[0] += 1
               elsif k.is_a?(Symbol)
                 scalar(":#{k}", STYLE_PLAIN, emit, blob, off)
+              elsif k.is_a?(String) && k == "<<"
+                # stdlib yaml_tree: a literal chevron key carries the
+                # explicit !!str tag (single-quoted) so it does not
+                # re-load as a merge
+                scalar("<<", STYLE_SQ, emit, blob, off)
+                emit.call(BUILD_TAG, 0, off[0], 5)
+                blob << "!!str"
+                off[0] += 5
               elsif k.is_a?(String)
                 place(k, emit, blob, off, seen)
               else
@@ -343,6 +351,12 @@ module Yeptris
               key_node = doc.new_scalar("", :single_quoted)
               key_node.set_tag("!")
               m.map_add_node(key_node, build(doc, v, seen))
+            elsif k.is_a?(::String) && k == "<<"
+              # stdlib yaml_tree: a literal chevron key carries the
+              # explicit !!str tag so it does not re-load as a merge
+              key_node = doc.new_scalar("<<", :single_quoted)
+              key_node.set_tag("!!str")
+              m.map_add_node(key_node, build(doc, v, seen))
             else
               m.map_add(key_text(k), build(doc, v, seen))
             end

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

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

@@ -76,6 +76,15 @@ YEPTRIS_API YeptrisNode yeptris_node_map_get(YeptrisNode node, const char* key,
 YEPTRIS_API int yeptris_node_map_at(YeptrisNode node, size_t index, YeptrisNode* key,
                                     YeptrisNode* value);
 
+/* Bulk children drain — the O(n) iteration primitive (ruby #168: the
+ * per-index seq_at/map_at walks make an 80k-row sequence O(n^2)). One
+ * call walks the child list once and fills out[0..cap) with handles:
+ * sequence elements in order; mapping KEY,VALUE pairs interleaved.
+ * Returns the total child count (mapping pairs count twice); out==NULL
+ * or cap==0 returns the count without allocating handles. Handles come
+ * from the document's pool — document_free reclaims them. */
+YEPTRIS_API size_t yeptris_node_children(YeptrisNode node, YeptrisNode* out, size_t cap);
+
 /* ---- Construction (TODO.impl/11 phase 3) ----
  *
  * Build documents from scratch and mutate them; the emitter and every

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

@@ -734,6 +734,7 @@ static YeptrisDocument cbor_wrap(yep_dom* dom, const void* buf, const yep_alloca
     d->transcoded_len = 0;
     d->input = (const char*)buf;
     d->finish_pool = NULL;
+    d->lazy_tape = NULL; /* field-by-field ctor: no garbage for free */
     return (YeptrisDocument)d;
 }
 
@@ -839,6 +840,7 @@ YEPTRIS_API YeptrisDocument yeptris_cbor_decode(const void* buf, size_t len, uin
     doc->transcoded_len = 0;
     doc->input = (const char*)buf;
     doc->finish_pool = NULL;
+    doc->lazy_tape = NULL; /* field-by-field ctor: no garbage for free */
     if (status != NULL) {
         *status = YEPTRIS_OK;
     }

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

@@ -703,7 +703,10 @@ static void cbor_write_item(cenc* e, uint32_t id, uint8_t* out, size_t* pos) {
 static int cbor_run(YeptrisDocument handle, uint32_t opts, uint8_t* out, size_t cap,
                     size_t* out_len, int* written) {
     yeptris_document* doc = (yeptris_document*)handle;
-    yep_dom* d = doc->dom;
+    yep_dom* d = yep_doc_dom(doc); /* #342 lazy: materialize on encode */
+    if (d == NULL) {
+        return YEPTRIS_ERROR_MEMORY;
+    }
     if (d->dcount == 0) {
         return YEPTRIS_ERROR_ARG;
     }

data/vendor/libyeptris/src/yeptris/doc.h

@@ -22,16 +22,35 @@ typedef struct yeptris_document {
     void* finish_pool; /* engine finish pool: resolved tags, folded and
                           escaped scalars outlive the engine through the
                           document */
+    void* lazy_tape;   /* #342 slice 2: the parsed tape when the tree is
+                        * deferred (gate-clean strict JSON). dom==NULL until
+                        * the first tree access materializes via dom_from_tape;
+                        * freed with the document. void* to avoid a header
+                        * cycle — parse.c casts to yeptris_json_tape* */
 } yeptris_document;
 
 /* Node handle: a (document, node-id) pair so nodes stay usable even if
  * the node pool grows (ids are stable; pointers are not). Defined here
  * (not parse.c) since the query layer and the builder share it. */
+/* #342 slice 2: the lazy-tree choke point. Returns the document's dom,
+ * materializing it from lazy_tape on first access (NULL when materialization
+ * fails — callers treat it as an empty/unusable tree). Every consumer that
+ * reads ->dom on a parse-produced document routes through here; the builder
+ * and CBOR decode paths set dom eagerly and are unaffected. parse.c owns it. */
 typedef struct yeptris_node {
     yeptris_document* doc;
     uint32_t id;
 } yeptris_node;
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+yep_dom* yep_doc_dom(yeptris_document* doc);
 yeptris_node* yep_handle_new(yeptris_document* doc, uint32_t id);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* YEP_DOC_H */

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

@@ -866,12 +866,18 @@ int dom_on_flow_commit(void* ctx) {
 }
 
 int dom_from_tape(yep_dom* d, const yeptris_json_tape* t) {
-    if (d == NULL || t == NULL || t->_src == NULL) {}
+    if (d == NULL || t == NULL || t->_src == NULL) {
+        return -1;
+    }
     /* the columns are the one representation valid on every route
      * (strict: native; lenient fused: lazily materialized from the
      * records; scalar-root lenient: native column writes) */
-    if (yeptris_tape_columns((yeptris_json_tape*)t) != 0) {}
-    if (t->kinds == NULL) {}
+    if (yeptris_tape_columns((yeptris_json_tape*)t) != 0) {
+        return -1;
+    }
+    if (t->kinds == NULL) {
+        return -1;
+    }
     d->input_base = (const char*)t->_src;
     d->input_len = t->_srclen;
     const char* src = (const char*)t->_src;
@@ -885,17 +891,23 @@ int dom_from_tape(yep_dom* d, const yeptris_json_tape* t) {
             break; /* the stream boundary record */
         case YEP_T_SEQ_OPEN:
         case YEP_T_MAP_OPEN: {
-            if (d->depth >= YEP_DOM_MAX_DEPTH) {}
+            if (d->depth >= YEP_DOM_MAX_DEPTH) {
+                return -1;
+            }
             uint32_t id =
                 dom_open_node(d, kind == YEP_T_SEQ_OPEN ? YEP_DOM_SEQUENCE : YEP_DOM_MAPPING, NULL,
                               NULL, 0, 0, 0, 1);
-            if (id == UINT32_MAX || dom_place(d, id) != 0) {}
+            if (id == UINT32_MAX || dom_place(d, id) != 0) {
+                return -1;
+            }
             d->map_pending_key[d->depth] = 0;
             d->stack[d->depth++] = id;
             break;
         }
         case YEP_T_CLOSE:
-            if (d->depth == 0) {}
+            if (d->depth == 0) {
+                return -1;
+            }
             d->depth--;
             break;
         case YEP_T_NULL:
@@ -952,7 +964,9 @@ int dom_from_tape(yep_dom* d, const yeptris_json_tape* t) {
                     /* escaped: unescape into the arena (the fused
                      * builder's arm, byte for byte) */
                     char* dst = yep_dom_str_tail(d, len);
-                    if (dst == NULL) {}
+                    if (dst == NULL) {
+                        return -1;
+                    }
                     d->nodes[id].value = yep_dom_str_commit(
                         d, yep_finish_double_into(src, off, off + len, dst, len));
                 } else {

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

@@ -45,6 +45,9 @@ YEPTRIS_API size_t yeptris_serialize_into_ex(YeptrisDocument handle,
     em.w.grow = 0;
     em.w.oom = 0;
     em.doc = (const yeptris_document*)handle;
+    if (yep_doc_dom((yeptris_document*)handle) == NULL) { /* #342 lazy */
+        return 0;
+    }
     em.w.p = NULL;
     em.w.last = 0;
     em.w.force_flow = 0;
@@ -100,6 +103,9 @@ YEPTRIS_API char* yeptris_serialize_ex(YeptrisDocument handle, const yeptris_emi
     em.w.grow = 0;
     em.w.oom = 0;
     em.doc = (const yeptris_document*)handle;
+    if (yep_doc_dom((yeptris_document*)handle) == NULL) { /* #342 lazy */
+        return NULL;
+    }
     em.w.p = NULL;
     em.w.last = 0;
     em.w.force_flow = 0;
@@ -174,6 +180,9 @@ YEPTRIS_API char* yeptris_serialize_json(YeptrisDocument handle, size_t* len) {
     em.w.grow = 0;
     em.w.oom = 0;
     em.doc = (const yeptris_document*)handle;
+    if (yep_doc_dom((yeptris_document*)handle) == NULL) { /* #342 lazy */
+        return NULL;
+    }
     em.w.p = NULL;
     em.w.last = 0;
     em.w.force_flow = 0;
@@ -224,6 +233,9 @@ YEPTRIS_API char* yeptris_serialize_json_ex(YeptrisDocument handle, size_t* len,
     em.w.grow = 0;
     em.w.oom = 0;
     em.doc = (const yeptris_document*)handle;
+    if (yep_doc_dom((yeptris_document*)handle) == NULL) { /* #342 lazy */
+        return NULL;
+    }
     em.w.p = NULL;
     em.w.last = 0;
     em.w.force_flow = 0;
@@ -378,6 +390,9 @@ YEPTRIS_API size_t yeptris_serialize_stream(YeptrisDocument handle,
     em.w.grow = 0;
     em.w.oom = 0;
     em.doc = (const yeptris_document*)handle;
+    if (yep_doc_dom((yeptris_document*)handle) == NULL) { /* #342 lazy */
+        return 0;
+    }
     em.w.p = NULL;
     em.w.last = 0;
     em.w.force_flow = 0;

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

@@ -721,6 +721,34 @@ YEPTRIS_API YeptrisStatus yeptris_marshal(const char* data, size_t len, YeptrisS
     return st;
 }
 
+/* #178 (ruby #168's fast path): the value records carry the resolver's
+ * verdict, NOT the source's explicit tag — a `!ruby/object` mapping
+ * would marshal as a plain hash, silently dropping the tag (psych's
+ * visitor revives it). One cheap pre-walk: any explicitly tagged node
+ * in the subtree → UNSUPPORTED, the host walks. Explicit CORE tags
+ * (!!str and friends) ride the same bail — correct, just conservative;
+ * bulk data is untagged. */
+static int dom_subtree_tagged(const yep_dom* d, uint32_t id) {
+    const yep_dnode* n = yep_dom_node(d, id);
+    if (n == NULL) {
+        return 0;
+    }
+    if (n->tag.len != 0) {
+        return 1;
+    }
+    for (uint32_t c = n->first_child; c != UINT32_MAX;) {
+        const yep_dnode* cn = yep_dom_node(d, c);
+        if (cn == NULL) {
+            break;
+        }
+        if (dom_subtree_tagged(d, c) != 0) {
+            return 1;
+        }
+        c = cn->next_sibling;
+    }
+    return 0;
+}
+
 YEPTRIS_API YeptrisStatus yeptris_marshal_node(YeptrisNode node, char** out, size_t* out_len) {
     if (node == NULL || out == NULL || out_len == NULL) {
         return YEPTRIS_ERROR_ARG;
@@ -728,6 +756,12 @@ YEPTRIS_API YeptrisStatus yeptris_marshal_node(YeptrisNode node, char** out, siz
     *out = NULL;
     *out_len = 0;
     yeptris_node* h = (yeptris_node*)node;
+    if (dom_subtree_tagged(h->doc->dom, h->id) != 0) {
+        yep_error_set(yep_error_tls(), YEP_ERR_UNEXPECTED, 0, 0, 0,
+                      "marshal: explicitly tagged node not expressible; "
+                      "fall back to the value walk");
+        return YEPTRIS_ERROR_UNSUPPORTED;
+    }
     yep_value_ctx* c = NULL;
     if (yep_values_from_dom(h->doc->dom, h->id, 0, &c) != 0) {
         return YEPTRIS_ERROR_MEMORY;

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

@@ -12,6 +12,7 @@
 #include "parse/numbers.h"
 #include "resolve/resolver.h"
 #include "scan/json.h"
+#include "tape_in.h"
 
 #include "parse/events.h"
 #include <errno.h>
@@ -38,6 +39,59 @@ YEPTRIS_API YeptrisDocument yeptris_parse(const char* buf, size_t len, YeptrisSt
     return yeptris_parse_ex(buf, len, NULL, status);
 }
 
+/* #342 slice 2: materialize the deferred tree on first access. The
+ * gate-clean JSON route carries the parsed TAPE (simdjson's design:
+ * its "DOM" is a tape) and pays dom_from_tape only when a consumer
+ * touches the tree — parse-only workloads never build nodes. */
+yep_dom* yep_doc_dom(yeptris_document* doc) {
+    if (doc == NULL) {
+        return NULL;
+    }
+    if (doc->dom == NULL && doc->lazy_tape != NULL) {
+        yeptris_json_tape* t = (yeptris_json_tape*)doc->lazy_tape;
+        yep_dom* dom = yep_dom_create(doc->sys);
+        if (dom != NULL && dom_from_tape(dom, t) == 0) {
+            doc->dom = dom;
+            yeptris_tape_free(t);
+            yep_free(doc->sys, t);
+            doc->lazy_tape = NULL;
+        } else {
+            yep_dom_destroy(dom);
+            dom = NULL; /* the tape stays: a later access retries, or
+                           free drops it (the materializer only fails on
+                           malformed NUM spans, which the strict gate
+                           already rejected at parse) */
+        }
+        return dom;
+    }
+    return doc->dom;
+}
+
+/* The strict-JSON document wrapper (both routes share it). */
+/* The lazy route's acceptance debt: the fused lenient walk records
+ * number runs UNVALIDATED (its simdjson-style deferred contract).
+ * parse_json's contract is RFC 8259 at parse time, so the deferred
+ * spans settle HERE — full-span shape check per NUM record, decoding
+ * the packed records directly (no columns build at parse; the walk
+ * guarantees recs are primary on this route). */
+static int lazy_nums_settled(const yeptris_json_tape* t) {
+    const char* p = (const char*)t->_src;
+    for (uint32_t i = 0; i < t->count; i++) {
+        uint64_t r = t->recs[i];
+        if ((uint8_t)(r & 0xFFu) != YEP_T_NUM) {
+            continue;
+        }
+        uint32_t len = (uint32_t)((r >> 8) & 0x7FFFFFu);
+        uint32_t off = (uint32_t)(r >> 32);
+        size_t adv = 0;
+        int flt = 0;
+        if (yep_json_number_shape(p + off, len, &adv, &flt) == 0 || adv != (size_t)len) {
+            return -1;
+        }
+    }
+    return 0;
+}
+
 /* The strict-JSON document wrapper (both routes share it). */
 static YeptrisDocument yep_json_doc_wrap(yep_dom* dom, const char* buf, size_t len,
                                          const yep_allocator* sys, YeptrisStatus* status) {
@@ -52,6 +106,7 @@ static YeptrisDocument yep_json_doc_wrap(yep_dom* dom, const char* buf, size_t l
     }
     doc->dom = dom;
     doc->sys = sys;
+    doc->lazy_tape = NULL;
     doc->schema = YEPTRIS_SCHEMA_12_CORE; /* strict JSON is core by construction */
     doc->transcoded = NULL;
     doc->transcoded_len = 0;
@@ -75,41 +130,44 @@ YEPTRIS_API YeptrisDocument yeptris_parse_json(const char* buf, size_t len, Yept
      * builds. Rejects, non-opener roots, and surprises fall to the
      * original sequence below, whose error precedence is byte-for-byte
      * the pinned behavior (json-suite-strict gates this). */
-    if (len > 0 && !yep_text_active()->gate_scan(buf, len)) {
+    int gated = len > 0 && yep_text_active()->gate_scan(buf, len);
+    if (!gated) {
         size_t off = 0;
         while (off < len &&
                (buf[off] == ' ' || buf[off] == '\t' || buf[off] == '\n' || buf[off] == '\r')) {
             off++;
         }
-        if (off < len && (buf[off] == '[' || buf[off] == '{')) {
+        /* tabs: the lenient walk's own pinned acceptance (its route
+         * takes them); the strict routes reject them (ErrorParity's
+         * pinned agreement). A tab-carrying buffer must NOT take the
+         * lazy walk — the validating sequence below reports exactly
+         * the pinned reject. */
+        if (off < len && (buf[off] == '[' || buf[off] == '{') && memchr(buf, '\t', len) == NULL) {
+            /* #342 slice 2: the fused LENIENT walk (one pass, records
+             * only — no node building) settles the deferred number
+             * grammar inline, then the tape rides the document and
+             * dom_from_tape builds nodes on the first tree access.
+             * A reject or malformed span falls to the original
+             * sequence below, whose error precedence is byte-for-byte
+             * the pinned behavior. */
             const yep_allocator* sys = yep_system_allocator();
-            yep_dom* dom = yep_dom_create(sys);
-            if (dom == NULL) {
+            yeptris_json_tape* t = yep_alloc(sys, sizeof(*t));
+            if (t == NULL) {
                 st = YEPTRIS_ERROR_MEMORY;
                 goto jfail;
             }
-            dom->input_base = buf;
-            dom->input_len = len;
-            dom->flow_strict = 1;
-            size_t close = 0;
-            int rc = dom_on_flow_build(dom, buf, off, len, 1, 0, (yep_view){0}, (yep_view){0}, 0,
-                                       YEP_DOM_MAX_DEPTH, &close);
-            dom->flow_strict = 0;
-            int tail_ok = 0;
-            if (rc == 1) {
-                /* trailing garbage after the closer is a reject the
-                 * fallback reports exactly as before */
-                size_t t = close + 1;
-                while (t < len &&
-                       (buf[t] == ' ' || buf[t] == '\t' || buf[t] == '\n' || buf[t] == '\r')) {
-                    t++;
+            if (yep_tape_walk_lenient_fused(buf, len, off, t) == YEPTRIS_OK &&
+                lazy_nums_settled(t) == 0) {
+                YeptrisDocument h = yep_json_doc_wrap(NULL, buf, len, sys, status);
+                if (h != NULL) {
+                    ((yeptris_document*)h)->lazy_tape = t;
+                    return h;
                 }
-                tail_ok = (t == len);
+                yeptris_tape_free(t); /* wrap failed (memory): below */
+            } else {
+                yeptris_tape_free(t); /* reject/malformed: below */
             }
-            if (rc == 1 && tail_ok && dom_on_flow_commit(dom) > 0) {
-                return yep_json_doc_wrap(dom, buf, len, sys, status);
-            }
-            yep_dom_destroy(dom); /* reject/rollback: the sequence below */
+            yep_free(sys, t);
         }
     }
     size_t verr = 0;
@@ -120,8 +178,7 @@ YEPTRIS_API YeptrisDocument yeptris_parse_json(const char* buf, size_t len, Yept
         goto jfail;
     }
     size_t uerr = 0;
-    if (yep_text_active()->gate_scan(buf, len) &&
-        !yep_utf8_validate((const unsigned char*)buf, len, &uerr)) {
+    if (gated && !yep_utf8_validate((const unsigned char*)buf, len, &uerr)) {
         yep_error_set(yep_error_tls(), YEP_ERR_ENCODING, 0, 0, uerr, "ill-formed UTF-8 at byte %zu",
                       uerr);
         st = YEPTRIS_ERROR_ENCODING;
@@ -343,6 +400,8 @@ engine_enter:
      * or an arena copy (dom_ev_str) — nothing references it */
     yep_pool_destroy(finish);
     doc->finish_pool = NULL;
+    doc->lazy_tape = NULL; /* field-by-field ctor: leave no garbage
+                            * (document_free frees a non-NULL tape) */
     return (YeptrisDocument)doc;
 
 fail:
@@ -363,6 +422,10 @@ YEPTRIS_API void yeptris_document_free(YeptrisDocument handle) {
     if (doc == NULL) {
         return;
     }
+    if (doc->lazy_tape != NULL) { /* never materialized: free stays free */
+        yeptris_tape_free((yeptris_json_tape*)doc->lazy_tape);
+        yep_free(doc->sys, doc->lazy_tape);
+    }
     yep_dom_destroy(doc->dom);
     yep_pool_destroy((yep_pool*)doc->finish_pool);
     yep_free(doc->sys, doc->transcoded);
@@ -371,7 +434,7 @@ YEPTRIS_API void yeptris_document_free(YeptrisDocument handle) {
 
 YEPTRIS_API size_t yeptris_document_count(YeptrisDocument handle) {
     yeptris_document* doc = (yeptris_document*)handle;
-    return doc ? doc->dom->dcount : 0;
+    return doc ? yep_doc_dom(doc)->dcount : 0;
 }
 
 yeptris_node* yep_handle_new(yeptris_document* doc, uint32_t id) {
@@ -390,10 +453,14 @@ static YeptrisNode node_new_handle(yeptris_document* doc, uint32_t id) {
 
 YEPTRIS_API YeptrisNode yeptris_document_root(YeptrisDocument handle, size_t index) {
     yeptris_document* doc = (yeptris_document*)handle;
-    if (doc == NULL || index >= doc->dom->dcount) {
+    if (doc == NULL) {
         return NULL;
     }
-    return node_new_handle(doc, doc->dom->docs[index]);
+    yep_dom* dom = yep_doc_dom(doc);
+    if (dom == NULL || index >= dom->dcount) {
+        return NULL;
+    }
+    return node_new_handle(doc, dom->docs[index]);
 }
 
 static const yep_dnode* node_of(YeptrisNode handle) {
@@ -588,6 +655,24 @@ YEPTRIS_API YeptrisNode yeptris_node_seq_at(YeptrisNode handle, size_t index) {
     return wrap((yeptris_node*)handle, id);
 }
 
+YEPTRIS_API size_t yeptris_node_children(YeptrisNode handle, YeptrisNode* out, size_t cap) {
+    const yep_dnode* n = node_of(handle);
+    if (n == NULL || (n->kind != YEP_DOM_SEQUENCE && n->kind != YEP_DOM_MAPPING)) {
+        return 0;
+    }
+    size_t count = 0;
+    uint32_t id = n->first_child;
+    while (id != UINT32_MAX) {
+        if (out != NULL && count < cap) {
+            out[count] = wrap((yeptris_node*)handle, id);
+        }
+        count++;
+        const yep_dnode* cur = yep_dom_node(((yeptris_node*)handle)->doc->dom, id);
+        id = cur ? cur->next_sibling : UINT32_MAX;
+    }
+    return count;
+}
+
 YEPTRIS_API size_t yeptris_node_map_count(YeptrisNode handle) {
     const yep_dnode* n = node_of(handle);
     return (n && n->kind == YEP_DOM_MAPPING) ? n->count / 2 : 0;

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

@@ -79,12 +79,16 @@ YEPTRIS_API yeptris_plan* yeptris_plan_compile(const char* spec, size_t len, Yep
         }
         return NULL;
     }
-    const yeptris_document* d = (const yeptris_document*)doc;
-    const yep_dnode* root = yep_dom_node(d->dom, d->dom->docs[0]);
-    yeptris_plan* plan = calloc(1, sizeof(*plan));
+    yeptris_document* d = (yeptris_document*)doc;
+    yeptris_plan* plan = calloc(1, sizeof(*plan)); /* before any goto: out frees it */
     if (plan == NULL) {
         goto mem;
     }
+    yep_dom* dd = yep_doc_dom(d); /* #342 lazy: the spec parse may defer */
+    if (dd == NULL) {
+        goto mem;
+    }
+    const yep_dnode* root = yep_dom_node(dd, dd->docs[0]);
     if (root == NULL || root->kind != 2) { /* the spec root is a mapping */
         goto bad;
     }
@@ -95,10 +99,10 @@ YEPTRIS_API yeptris_plan* yeptris_plan_compile(const char* spec, size_t len, Yep
     int saw_kind = 0;
     uint32_t pair = root->first_child;
     while (pair != UINT32_MAX) {
-        const yep_dnode* kn = yep_dom_node(d->dom, pair);
-        const yep_dnode* vn = yep_dom_node(d->dom, kn->next_sibling);
-        yep_view kv = sv_view(d->dom, kn->value);
-        yep_view vv = sv_view(d->dom, vn->value);
+        const yep_dnode* kn = yep_dom_node(dd, pair);
+        const yep_dnode* vn = yep_dom_node(dd, kn->next_sibling);
+        yep_view kv = sv_view(dd, kn->value);
+        yep_view vv = sv_view(dd, vn->value);
         if (kv.len == 4 && memcmp(kv.p, "kind", 4) == 0) {
             saw_kind = 1;
             if (!(vv.len == 3 && (memcmp(vv.p, "seq", 3) == 0 || memcmp(vv.p, "map", 3) == 0))) {
@@ -130,7 +134,7 @@ YEPTRIS_API yeptris_plan* yeptris_plan_compile(const char* spec, size_t len, Yep
         if (path_node->tag_id != YEPTRIS_TAG_STR) {
             goto bad; /* the path is a string, not a number */
         }
-        yep_view vv = sv_view(d->dom, path_node->value);
+        yep_view vv = sv_view(dd, path_node->value);
         if (vv.len != 0) { /* "" rides the seq root like no path */
             plan->seg_off = malloc(sizeof(uint32_t));
             plan->seg_len = malloc(sizeof(uint32_t));
@@ -159,11 +163,11 @@ YEPTRIS_API yeptris_plan* yeptris_plan_compile(const char* spec, size_t len, Yep
         size_t off = 0;
         uint32_t cn = path_node->first_child;
         for (size_t i = 0; i < n; i++) {
-            const yep_dnode* seg = yep_dom_node(d->dom, cn);
+            const yep_dnode* seg = yep_dom_node(dd, cn);
             if (seg == NULL || seg->kind != 0 || seg->tag_id != YEPTRIS_TAG_STR) {
                 goto bad; /* every segment is a string */
             }
-            yep_view sv = sv_view(d->dom, seg->value);
+            yep_view sv = sv_view(dd, seg->value);
             if (sv.len == 0) {
                 goto bad;
             }
@@ -191,7 +195,7 @@ YEPTRIS_API yeptris_plan* yeptris_plan_compile(const char* spec, size_t len, Yep
     }
     uint32_t cn = children->first_child;
     for (size_t i = 0; i < plan->ncols; i++) {
-        const yep_dnode* leaf = yep_dom_node(d->dom, cn);
+        const yep_dnode* leaf = yep_dom_node(dd, cn);
         if (leaf == NULL || leaf->kind != 2) {
             goto bad;
         }
@@ -200,10 +204,10 @@ YEPTRIS_API yeptris_plan* yeptris_plan_compile(const char* spec, size_t len, Yep
         int kind = -1;
         uint32_t lp = leaf->first_child;
         while (lp != UINT32_MAX) {
-            const yep_dnode* lk = yep_dom_node(d->dom, lp);
-            const yep_dnode* lv = yep_dom_node(d->dom, lk->next_sibling);
-            yep_view lkv = sv_view(d->dom, lk->value);
-            yep_view lvv = sv_view(d->dom, lv->value);
+            const yep_dnode* lk = yep_dom_node(dd, lp);
+            const yep_dnode* lv = yep_dom_node(dd, lk->next_sibling);
+            yep_view lkv = sv_view(dd, lk->value);
+            yep_view lvv = sv_view(dd, lv->value);
             if (lkv.len == 4 && memcmp(lkv.p, "name", 4) == 0) {
                 if (lv->kind != 0 || lvv.len == 0) {
                     goto bad;
@@ -657,15 +661,15 @@ yeptris_document_plan_walk(YeptrisDocument doc, const yeptris_plan* plan, Yeptri
     if (st != NULL) {
         *st = YEPTRIS_OK;
     }
-    const yeptris_document* d = (const yeptris_document*)doc;
-    if (doc == NULL || plan == NULL || d->dom == NULL || d->dom->dcount == 0) {
+    const yep_dom* dd = doc == NULL ? NULL : yep_doc_dom((yeptris_document*)doc);
+    if (doc == NULL || plan == NULL || dd == NULL || dd->dcount == 0) {
         if (st != NULL) {
             *st = YEPTRIS_ERROR_ARG;
         }
         return NULL;
     }
-    const yep_dnode* root = yep_dom_node(d->dom, d->dom->docs[0]);
-    const yep_dnode* container = dom_find_rows(d->dom, root, plan);
+    const yep_dnode* root = yep_dom_node(dd, dd->docs[0]);
+    const yep_dnode* container = dom_find_rows(dd, root, plan);
     if (container == NULL) {
         if (st != NULL) {
             *st = YEPTRIS_ERROR_PARSE; /* document shape disagreement */
@@ -676,7 +680,7 @@ yeptris_document_plan_walk(YeptrisDocument doc, const yeptris_plan* plan, Yeptri
     size_t rows = 0;
     for (uint32_t cur = container->first_child; cur != UINT32_MAX;) {
         const yep_dnode* row;
-        cur = dom_rows_next(d->dom, container, cur, &row);
+        cur = dom_rows_next(dd, container, cur, &row);
         if (row != NULL) {
             rows++;
         }
@@ -690,15 +694,15 @@ yeptris_document_plan_walk(YeptrisDocument doc, const yeptris_plan* plan, Yeptri
     size_t row_i = 0;
     for (uint32_t cur = container->first_child; cur != UINT32_MAX && row_i < rows;) {
         const yep_dnode* row;
-        cur = dom_rows_next(d->dom, container, cur, &row);
+        cur = dom_rows_next(dd, container, cur, &row);
         if (row == NULL) {
             continue;
         }
         uint32_t cn = row->first_child;
         while (cn != UINT32_MAX) {
-            const yep_dnode* k = yep_dom_node(d->dom, cn);
-            const yep_dnode* v = yep_dom_node(d->dom, k->next_sibling);
-            yep_view kv = sv_view(d->dom, k->value);
+            const yep_dnode* k = yep_dom_node(dd, cn);
+            const yep_dnode* v = yep_dom_node(dd, k->next_sibling);
+            yep_view kv = sv_view(dd, k->value);
             int col_idx = -1;
             if (k->kind == YEP_DOM_SCALAR) {
                 for (size_t c = 0; c < plan->ncols; c++) {
@@ -710,10 +714,10 @@ yeptris_document_plan_walk(YeptrisDocument doc, const yeptris_plan* plan, Yeptri
                 }
             }
             if (col_idx >= 0) {
-                const yep_dnode* val = dom_alias_final(d->dom, v);
+                const yep_dnode* val = dom_alias_final(dd, v);
                 yep_result_col* col = &r->cols[col_idx];
                 if (val != NULL && val->kind == YEP_DOM_SCALAR && val->tag_id != YEPTRIS_TAG_NULL) {
-                    yep_view sv = sv_view(d->dom, val->value);
+                    yep_view sv = sv_view(dd, val->value);
                     int filled = 0;
                     switch (col->kind) {
                     case YEP_PLAN_STR:

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

@@ -601,8 +601,8 @@ reject:
  * (the classify scan carries no accept/reject structure) and
  * yeptris_tape_convert owns validation. Everything else matches
  * tape_walk state for state. */
-static YeptrisStatus tape_walk_lnt_fused(const char* p, size_t len, size_t open,
-                                         yeptris_json_tape* t) {
+YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open,
+                                          yeptris_json_tape* t) {
     if (tape_carve(t, len) != YEPTRIS_OK) {
         return YEPTRIS_ERROR_MEMORY;
     }
@@ -1090,7 +1090,7 @@ YEPTRIS_API YeptrisStatus yeptris_parse_json_tape_lenient(const char* source, si
         }
         free(idx);
 #endif
-        return tape_walk_lnt_fused(source, len, at, tape);
+        return yep_tape_walk_lenient_fused(source, len, at, tape);
     }
 
     /* scalar root: one record, same deferred split for numbers */

data/vendor/libyeptris/src/yeptris/tape_in.h

@@ -0,0 +1,19 @@
+/* tape_in.h — the tape module's internal seams (not public ABI).
+ *
+ * parse.c's #342 slice-2 lazy route drives the fused lenient walk
+ * directly: the gate and opener checks it already ran must not be
+ * repeated (the lenient public entry re-gates). The walk's contract
+ * is the public entry's: gate-clean buffer, p[open] is '[' or '{',
+ * tail must be whitespace-only. */
+#ifndef YEP_TAPE_IN_H
+#define YEP_TAPE_IN_H
+
+#include <stddef.h>
+
+#include <yeptris/tape.h>
+
+/* tape.c (was tape_walk_lnt_fused) */
+YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open,
+                                          yeptris_json_tape* t);
+
+#endif

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.13.1
+  version: 0.6.15.1
 platform: ruby
 authors:
 - Ribose Inc.
@@ -164,6 +164,7 @@ files:
 - vendor/libyeptris/src/yeptris/scan/scan.h
 - vendor/libyeptris/src/yeptris/schema.c
 - vendor/libyeptris/src/yeptris/tape.c
+- vendor/libyeptris/src/yeptris/tape_in.h
 - vendor/libyeptris/src/yeptris/version.c
 - vendor/libyeptris/src/yeptris/visit/dom_visit.c
 - vendor/libyeptris/src/yeptris/visit/json_visit.c