yeptris 0.6.57.1-arm-linux-eabihf → 0.6.58.1-arm-linux-eabihf

data/vendor/libyeptris/src/yeptris/validate/jsonschema.c

@@ -0,0 +1,1022 @@
+/* jsonschema.c — the JSON Schema draft 2020-12 keyword subset
+ * (#882 slice 2).
+ *
+ * The schema and the target are both parsed with the same engine; the
+ * walk applies the schema tree to the instance tree and emits
+ * diagnostics at instance JSON-pointer paths. Subset: type, enum,
+ * const, pattern, minimum/maximum/exclusive*, minLength/maxLength
+ * (code points), minItems/maxItems, uniqueItems, properties, required,
+ * additionalProperties (bool or schema), items (+ prefixItems; the
+ * draft-07 array form rides as prefixItems), allOf/anyOf/oneOf/not,
+ * $ref (LOCAL "#/..." pointers — $defs and definitions both resolve),
+ * boolean schemas. Unknown keywords, and known keywords whose values
+ * cannot be read, are IGNORED (2020-12's posture) — an unreadable
+ * constraint never guesses.
+ *
+ * Instance types ride the core-schema resolution (the YAML->JSON data
+ * model): "y" is boolean, 1.0 is integer (2020-12: zero fractional
+ * part), floats and ints are both numbers.
+ *
+ * Guards: the walk depth is the DOM's own parse-bounded depth; a
+ * consecutive-$ref chain (schema-only cycles that consume no instance
+ * structure) caps at 64 expansions and reports DIAG_REF. Every array
+ * is bounded; allocation failure flags the context and unwinds.
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include <yeptris/validate.h>
+
+#include "../memory/allocator.h"
+#include "../parse/numbers.h"
+#include "../resolve/resolver.h"
+#include "internal.h"
+
+#define JS_MAX_REF_CHAIN 64
+#define JS_MAX_TOKENS 256
+#define JS_MAX_UNIQUE 4096 /* uniqueItems' hash table cap; over: O(n^2) probe */
+
+typedef struct {
+    yep_vctx v;        /* instance-side context (path, report, guards) */
+    const yep_dom* sd; /* the schema document's tree */
+    uint32_t sroot;    /* the schema's document root */
+} js_ctx;
+
+/* ---- schema-side facts -------------------------------------------------- */
+
+static const yep_dnode* snode(const js_ctx* j, uint32_t id) {
+    return yep_dom_node(j->sd, id);
+}
+
+/* First pair of the mapping whose key bytes equal `name`; 1 + *val_out,
+ * 0 absent. Only scalar keys match (collection keys never will). */
+static int kw_get(const js_ctx* j, uint32_t map_id, const char* name, uint32_t* val_out) {
+    const yep_dnode* m = snode(j, map_id);
+    if (m == NULL || m->kind != YEP_DOM_MAPPING) {
+        return 0;
+    }
+    size_t nl = strlen(name);
+    uint32_t k = m->first_child;
+    while (k != UINT32_MAX) {
+        uint32_t v = snode(j, k) ? snode(j, k)->next_sibling : UINT32_MAX;
+        const yep_dnode* kn = snode(j, k);
+        if (kn != NULL && kn->kind == YEP_DOM_SCALAR) {
+            yep_view kv = yep_dom_view(j->sd, kn->value);
+            if (kv.len == nl && (nl == 0 || memcmp(kv.p, name, nl) == 0)) {
+                if (val_out != NULL) {
+                    *val_out = v;
+                }
+                return 1;
+            }
+        }
+        k = v != UINT32_MAX && snode(j, v) ? snode(j, v)->next_sibling : UINT32_MAX;
+    }
+    return 0;
+}
+
+/* A schema-valued keyword: a mapping, or the boolean schemas. */
+static int schema_truth(const js_ctx* j, uint32_t id, int* is_false) {
+    const yep_dnode* n = snode(j, id);
+    if (n == NULL) {
+        *is_false = 0;
+        return 0;
+    }
+    if (n->kind == YEP_DOM_MAPPING) {
+        *is_false = 0;
+        return 1;
+    }
+    if (n->kind == YEP_DOM_SCALAR && yep_validate_scalar_tag(n) == YEPTRIS_TAG_BOOL) {
+        yep_view v = yep_dom_view(j->sd, n->value);
+        *is_false = (v.len == 5 && memcmp(v.p, "false", 5) == 0);
+        return 1; /* true/false both carry meaning */
+    }
+    *is_false = 0;
+    return 0; /* an unreadable schema: ignored */
+}
+
+static int kw_schema(const js_ctx* j, uint32_t map_id, const char* name, uint32_t* schema_out,
+                     int* is_false_out) {
+    uint32_t val;
+    if (!kw_get(j, map_id, name, &val) || val == UINT32_MAX) {
+        return 0;
+    }
+    int is_false = 0;
+    if (!schema_truth(j, val, &is_false)) {
+        return 0;
+    }
+    *schema_out = val;
+    *is_false_out = is_false;
+    return 1;
+}
+
+/* ---- instance-side facts ------------------------------------------------ */
+
+/* Resolves an alias to the real node id (one hop; the DOM's targets
+ * are real nodes). */
+static uint32_t inst_real(const yep_dom* d, uint32_t id) {
+    const yep_dnode* n = yep_dom_node(d, id);
+    if (n != NULL && n->kind == YEP_DOM_ALIAS && n->target != UINT32_MAX) {
+        return n->target;
+    }
+    return id;
+}
+
+/* The instance's JSON type word (7 bytes max); *integer receives 1 when
+ * a float also satisfies 2020-12's zero-fraction rule. */
+static void inst_type(const yep_dom* d, uint32_t id, const char** word, int* integer) {
+    *integer = 0;
+    const yep_dnode* n = yep_dom_node(d, id);
+    if (n == NULL) {
+        *word = "string";
+        return;
+    }
+    if (n->kind == YEP_DOM_ALIAS) {
+        if (n->target != UINT32_MAX) {
+            inst_type(d, n->target, word, integer);
+        } else {
+            *word = "string";
+        }
+        return;
+    }
+    if (n->kind == YEP_DOM_SEQUENCE) {
+        *word = "array";
+        return;
+    }
+    if (n->kind == YEP_DOM_MAPPING) {
+        *word = "object";
+        return;
+    }
+    switch (yep_validate_scalar_tag(n)) {
+    case YEPTRIS_TAG_NULL:
+        *word = "null";
+        break;
+    case YEPTRIS_TAG_BOOL:
+        *word = "boolean";
+        break;
+    case YEPTRIS_TAG_INT:
+        *word = "integer";
+        *integer = 1;
+        break;
+    case YEPTRIS_TAG_FLOAT: {
+        yep_view v = yep_dom_view(d, n->value);
+        double dv;
+        /* 2020-12: "integer" means a zero fractional part. The range
+         * guard must read the PARSED value (it once sat before the
+         * parse, saw dv==0, folded constant-true, and left the cast
+         * UB on out-of-range/NaN doubles). No libm: in int64 range a
+         * cast round-trips iff the fractional part is zero; outside
+         * it every finite double is already integral; NaN is not. */
+        if (yep_num_f64(v.p, v.len, &dv) == 0) {
+            const int in_i64 = dv >= -9223372036854775808.0 && dv < 9223372036854775808.0;
+            if (in_i64 ? dv == (double)(int64_t)dv : dv == dv) {
+                *word = "integer";
+                *integer = 1;
+            } else {
+                *word = "number";
+            }
+        } else {
+            *word = "number";
+        }
+        break;
+    }
+    default:
+        *word = "string";
+        break;
+    }
+}
+
+/* The instance's numeric value (int or float); 0 when not numeric. */
+static int inst_number(const yep_dom* d, uint32_t id, double* out) {
+    const yep_dnode* n = yep_dom_node(d, id);
+    if (n == NULL) {
+        return 0;
+    }
+    if (n->kind == YEP_DOM_ALIAS) {
+        return n->target != UINT32_MAX && inst_number(d, n->target, out);
+    }
+    if (n->kind != YEP_DOM_SCALAR) {
+        return 0;
+    }
+    uint8_t tag = yep_validate_scalar_tag(n);
+    if (tag != YEPTRIS_TAG_INT && tag != YEPTRIS_TAG_FLOAT) {
+        return 0;
+    }
+    yep_view v = yep_dom_view(d, n->value);
+    int64_t iv = 0;
+    if (yep_num_i64(v.p, v.len, &iv) == 0) {
+        *out = (double)iv;
+        return 1;
+    }
+    return yep_num_f64(v.p, v.len, out) == 0;
+}
+
+static int inst_seq_count(const yep_dom* d, uint32_t id, uint32_t* count) {
+    const yep_dnode* n = yep_dom_node(d, id);
+    if (n == NULL || n->kind != YEP_DOM_SEQUENCE) {
+        return 0;
+    }
+    *count = n->count;
+    return 1;
+}
+
+/* ---- the walk ----------------------------------------------------------- */
+
+static void js_apply(js_ctx* j, uint32_t schema_id, uint32_t inst_id, int depth);
+
+/* A suppressed probe: does `schema_id` hold at `inst_id`? Diagnostics
+ * during the trial are swallowed. */
+static int js_holds(js_ctx* j, uint32_t schema_id, uint32_t inst_id, int depth) {
+    int save = j->v.trial_hit;
+    j->v.trial_hit = 0;
+    j->v.suppress++;
+    js_apply(j, schema_id, inst_id, depth);
+    j->v.suppress--;
+    int hit = j->v.trial_hit;
+    j->v.trial_hit = save;
+    return !hit;
+}
+
+/* Local "#/..." pointer resolution against the schema document. */
+static int resolve_ref(js_ctx* j, const char* p, uint32_t plen, uint32_t* out) {
+    if (plen == 0 || p[0] != '#') {
+        return 0; /* remote/anchor forms are out of the subset */
+    }
+    uint32_t cur = j->sroot;
+    size_t i = 1;
+    if (i >= plen || p[i] != '/') {
+        *out = cur; /* "#" alone is the root */
+        return i == plen;
+    }
+    int tokens = 0;
+    while (i < plen) {
+        if (p[i] != '/') {
+            return 0;
+        }
+        i++;
+        char token[128];
+        size_t tl = 0;
+        while (i < plen && p[i] != '/') {
+            char b = p[i];
+            if (b == '~' && i + 1 < plen && (p[i + 1] == '0' || p[i + 1] == '1')) {
+                b = p[i + 1] == '0' ? '~' : '/';
+                i++;
+            } else if (b == '~') {
+                return 0; /* a dangling ~ escape */
+            }
+            if (tl + 1 >= sizeof(token)) {
+                return 0;
+            }
+            token[tl++] = b;
+            i++;
+        }
+        if (++tokens > JS_MAX_TOKENS) {
+            return 0;
+        }
+        const yep_dnode* n = snode(j, cur);
+        if (n == NULL) {
+            return 0;
+        }
+        if (n->kind == YEP_DOM_SEQUENCE) {
+            /* a decimal array index (JSON pointer: no leading zeros,
+             * but be lenient — the pointer either resolves or not) */
+            uint32_t idx = 0;
+            if (tl == 0) {
+                return 0;
+            }
+            for (size_t t = 0; t < tl; t++) {
+                if (token[t] < '0' || token[t] > '9' || idx > 999999) {
+                    return 0;
+                }
+                idx = idx * 10 + (uint32_t)(token[t] - '0');
+            }
+            uint32_t count = 0;
+            if (!inst_seq_count(j->sd, cur, &count) || idx >= count) {
+                return 0;
+            }
+            uint32_t ch = n->first_child;
+            while (ch != UINT32_MAX && idx > 0) {
+                ch = snode(j, ch) ? snode(j, ch)->next_sibling : UINT32_MAX;
+                idx--;
+            }
+            cur = ch;
+        } else if (n->kind == YEP_DOM_MAPPING) {
+            uint32_t k = n->first_child;
+            int found = 0;
+            while (k != UINT32_MAX && !found) {
+                uint32_t v = snode(j, k) ? snode(j, k)->next_sibling : UINT32_MAX;
+                const yep_dnode* kn = snode(j, k);
+                if (kn != NULL && kn->kind == YEP_DOM_SCALAR) {
+                    yep_view kv = yep_dom_view(j->sd, kn->value);
+                    if (kv.len == tl && (tl == 0 || memcmp(kv.p, token, tl) == 0)) {
+                        cur = v;
+                        found = 1;
+                    }
+                }
+                k = v != UINT32_MAX && snode(j, v) ? snode(j, v)->next_sibling : UINT32_MAX;
+            }
+            if (!found) {
+                return 0;
+            }
+        } else {
+            return 0; /* a pointer into a scalar */
+        }
+    }
+    *out = cur;
+    return cur != UINT32_MAX;
+}
+
+/* uniqueItems: canonical hash buckets, canonical equality inside a
+ * bucket; allocation failure skips the check (oom flags the walk). */
+static void check_unique(js_ctx* j, uint32_t seq_id, uint32_t inst_off) {
+    const yep_dom* d = j->v.dom;
+    const yep_dnode* s = yep_dom_node(d, seq_id);
+    uint32_t n = s->count;
+    if (n < 2) {
+        return;
+    }
+    const yep_allocator* sys = yep_system_allocator();
+    uint32_t cap = 8;
+    while (cap < n * 2 && cap < JS_MAX_UNIQUE) {
+        cap *= 2;
+    }
+    /* cap never reaches n when n exceeds JS_MAX_UNIQUE: elements beyond
+     * a FULL table are unchecked below (a 100%%-full table cannot probe
+     * — the linear scan would spin forever). Bounded memory, bounded
+     * time; the check degrades to the first `cap` distinct entries. */
+    struct {
+        uint32_t hash;
+        uint32_t node; /* +1 encoded */
+    }* tbl = yep_alloc(sys, (size_t)cap * sizeof(*tbl));
+    if (tbl == NULL) {
+        j->v.oom = 1;
+        return;
+    }
+    memset(tbl, 0, (size_t)cap * sizeof(*tbl));
+    uint32_t ch = s->first_child;
+    int idx = 0;
+    int reported = 0;
+    uint32_t inserted = 0;
+    while (ch != UINT32_MAX && !reported) {
+        if (inserted == cap) {
+            break; /* the table is full: stop checking (see the cap note) */
+        }
+        uint64_t h64 = yep_validate_node_hash(d, ch, 0);
+        uint32_t h = (uint32_t)(h64 ^ (h64 >> 32));
+        uint32_t i = h & (cap - 1);
+        int dup = 0;
+        while (tbl[i].node != 0) {
+            if (tbl[i].hash == h && yep_validate_node_equal(d, tbl[i].node - 1, d, ch, 0)) {
+                dup = 1;
+                break;
+            }
+            i = (i + 1) & (cap - 1);
+        }
+        if (dup) {
+            reported = 1;
+            yep_validate_emit(&j->v, YEPTRIS_DIAG_UNIQUE_ITEMS, inst_off,
+                              "elements %u and %u are equal", (uint32_t)idx, (uint32_t)(idx - 1));
+        } else {
+            tbl[i].hash = h;
+            tbl[i].node = ch + 1;
+            inserted++;
+        }
+        ch = yep_dom_node(d, ch) ? yep_dom_node(d, ch)->next_sibling : UINT32_MAX;
+        idx++;
+    }
+    yep_free(sys, tbl);
+}
+
+/* The instance's string length in code points (2020-12 minLength/
+ * maxLength). 0 when the instance is not a string. */
+static int inst_str_len(const yep_dom* d, uint32_t id, uint32_t* out) {
+    const yep_dnode* n = yep_dom_node(d, id);
+    if (n == NULL) {
+        return 0;
+    }
+    if (n->kind == YEP_DOM_ALIAS) {
+        return n->target != UINT32_MAX && inst_str_len(d, n->target, out);
+    }
+    if (n->kind != YEP_DOM_SCALAR || yep_validate_scalar_tag(n) != YEPTRIS_TAG_STR) {
+        return 0;
+    }
+    yep_view v = yep_dom_view(d, n->value);
+    uint32_t chars = 0;
+    for (uint32_t i = 0; i < v.len; i++) {
+        chars += ((((unsigned char)v.p[i]) & 0xC0) != 0x80);
+    }
+    *out = chars;
+    return 1;
+}
+
+/* Reads a keyword's numeric value (int or float scalar); 0 unreadable. */
+static int schema_number(const js_ctx* j, uint32_t id, double* out) {
+    const yep_dnode* n = snode(j, id);
+    if (n == NULL || n->kind != YEP_DOM_SCALAR) {
+        return 0;
+    }
+    uint8_t tag = yep_validate_scalar_tag(n);
+    if (tag != YEPTRIS_TAG_INT && tag != YEPTRIS_TAG_FLOAT) {
+        return 0;
+    }
+    yep_view v = yep_dom_view(j->sd, n->value);
+    int64_t iv = 0;
+    if (yep_num_i64(v.p, v.len, &iv) == 0) {
+        *out = (double)iv;
+        return 1;
+    }
+    return yep_num_f64(v.p, v.len, out) == 0;
+}
+
+/* Applies one keyword value that must be a string (the type names,
+ * pattern sources); 0 when unreadable. */
+static int schema_word(const js_ctx* j, uint32_t id, const char** p, uint32_t* len) {
+    const yep_dnode* n = snode(j, id);
+    if (n == NULL || n->kind != YEP_DOM_SCALAR || yep_validate_scalar_tag(n) != YEPTRIS_TAG_STR) {
+        return 0;
+    }
+    yep_view v = yep_dom_view(j->sd, n->value);
+    if (v.p == NULL) {
+        return 0;
+    }
+    *p = v.p;
+    *len = v.len;
+    return 1;
+}
+
+static void js_apply(js_ctx* j, uint32_t schema_id, uint32_t inst_id, int depth) {
+    if (j->v.oom) {
+        return;
+    }
+    if (++depth > YEP_DOM_MAX_DEPTH) {
+        if (depth == YEP_DOM_MAX_DEPTH + 1) {
+            yep_validate_emit(&j->v, YEPTRIS_DIAG_DEPTH, UINT32_MAX,
+                              "schema application exceeded the nesting limit");
+        }
+        return;
+    }
+    inst_id = inst_real(j->v.dom, inst_id);
+    const yep_dnode* s = snode(j, schema_id);
+    if (s == NULL) {
+        return;
+    }
+
+    /* the boolean schemas */
+    if (s->kind != YEP_DOM_MAPPING) {
+        if (s->kind == YEP_DOM_SCALAR && yep_validate_scalar_tag(s) == YEPTRIS_TAG_BOOL) {
+            yep_view v = yep_dom_view(j->sd, s->value);
+            if (v.len == 5 && memcmp(v.p, "false", 5) == 0) {
+                yep_validate_emit(&j->v, YEPTRIS_DIAG_FALSE_SCHEMA,
+                                  yep_validate_node_off(j->v.dom, inst_id),
+                                  "the schema is false here");
+            }
+        }
+        return; /* true (or anything unreadable) constrains nothing */
+    }
+
+    /* $ref composes with its siblings (2020-12); the chain guard kills
+     * schema-only cycles that consume no instance structure */
+    uint32_t ref_val;
+    if (kw_get(j, schema_id, "$ref", &ref_val) && ref_val != UINT32_MAX) {
+        const char* rp = NULL;
+        uint32_t rl = 0;
+        if (schema_word(j, ref_val, &rp, &rl)) {
+            if (++j->v.ref_depth > JS_MAX_REF_CHAIN) {
+                yep_validate_emit(&j->v, YEPTRIS_DIAG_REF, yep_validate_node_off(j->v.dom, inst_id),
+                                  "$ref chain exceeds %d (a cycle?)", JS_MAX_REF_CHAIN);
+                j->v.ref_depth = 0;
+                return;
+            }
+            uint32_t target = UINT32_MAX;
+            if (!resolve_ref(j, rp, rl, &target)) {
+                yep_validate_emit(&j->v, YEPTRIS_DIAG_REF, yep_validate_node_off(j->v.dom, inst_id),
+                                  "$ref \"%.*s\" does not resolve", (int)(rl > 64 ? 64 : rl), rp);
+                j->v.ref_depth = 0;
+                return;
+            }
+            js_apply(j, target, inst_id, depth);
+            j->v.ref_depth = 0;
+        }
+        /* an unreadable $ref value: ignored like any unknown keyword */
+    } else {
+        j->v.ref_depth = 0;
+    }
+
+    /* type: a single word or a list of words */
+    {
+        uint32_t tv;
+        if (kw_get(j, schema_id, "type", &tv) && tv != UINT32_MAX) {
+            const yep_dnode* tn = snode(j, tv);
+            const char* word = NULL;
+            uint32_t wl = 0;
+            const char* it = NULL;
+            int iis_int = 0;
+            inst_type(j->v.dom, inst_id, &it, &iis_int);
+            int matched = 0;
+            int have = 0;
+            if (tn != NULL && tn->kind == YEP_DOM_SCALAR && schema_word(j, tv, &word, &wl)) {
+                have = 1;
+                matched = (strlen(it) == wl && memcmp(it, word, wl) == 0);
+                /* "number" also accepts integers */
+                if (!matched && wl == 6 && memcmp(word, "number", 6) == 0 && iis_int) {
+                    matched = 1;
+                }
+            } else if (tn != NULL && tn->kind == YEP_DOM_SEQUENCE) {
+                have = 1;
+                uint32_t ch = tn->first_child;
+                while (ch != UINT32_MAX && !matched) {
+                    const char* w2 = NULL;
+                    uint32_t l2 = 0;
+                    if (schema_word(j, ch, &w2, &l2)) {
+                        matched = (strlen(it) == l2 && memcmp(it, w2, l2) == 0);
+                        if (!matched && l2 == 6 && memcmp(w2, "number", 6) == 0 && iis_int) {
+                            matched = 1;
+                        }
+                    }
+                    ch = snode(j, ch) ? snode(j, ch)->next_sibling : UINT32_MAX;
+                }
+            }
+            if (have && !matched) {
+                char want[24];
+                size_t cl = wl < sizeof(want) - 1 ? wl : sizeof(want) - 1;
+                if (cl > 0 && word != NULL) {
+                    memcpy(want, word, cl);
+                }
+                want[cl] = '\0';
+                yep_validate_emit(&j->v, YEPTRIS_DIAG_TYPE,
+                                  yep_validate_node_off(j->v.dom, inst_id), "expected %s, got %s",
+                                  want, it);
+            }
+        }
+    }
+
+    /* const / enum */
+    {
+        uint32_t cv;
+        if (kw_get(j, schema_id, "const", &cv) && cv != UINT32_MAX && snode(j, cv) != NULL) {
+            if (!yep_validate_node_equal(j->sd, cv, j->v.dom, inst_id, 0)) {
+                yep_validate_emit(&j->v, YEPTRIS_DIAG_CONST,
+                                  yep_validate_node_off(j->v.dom, inst_id),
+                                  "value is not the constant");
+            }
+        }
+        uint32_t ev;
+        if (kw_get(j, schema_id, "enum", &ev) && ev != UINT32_MAX) {
+            const yep_dnode* en = snode(j, ev);
+            if (en != NULL && en->kind == YEP_DOM_SEQUENCE) {
+                int found = 0;
+                uint32_t members = 0;
+                uint32_t ch = en->first_child;
+                while (ch != UINT32_MAX) {
+                    members++;
+                    if (!found && yep_validate_node_equal(j->sd, ch, j->v.dom, inst_id, 0)) {
+                        found = 1;
+                    }
+                    ch = snode(j, ch) ? snode(j, ch)->next_sibling : UINT32_MAX;
+                }
+                if (!found) {
+                    yep_validate_emit(&j->v, YEPTRIS_DIAG_ENUM,
+                                      yep_validate_node_off(j->v.dom, inst_id),
+                                      "value is not one of %u enum members", members);
+                }
+            }
+        }
+    }
+
+    /* the numeric bounds (ignored on non-numeric instances) */
+    {
+        double iv = 0;
+        int is_num = inst_number(j->v.dom, inst_id, &iv);
+        if (is_num) {
+            uint32_t mv;
+            if (kw_get(j, schema_id, "minimum", &mv) && mv != UINT32_MAX) {
+                double b;
+                if (schema_number(j, mv, &b) && iv < b) {
+                    yep_validate_emit(&j->v, YEPTRIS_DIAG_MINIMUM,
+                                      yep_validate_node_off(j->v.dom, inst_id),
+                                      "%g is less than the minimum %g", iv, b);
+                }
+            }
+            if (kw_get(j, schema_id, "maximum", &mv) && mv != UINT32_MAX) {
+                double b;
+                if (schema_number(j, mv, &b) && iv > b) {
+                    yep_validate_emit(&j->v, YEPTRIS_DIAG_MAXIMUM,
+                                      yep_validate_node_off(j->v.dom, inst_id),
+                                      "%g is greater than the maximum %g", iv, b);
+                }
+            }
+            if (kw_get(j, schema_id, "exclusiveMinimum", &mv) && mv != UINT32_MAX) {
+                double b;
+                if (schema_number(j, mv, &b) && iv <= b) {
+                    yep_validate_emit(&j->v, YEPTRIS_DIAG_EXCLUSIVE_MINIMUM,
+                                      yep_validate_node_off(j->v.dom, inst_id),
+                                      "%g is not greater than %g", iv, b);
+                }
+            }
+            if (kw_get(j, schema_id, "exclusiveMaximum", &mv) && mv != UINT32_MAX) {
+                double b;
+                if (schema_number(j, mv, &b) && iv >= b) {
+                    yep_validate_emit(&j->v, YEPTRIS_DIAG_EXCLUSIVE_MAXIMUM,
+                                      yep_validate_node_off(j->v.dom, inst_id),
+                                      "%g is not less than %g", iv, b);
+                }
+            }
+        }
+    }
+
+    /* string length + pattern (ignored on non-strings) */
+    {
+        uint32_t sl = 0;
+        int is_str = inst_str_len(j->v.dom, inst_id, &sl);
+        if (is_str) {
+            uint32_t mv;
+            if (kw_get(j, schema_id, "minLength", &mv) && mv != UINT32_MAX) {
+                double b;
+                if (schema_number(j, mv, &b) && (double)sl < b) {
+                    yep_validate_emit(&j->v, YEPTRIS_DIAG_MIN_LENGTH,
+                                      yep_validate_node_off(j->v.dom, inst_id),
+                                      "length %u is shorter than %g", sl, b);
+                }
+            }
+            if (kw_get(j, schema_id, "maxLength", &mv) && mv != UINT32_MAX) {
+                double b;
+                if (schema_number(j, mv, &b) && (double)sl > b) {
+                    yep_validate_emit(&j->v, YEPTRIS_DIAG_MAX_LENGTH,
+                                      yep_validate_node_off(j->v.dom, inst_id),
+                                      "length %u is longer than %g", sl, b);
+                }
+            }
+            uint32_t pv;
+            if (kw_get(j, schema_id, "pattern", &pv) && pv != UINT32_MAX) {
+                const char* pat = NULL;
+                uint32_t pl = 0;
+                if (schema_word(j, pv, &pat, &pl)) {
+                    const yep_dnode* n = yep_dom_node(j->v.dom, inst_id);
+                    yep_view v = yep_dom_view(j->v.dom, n->value);
+                    int rc = yep_re_search(pat, pl, v.p != NULL ? v.p : "", v.len);
+                    if (rc == 0) {
+                        yep_validate_emit(&j->v, YEPTRIS_DIAG_PATTERN,
+                                          yep_validate_node_off(j->v.dom, inst_id),
+                                          "does not match the pattern");
+                    }
+                    /* rc < 0: the pattern is outside the subset — ignored */
+                }
+            }
+        }
+    }
+
+    /* array bounds + uniqueness + items (ignored on non-arrays) */
+    {
+        uint32_t cnt = 0;
+        if (inst_seq_count(j->v.dom, inst_id, &cnt)) {
+            uint32_t mv;
+            if (kw_get(j, schema_id, "minItems", &mv) && mv != UINT32_MAX) {
+                double b;
+                if (schema_number(j, mv, &b) && (double)cnt < b) {
+                    yep_validate_emit(&j->v, YEPTRIS_DIAG_MIN_ITEMS,
+                                      yep_validate_node_off(j->v.dom, inst_id),
+                                      "%u items is fewer than %g", cnt, b);
+                }
+            }
+            if (kw_get(j, schema_id, "maxItems", &mv) && mv != UINT32_MAX) {
+                double b;
+                if (schema_number(j, mv, &b) && (double)cnt > b) {
+                    yep_validate_emit(&j->v, YEPTRIS_DIAG_MAX_ITEMS,
+                                      yep_validate_node_off(j->v.dom, inst_id),
+                                      "%u items is more than %g", cnt, b);
+                }
+            }
+            uint32_t uv;
+            int uf = 0;
+            if (kw_schema(j, schema_id, "uniqueItems", &uv, &uf) && uf == 0) {
+                check_unique(j, inst_id, yep_validate_node_off(j->v.dom, inst_id));
+            }
+            /* prefixItems: per-index schemas; the draft-07 array form
+             * of items rides the same semantics */
+            uint32_t prefix = 0;
+            uint32_t pv;
+            if (kw_get(j, schema_id, "prefixItems", &pv) && pv != UINT32_MAX) {
+                const yep_dnode* pn = snode(j, pv);
+                if (pn != NULL && pn->kind == YEP_DOM_SEQUENCE) {
+                    uint32_t i = 0;
+                    uint32_t ch = pn->first_child;
+                    uint32_t ich = yep_dom_node(j->v.dom, inst_id)->first_child;
+                    while (ch != UINT32_MAX && ich != UINT32_MAX) {
+                        uint32_t ns = snode(j, ch) ? snode(j, ch)->next_sibling : UINT32_MAX;
+                        uint32_t ni = yep_dom_node(j->v.dom, ich)
+                                          ? yep_dom_node(j->v.dom, ich)->next_sibling
+                                          : UINT32_MAX;
+                        size_t mark = j->v.path_len;
+                        if (yep_validate_path_push_index(&j->v, i) == 0) {
+                            js_apply(j, ch, ich, depth);
+                            yep_validate_path_pop(&j->v, mark);
+                        }
+                        prefix++;
+                        i++;
+                        ch = ns;
+                        ich = ni;
+                    }
+                }
+            }
+            /* items: a single schema over the remaining elements; the
+             * draft-07 array form counts as the prefix */
+            if (kw_get(j, schema_id, "items", &pv) && pv != UINT32_MAX) {
+                const yep_dnode* pn = snode(j, pv);
+                int is_false = 0;
+                if (pn != NULL && pn->kind == YEP_DOM_SEQUENCE) {
+                    /* the draft-07 tuple shim: per-index, from scratch */
+                    uint32_t i = 0;
+                    uint32_t ch = pn->first_child;
+                    uint32_t ich = yep_dom_node(j->v.dom, inst_id)->first_child;
+                    while (ch != UINT32_MAX && ich != UINT32_MAX) {
+                        uint32_t ns = snode(j, ch) ? snode(j, ch)->next_sibling : UINT32_MAX;
+                        uint32_t ni = yep_dom_node(j->v.dom, ich)
+                                          ? yep_dom_node(j->v.dom, ich)->next_sibling
+                                          : UINT32_MAX;
+                        size_t mark = j->v.path_len;
+                        if (yep_validate_path_push_index(&j->v, i) == 0) {
+                            js_apply(j, ch, ich, depth);
+                            yep_validate_path_pop(&j->v, mark);
+                        }
+                        i++;
+                        ch = ns;
+                        ich = ni;
+                    }
+                } else if (schema_truth(j, pv, &is_false)) {
+                    /* items applies from prefixItems' count on */
+                    uint32_t ich = yep_dom_node(j->v.dom, inst_id)->first_child;
+                    for (uint32_t skip = 0; skip < prefix && ich != UINT32_MAX; skip++) {
+                        ich = yep_dom_node(j->v.dom, ich)
+                                  ? yep_dom_node(j->v.dom, ich)->next_sibling
+                                  : UINT32_MAX;
+                    }
+                    for (uint32_t i = prefix; i < cnt && ich != UINT32_MAX; i++) {
+                        uint32_t ni = yep_dom_node(j->v.dom, ich)
+                                          ? yep_dom_node(j->v.dom, ich)->next_sibling
+                                          : UINT32_MAX;
+                        size_t mark = j->v.path_len;
+                        if (yep_validate_path_push_index(&j->v, i) == 0) {
+                            js_apply(j, pv, ich, depth);
+                            yep_validate_path_pop(&j->v, mark);
+                        }
+                        ich = ni;
+                    }
+                }
+            }
+        }
+    }
+
+    /* allOf / anyOf / oneOf / not */
+    {
+        uint32_t cv;
+        if (kw_get(j, schema_id, "allOf", &cv) && cv != UINT32_MAX) {
+            const yep_dnode* cn = snode(j, cv);
+            if (cn != NULL && cn->kind == YEP_DOM_SEQUENCE) {
+                uint32_t ch = cn->first_child;
+                while (ch != UINT32_MAX) {
+                    uint32_t nc = snode(j, ch) ? snode(j, ch)->next_sibling : UINT32_MAX;
+                    js_apply(j, ch, inst_id, depth);
+                    ch = nc;
+                }
+            }
+        }
+        if (kw_get(j, schema_id, "anyOf", &cv) && cv != UINT32_MAX) {
+            const yep_dnode* cn = snode(j, cv);
+            if (cn != NULL && cn->kind == YEP_DOM_SEQUENCE) {
+                int any = 0;
+                uint32_t branches = 0;
+                uint32_t ch = cn->first_child;
+                while (ch != UINT32_MAX) {
+                    branches++;
+                    if (!any && js_holds(j, ch, inst_id, depth)) {
+                        any = 1;
+                    }
+                    ch = snode(j, ch) ? snode(j, ch)->next_sibling : UINT32_MAX;
+                }
+                if (!any) {
+                    yep_validate_emit(&j->v, YEPTRIS_DIAG_ANY_OF,
+                                      yep_validate_node_off(j->v.dom, inst_id),
+                                      "none of the %u anyOf branches matched", branches);
+                }
+            }
+        }
+        if (kw_get(j, schema_id, "oneOf", &cv) && cv != UINT32_MAX) {
+            const yep_dnode* cn = snode(j, cv);
+            if (cn != NULL && cn->kind == YEP_DOM_SEQUENCE) {
+                uint32_t matches = 0;
+                uint32_t branches = 0;
+                uint32_t ch = cn->first_child;
+                while (ch != UINT32_MAX) {
+                    branches++;
+                    if (js_holds(j, ch, inst_id, depth)) {
+                        matches++;
+                    }
+                    ch = snode(j, ch) ? snode(j, ch)->next_sibling : UINT32_MAX;
+                }
+                if (matches != 1) {
+                    yep_validate_emit(&j->v, YEPTRIS_DIAG_ONE_OF,
+                                      yep_validate_node_off(j->v.dom, inst_id),
+                                      "%u of the %u oneOf branches matched (exactly one "
+                                      "required)",
+                                      matches, branches);
+                }
+            }
+        }
+        if (kw_get(j, schema_id, "not", &cv) && cv != UINT32_MAX) {
+            if (js_holds(j, cv, inst_id, depth)) {
+                yep_validate_emit(&j->v, YEPTRIS_DIAG_NOT, yep_validate_node_off(j->v.dom, inst_id),
+                                  "the not-schema matched");
+            }
+        }
+    }
+
+    /* the object keywords (ignored on non-objects) */
+    {
+        const yep_dnode* n = yep_dom_node(j->v.dom, inst_id);
+        if (n != NULL && n->kind == YEP_DOM_MAPPING) {
+            /* properties: known keys */
+            uint32_t props = UINT32_MAX;
+            int have_props = kw_get(j, schema_id, "properties", &props) && props != UINT32_MAX &&
+                             snode(j, props) != NULL && snode(j, props)->kind == YEP_DOM_MAPPING;
+            uint32_t req;
+            if (kw_get(j, schema_id, "required", &req) && req != UINT32_MAX) {
+                const yep_dnode* rn = snode(j, req);
+                if (rn != NULL && rn->kind == YEP_DOM_SEQUENCE) {
+                    uint32_t ch = rn->first_child;
+                    while (ch != UINT32_MAX) {
+                        const char* name = NULL;
+                        uint32_t nl = 0;
+                        uint32_t nc = snode(j, ch) ? snode(j, ch)->next_sibling : UINT32_MAX;
+                        if (schema_word(j, ch, &name, &nl)) {
+                            uint32_t hit = UINT32_MAX;
+                            uint32_t k = n->first_child;
+                            while (k != UINT32_MAX) {
+                                uint32_t v = yep_dom_node(j->v.dom, k)
+                                                 ? yep_dom_node(j->v.dom, k)->next_sibling
+                                                 : UINT32_MAX;
+                                const yep_dnode* kn = yep_dom_node(j->v.dom, k);
+                                if (kn != NULL && kn->kind == YEP_DOM_SCALAR) {
+                                    yep_view kv = yep_dom_view(j->v.dom, kn->value);
+                                    if (kv.len == nl && (nl == 0 || memcmp(kv.p, name, nl) == 0)) {
+                                        hit = v;
+                                        break;
+                                    }
+                                }
+                                k = v != UINT32_MAX && yep_dom_node(j->v.dom, v)
+                                        ? yep_dom_node(j->v.dom, v)->next_sibling
+                                        : UINT32_MAX;
+                            }
+                            if (hit == UINT32_MAX) {
+                                char namebuf[64];
+                                size_t cl = nl < sizeof(namebuf) - 1 ? nl : sizeof(namebuf) - 1;
+                                memcpy(namebuf, name, cl);
+                                namebuf[cl] = '\0';
+                                /* the diagnostic points at the missing
+                                 * leaf: object path + /key (the ajv
+                                 * instancePath convention) */
+                                size_t mark = j->v.path_len;
+                                int pushed = yep_validate_path_push(&j->v, namebuf, cl);
+                                yep_validate_emit(&j->v, YEPTRIS_DIAG_REQUIRED,
+                                                  yep_validate_node_off(j->v.dom, inst_id),
+                                                  "missing required property \"%s\"", namebuf);
+                                if (pushed == 0) {
+                                    yep_validate_path_pop(&j->v, mark);
+                                }
+                            }
+                        }
+                        ch = nc;
+                    }
+                }
+            }
+            /* properties walk (values through their schemas) */
+            if (have_props) {
+                const yep_dnode* pn = snode(j, props);
+                uint32_t k = pn->first_child;
+                while (k != UINT32_MAX) {
+                    uint32_t v = snode(j, k) ? snode(j, k)->next_sibling : UINT32_MAX;
+                    const yep_dnode* kn = snode(j, k);
+                    if (kn != NULL && kn->kind == YEP_DOM_SCALAR) {
+                        yep_view kv = yep_dom_view(j->sd, kn->value);
+                        /* find the child pair by key bytes */
+                        uint32_t ck = n->first_child;
+                        while (ck != UINT32_MAX) {
+                            uint32_t cv = yep_dom_node(j->v.dom, ck)
+                                              ? yep_dom_node(j->v.dom, ck)->next_sibling
+                                              : UINT32_MAX;
+                            const yep_dnode* ckn = yep_dom_node(j->v.dom, ck);
+                            if (ckn != NULL && ckn->kind == YEP_DOM_SCALAR) {
+                                yep_view ckv = yep_dom_view(j->v.dom, ckn->value);
+                                if (ckv.len == kv.len &&
+                                    (kv.len == 0 || memcmp(ckv.p, kv.p, kv.len) == 0)) {
+                                    size_t mark = j->v.path_len;
+                                    if (yep_validate_path_push(&j->v, kv.p != NULL ? kv.p : "",
+                                                               kv.len) == 0) {
+                                        js_apply(j, v, cv, depth);
+                                        yep_validate_path_pop(&j->v, mark);
+                                    }
+                                    break;
+                                }
+                            }
+                            ck = cv != UINT32_MAX && yep_dom_node(j->v.dom, cv)
+                                     ? yep_dom_node(j->v.dom, cv)->next_sibling
+                                     : UINT32_MAX;
+                        }
+                    }
+                    k = v != UINT32_MAX && snode(j, v) ? snode(j, v)->next_sibling : UINT32_MAX;
+                }
+            }
+            /* additionalProperties: the keys properties does not name */
+            uint32_t ap;
+            int af = 0;
+            if (kw_schema(j, schema_id, "additionalProperties", &ap, &af)) {
+                /* k steps pair-to-pair: every visited node IS a key */
+                uint32_t k = n->first_child;
+                while (k != UINT32_MAX) {
+                    uint32_t v = yep_dom_node(j->v.dom, k) ? yep_dom_node(j->v.dom, k)->next_sibling
+                                                           : UINT32_MAX;
+                    const yep_dnode* kn = yep_dom_node(j->v.dom, k);
+                    if (kn != NULL && kn->kind == YEP_DOM_SCALAR) {
+                        yep_view kv = yep_dom_view(j->v.dom, kn->value);
+                        int known = 0;
+                        if (have_props) {
+                            uint32_t pk = snode(j, props)->first_child;
+                            while (pk != UINT32_MAX && !known) {
+                                const yep_dnode* pkn = snode(j, pk);
+                                uint32_t pv =
+                                    snode(j, pk) ? snode(j, pk)->next_sibling : UINT32_MAX;
+                                if (pkn != NULL && pkn->kind == YEP_DOM_SCALAR) {
+                                    yep_view pw = yep_dom_view(j->sd, pkn->value);
+                                    known = pw.len == kv.len &&
+                                            (kv.len == 0 || memcmp(pw.p, kv.p, kv.len) == 0);
+                                }
+                                pk = pv != UINT32_MAX && snode(j, pv) ? snode(j, pv)->next_sibling
+                                                                      : UINT32_MAX;
+                            }
+                        }
+                        if (!known) {
+                            char namebuf[64];
+                            size_t cl = kv.len < sizeof(namebuf) - 1 ? kv.len : sizeof(namebuf) - 1;
+                            if (cl > 0 && kv.p != NULL) {
+                                memcpy(namebuf, kv.p, cl);
+                            }
+                            namebuf[cl] = '\0';
+                            if (af) {
+                                yep_validate_emit(&j->v, YEPTRIS_DIAG_ADDITIONAL_PROPERTY,
+                                                  yep_validate_node_off(j->v.dom, k),
+                                                  "additional property \"%s\"", namebuf);
+                            } else {
+                                size_t mark = j->v.path_len;
+                                if (yep_validate_path_push(&j->v, namebuf, cl) == 0) {
+                                    js_apply(j, ap, v, depth);
+                                    yep_validate_path_pop(&j->v, mark);
+                                }
+                            }
+                        }
+                    }
+                    k = v != UINT32_MAX && yep_dom_node(j->v.dom, v)
+                            ? yep_dom_node(j->v.dom, v)->next_sibling
+                            : UINT32_MAX;
+                }
+            }
+        }
+    }
+}
+
+/* ---- the entry ----------------------------------------------------------- */
+
+/* Validates one instance document root against the schema root.
+ * Returns 0 ok, -1 OOM. */
+static int js_validate_doc(js_ctx* j, uint32_t inst_root) {
+    js_apply(j, j->sroot, inst_root, 0);
+    return j->v.oom ? -1 : 0;
+}
+
+/* The public entry lives in validate.c (yeptris_json_schema_validate):
+ * it parses both sides, builds the report and drives this seam per
+ * document (the declaration is internal.h's — the shared SSOT). */
+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) {
+    js_ctx j;
+    memset(&j, 0, sizeof(j));
+    j.sd = schema_dom;
+    j.sroot = schema_root;
+    j.v.dom = instance_dom;
+    j.v.rep = rep;
+    j.v.input = instance_dom->input_base;
+    j.v.input_len = instance_dom->input_len;
+    for (uint32_t i = 0; i < doc_count; i++) {
+        j.v.path_len = 0;
+        js_validate_doc(&j, doc_roots[i]);
+        if (j.v.oom) {
+            yep_free(yep_system_allocator(), j.v.line_off);
+            yep_free(yep_system_allocator(), j.v.path);
+            return -1;
+        }
+    }
+    /* the walk's scratch (the lazy line index, the path buffer) dies
+     * here: the report carries only finished diagnostics */
+    yep_free(yep_system_allocator(), j.v.line_off);
+    yep_free(yep_system_allocator(), j.v.path);
+    return 0;
+}