yeptris 0.6.57.1-arm-linux-eabihf → 0.6.59.1-arm-linux-eabihf

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.57.1".freeze
+  VERSION = "0.6.59.1".freeze
 
   # Informational notices are OPT-IN (yeptris-ruby#217): consumers
   # embed yeptris inside CLIs that assert clean stderr, and a
@@ -54,6 +54,7 @@ module Yeptris
   autoload :ValueML, "yeptris/valueml"
   autoload :Psych, "yeptris/psych"
   autoload :Schema, "yeptris/schema"
+  autoload :Validation, "yeptris/validation"
   autoload :CBOR, "yeptris/cbor"
 end
 

data/vendor/libyeptris/CMakeLists.txt

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

data/vendor/libyeptris/src/CMakeLists.txt

@@ -39,9 +39,14 @@ set(YEPTRIS_SOURCES
     yeptris/resolve/tags.c
     yeptris/resolve/core12.c
     yeptris/resolve/compat11.c
+    yeptris/resolve/json12.c
     yeptris/parse/numbers.c
     yeptris/events/values.c
     yeptris/schema.c
+    yeptris/validate/regexp.c
+    yeptris/validate/validate.c
+    yeptris/validate/compile.c
+    yeptris/validate/jsonschema.c
     yeptris/tape.c
     yeptris/plan.c
 
@@ -95,6 +100,7 @@ set(YEPTRIS_PUBLIC_HEADERS
     ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/parse.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/values.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/schema.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/validate.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/tape.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/plan.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/marshal.h

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

@@ -25,7 +25,8 @@ typedef enum {
     YEPTRIS_ERROR_ARG = 6,         /* invalid argument (NULL handle, bad option) */
     YEPTRIS_ERROR_UNSUPPORTED = 7, /* requested feature not built in */
     YEPTRIS_ERROR_INTERNAL = 8,    /* invariant violation — a bug, please report */
-    YEPTRIS_ERROR_SCHEMA = 9, /* descriptor materialization: a REQUIRED node missing (issue #238) */
+    YEPTRIS_ERROR_SCHEMA = 9,      /* validation: the report carries diagnostics (#882);
+                                    * descriptor materialization: REQUIRED missing (#238) */
 } YeptrisStatus;
 
 /* Message of the most recent failure on the calling thread, with its

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

@@ -40,10 +40,12 @@ typedef enum {
     YEPTRIS_TAG_CUSTOM = 11,
 } YeptrisTagId;
 
-/* Schemas. */
+/* Schemas. Appending only — bindings hard-code the values (test_abi). */
 typedef enum {
     YEPTRIS_SCHEMA_12_CORE = 0, /* default: the yaml-test-suite target */
     YEPTRIS_SCHEMA_11_COMPAT,   /* libyaml/Psych implicit typing */
+    YEPTRIS_SCHEMA_12_JSON,     /* spec 10.2: JSON productions; plain
+                                 * scalars matching none are errors (#882) */
 } YeptrisSchema;
 
 /* Canonical tag URI for a core id ("tag:yaml.org,2002:str"); NULL for

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

@@ -0,0 +1,200 @@
+/* validate.h — the validation face (issue #882).
+ *
+ * Two checks over one engine pass:
+ *
+ *  1. SCHEMA-FAMILY validation (`yeptris_validate`): parse + validate
+ *     fused. Under YEPTRIS_SCHEMA_12_CORE the walk checks explicit-tag
+ *     consistency (spec 10.3 resolution) and mapping-key uniqueness
+ *     (spec 3.2.1.3: keys compare by canonical form — 0o13 and 0xB
+ *     are the same key). Under YEPTRIS_SCHEMA_12_JSON the spec 10.2
+ *     family applies: every PLAIN scalar must match a JSON production
+ *     (the table's `*` -> Error row), mapping keys must be strings,
+ *     non-JSON tags are rejected; core checks still run.
+ *
+ *  2. JSON SCHEMA validation (`yeptris_json_schema_validate`): the
+ *     schema arrives as bytes (parsed with the same engine), the
+ *     target against it — draft 2020-12 keyword subset (see the entry
+ *     comment). Unknown keywords are ignored, per 2020-12.
+ *
+ * Every diagnostic carries a JSON-pointer instance path ("/a/b/0" —
+ * ~0/~1 escaped), a YEPTRIS_DIAG_* code, a bounded expected/got
+ * detail, and the offending node's 1-based line/column (0 = unknown:
+ * scalars whose bytes the DOM owns in its arena have no input
+ * position; the path still identifies them exactly).
+ *
+ * Results are WHOLE REPORTS: one call, no per-diagnostic callback —
+ * the caller drains the flat array and frees the report once.
+ */
+#ifndef YEPTRIS_VALIDATE_H
+#define YEPTRIS_VALIDATE_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <yeptris/api.h>
+#include <yeptris/error.h>
+#include <yeptris/parse.h> /* YeptrisDocument, YeptrisSchema */
+#include <yeptris/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Diagnostic codes. Appending only — bindings hard-code the values
+ * (test_abi pins the head). */
+typedef enum {
+    YEPTRIS_DIAG_NONE = 0,
+    /* the schema-family walk */
+    YEPTRIS_DIAG_TAG_MISMATCH = 1,   /* explicit tag contradicts content */
+    YEPTRIS_DIAG_KEY_NOT_STRING = 2, /* json12: mapping key is not a string */
+    YEPTRIS_DIAG_NON_JSON_TYPE = 3,  /* json12: plain scalar matches no
+                                      * JSON production / carries a
+                                      * non-JSON tag (spec 10.2.2 Error) */
+    YEPTRIS_DIAG_DUPLICATE_KEY = 4,  /* equal keys in one mapping */
+    /* the JSON Schema walk */
+    YEPTRIS_DIAG_TYPE = 5,
+    YEPTRIS_DIAG_REQUIRED = 6,
+    YEPTRIS_DIAG_ENUM = 7,
+    YEPTRIS_DIAG_CONST = 8,
+    YEPTRIS_DIAG_PATTERN = 9,
+    YEPTRIS_DIAG_MINIMUM = 10,
+    YEPTRIS_DIAG_MAXIMUM = 11,
+    YEPTRIS_DIAG_EXCLUSIVE_MINIMUM = 12,
+    YEPTRIS_DIAG_EXCLUSIVE_MAXIMUM = 13,
+    YEPTRIS_DIAG_MIN_LENGTH = 14,
+    YEPTRIS_DIAG_MAX_LENGTH = 15,
+    YEPTRIS_DIAG_MIN_ITEMS = 16,
+    YEPTRIS_DIAG_MAX_ITEMS = 17,
+    YEPTRIS_DIAG_UNIQUE_ITEMS = 18,
+    YEPTRIS_DIAG_ADDITIONAL_PROPERTY = 19,
+    YEPTRIS_DIAG_ANY_OF = 20,
+    YEPTRIS_DIAG_ONE_OF = 21,
+    YEPTRIS_DIAG_NOT = 22,
+    YEPTRIS_DIAG_REF = 23,          /* $ref unresolvable / chain too deep */
+    YEPTRIS_DIAG_FALSE_SCHEMA = 24, /* the schema is `false` here */
+    YEPTRIS_DIAG_DEPTH = 25,        /* recursion guard tripped */
+    YEPTRIS_DIAG_LIMIT = 26,        /* report truncated (the sentinel
+                                     * rides the LAST slot; more
+                                     * diagnostics were dropped) */
+    /* the 2020-12 sweep (#885 item 2) */
+    YEPTRIS_DIAG_MULTIPLE_OF = 27,
+    YEPTRIS_DIAG_MIN_PROPERTIES = 28,
+    YEPTRIS_DIAG_MAX_PROPERTIES = 29,
+    YEPTRIS_DIAG_CONTAINS = 30,
+    YEPTRIS_DIAG_MIN_CONTAINS = 31,
+    YEPTRIS_DIAG_MAX_CONTAINS = 32,
+    YEPTRIS_DIAG_DEPENDENT_REQUIRED = 33,
+} YeptrisDiagCode;
+
+/* Bounded diagnostic text; always NUL-terminated (over-long paths and
+ * details truncate — the same discipline as the error channel). */
+#define YEPTRIS_DIAG_PATH_MAX 256
+#define YEPTRIS_DIAG_DETAIL_MAX 128
+
+typedef struct yeptris_diagnostic {
+    uint32_t code; /* YeptrisDiagCode */
+    uint32_t line; /* 1-based; 0 = unknown */
+    uint32_t col;  /* 1-based; 0 = unknown */
+    uint32_t offset;
+    char path[YEPTRIS_DIAG_PATH_MAX];
+    char detail[YEPTRIS_DIAG_DETAIL_MAX];
+} yeptris_diagnostic;
+YEPTRIS_CT_ASSERT(sizeof(yeptris_diagnostic) ==
+                  16 + YEPTRIS_DIAG_PATH_MAX + YEPTRIS_DIAG_DETAIL_MAX);
+
+/* The diagnostics list. Opaque; free it with
+ * yeptris_validate_report_free (one call, everything). */
+typedef struct yeptris_validate_report yeptris_validate_report;
+
+/* Diagnostic count (0 = the document is valid). */
+YEPTRIS_API size_t yeptris_validate_report_count(const yeptris_validate_report* report);
+
+/* Diagnostic i (0-based); NULL out of range. Memory: borrowed from the
+ * report — valid until yeptris_validate_report_free. */
+YEPTRIS_API const yeptris_diagnostic*
+yeptris_validate_report_at(const yeptris_validate_report* report, size_t index);
+
+YEPTRIS_API void yeptris_validate_report_free(yeptris_validate_report* report);
+
+/* Parses `buf` (the same front door as yeptris_parse_ex: encodings,
+ * BOM, NEL normalization) and validates every document of the stream
+ * against `schema`. Paths are root-relative per document.
+ *
+ * Status: YEPTRIS_OK (valid; *out is a report — possibly with zero
+ * diagnostics for an empty stream); YEPTRIS_ERROR_SCHEMA (invalid:
+ * drain *out); YEPTRIS_ERROR_PARSE / DEPTH / ENCODING / MEMORY (the
+ * parse itself failed; *out stays NULL); YEPTRIS_ERROR_ARG.
+ *
+ * Memory: the caller owns *out; free it with
+ * yeptris_validate_report_free. */
+YEPTRIS_API YeptrisStatus yeptris_validate(const char* buf, size_t len, YeptrisSchema schema,
+                                           yeptris_validate_report** out);
+
+/* Validates an already-parsed document (or stream). The document is
+ * not modified; the report borrows nothing from it. */
+YEPTRIS_API YeptrisStatus yeptris_validate_document(YeptrisDocument doc, YeptrisSchema schema,
+                                                    yeptris_validate_report** out);
+
+/* JSON Schema draft 2020-12 subset (#882 slice 2; #885 item 2). `schema`
+ * is parsed with the same engine (JSON is YAML flow); document 0 of the
+ * stream is the schema. Keyword subset: type, enum, const, pattern,
+ * minimum/maximum/exclusiveMinimum/exclusiveMaximum (numeric, 2020-12
+ * form), multipleOf (libm-free quotient test), minLength/maxLength
+ * (code points), minItems/maxItems, uniqueItems, contains (+ the
+ * minContains/maxContains qualifiers), items (+ prefixItems; the
+ * draft-07 array form rides as prefixItems), properties, required,
+ * patternProperties, propertyNames, minProperties/maxProperties,
+ * additionalProperties (bool or schema; excludes patternProperties
+ * matches), dependentRequired, dependentSchemas, if/then/else,
+ * allOf/anyOf/oneOf/not, $ref (LOCAL "#/..." pointers only — $defs and
+ * definitions both resolve). Boolean schemas (`true`/`false`) apply.
+ * Unknown keywords and known keywords with unreadable values are
+ * ignored (2020-12). Instance types ride the core-schema resolution
+ * (the YAML->JSON data model): "y" is boolean, 1.0 is integer.
+ *
+ * Status: as yeptris_validate, plus YEPTRIS_ERROR_ARG when the schema
+ * bytes hold no document, and YEPTRIS_ERROR_PARSE when they do not
+ * parse. A $ref that resolves nowhere is a DIAG_REF diagnostic, not a
+ * status. Recursion is depth-guarded (the engine's guard): a
+ * self-referential $ref over a deep or cyclic chain reports DIAG_DEPTH
+ * / DIAG_REF — never a crash. */
+YEPTRIS_API YeptrisStatus yeptris_json_schema_validate(const char* schema, size_t schema_len,
+                                                       const char* buf, size_t len,
+                                                       yeptris_validate_report** out);
+
+/* The COMPILED SCHEMA — the leptris-XSD economy (#885 item 3): parse
+ * the schema ONCE, validate MANY instance streams against the retained
+ * model. The handle owns everything it reads: the schema bytes (copied
+ * — the retained DOM's views borrow them), the parsed document, and
+ * the pattern kernel's compiled programs (the XSD content-model
+ * analog: `(a+)+$` compiles once here, not once per validated string
+ * the way the one-shot face pays). yeptris_schema_compile returns NULL
+ * on failure; yeptris_last_error() carries the why (bad arguments,
+ * bytes that hold no document, a schema that does not parse,
+ * allocation failure).
+ *
+ * yeptris_schema_validate keeps yeptris_json_schema_validate's exact
+ * status/report contract; diagnostics enumerate every miss across
+ * every document of the instance stream. yeptris_schema_free releases
+ * the handle and everything it owns in ONE call (no refcounting) —
+ * afterwards the handle is DEAD: passing it anywhere is undefined,
+ * exactly like a freed document. NULL is accepted (a no-op).
+ *
+ * Thread law: one schema handle per thread, like documents — the
+ * handle is immutable after compile (the pattern programs are built at
+ * compile time), so read-only sharing across threads is safe; reports
+ * are per-call and caller-owned. */
+typedef struct yeptris_schema yeptris_schema;
+
+YEPTRIS_API yeptris_schema* yeptris_schema_compile(const char* bytes, size_t n);
+
+YEPTRIS_API YeptrisStatus yeptris_schema_validate(yeptris_schema* s, const char* buf, size_t len,
+                                                  yeptris_validate_report** out);
+
+YEPTRIS_API void yeptris_schema_free(yeptris_schema* s);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_VALIDATE_H */

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

@@ -18,6 +18,7 @@
 #include <yeptris/parse.h>
 #include <yeptris/resolve.h>
 #include <yeptris/types.h>
+#include <yeptris/validate.h>
 #include <yeptris/version.h>
 
 #endif /* YEPTRIS_H */

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

@@ -236,10 +236,15 @@ static YeptrisDocument parse_impl(const char* buf, size_t len, const YeptrisPars
         goto fail;
     }
 
+    /* a NULL/0-byte stream is a valid empty input: parse it through a
+     * non-null base so the BOM arithmetic never computes NULL+0
+     * (clang's UBSan flags the zero-offset-null form; gcc's does not —
+     * the schema-econ BadInputs pin surfaced it on the macOS arm64 leg) */
+    const char* src = buf != NULL ? buf : "";
     const yep_allocator* sys = yep_system_allocator();
 
     /* Encoding front-end: BOM sniff; borrow UTF-8, transcode the rest. */
-    const char* data = buf;
+    const char* data = src;
     size_t data_len = len;
     unsigned char* transcoded = NULL;
     size_t transcoded_len = 0;
@@ -256,8 +261,8 @@ static YeptrisDocument parse_impl(const char* buf, size_t len, const YeptrisPars
         goto engine_enter;
     }
 
-    size_t bom = yep_bom_sniff((const unsigned char*)buf, len, &enc);
-    data = buf + bom;
+    size_t bom = yep_bom_sniff((const unsigned char*)src, len, &enc);
+    data = src + bom;
     data_len = len - bom;
 
     if (enc == YEP_ENC_UTF16LE || enc == YEP_ENC_UTF16BE || enc == YEP_ENC_UTF32LE ||
@@ -325,9 +330,13 @@ static YeptrisDocument parse_impl(const char* buf, size_t len, const YeptrisPars
 engine_enter:
     eng = yep_engine_create(sys);
     if (opts != NULL) {
+        /* the typing SSOT: the family's resolver (compat11 when asked,
+         * json12 for the 12_JSON validation family, core12 otherwise) */
         yep_engine_set_resolver(eng, opts->schema == YEPTRIS_SCHEMA_11_COMPAT
                                          ? yep_resolver_compat11()
-                                         : yep_resolver_core12());
+                                         : (opts->schema == YEPTRIS_SCHEMA_12_JSON
+                                                ? yep_resolver_json12()
+                                                : yep_resolver_core12()));
         if (opts->schema == YEPTRIS_SCHEMA_11_COMPAT) {
             /* the compat schema is the psych/libyaml surface: its grammar
              * must accept what libyaml accepts (the flow floor is suite-
@@ -357,9 +366,13 @@ engine_enter:
         }
         /* the direct builders resolve with the engine's schema (the typing
          * SSOT — one resolver decision per scalar, whichever path builds) */
-        dom->resolver = (opts != NULL && opts->schema == YEPTRIS_SCHEMA_11_COMPAT)
-                            ? yep_resolver_compat11()
-                            : yep_resolver_core12();
+        if (opts != NULL && opts->schema == YEPTRIS_SCHEMA_11_COMPAT) {
+            dom->resolver = yep_resolver_compat11();
+        } else if (opts != NULL && opts->schema == YEPTRIS_SCHEMA_12_JSON) {
+            dom->resolver = yep_resolver_json12();
+        } else {
+            dom->resolver = yep_resolver_core12();
+        }
         /* BEFORE the run: input-slice strings borrow as views (zero copy)
          * — the document keeps `transcoded` alive for exactly this. Set
          * after, every scalar was arena-copied (found 2026-09-10). */
@@ -422,6 +435,8 @@ engine_enter:
     } else if (have_tape && !norm_kept_raw &&
                ytap_fused_run(&yt, (opts != NULL && opts->schema == YEPTRIS_SCHEMA_11_COMPAT)
                                        ? yep_resolver_compat11()
+                                   : (opts != NULL && opts->schema == YEPTRIS_SCHEMA_12_JSON)
+                                       ? yep_resolver_json12()
                                        : yep_resolver_core12()) == 0) {
         /* the fused block runner owned the whole document — the engine
          * never runs (TODO.restructure/79). Its only cost was the parse
@@ -496,9 +511,8 @@ engine_enter:
     }
     yep_mutex_init(&doc->lazy_mu);
     doc->sys = sys;
-    doc->schema = (opts != NULL && opts->schema == YEPTRIS_SCHEMA_11_COMPAT)
-                      ? YEPTRIS_SCHEMA_11_COMPAT
-                      : YEPTRIS_SCHEMA_12_CORE;
+    doc->schema = (opts != NULL && opts->schema != YEPTRIS_SCHEMA_12_CORE) ? opts->schema
+                                                                           : YEPTRIS_SCHEMA_12_CORE;
     doc->transcoded = transcoded;
     doc->transcoded_len = transcoded_len;
     doc->input = buf;

data/vendor/libyeptris/src/yeptris/resolve/json12.c

@@ -0,0 +1,103 @@
+/* json12.c — the spec 10.2 JSON schema resolver (#882).
+ *
+ * The productions are the spec 10.2.2 table (1.2.2 erratum kept: the
+ * float regex needs NO digits after the dot — "0." is a float):
+ *   null:  null
+ *   bool:  true | false
+ *   int:   -? ( 0 | [1-9] [0-9]* )
+ *   float: -? ( 0 | [1-9] [0-9]* ) ( \. [0-9]* )? ( [eE] [-+]? [0-9]+ )?
+ *   *  -> Error (the validator's business; the resolver stays str)
+ *
+ * Deliberately NOT accepted (the core schema's extensions): "True"/
+ * "False"/"NULL" casings, "~"/empty nulls, +signs, 0o/0x radix, .inf/
+ * .nan, underscores. The example-10.8 Invalid list pins each one.
+ *
+ * Shape: yep_json12_plain is the ONE classifier — the resolver wraps
+ * it, and the validator re-asks it per plain scalar (no second truth
+ * table anywhere). Parse never errors here: a scalar outside the
+ * productions resolves str so the DOM stays family-neutral; the
+ * validation face turns the spec's Error row into diagnostics.
+ */
+
+#include <stdint.h>
+#include <string.h>
+
+#include "resolver.h"
+
+/* JSON int: -?(0|[1-9][0-9]*); optionally continues as the float
+ * production (the int regex is a prefix of the float one). Returns 1
+ * (int), 2 (float), 0 (no production). */
+int yep_json12_plain(const char* p, uint32_t n) {
+    if (n == 0) {
+        return 0;
+    }
+    if (n == 4 && memcmp(p, "null", 4) == 0) {
+        return 4; /* null */
+    }
+    if (n == 4 && memcmp(p, "true", 4) == 0) {
+        return 3; /* bool */
+    }
+    if (n == 5 && memcmp(p, "false", 5) == 0) {
+        return 3;
+    }
+    uint32_t i = (p[0] == '-') ? 1 : 0;
+    if (i >= n) {
+        return 0; /* lone "-" (or empty after the prefix check) */
+    }
+    /* int part: 0 | [1-9][0-9]* — no +sign, no leading zeros */
+    if (p[i] == '0') {
+        i++;
+    } else if (p[i] >= '1' && p[i] <= '9') {
+        i++;
+        while (i < n && p[i] >= '0' && p[i] <= '9') {
+            i++;
+        }
+    } else {
+        return 0;
+    }
+    if (i == n) {
+        return 1; /* bare int */
+    }
+    /* float tail: (\.[0-9]*)? ([eE][-+]?[0-9]+)? — at least one of the
+     * two must be present (a bare int already returned) */
+    int floaty = 0;
+    if (p[i] == '.') {
+        floaty = 1;
+        i++;
+        while (i < n && p[i] >= '0' && p[i] <= '9') {
+            i++; /* digits optional after the dot (1.2.2 erratum) */
+        }
+    }
+    if (i < n && (p[i] == 'e' || p[i] == 'E')) {
+        i++;
+        if (i < n && (p[i] == '+' || p[i] == '-')) {
+            i++;
+        }
+        int ed = 0;
+        while (i < n && p[i] >= '0' && p[i] <= '9') {
+            i++;
+            ed = 1;
+        }
+        if (!ed) {
+            return 0; /* exponent sign(s) with no digits */
+        }
+        floaty = 1;
+    }
+    return (floaty && i == n) ? 2 : 0;
+}
+
+static yep_tag_id json12(void* ctx, const char* p, uint32_t n) {
+    (void)ctx;
+    return (yep_tag_id)yep_json12_plain(p, n);
+}
+
+static yep_tag_id json12_number(void* ctx, int is_float) {
+    (void)ctx;
+    return is_float ? 2 : 1;
+}
+
+static const yep_resolver k_json12 = {json12, json12_number, NULL};
+
+const yep_resolver* yep_resolver_json12(void) {
+    return &k_json12;
+}

data/vendor/libyeptris/src/yeptris/resolve/resolver.h

@@ -40,6 +40,15 @@ static inline yep_tag_id yep_resolve_number(const yep_resolver* r, int is_float)
 const yep_resolver* yep_resolver_core12(void);
 const yep_resolver* yep_resolver_compat11(void);
 
+/* The spec 10.2 JSON schema resolver (#882): null/true/false exact,
+ * the JSON int and float productions, everything else str. Parse stays
+ * lenient — the VALIDATOR flags plain scalars that matched no
+ * production (the spec's `*` -> Error row) through the classifier. */
+const yep_resolver* yep_resolver_json12(void);
+/* 1 when the plain span matches a JSON-schema production. The one
+ * truth table for the 12_JSON family (validate/ re-asks it). */
+int yep_json12_plain(const char* p, uint32_t n);
+
 /* core tag id <-> canonical URI (tags.c is the identity SSOT). */
 const char* yep_tag_uri(yep_tag_id id);