yeptris 0.6.51.0-arm-linux-eabihf → 0.6.53.0-arm-linux-eabihf

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1762c833f5c3ee978bdf6b43d59e7ae4523ff6edba01ade64354eddd3f3cfbf9
-  data.tar.gz: a84e2415681f867a3aa4b1d45ee16ccfcb66213bd6f8494905ec9d420663c217
+  metadata.gz: 49aed5138b8f170e696098a0698b5033e98759f5e95e03828fdb49b323e92da7
+  data.tar.gz: '0029418e8dd3ed5d41d89683414a9b29fcc29a40a4dd5cb8e4eb53141ff96c13'
 SHA512:
-  metadata.gz: c87d565da52486b460e944c1a04aa89f100118de2ad0255e31a0d0497dbc7d2b5c588531b7097f2212087006a0cec2a39d44734159605b060c16029bfd76940a
-  data.tar.gz: 352d9550314e65f0c920d97ac1859d36fdb0b3492acd965be1f7568452e057fbe30dbf5ad7b10fa09ee15e70c0844bbdce691f77a8f7479654fb2cc94e1d32fd
+  metadata.gz: b6d55c01b48054dd92faa635b018514ef6fda5d897a6d6813716c72faa9ea61360435ad002df22b45c33cb5fbda8ed88f9fd8febe9502e667ce023e3dd1d478f
+  data.tar.gz: c2904a905ad014413a43ffb8cb2b12dba583a2e3f83fa6753c4b4724b43ca652f9fed770bf6d2eb55f98819b5db1260fd7a8293252d005d8c2f090995162a092

data/ext/yeptris_native/version.h

@@ -11,8 +11,8 @@
 
 #define YEPTRIS_VERSION_MAJOR 0
 #define YEPTRIS_VERSION_MINOR 6
-#define YEPTRIS_VERSION_PATCH 51
-#define YEPTRIS_VERSION_STRING "0.6.51"
+#define YEPTRIS_VERSION_PATCH 53
+#define YEPTRIS_VERSION_STRING "0.6.53"
 
 #ifdef __cplusplus
 extern "C" {

data/ext/yeptris_native/yeptris_native.c

@@ -483,7 +483,17 @@ RUBY_FUNC_EXPORTED void Init_native(void) {
     rb_define_singleton_method(mNat, "shape_mode", native_shape_mode, 0);
     rb_define_singleton_method(mNat, "shape_mode=", native_shape_mode_set, 1);
     rb_define_singleton_method(mNat, "scan_time", native_scan_time, 2);
-    rb_define_const(mNat, "AVAILABLE", Qtrue);
+    /* the leptris bridge vendors this same ext (leptris's
+     * lib/leptris/xml/native_3_3.so), so both gems can co-initialize
+     * in one process: the second init re-ran rb_define_const and
+     * warned "already initialized constant Yeptris::Native::AVAILABLE"
+     * — which moxml treated as an adapter load failure and fell back
+     * to nokogiri for the rest of the process (yeptris-ruby#336).
+     * Re-registration is idempotent: skip the const when the first
+     * init (either gem's copy) already defined it. */
+    if (!rb_const_defined_at(mNat, rb_intern("AVAILABLE"))) {
+        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);

data/lib/yeptris/document.rb

@@ -16,7 +16,7 @@ class Yeptris::Document
   # The schema this document was parsed with (a parse property).
   attr_reader :parse_schema
 
-  def initialize(c_ptr = nil, freed = Freed.new(:alive), parse_schema = :core_12)
+  def initialize(c_ptr = nil, freed = Freed.new(:alive), parse_schema = :core_12, source = nil)
     # The pointer is produced by the FFI parse/create calls; a nil (or
     # non-pointer) argument is an API misuse — Document.parse and
     # Document.create are the entry points. Fail with that guidance
@@ -30,6 +30,13 @@ class Yeptris::Document
     @c_ptr = c_ptr
     @freed = freed
     @parse_schema = parse_schema
+    # the C document BORROWS the input: string values are zero-copy
+    # views over the caller's bytes (parse.h/doc.h) — the FFI call only
+    # pins the String for the call's duration, so the document must
+    # retain it or the next GC frees memory every later node.value/
+    # tag read still points into (audit 2026-10-31: parse(io.read) was
+    # collectable immediately)
+    @source = source
     @readonly = false
     # Strong wrapper cache keyed on the C node address: the same C node
     # always yields the same Ruby object (identity for aliases/eql?),
@@ -61,7 +68,7 @@ class Yeptris::Document
       raise Yeptris::ParseError,
             "parse failed: #{Yeptris::FFI.last_error_message}"
     end
-    wrap_schema(doc, schema)
+    wrap_schema(doc, schema, yaml)
   end
 
   def self.parse_json(json)
@@ -71,7 +78,7 @@ class Yeptris::Document
     raise Yeptris::ParseError,
           "json parse failed: #{Yeptris::FFI.last_error_message}" if doc.null?
 
-    wrap_schema(doc, :core_12) # strict JSON is core by construction
+    wrap_schema(doc, :core_12, json) # strict JSON is core by construction
   end
 
   # An empty document for from-scratch construction (TODO.impl/11 p3).
@@ -99,8 +106,8 @@ class Yeptris::Document
   # host scalar policies (Psych's dot-required float) are conditioned
   # on it. The parse constructors set the real one; plain wrap keeps
   # the core_12 default (yeptris_parse's default).
-  def self.wrap_schema(c_ptr, schema)
-    new(c_ptr, Freed.new(:alive), schema)
+  def self.wrap_schema(c_ptr, schema, source = nil)
+    new(c_ptr, Freed.new(:alive), schema, source)
   end
 
   # #182: the stream-children wrapper owns NOTHING (the parent

data/lib/yeptris/psych/parser.rb

@@ -25,6 +25,10 @@ module Yeptris
         yaml = yaml.to_s
         @filename = filename
         flat, arena = Materializer.drain(yaml, schema: :compat_11)
+        # the engine's arena is UTF-8 bytes; without the tag every
+        # scalar reached handlers as ASCII-8BIT (stdlib Psych hands
+        # UTF-8; TreeBuilder then propagated binary into node values)
+        arena.force_encoding(Encoding::UTF_8)
         dispatch(flat, arena)
         self
       rescue ParseError => e

data/lib/yeptris/psych.rb

@@ -143,8 +143,21 @@ module Yeptris
       # Psych 5: load is safe — plain data structures only. Tagged
       # nodes raise DisallowedClass unless their class is permitted
       # (Date/Time/Symbol are built in; they are plain data here).
-      def load(yaml, permitted_classes: [::Date, ::Time], aliases: false, **)
-        safe_load(yaml, permitted_classes: permitted_classes, aliases: aliases)
+      def load(yaml, permitted_classes: [::Date, ::Time], aliases: false,
+               symbolize_names: false, fallback: nil, filename: nil, **)
+        res = safe_load(yaml, permitted_classes: permitted_classes, aliases: aliases,
+                        symbolize_names: symbolize_names)
+        if res.nil? && !fallback.nil?
+          # stdlib's fallback: answers when the stream is empty or has
+          # NO documents — a document whose content IS nil still loads
+          # as nil. The safe path cannot tell those two apart, so the
+          # corner re-checks the count (only when a fallback rides).
+          doc = ::Yeptris::Document.parse(yaml, schema: :compat_11)
+          empty = doc.nil? || doc.document_count.zero?
+          doc&.free
+          return fallback if empty
+        end
+        res
       end
 
       # Full revival over the Nodes tree: !ruby/object, !ruby/struct,

data/lib/yeptris/valueml.rb

@@ -20,6 +20,25 @@ module Yeptris
   # int64 the C resolver leaves the scalar a string; Psych
   # materializes Integer (issue #31) — every walk rebuilds it.
   PSYCH_INT_SHAPE = /\A[-+]?(?:0|[1-9](?:[0-9]|,[0-9]|_[0-9])*)\z/.freeze
+
+  # The typed-string conversion law, ONE place: a big-int-shaped
+  # string rebuilds to Integer, an implicit-plain ':name' scans to a
+  # Symbol (Psych's ScalarScanner; quoted ':x' stays a String).
+  # Every str-column conversion rides this — the pair fast path
+  # drifted once and handed bignums/symbol-keys through as Strings
+  # (audit 2026-10-31).
+  def self.str_to_value(text, typed)
+    return text unless typed
+
+    if text.length > 18 && PSYCH_INT_SHAPE.match?(text)
+      text.delete(",_").to_i
+    elsif text.length > 1 && text.start_with?(":") && !text.start_with?("::")
+      text[1..].to_sym
+    else
+      text
+    end
+  end
+
     V_TS = 6
     SEQ_OPEN = 7
     MAP_OPEN = 8
@@ -155,15 +174,7 @@ module Yeptris
           text = arena.byteslice(flat[i + OFF], flat[i + LEN])
           # implicit-plain ':name' scans to a Symbol (Psych's
           # ScalarScanner); quoted ':x' stays a String
-          v = if flat[i + B] == 1 && text.length > 18 &&
-                PSYCH_INT_SHAPE.match?(text)
-                text.delete(",_").to_i
-              elsif flat[i + B] == 1 && text.length > 1 &&
-                text.start_with?(":") && !text.start_with?("::")
-                text[1..].to_sym
-              else
-                text
-              end
+          v = str_to_value(text, flat[i + B] == 1)
           if pending_anchor
             anchors[pending_anchor] = v
             pending_anchor = nil
@@ -284,20 +295,9 @@ module Yeptris
            pending_anchor.nil? && !stack.empty? && stack.last.is_a?(Hash)
           kt = arena.byteslice(offs[i], lens[i])
           if kt != "<<"
-            key = if bools[i] == 1 && kt.length > 1 && kt.start_with?(":") &&
-                     !kt.start_with?("::")
-              kt[1..].to_sym
-            else
-              kt
-            end
+            key = str_to_value(kt, bools[i] == 1)
             vt = arena.byteslice(offs[i + 1], lens[i + 1])
-            stack.last[key] =
-              if bools[i + 1] == 1 && vt.length > 1 && vt.start_with?(":") &&
-                 !vt.start_with?("::")
-                vt[1..].to_sym
-              else
-                vt
-              end
+            stack.last[key] = str_to_value(vt, bools[i + 1] == 1)
             i += 2
             next
           end
@@ -305,15 +305,7 @@ module Yeptris
         case kinds[i]
         when V_STR
           text = arena.byteslice(offs[i], lens[i])
-          v = if bools[i] == 1 && text.length > 18 &&
-                PSYCH_INT_SHAPE.match?(text)
-                text.delete(",_").to_i
-              elsif bools[i] == 1 && text.length > 1 &&
-                text.start_with?(":") && !text.start_with?("::")
-                text[1..].to_sym
-              else
-                text
-              end
+          v = str_to_value(text, bools[i] == 1)
           if pending_anchor
             anchors[pending_anchor] = v
             pending_anchor = nil

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.51.0".freeze
+  VERSION = "0.6.53.0".freeze
 
   # Informational notices are OPT-IN (yeptris-ruby#217): consumers
   # embed yeptris inside CLIs that assert clean stderr, and a

data/vendor/libyeptris/CMakeLists.txt

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

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

@@ -687,6 +687,13 @@ static int cm_value(cm_ctx* c, cm_buf* out) {
             return cm_fail(c, YEPTRIS_ERROR_UNSUPPORTED); /* the host loop raises */
         }
         double d = strtod(tmp, NULL);
+        if (!isfinite(d)) {
+            /* the literal spellings gate above; a strtod OVERFLOW
+             * ("1e999") manufactures the same non-finite without
+             * spelling it — the same strict reject (Ruby streams only
+             * ever carry finites or the literal inf/nan spellings) */
+            return cm_fail(c, YEPTRIS_ERROR_UNSUPPORTED);
+        }
         uint8_t fw = yep_cbor_float_width(d);
         if (cm_reserve(c, out, 9) != 0) {
             return -1;

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

@@ -142,14 +142,16 @@ static yep_sview dom_str_in(yep_dom* d, const yep_view* v, int borrowed) {
  * given metadata; tag/anchor views encode through dom_str_in (tags and
  * event-path anchors copy to the arena; input-backed views borrow).
  * tag_id stays 0 — the caller resolves (scalars) or leaves 0. */
-/* Value assign + the emit-side fact bit (issue #352 lane 2): the bit
- * is "verified clean" of the dq-forced byte set — the serializer's
- * sc_route then skips its per-derive rescan. The scan is the SSOT
- * predicate (yep_scan_dq_forced); every value assignment routes
+/* Value assign + the emit-side fact bits (issues #352 lanes 2-3):
+ * no_exotic is "verified clean" of the dq-forced byte set (sc_route
+ * skips its rescan); plain_ok is the full plain-safety verdict (the
+ * emitter skips its walk — the block kernel's 35% frame). Both facts
+ * ride the scan/'s SSOT predicates; every value assignment routes
  * through here so no path can leave a dirty scalar marked clean. */
 static void dom_set_value(yep_dom* d, uint32_t id, const yep_view* v, int borrowed) {
     d->nodes[id].value = dom_str_in(d, v, borrowed);
     d->nodes[id].no_exotic = !yep_scan_dq_forced(v->p, v->len);
+    d->nodes[id].plain_ok = (uint8_t)yep_scan_plain_safe(v->p, v->len);
 }
 
 uint32_t dom_open_node(yep_dom* d, uint8_t kind, const yep_view* tag, const yep_view* anchor,
@@ -221,8 +223,13 @@ static int dom_anchor_set(yep_dom* d, uint32_t ordinal, uint32_t node) {
         if (d->anchor_nodes != NULL) {
             memcpy(na, d->anchor_nodes, d->anchor_nodes_cap * sizeof(*na));
             yep_free(d->sys, d->anchor_nodes);
-            yep_free(d->sys, d->mut_att);
-            yep_free(d->sys, d->mut_depth);
+            /* ONLY the anchor table: the mut side tables belong to
+             * dom_mut_grow alone (it allocates, copies and frees them
+             * together with the cap that tracks their size). These two
+             * frees were copy-paste debris from that path -- harmless
+             * today only because the mutation tables cannot exist
+             * during a parse -- but the ownership must not rely on
+             * that accident (audit 2026-10-31). */
         }
         d->anchor_nodes = na;
         d->anchor_nodes_cap = cap;
@@ -1139,7 +1146,7 @@ void dom_on_flow_rollback(void* ctx) {
  * call — the DOM stack mirrors what the MAP_START event would have
  * pushed. 0 only for the depth cap (the engine then takes the events,
  * which own the error). */
-int dom_on_block_open(void* ctx, const yep_view* key, uint32_t line, uint16_t key_col) {
+int dom_on_block_open(void* ctx, const yep_view* key, uint32_t line, uint32_t key_col) {
     yep_dom* d = (yep_dom*)ctx;
     if (d->depth >= YEP_DOM_MAX_DEPTH) {
         return 0;
@@ -1187,7 +1194,7 @@ int dom_on_block_item(void* ctx, const yep_block_value* v) {
  * happen when the engine resolved the name) falls back to the two
  * events with nothing built. */
 int dom_on_block_pair(void* ctx, const yep_view* key, const yep_block_value* v, uint32_t line,
-                      uint16_t key_col, uint16_t val_col) {
+                      uint32_t key_col, uint32_t val_col) {
     yep_dom* d = (yep_dom*)ctx;
     uint32_t target = 0;
     if (v->cls == YEP_LVAL_ALIAS) {

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

@@ -68,6 +68,12 @@ typedef struct yep_dnode {
                             * byte set (#352 lane 2): the serializer's
                             * sc_route skips its rescan. Set at every
                             * value assignment; 0 = unknown = scan. */
+    uint8_t plain_ok;      /* value bytes verified yep_scan_plain_safe
+                            * (#352 lane 3): the emitter skips its
+                            * plain-safety walk (the block kernel's 35%
+                            * frame). Same invariant as no_exotic: set
+                            * at every dom_set_value; 0 = unknown =
+                            * derive. */
     uint8_t tag_id;        /* resolved tag (resolve/resolver.h) */
     uint32_t first_child;  /* child link (mappings: key,value,key,value…) */
     uint32_t last_child;
@@ -283,8 +289,8 @@ int dom_on_scalar(void* ctx, const yep_view* value, const yep_view* tag, const y
                   int borrowed);
 
 int dom_on_block_pair(void* ctx, const yep_view* key, const struct yep_block_value* v,
-                      uint32_t line, uint16_t key_col, uint16_t val_col);
-int dom_on_block_open(void* ctx, const yep_view* key, uint32_t line, uint16_t key_col);
+                      uint32_t line, uint32_t key_col, uint32_t val_col);
+int dom_on_block_open(void* ctx, const yep_view* key, uint32_t line, uint32_t key_col);
 int dom_on_block_item(void* ctx, const yep_block_value* v);
 
 /* Direct DOM construction from a strict-validated JSON buffer

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

@@ -241,7 +241,7 @@ static int yt_on_scalar(void* ctx, const yep_view* value, const yep_view* tag,
 }
 
 static int yt_on_block_pair(void* ctx, const yep_view* key, const yep_block_value* v, uint32_t line,
-                            uint16_t key_col, uint16_t val_col) {
+                            uint32_t key_col, uint32_t val_col) {
     (void)line;
     (void)key_col;
     (void)val_col; /* yep_dnode carries no positions (64-2c) */
@@ -278,7 +278,7 @@ static int yt_on_block_pair(void* ctx, const yep_view* key, const yep_block_valu
     return 1; /* handled: the engine skips the two events */
 }
 
-static int yt_on_block_open(void* ctx, const yep_view* key, uint32_t line, uint16_t key_col) {
+static int yt_on_block_open(void* ctx, const yep_view* key, uint32_t line, uint32_t key_col) {
     (void)line;
     (void)key_col;
     yep_ytape* t = (yep_ytape*)ctx;

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

@@ -551,6 +551,10 @@ YEPTRIS_API size_t yeptris_serialize_stream(YeptrisDocument handle,
         return 0;
     }
     em.w.p = window;
+    /* the writer owns the window size now: wr_put's chunked path and
+     * the fused member write bounds-check against it (a scalar larger
+     * than the window used to memcpy straight past it) */
+    em.w.cap = YEP_EMIT_WATERMARK * 2;
     em.w.sink_aborted = 0;
     size_t total = yep_emit_run(&em, 0);
     if (em.w.len > 0 && !em.w.sink_aborted) {

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

@@ -1,203 +1,21 @@
-/* style.c — the style rule table (TODO.impl/13). */
+/* style.c — the style rule table (TODO.impl/13).
+ *
+ * The plain-safety predicate LIVES in scan/scan.c (yep_scan_plain_safe,
+ * #352 lane 3): bytes→facts is scan/'s alone, and the DOM's parse-time
+ * fact bit and this emitter side read the ONE walk so the verdicts
+ * cannot drift. These are the emit-side names over it. */
 
 #include "style.h"
 
-#include <string.h>
-
-static int is_blank(char c) {
-    return c == ' ' || c == '\t';
-}
-
-static int is_break(char c) {
-    return c == '\n' || c == '\r';
-}
+#include "../scan/scan.h"
 
 int yep_style_plain_safe(const char* p, uint32_t len) {
-    if (len == 0) {
-        return 0; /* empty needs quotes or an empty-value slot */
-    }
-    if (is_blank(p[0]) || is_blank(p[len - 1])) {
-        return 0;
-    }
-    if (len >= 3 && (unsigned char)p[0] == 0xef && (unsigned char)p[1] == 0xbb &&
-        (unsigned char)p[2] == 0xbf) {
-        /* a LEADING U+FEFF re-parses as a document BOM and vanishes —
-         * the emitted form must carry its escape ("\uFEFF", the
-         * nightly's run 38258674337); mid-token BOMs ride plain */
-        return 0;
-    }
-    switch (p[0]) {
-    case ':':
-        /* libyaml (Psych symbol dumps ":name"): a leading colon only
-         * indicates when followed by a blank/EOL — the interior rule
-         * below covers it; ":name" stays plain */
-        break;
-    case '-':
-    case '?':
-        /* indicators only before a blank or EOL: "-5" and "?x" are
-         * plain (libyaml emits negative numbers plain; Psych, too) —
-         * but fall through: the document-marker check below owns
-         * the bare "---"/"..." (libyaml quotes those) */
-        if (len == 1 || is_blank(p[1])) {
-            return 0;
-        }
-        break;
-    case ',':
-    case '[':
-    case ']':
-    case '{':
-    case '}':
-    case '#':
-    case '&':
-    case '*':
-    case '!':
-    case '|':
-    case '>':
-    case '\'':
-    case '"':
-    case '%':
-    case '@':
-    case '`':
-        return 0;
-    default:
-        break;
-    }
-    /* The interior scan in SWAR words: every reject condition is a
-     * byte-class adjacency, so one masked word test is exact —
-     * break/tab bytes reject directly; ':' rejects with a blank at its
-     * NEXT lane (or the span's EOL); '#' with a blank at its PREVIOUS
-     * lane (the span's first byte is exempt — the head switch already
-     * handled a leading '#'). Cross-word adjacency rides one carried
-     * byte per boundary; the tail runs the byte loop, whose rules read
-     * real neighbors and need no carries. */
-    {
-        const uint64_t ONES = 0x0101010101010101ull;
-        const uint64_t HIGH = 0x8080808080808080ull;
-#define YST_ZDET(w, ch)                                                                            \
-    ((((w) ^ (uint64_t)(ch) * ONES) - ONES) & ~((w) ^ (uint64_t)(ch) * ONES) & HIGH)
-        /* the all-boring accept (#742): a span of pure [0-9A-Za-z_]
-         * makes EVERY rule in this function vacuous — no indicators
-         * (the head switch), no blanks at the ends, no BOM, no
-         * ': '/' #' adjacency, no breaks, and no ---/... marker — so
-         * one range test per word accepts without the six-mask walk.
-         * Anything else falls through to the exact scan below. */
-        {
-            uint32_t bi = 0;
-            int boring = 1;
-            while (bi + 8 <= len) {
-                uint64_t bw;
-                memcpy(&bw, p + bi, 8);
-                if (bw & HIGH) {
-                    boring = 0;
-                    break;
-                }
-                /* per-lane unsigned range checks via borrow bits: alpha
-                 * is (t - 'a') and ('z' - t) both borrow-free with
-                 * t = w|0x20 (A-Z fold); digits bound 0x30..0x39 */
-                uint64_t t = bw | (ONES * 0x20);
-                uint64_t bad = ((t - ONES * 0x61) | (ONES * 0x7A - t)) & HIGH; /* alpha */
-                bad |= ((bw - ONES * 0x30) | (ONES * 0x39 - bw)) & HIGH;       /* digit */
-                bad &= ~YST_ZDET(bw, '_'); /* the one extra boring byte */
-                if (bad != 0) {
-                    boring = 0;
-                    break;
-                }
-                bi += 8;
-            }
-            if (boring) {
-                for (; bi < len; bi++) {
-                    char c = p[bi];
-                    int a = (c | 0x20);
-                    if (!((c >= '0' && c <= '9') || (a >= 'a' && a <= 'z') || c == '_')) {
-                        boring = 0;
-                        break;
-                    }
-                }
-                if (boring) {
-                    return 1;
-                }
-            }
-        }
-        uint32_t i = 0;
-        int prev_blank7 = 0;
-        while (i + 8 <= len) {
-            uint64_t w;
-            memcpy(&w, p + i, 8);
-            if (w & HIGH) {
-                /* multibyte content: the byte loop owns the rest — a raw
-                 * LS/PS/NEL rides in a scalar value since the quote-aware
-                 * normalizer (#638) and is a line break on re-parse, so
-                 * the value must be quoted, not plain (the nightly's
-                 * round 18, crash-1e79b2e3) */
-                break;
-            }
-            uint64_t space = YST_ZDET(w, ' ');
-            uint64_t tab = YST_ZDET(w, '\t');
-            uint64_t blank = space | tab;
-            uint64_t colon = YST_ZDET(w, ':');
-            uint64_t hash = YST_ZDET(w, '#');
-            /* tab and the breaks reject outright */
-            if (tab | YST_ZDET(w, '\n') | YST_ZDET(w, '\r')) {
-                return 0;
-            }
-            /* ':' + blank next: (blank >> 8) pulls lane i+1's flag down
-             * into lane i; the word's last lane takes the peeked byte
-             * (EOL at the span end counts as blank — the rule rejects
-             * there) */
-            if (colon) {
-                int next_blank = i + 8 < len ? is_blank(p[i + 8]) : 1;
-                if (colon & ((blank >> 8) | (next_blank ? (uint64_t)0x80 << 56 : 0))) {
-                    return 0;
-                }
-            }
-            /* '#' + blank prev: (blank << 8) lifts lane i-1's flag up
-             * into lane i; lane 0 takes the carried last-lane flag */
-            if (hash && (hash & ((blank << 8) | (prev_blank7 ? 0x80 : 0)))) {
-                return 0;
-            }
-            prev_blank7 = (int)((blank >> 63) & 1); /* lane 7's flag is its top bit */
-            i += 8;
-        }
-#undef YST_ZDET
-        for (; i < len; i++) {
-            char c = p[i];
-            if (is_break(c) || c == '\t') {
-                return 0;
-            }
-            if ((unsigned char)c == 0xE2 && i + 2 < len && (unsigned char)p[i + 1] == 0x80 &&
-                ((unsigned char)p[i + 2] & 0xFE) == 0xA8) {
-                return 0; /* a raw LS/PS re-parses as a line break */
-            }
-            if ((unsigned char)c == 0xC2 && i + 1 < len && (unsigned char)p[i + 1] == 0x85) {
-                return 0; /* a raw NEL ditto */
-            }
-            if (c == ':') {
-                if (i + 1 >= len || is_blank(p[i + 1])) {
-                    return 0;
-                }
-            }
-            if (c == '#') {
-                if (i > 0 && is_blank(p[i - 1])) {
-                    return 0;
-                }
-            }
-        }
-    }
-    /* document markers */
-    if (len >= 3 && (memcmp(p, "---", 3) == 0 || memcmp(p, "...", 3) == 0) &&
-        (len == 3 || p[3] == ' ' || p[3] == '\t' || p[3] == '\n' || p[3] == '\r')) {
-        /* a PREFIX marker is worse than the bare one: emitted plain at
-         * line start, "--- ..." re-reads as a document marker (the
-         * nightly's "--- --- >" folded-plain crasher) — libyaml quotes
-         * both */
-        return 0;
-    }
-    return 1;
+    return yep_scan_plain_safe(p, len);
 }
 
 int yep_style_plain_key_safe(const char* p, uint32_t len) {
     /* plain_safe's colon rule is the key rule too: a colon only ends a
      * key when followed by a blank/EOL, so "a:b" and ":name" are plain
      * keys (libyaml emits Psych's symbol dumps exactly this way) */
-    return yep_style_plain_safe(p, len);
+    return yep_scan_plain_safe(p, len);
 }