yeptris 0.6.57.1 → 0.6.58.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ca19dc06edfa2c51b8d193845713970526fb9c933a9d4ff438b4536e6847ff8
-  data.tar.gz: 2d32ef5b5b0702e0d24accf88ddad7ec35dc922e33277037332d675b6c3316d7
+  metadata.gz: 6981f8111e961331c95ba918de35aa2cf06dcaa693278f96aa826b9ef9e1004c
+  data.tar.gz: e98d9a8bbeedf17aa199d9c90fa21e6c36320512d43deb05fd625c1ef70369dc
 SHA512:
-  metadata.gz: 79953b07f1bce4b68ca9d8a7124cbc11313ddb56f067291f9a8f3979f8cb9aee59c3af0370f076474d8abe64253e1c757fa04df8c8b7d236fec41e7c97cc3e7e
-  data.tar.gz: 71668f985884d66d6828c50d854caf079f0f1c2dd40d7ecaf7fd5d49257b9f754f64d8d66296e3df6836d589e2b7ce36e9df36e2a17ce7b167c02d7e6c13d68b
+  metadata.gz: 230b0b6b76cbeca7bc38be46839656d3f9b12653231c9d7b3284d84604325c2a0932effeefc3377b2e95f8036bdc99e60c92184aa35794852c14f9af54a952ad
+  data.tar.gz: 20f44cbc4f53e2af25622aa1fbdf47e4710c329b6ea48910104da75d8421bff65a96ddb1f928672eceb5cf543323ea7d2c4d01562a09bc043683661e92dd0517

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.58.1".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.57
+    VERSION 0.6.58
     DESCRIPTION "Ultra-fast YAML 1.2 parser, emitter and streamer in C"
     LANGUAGES C CXX
 )

data/vendor/libyeptris/src/CMakeLists.txt

@@ -39,9 +39,13 @@ 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/jsonschema.c
     yeptris/tape.c
     yeptris/plan.c
 
@@ -95,6 +99,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,157 @@
+/* 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) */
+} 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). `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),
+ * minLength/maxLength (code points), minItems/maxItems, uniqueItems,
+ * items (+ prefixItems; the draft-07 array form rides as prefixItems),
+ * properties, required, additionalProperties (bool or schema),
+ * 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);
+
+#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

@@ -325,9 +325,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 +361,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 +430,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 +506,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);
 

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

@@ -0,0 +1,102 @@
+/* validate/internal.h — the validation face's shared internals (#882).
+ *
+ * Private to src/yeptris/validate/: the report shape, the diagnostic
+ * emitter (path capture + line/col resolution), and the JSON-pointer
+ * scratch path. The two walks (validate.c's schema family and
+ * jsonschema.c's keyword subset) share only this — MECE keeps the
+ * checks themselves in their own TUs.
+ */
+#ifndef YEP_VALIDATE_INTERNAL_H
+#define YEP_VALIDATE_INTERNAL_H
+
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <yeptris/validate.h>
+
+#include "../dom/dom.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* The report cap: a hostile document can carry O(nodes) violations, so
+ * the walk stops here and the LIMIT sentinel replaces the last slot. */
+#define YEP_VALIDATE_MAX_DIAGS 256
+
+struct yeptris_validate_report {
+    yeptris_diagnostic* diags;
+    uint32_t count;
+    int truncated;
+};
+
+typedef struct yep_vctx {
+    const yep_dom* dom;
+    yeptris_validate_report* rep;
+    /* line/col resolution over the node bytes (lazy: built on the
+     * first positioned diagnostic; valid documents never pay) */
+    const char* input;
+    size_t input_len;
+    uint32_t* line_off; /* byte offset of every line start */
+    uint32_t line_cnt, line_cap;
+    /* JSON-pointer path under construction (DFS scratch) */
+    char* path;
+    size_t path_len, path_cap;
+    int depth; /* the walk's nesting guard (never exceeds the DOM's) */
+    int oom;   /* an allocation failed: stop diagnosing */
+    /* JSON Schema trial suppression (anyOf/oneOf/not probes) */
+    int suppress;
+    int trial_hit;
+    int ref_depth; /* consecutive $ref expansions */
+} yep_vctx;
+
+/* Offset of a node's first positioned byte (the value span of the node
+ * itself, or of its first scalar leaf for collections; UINT32_MAX when
+ * everything reachable lives in the arena — line/col unknown). */
+uint32_t yep_validate_node_off(const yep_dom* d, uint32_t id);
+
+/* Emits one diagnostic at the current path. line/col resolve from
+ * `off` through the lazy line index; 0/0 when unknown. Detail is
+ * printf-composed into the bounded slot. Never fails the caller: the
+ * report cap turns the last slot into the LIMIT sentinel. */
+void yep_validate_emit(yep_vctx* c, int code, uint32_t off, const char* detail_fmt, ...);
+
+/* JSON-pointer path scratch: push an escaped segment / a decimal
+ * index, pop to a mark. 0 ok, -1 OOM (ctx.oom set; the walk unwinds). */
+int yep_validate_path_push(yep_vctx* c, const char* seg, size_t seg_len);
+int yep_validate_path_push_index(yep_vctx* c, uint32_t idx);
+void yep_validate_path_pop(yep_vctx* c, size_t mark);
+
+/* The bounded ECMA-regex subset behind `pattern` (jsonschema.c):
+ * literals, '.', classes, groups, alternation, the greedy/lazy
+ * quantifiers, anchors, \d\w\s\D\W\S\b\B and \xHH. Byte-oriented
+ * (ASCII classes; UTF-8 literals match byte-wise). A Thompson NFA —
+ * O(len * m), no backtracking blowup; patterns over the program
+ * budget are invalid. 1 match, 0 no match, -1 invalid pattern. */
+int yep_re_search(const char* pat, uint32_t pat_len, const char* s, uint32_t s_len);
+
+/* Canonical scalar tag of a DOM node (explicit tag, then the parse
+ * resolver's plain verdict, then str): the value model both walks
+ * compare under. */
+uint8_t yep_validate_scalar_tag(const yep_dnode* n);
+
+/* Canonical-form hash and equality over DOM subtrees (spec 3.2.1.3:
+ * same tag + canonical form; numbers numerically within a tag). The
+ * equality may cross documents — the schema's enum/const live in a
+ * different DOM than the instance. Depth-bounded. */
+uint64_t yep_validate_node_hash(const yep_dom* d, uint32_t id, int depth);
+int yep_validate_node_equal(const yep_dom* da, uint32_t a, const yep_dom* db, uint32_t b,
+                            int depth);
+
+/* jsonschema.c's driver: applies the schema tree (its own DOM) to
+ * every instance document root, emitting into `rep`. Returns 0, -1
+ * on OOM. */
+int yep_jsonschema_run(const yep_dom* schema_dom, uint32_t schema_root, const yep_dom* instance_dom,
+                       const uint32_t* doc_roots, uint32_t doc_count, yeptris_validate_report* rep);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEP_VALIDATE_INTERNAL_H */