yeptris 0.1.12.0 → 0.1.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9fa74d905a2d19dbeaf70381760c3a629738808e507d0ef9f33c9e266b756854
-  data.tar.gz: 2d3fb1c11b0d2dbb88c5bb75e837f41abe971992c1940a8c5be191b0168411b8
+  metadata.gz: 17b1311c9327a9986b7bb89f3731fd40ca040c49336fdb97596951fbf87ed1c0
+  data.tar.gz: 6c1b2f707d15d469963ffc0ee030fc90287a5e01954d7431996f24765bddf9e3
 SHA512:
-  metadata.gz: e621ced9cf2707ada102a8633f7f75f597f63488f2a66da4efdb0dd3e292ef0719bbba509db321ca9e5cfd38f455a732a90cb3d1709b79f4ae7cab5ef0dd48da
-  data.tar.gz: 9d5efd07ce2e2f498320133776e3b0ed08e1fec4977a7e5cd1b607616630377bc29f7d5708e00c058c2f7d97022a6b668d6e3865c33da17a7d9c8ba71d445f2e
+  metadata.gz: b04ca9a9d899c00207d8cf09ab1d1aa071c1cc63f2adab17cf87453d0a0646fc84c9df9f3e80f245bbc977a32e67feb7f25e2b562293a59adc102764b80507dc
+  data.tar.gz: 25c9033573e619dc69924f4ae15c102b650efdbf7d39c1dcc4d3d73243d1d0ac3037750c7b28b5e6d28562175296fd4b125e39253f4ab9c9ed799529d7fcb4ee

data/README.adoc

@@ -52,9 +52,47 @@ Handles are document-scoped: `Document#free` releases everything
 (one C call), a GC finalizer backs it up, and any use after free
 raises `Yeptris::FreedError` — never a segfault.
 
-== Native materializer (opt-in): faster than JSON.parse
+== Two load surfaces: YAML and strict JSON
+
+`Yeptris::YAML.load` keeps the Psych contract for EVERY input —
+including JSON-shaped ones. `{"a": [1,]}` is legal flow YAML (spec
+production [141] allows the trailing comma); `"1e3"` is a Psych
+String. These semantics never flip because input happens to look
+like JSON.
+
+`Yeptris::JSON.load` is the STRICT RFC 8259 surface — exact
+`JSON.parse` semantics by construction (spec-pinned in
+`spec/json_parity_spec.rb`: every value and every error case,
+Bignum integers, exponent-only floats, duplicate keys). Engines,
+fastest first:
+
+1. **Native materializer** (opt-in build; see below): a fused C scan
+   → `VALUE` parser. Order-alternating interleaved profile, 152 KB /
+   ~29k-value corpus, Ruby 3.4:
++
+....
+CI referee (gated at 1.05 on both platforms, order-alternating
+interleave, N=200):
+  ubuntu (x86_64, gc=disable)   mean 0.961x  vs JSON.parse
+  macos  (arm64,  gc=none)      mean 0.718x  (head-to-head 173/200)
+....
+
+The parse-window GC strategy is per-arch and runtime-switchable:
+`Yeptris::Native.gc_mode` / `YEPTRIS_NATIVE_GC` = `:none`
+(steady-state: +0 heap pages, the stdlib's own GC cadence — the
+default on arm64) or `:disable` (no GC during the parse — the
+default on x86_64, faster where pages are free). On a LOADED x86_64
+box prefer `:none`: `:disable` grows ~478 heap pages per 50 parses,
+and page growth under contention is exactly the loaded-box
+regression. `:start` (in-window collection) measured 8x — dead.
+2. **Record-drain fallback** (always available): the strict-JSON
+   validator gates, then the value records convert without the Psych
+   quirk table — exact parity with engine 1, spec-pinned.
+
+The committed profile (`benchmark/json_profile.rb`) is the fair
+benchmark of record — any performance claim runs through it.
 
-For JSON-shaped input, the binding can beat Ruby's own `JSON.parse`:
+=== Building the native materializer (opt-in)
 
 ....
 cd ext/yeptris_native
@@ -62,22 +100,9 @@ YEPTRIS_LIB_PATH=/path/to/libyeptris.dylib ruby extconf.rb && make
 cp native.bundle ../../lib/yeptris/   # or .so on Linux
 ....
 
-`require "yeptris"` picks it up automatically (a missing build falls
-back to the FFI Marshal ladder silently). Measured on the 152 KB /
-29.4k-value JSON corpus (mean of 300, Ruby 3.4):
-
-....
-JSON.parse           mean 1.597 ms
-Yeptris::YAML.load   mean 1.145 ms   (0.72x — faster than JSON.parse)
-Psych.load           mean 40.60 ms   (35x slower than yeptris)
-....
-
-The extension is a fused RFC 8259 → `VALUE` parser (one pass, no
-intermediate records): libyeptris scan kernels tokenize, the Ruby C
-API allocates, repeated keys/tokens share one frozen `String`, and GC
-is paused for the duration. YAML inputs keep the FFI ladder so
-timestamps, aliases, and Psych's scalar quirks resolve through the
-same path `Psych.load` uses.
+`require "yeptris"` picks it up automatically (`Yeptris::JSON` then
+uses it; missing builds silently use the fallback — the gem installs
+without compiling).
 
 == Shipped beyond the original plan
 

data/ext/yeptris_native/extconf.rb

@@ -2,6 +2,9 @@
 
 require "mkmf"
 
+# libyeptris location: YEPTRIS_LIB_PATH (file or dir), then sibling
+# checkouts. CI sets YEPTRIS_LIB_PATH (the built shared library) and
+# YEPTRIS_SRC (the C checkout) explicitly.
 lib_path = ENV["YEPTRIS_LIB_PATH"]
 candidates = []
 if lib_path
@@ -13,11 +16,12 @@ candidates << File.expand_path("../../../../yeptris/build/src", __dir__)
 candidates << File.expand_path("../../../yeptris/build-validate/src", __dir__)
 candidates << File.expand_path("../../../yeptris/build/src", __dir__)
 
-src_root = [
-  File.expand_path("../../../../yeptris/src", __dir__),
-  File.expand_path("../../../yeptris/src", __dir__),
-].find { |d| d && File.directory?(File.join(d, "include")) }
-abort "yeptris sources not found" unless src_root
+# Source root: YEPTRIS_SRC (CI / explicit), then sibling checkouts.
+src_roots = [ENV["YEPTRIS_SRC"]].compact
+src_roots << File.expand_path("../../../../yeptris/src", __dir__)
+src_roots << File.expand_path("../../../yeptris/src", __dir__)
+src_root = src_roots.find { |d| d && File.directory?(File.join(d, "include")) }
+abort "yeptris sources not found (set YEPTRIS_SRC)" unless src_root
 
 $INCFLAGS << " -I#{src_root}/include -I#{src_root}/yeptris"
 %w[build-validate/generated build/generated].each do |g|

data/ext/yeptris_native/json_ruby.c

@@ -1,14 +1,14 @@
 /* json_ruby.c — fused RFC 8259 → Ruby VALUE (TODO.restructure/22). */
 #include <ruby.h>
 #include <ruby/encoding.h>
+#include <ruby/intern.h>
 #include <stdlib.h>
 #include <string.h>
-#include "parse/numbers.h"
 #include "parse/scalars.h"
 #include "scan/json.h"
 
 #define YEP_JR_MAX 1000
-#define YEP_KC 256
+#define YEP_KC 1024
 
 typedef struct {
     uint64_t h;
@@ -86,64 +86,92 @@ static VALUE jr_str(jr* j, int as_key) {
         sp = j->p + start + 1;
         sl = (long)(close - start - 1);
     }
-    if (as_key || sl <= 2) return jr_cached(j, sp, sl);
+    if (as_key || sl <= 24) return jr_cached(j, sp, sl);
     return rb_enc_str_new(sp, sl, j->enc);
 }
 
 static VALUE jr_num(jr* j) {
     size_t start = j->i;
-    if (!yep_json_number(j->p, j->len, &j->i)) { j->err = -2; return Qnil; }
-    const char* s = j->p + start;
-    uint32_t n = (uint32_t)(j->i - start);
-    int is_float = 0, neg = 0;
-    uint32_t k = 0;
-    if (s[0] == '-') { neg = 1; k = 1; }
-    for (; k < n; k++) {
-        char c = s[k];
-        if (c == '.' || c == 'e' || c == 'E') { is_float = 1; break; }
+    int shape = 0;
+    int64_t iv = 0;
+    double dv = 0.0;
+    /* the fused kernel (scan/json.h): ONE grammar walk, values out */
+    if (!yep_json_number_scan(j->p, j->len, &j->i, &shape, &iv, &dv)) {
+        j->err = -2;
+        return Qnil;
     }
-    if (!is_float && n - (uint32_t)neg <= 18) {
-        int64_t v = 0;
-        for (k = (uint32_t)neg; k < n; k++) v = v * 10 + (s[k] - '0');
-        if (neg) v = -v;
-        return LL2NUM(v);
+    if (shape == 0) {
+        return LL2NUM(iv);
     }
-    if (is_float) {
-        double d = 0.0;
-        if (yep_num_f64(s, n, &d) != 0) { j->err = -2; return Qnil; }
-        return DBL2NUM(d);
+    if (shape == 1) {
+        return DBL2NUM(dv);
     }
-    int64_t v = 0;
-    if (yep_num_i64(s, n, &v) != 0) {
-        double d = 0.0;
-        if (yep_num_f64(s, n, &d) != 0) { j->err = -2; return Qnil; }
-        return DBL2NUM(d);
+    /* integer text beyond int64: exact Bignum from the validated
+     * span (JSON.parse's behavior). Absurd lengths degrade to the
+     * approximate double. */
+    size_t n = j->i - start;
+    if (n < 512) {
+        char buf[512];
+        memcpy(buf, j->p + start, n);
+        buf[n] = '\0';
+        return rb_cstr_to_inum(buf, 10, TRUE);
     }
-    return LL2NUM(v);
+    return DBL2NUM(dv);
 }
 
+/* Insert strategy (TODO.restructure/34): bulk lands all pairs in one
+ * rb_hash_bulk_insert (skips per-pair dispatch) but costs +1.4k
+ * intermediate allocations on the reference corpus — the CI referee
+ * rules per platform. aset = the per-pair rb_hash_aset loop. */
+enum { YEP_INS_BULK = 0, YEP_INS_ASET = 1 };
+static int yep_ins_mode = YEP_INS_BULK;
+
 static VALUE jr_object(jr* j) {
     j->i++; j->depth++;
     VALUE h = rb_hash_new_capa(8);
     jr_ws(j);
     if (j->i < j->len && j->p[j->i] == '}') { j->i++; j->depth--; return h; }
+    VALUE pairs[64];
+    VALUE* pv = pairs;
+    size_t pcap = 64, pn = 0, heap_cap = 0;
     for (;;) {
         jr_ws(j);
-        if (j->i >= j->len || j->p[j->i] != '"') { j->err = -2; return Qnil; }
+        if (j->i >= j->len || j->p[j->i] != '"') { j->err = -2; goto out; }
         VALUE key = jr_str(j, 1);
-        if (j->err) return Qnil;
+        if (j->err) goto out;
         jr_ws(j);
-        if (j->i >= j->len || j->p[j->i] != ':') { j->err = -2; return Qnil; }
+        if (j->i >= j->len || j->p[j->i] != ':') { j->err = -2; goto out; }
         j->i++;
         VALUE val = jr_value(j);
-        if (j->err) return Qnil;
-        rb_hash_aset(h, key, val);
+        if (j->err) goto out;
+        if (yep_ins_mode == YEP_INS_ASET) {
+            rb_hash_aset(h, key, val);
+        } else {
+            if (pn + 2 > pcap) {
+                size_t ncap = pcap * 2;
+                VALUE* nv = malloc(ncap * sizeof(VALUE));
+                if (!nv) { j->err = -1; goto out; }
+                memcpy(nv, pv, pn * sizeof(VALUE));
+                if (pv != pairs) { free(pv); heap_cap = 1; }
+                pv = nv; pcap = ncap;
+            }
+            pv[pn++] = key;
+            pv[pn++] = val;
+        }
         jr_ws(j);
-        if (j->i >= j->len) { j->err = -2; return Qnil; }
+        if (j->i >= j->len) { j->err = -2; goto out; }
         if (j->p[j->i] == ',') { j->i++; continue; }
-        if (j->p[j->i] == '}') { j->i++; j->depth--; return h; }
-        j->err = -2; return Qnil;
+        if (j->p[j->i] == '}') { j->i++; break; }
+        j->err = -2; goto out;
     }
+    if (yep_ins_mode == YEP_INS_BULK) {
+        rb_hash_bulk_insert((long)pn, (const VALUE*)pv, h);
+    }
+out:
+    if (pv != pairs) { free(pv); (void)heap_cap; }
+    if (j->err) return Qnil;
+    j->depth--;
+    return h;
 }
 
 static VALUE jr_array(jr* j) {
@@ -187,16 +215,56 @@ static VALUE jr_value(jr* j) {
     j->err = -2; return Qnil;
 }
 
+/* GC strategy for the parse window (TODO.restructure/34): JSON.parse
+ * pays minor GCs mid-parse and recycles slots continuously; a blanket
+ * disable defers every collection — fresh pages each iteration, which
+ * is cheap idle and expensive exactly under memory contention (the
+ * loaded-box regression). The strategy is a runtime choice so the CI
+ * referee can A/B without rebuilds:
+ *   disable (default) — pause GC for the window
+ *   none               — never pause
+ *   start              — pause, then one gc_start before returning
+ *                        (pay the minor GC in-window, like JSON.parse)
+ */
+enum { YEP_GC_DISABLE = 0, YEP_GC_NONE = 1, YEP_GC_START = 2 };
+/* Default per arch (TODO.restructure/35, two CI rounds of evidence):
+ * - aarch64/darwin: NONE — +0 heap pages, the stdlib's own GC cadence
+ *   (0.745x mean, h2h 91% on mac runners; disable was 0.899x/48%).
+ * - x86_64: DISABLE — fresh CI VMs have free pages and cheaper
+ *   page faults than minor GCs (0.911-0.922x vs none's 1.06-1.20x).
+ * The mechanism cuts both ways under load: disable's +478 pages/50
+ * iters is exactly what a LOADED x86 box punishes — set
+ * YEPTRIS_NATIVE_GC=none there (documented in README). */
+#if defined(__aarch64__) || defined(__arm__) || defined(__ARMEL__) || defined(_M_ARM64)
+#define YEP_GC_DEFAULT YEP_GC_NONE
+#else
+#define YEP_GC_DEFAULT YEP_GC_DISABLE
+#endif
+static int yep_gc_mode = YEP_GC_DEFAULT;
+
+int yep_rb_gc_mode(void) { return yep_gc_mode; }
+int yep_rb_ins_mode(void) { return yep_ins_mode; }
+void yep_rb_set_ins_mode(int mode) {
+    if (mode == YEP_INS_BULK || mode == YEP_INS_ASET) yep_ins_mode = mode;
+}
+void yep_rb_set_gc_mode(int mode) {
+    if (mode >= YEP_GC_DISABLE && mode <= YEP_GC_START) {
+        yep_gc_mode = mode;
+    }
+}
+
 VALUE yep_rb_parse_json(const char* p, size_t len) {
     jr j;
     memset(&j, 0, sizeof(j));
     j.p = p; j.len = len; j.enc = rb_utf8_encoding();
-    VALUE already = rb_gc_disable();
+    VALUE already = Qtrue;
+    if (yep_gc_mode != YEP_GC_NONE) already = rb_gc_disable();
     VALUE v = jr_value(&j);
     jr_ws(&j);
     if (j.i != len && j.err == 0) j.err = -2;
     free(j.scratch);
     if (already == Qfalse) rb_gc_enable();
+    if (yep_gc_mode == YEP_GC_START && j.err == 0) rb_gc_start();
     if (j.err == -1) rb_raise(rb_eNoMemError, "yeptris native json");
     if (j.err != 0) rb_raise(rb_path2class("Yeptris::ParseError"), "native json parse failed");
     return v;

data/ext/yeptris_native/yeptris_native.c

@@ -322,6 +322,49 @@ static VALUE native_load_stream(VALUE self, VALUE input, VALUE schema) {
     return ctx_result(&s.inner, st == YEPTRIS_OK ? YEPTRIS_ERROR_INTERNAL : st);
 }
 
+/* GC-strategy surface (TODO.restructure/34): ENV at load sets the
+ * default; the setter re-picks at runtime so the CI referee can A/B
+ * in-process. Symbols: :disable, :none, :start. */
+extern int yep_rb_gc_mode(void);
+extern void yep_rb_set_gc_mode(int mode);
+extern int yep_rb_ins_mode(void);
+extern void yep_rb_set_ins_mode(int mode);
+
+static VALUE native_gc_mode(VALUE self) {
+    (void)self;
+    switch (yep_rb_gc_mode()) {
+    case 1: return ID2SYM(rb_intern("none"));
+    case 2: return ID2SYM(rb_intern("start"));
+    default: return ID2SYM(rb_intern("disable"));
+    }
+}
+
+static VALUE native_ins_mode(VALUE self) {
+    (void)self;
+    return yep_rb_ins_mode() == 1 ? ID2SYM(rb_intern("aset")) : ID2SYM(rb_intern("bulk"));
+}
+
+static VALUE native_ins_mode_set(VALUE self, VALUE mode) {
+    (void)self;
+    Check_Type(mode, T_SYMBOL);
+    ID id = rb_sym2id(mode);
+    if (id == rb_intern("bulk")) yep_rb_set_ins_mode(0);
+    else if (id == rb_intern("aset")) yep_rb_set_ins_mode(1);
+    else rb_raise(rb_eArgError, "ins_mode must be :bulk or :aset");
+    return mode;
+}
+
+static VALUE native_gc_mode_set(VALUE self, VALUE mode) {
+    (void)self;
+    Check_Type(mode, T_SYMBOL);
+    ID id = rb_sym2id(mode);
+    if (id == rb_intern("disable")) yep_rb_set_gc_mode(0);
+    else if (id == rb_intern("none")) yep_rb_set_gc_mode(1);
+    else if (id == rb_intern("start")) yep_rb_set_gc_mode(2);
+    else rb_raise(rb_eArgError, "gc_mode must be :disable, :none, or :start");
+    return mode;
+}
+
 RUBY_FUNC_EXPORTED void Init_native(void) {
     utf8_enc = rb_utf8_encoding();
     VALUE mYep = rb_define_module("Yeptris");
@@ -329,5 +372,15 @@ RUBY_FUNC_EXPORTED void Init_native(void) {
     rb_define_singleton_method(mNat, "load_json", native_load_json, 1);
     rb_define_singleton_method(mNat, "load", native_load, 2);
     rb_define_singleton_method(mNat, "load_stream", native_load_stream, 2);
+    rb_define_singleton_method(mNat, "gc_mode", native_gc_mode, 0);
+    rb_define_singleton_method(mNat, "gc_mode=", native_gc_mode_set, 1);
+    rb_define_singleton_method(mNat, "ins_mode", native_ins_mode, 0);
+    rb_define_singleton_method(mNat, "ins_mode=", native_ins_mode_set, 1);
     rb_define_const(mNat, "AVAILABLE", Qtrue);
+    const char* env = getenv("YEPTRIS_NATIVE_GC");
+    if (env != NULL && strcmp(env, "none") == 0) yep_rb_set_gc_mode(1);
+    else if (env != NULL && strcmp(env, "start") == 0) yep_rb_set_gc_mode(2);
+    else if (env != NULL && strcmp(env, "disable") == 0) yep_rb_set_gc_mode(0);
+    const char* ins = getenv("YEPTRIS_NATIVE_INSERT");
+    if (ins != NULL && strcmp(ins, "aset") == 0) yep_rb_set_ins_mode(1);
 }

data/lib/yeptris/json.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Yeptris
+  # The STRICT JSON surface (TODO.restructure/31).
+  #
+  # `Yeptris::JSON.load` targets EXACT `JSON.parse` semantics — that
+  # is its parity target, spec-pinned (spec/json_parity_spec.rb).
+  # It is deliberately separate from Yeptris::YAML: the YAML surface
+  # keeps the Psych contract for every input (JSON-shaped included),
+  # so the two never drift into each other's semantics.
+  #
+  # Engines, fastest first (both exact — the parity spec runs against
+  # whichever is loaded):
+  # 1. the native materializer (fused C scan → VALUE; opt-in build)
+  # 2. the record drain + strict conversion walk (always available)
+  module JSON
+    class Error < ::Yeptris::Error; end
+    class ParseError < Error; end
+
+    module_function
+
+    def load(source)
+      source = ::Yeptris.read_input(source)
+      source = source.to_s
+      if defined?(::Yeptris::Native)
+        begin
+          return ::Yeptris::Native.load_json(source)
+        rescue ::Yeptris::ParseError => e
+          raise ParseError, e.message
+        end
+      end
+      strict_fallback(source)
+    end
+
+    # The always-available engine: the strict-JSON validator gates
+    # (parse_json raises on anything RFC 8259 rejects), then the
+    # value records convert WITHOUT the Psych quirk table — floats
+    # are always Floats, bools always bools ("1e3" is 1000.0 here
+    # and a String on the YAML surface; each surface is its own
+    # contract).
+    def strict_fallback(source)
+      begin
+        gate = ::Yeptris::Document.parse_json(source)
+      rescue ::Yeptris::ParseError => e
+        raise ParseError, e.message
+      end
+      begin
+        cols = ::Yeptris::FFI::ValueColumns.new
+        st = ::Yeptris::FFI.yeptris_value_drain_columns(
+          source, source.bytesize, ::Yeptris::FFI::SCHEMA_12_CORE, cols
+        )
+        raise ParseError, ::Yeptris::FFI.last_error_message if st != ::Yeptris::FFI::OK
+
+        begin
+          walk_strict(cols)
+        ensure
+          ::Yeptris::FFI.yeptris_value_free_columns(cols)
+        end
+      ensure
+        gate.free
+      end
+    end
+
+    # Placement mechanics mirror ValueML.walk_columns; the CONVERSION
+    # is the strict-JSON one (no ':sym' scan, no y/n quirk, no
+    # dot-required floats). Anchors/aliases/timestamps cannot occur
+    # in strict JSON — reaching them is an internal error.
+    def walk_strict(cols)
+      n = cols[:count]
+      kinds = cols[:kinds].read_bytes(n).unpack("C*")
+      ikeys = cols[:is_keys].read_bytes(n).unpack("C*")
+      bools = cols[:bools].read_bytes(n).unpack("C*")
+      offs = cols[:offs].read_bytes(n * 4).unpack("V*")
+      lens = cols[:lens].read_bytes(n * 4).unpack("V*")
+      pays = cols[:payloads].read_bytes(n * 8).unpack("q<*")
+      arena = cols[:arena_len].zero? ? +"" : cols[:arena].read_bytes(cols[:arena_len])
+      arena.force_encoding(Encoding::UTF_8)
+
+      docs = []
+      stack = []
+      pending_key = nil
+      i = 0
+      while i < n
+        case kinds[i]
+        when ValueML::DOC
+          docs.push(nil)
+        when ValueML::SEQ_OPEN
+          place(docs, stack, pending_key) { [] }
+          pending_key = nil
+        when ValueML::MAP_OPEN
+          place(docs, stack, pending_key) { {} }
+          pending_key = nil
+        when ValueML::CLOSE
+          stack.pop
+        when ValueML::V_STR
+          text = arena.byteslice(offs[i], lens[i])
+          if ikeys[i] == 1 && !stack.empty? && stack.last.is_a?(Hash)
+            pending_key = text
+          else
+            # Records carry int64 payloads: an integer-beyond-int64
+            # degrades to a PLAIN string (b==1). In strict JSON a
+            # plain (unquoted) scalar can ONLY be a number — every
+            # real string is quoted and arrives b==0 — so rebuild the
+            # exact Integer (JSON.parse parity, Bignum included).
+            if bools[i] == 1
+              place(docs, stack, pending_key) { Integer(text, 10) }
+            else
+              place(docs, stack, pending_key) { text }
+            end
+            pending_key = nil
+          end
+        when ValueML::V_INT
+          place(docs, stack, pending_key) { pays[i] }
+          pending_key = nil
+        when ValueML::V_FLOAT
+          place(docs, stack, pending_key) { [pays[i]].pack("q<").unpack1("E") }
+          pending_key = nil
+        when ValueML::V_BOOL
+          place(docs, stack, pending_key) { bools[i] == 1 }
+          pending_key = nil
+        when ValueML::V_NULL
+          place(docs, stack, pending_key) { nil }
+          pending_key = nil
+        else
+          raise Error, "internal: impossible record #{kinds[i]} in strict JSON"
+        end
+        i += 1
+      end
+      docs.empty? ? nil : docs.first
+    end
+
+    def place(docs, stack, key)
+      v = yield
+      if stack.empty?
+        docs[-1] = v
+      elsif key
+        stack.last[key] = v
+      else
+        stack.last.push(v)
+      end
+      stack.push(v) if v.is_a?(Array) || v.is_a?(Hash)
+      v
+    end
+  end
+end

data/lib/yeptris/yaml.rb

@@ -10,16 +10,14 @@ module Yeptris
     # Loads the FIRST document of a YAML stream as native Ruby objects.
     # schema: :compat_11 selects Psych/libyaml implicit typing
     # (yes/no, 0o/octal, sexagesimal); :core_12 (default) is YAML 1.2.
+    #
+    # This surface keeps the Psych contract for EVERY input — including
+    # JSON-shaped ones (`{"a": [1,]}` is legal flow YAML; `"1e3"` is a
+    # Psych String). Strict RFC 8259 semantics live on Yeptris::JSON
+    # (TODO.restructure/31): defaults follow proof, not benchmarks.
     def load(yaml, schema: :compat_11)
       yaml = Yeptris.read_input(yaml)
       yaml = yaml.to_s
-      # The native C materializer fuses strict-JSON scan→VALUE in one
-      # pass (beats JSON.parse on the 152 KB corpus). YAML inputs keep
-      # the FFI ladder so timestamps, aliases, and Psych's scalar
-      # quirks all resolve through the same path Psych.load uses.
-      if defined?(Yeptris::Native) && native_json?(yaml)
-        return Yeptris::Native.load_json(yaml)
-      end
       docs = _drain_all(yaml, schema)
       docs.empty? ? nil : docs.first
     end
@@ -31,22 +29,6 @@ module Yeptris
       _drain_all(yaml, schema)
     end
 
-    # Strict-JSON sniff: first non-space is { or [ — the fused native
-    # path beats JSON.parse on this shape (TODO.restructure/22).
-    def native_json?(bytes)
-      i = 0
-      len = bytes.bytesize
-      while i < len
-        c = bytes.getbyte(i)
-        return true if c == 0x7b || c == 0x5b # { or [
-        return false unless c == 0x20 || c == 0x09 || c == 0x0a || c == 0x0d
-
-        i += 1
-      end
-      false
-    end
-    private_class_method :native_json?
-
     # The Marshal fast path when the loaded libyeptris has it (>= 0.1.11
     # era builds), falling back to the columnar drain and finally the
     # record drain — one code path, the fastest the library offers.

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.1.12.0".freeze
+  VERSION = "0.1.13.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
@@ -39,6 +39,7 @@ module Yeptris
   autoload :Document, "yeptris/document"
   autoload :Node, "yeptris/node"
   autoload :YAML, "yeptris/yaml"
+  autoload :JSON, "yeptris/json"
   autoload :Materializer, "yeptris/materializer"
   autoload :ValueML, "yeptris/valueml"
   autoload :Psych, "yeptris/psych"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.1.12.0
+  version: 0.1.13.1
 platform: ruby
 authors:
 - Ribose Inc.
@@ -40,6 +40,7 @@ files:
 - lib/yeptris.rb
 - lib/yeptris/document.rb
 - lib/yeptris/ffi.rb
+- lib/yeptris/json.rb
 - lib/yeptris/materializer.rb
 - lib/yeptris/node.rb
 - lib/yeptris/psych.rb