ata-validator 0.1.0 → 0.4.0

package/src/ata.cpp

@@ -2,10 +2,17 @@
 
 #include <algorithm>
 #include <cmath>
-#include <regex>
+#include <re2/re2.h>
 #include <set>
 #include <unordered_map>
 
+#ifdef _WIN32
+#include <windows.h>
+#include <sysinfoapi.h>
+#else
+#include <unistd.h>
+#endif
+
 #include "simdjson.h"
 
 // --- Fast format validators (no std::regex) ---
@@ -133,6 +140,43 @@ namespace ata {
 
 using namespace simdjson;
 
+// Canonical JSON: sort object keys for semantic equality comparison
+static std::string canonical_json(dom::element el) {
+  switch (el.type()) {
+    case dom::element_type::OBJECT: {
+      dom::object obj; el.get(obj);
+      std::vector<std::pair<std::string_view, dom::element>> entries;
+      for (auto [k, v] : obj) entries.push_back({k, v});
+      std::sort(entries.begin(), entries.end(),
+                [](const auto& a, const auto& b) { return a.first < b.first; });
+      std::string r = "{";
+      for (size_t i = 0; i < entries.size(); ++i) {
+        if (i) r += ',';
+        r += '"';
+        r += entries[i].first;
+        r += "\":";
+        r += canonical_json(entries[i].second);
+      }
+      r += '}';
+      return r;
+    }
+    case dom::element_type::ARRAY: {
+      dom::array arr; el.get(arr);
+      std::string r = "[";
+      bool first = true;
+      for (auto v : arr) {
+        if (!first) r += ',';
+        first = false;
+        r += canonical_json(v);
+      }
+      r += ']';
+      return r;
+    }
+    default:
+      return std::string(minify(el));
+  }
+}
+
 // Forward declarations
 struct schema_node;
 using schema_node_ptr = std::shared_ptr<schema_node>;
@@ -153,7 +197,7 @@ struct schema_node {
   std::optional<uint64_t> min_length;
   std::optional<uint64_t> max_length;
   std::optional<std::string> pattern;
-  std::shared_ptr<std::regex> compiled_pattern;  // cached compiled regex
+  std::shared_ptr<re2::RE2> compiled_pattern;  // cached compiled regex (RE2)
 
   // array
   std::optional<uint64_t> min_items;
@@ -161,6 +205,9 @@ struct schema_node {
   bool unique_items = false;
   schema_node_ptr items_schema;
   std::vector<schema_node_ptr> prefix_items;
+  schema_node_ptr contains_schema;
+  std::optional<uint64_t> min_contains;
+  std::optional<uint64_t> max_contains;
 
   // object
   std::unordered_map<std::string, schema_node_ptr> properties;
@@ -169,9 +216,17 @@ struct schema_node {
   schema_node_ptr additional_properties_schema;
   std::optional<uint64_t> min_properties;
   std::optional<uint64_t> max_properties;
-
-  // patternProperties
-  std::vector<std::pair<std::string, schema_node_ptr>> pattern_properties;
+  schema_node_ptr property_names_schema;
+  std::unordered_map<std::string, std::vector<std::string>> dependent_required;
+  std::unordered_map<std::string, schema_node_ptr> dependent_schemas;
+
+  // patternProperties — each entry: (pattern_string, schema, compiled_regex)
+  struct pattern_prop {
+    std::string pattern;
+    schema_node_ptr schema;
+    std::shared_ptr<re2::RE2> compiled;
+  };
+  std::vector<pattern_prop> pattern_properties;
 
   // enum / const
   std::optional<std::string> enum_values_raw;  // raw JSON array string
@@ -195,16 +250,56 @@ struct schema_node {
   // $ref
   std::string ref;
 
+  // $defs — stored on node for pointer navigation
+  std::unordered_map<std::string, schema_node_ptr> defs;
+
   // boolean schema
   std::optional<bool> boolean_schema;
 };
 
+// --- Codegen: flat bytecode plan ---
+namespace cg {
+enum class op : uint8_t {
+  END=0, EXPECT_OBJECT, EXPECT_ARRAY, EXPECT_STRING, EXPECT_NUMBER,
+  EXPECT_INTEGER, EXPECT_BOOLEAN, EXPECT_NULL, EXPECT_TYPE_MULTI,
+  CHECK_MINIMUM, CHECK_MAXIMUM, CHECK_EX_MINIMUM, CHECK_EX_MAXIMUM,
+  CHECK_MULTIPLE_OF, CHECK_MIN_LENGTH, CHECK_MAX_LENGTH, CHECK_PATTERN,
+  CHECK_FORMAT, CHECK_MIN_ITEMS, CHECK_MAX_ITEMS, CHECK_UNIQUE_ITEMS,
+  ARRAY_ITEMS, CHECK_REQUIRED, CHECK_MIN_PROPS, CHECK_MAX_PROPS,
+  OBJ_PROPS_START, OBJ_PROP, OBJ_PROPS_END, CHECK_NO_ADDITIONAL,
+  CHECK_ENUM_STR, CHECK_ENUM, CHECK_CONST, COMPOSITION,
+};
+struct ins { op o; uint32_t a=0, b=0; };
+struct plan {
+  std::vector<ins> code;
+  std::vector<double> doubles;
+  std::vector<std::string> strings;
+  std::vector<std::shared_ptr<re2::RE2>> regexes;
+  std::vector<std::vector<std::string>> enum_sets;
+  std::vector<std::vector<std::string>> type_sets;
+  std::vector<uint8_t> format_ids;
+  std::vector<std::vector<ins>> subs;
+};
+}  // namespace cg
+
 struct compiled_schema {
   schema_node_ptr root;
   std::unordered_map<std::string, schema_node_ptr> defs;
   std::string raw_schema;
-  dom::parser parser;
-  dom::parser doc_parser;  // reusable parser for document validation
+  dom::parser parser;          // used only at compile time
+  cg::plan gen_plan;           // codegen validation plan
+  bool use_ondemand = false;   // true if codegen plan supports On Demand
+};
+
+// Thread-local persistent parsers — reused across all validate calls on the
+// same thread.  Keeps internal buffers hot in cache and avoids re-allocation.
+static dom::parser& tl_dom_parser() {
+  thread_local dom::parser p;
+  return p;
+}
+static simdjson::ondemand::parser& tl_od_parser() {
+  thread_local simdjson::ondemand::parser p;
+  return p;
 };
 
 // --- Schema compilation ---
@@ -218,7 +313,9 @@ static schema_node_ptr compile_node(dom::element el,
 
   // Boolean schema
   if (el.is<bool>()) {
-    node->boolean_schema = bool(el);
+    bool bval;
+    el.get(bval);
+    node->boolean_schema = bval;
     return node;
   }
 
@@ -226,7 +323,8 @@ static schema_node_ptr compile_node(dom::element el,
     return node;
   }
 
-  auto obj = dom::object(el);
+  dom::object obj;
+  el.get(obj);
 
   // $ref
   dom::element ref_el;
@@ -245,7 +343,7 @@ static schema_node_ptr compile_node(dom::element el,
       type_el.get(sv);
       node->types.emplace_back(sv);
     } else if (type_el.is<dom::array>()) {
-      for (auto t : dom::array(type_el)) {
+      dom::array type_arr; type_el.get(type_arr); for (auto t : type_arr) {
         std::string_view sv;
         if (t.get(sv) == SUCCESS) {
           node->types.emplace_back(sv);
@@ -291,11 +389,9 @@ static schema_node_ptr compile_node(dom::element el,
     std::string_view sv;
     if (str_el.get(sv) == SUCCESS) {
       node->pattern = std::string(sv);
-      try {
-        node->compiled_pattern =
-            std::make_shared<std::regex>(node->pattern.value());
-      } catch (...) {
-        // Invalid regex — leave compiled_pattern null
+      auto re = std::make_shared<re2::RE2>(node->pattern.value());
+      if (re->ok()) {
+        node->compiled_pattern = std::move(re);
       }
     }
   }
@@ -317,7 +413,7 @@ static schema_node_ptr compile_node(dom::element el,
   // prefixItems (Draft 2020-12)
   dom::element pi_el;
   if (obj["prefixItems"].get(pi_el) == SUCCESS && pi_el.is<dom::array>()) {
-    for (auto item : dom::array(pi_el)) {
+    dom::array pi_arr; pi_el.get(pi_arr); for (auto item : pi_arr) {
       node->prefix_items.push_back(compile_node(item, ctx));
     }
   }
@@ -327,17 +423,32 @@ static schema_node_ptr compile_node(dom::element el,
     node->items_schema = compile_node(items_el, ctx);
   }
 
+  // contains
+  dom::element contains_el;
+  if (obj["contains"].get(contains_el) == SUCCESS) {
+    node->contains_schema = compile_node(contains_el, ctx);
+  }
+  dom::element mc_el;
+  if (obj["minContains"].get(mc_el) == SUCCESS) {
+    uint64_t v;
+    if (mc_el.get(v) == SUCCESS) node->min_contains = v;
+  }
+  if (obj["maxContains"].get(mc_el) == SUCCESS) {
+    uint64_t v;
+    if (mc_el.get(v) == SUCCESS) node->max_contains = v;
+  }
+
   // object constraints
   dom::element props_el;
   if (obj["properties"].get(props_el) == SUCCESS && props_el.is<dom::object>()) {
-    for (auto [key, val] : dom::object(props_el)) {
+    dom::object props_obj; props_el.get(props_obj); for (auto [key, val] : props_obj) {
       node->properties[std::string(key)] = compile_node(val, ctx);
     }
   }
 
   dom::element req_el;
   if (obj["required"].get(req_el) == SUCCESS && req_el.is<dom::array>()) {
-    for (auto r : dom::array(req_el)) {
+    dom::array req_arr; req_el.get(req_arr); for (auto r : req_arr) {
       std::string_view sv;
       if (r.get(sv) == SUCCESS) {
         node->required.emplace_back(sv);
@@ -348,7 +459,7 @@ static schema_node_ptr compile_node(dom::element el,
   dom::element ap_el;
   if (obj["additionalProperties"].get(ap_el) == SUCCESS) {
     if (ap_el.is<bool>()) {
-      node->additional_properties_bool = bool(ap_el);
+      bool ap_bool; ap_el.get(ap_bool); node->additional_properties_bool = ap_bool;
     } else {
       node->additional_properties_schema = compile_node(ap_el, ctx);
     }
@@ -363,13 +474,51 @@ static schema_node_ptr compile_node(dom::element el,
     if (str_el.get(v) == SUCCESS) node->max_properties = v;
   }
 
-  // patternProperties
+  // propertyNames
+  dom::element pn_el;
+  if (obj["propertyNames"].get(pn_el) == SUCCESS) {
+    node->property_names_schema = compile_node(pn_el, ctx);
+  }
+
+  // dependentRequired
+  dom::element dr_el;
+  if (obj["dependentRequired"].get(dr_el) == SUCCESS &&
+      dr_el.is<dom::object>()) {
+    dom::object dr_obj; dr_el.get(dr_obj); for (auto [key, val] : dr_obj) {
+      std::vector<std::string> deps;
+      if (val.is<dom::array>()) {
+        dom::array val_arr; val.get(val_arr); for (auto d : val_arr) {
+          std::string_view sv;
+          if (d.get(sv) == SUCCESS) deps.emplace_back(sv);
+        }
+      }
+      node->dependent_required[std::string(key)] = std::move(deps);
+    }
+  }
+
+  // dependentSchemas
+  dom::element ds_el;
+  if (obj["dependentSchemas"].get(ds_el) == SUCCESS &&
+      ds_el.is<dom::object>()) {
+    dom::object ds_obj; ds_el.get(ds_obj); for (auto [key, val] : ds_obj) {
+      node->dependent_schemas[std::string(key)] = compile_node(val, ctx);
+    }
+  }
+
+  // patternProperties — compile regex at schema compile time
   dom::element pp_el;
   if (obj["patternProperties"].get(pp_el) == SUCCESS &&
       pp_el.is<dom::object>()) {
-    for (auto [key, val] : dom::object(pp_el)) {
-      node->pattern_properties.emplace_back(std::string(key),
-                                             compile_node(val, ctx));
+    dom::object pp_obj; pp_el.get(pp_obj);
+    for (auto [key, val] : pp_obj) {
+      schema_node::pattern_prop pp;
+      pp.pattern = std::string(key);
+      pp.schema = compile_node(val, ctx);
+      auto re = std::make_shared<re2::RE2>(pp.pattern);
+      if (re->ok()) {
+        pp.compiled = std::move(re);
+      }
+      node->pattern_properties.push_back(std::move(pp));
     }
   }
 
@@ -392,10 +541,10 @@ static schema_node_ptr compile_node(dom::element el,
   // enum — pre-minify each value at compile time
   dom::element enum_el;
   if (obj["enum"].get(enum_el) == SUCCESS) {
-    node->enum_values_raw = std::string(minify(enum_el));
+    node->enum_values_raw = canonical_json(enum_el);
     if (enum_el.is<dom::array>()) {
-      for (auto e : dom::array(enum_el)) {
-        node->enum_values_minified.push_back(std::string(minify(e)));
+      dom::array enum_arr; enum_el.get(enum_arr); for (auto e : enum_arr) {
+        node->enum_values_minified.push_back(canonical_json(e));
       }
     }
   }
@@ -403,23 +552,26 @@ static schema_node_ptr compile_node(dom::element el,
   // const
   dom::element const_el;
   if (obj["const"].get(const_el) == SUCCESS) {
-    node->const_value_raw = std::string(minify(const_el));
+    node->const_value_raw = canonical_json(const_el);
   }
 
   // composition
   dom::element comp_el;
   if (obj["allOf"].get(comp_el) == SUCCESS && comp_el.is<dom::array>()) {
-    for (auto s : dom::array(comp_el)) {
+    dom::array comp_arr; comp_el.get(comp_arr);
+    for (auto s : comp_arr) {
       node->all_of.push_back(compile_node(s, ctx));
     }
   }
   if (obj["anyOf"].get(comp_el) == SUCCESS && comp_el.is<dom::array>()) {
-    for (auto s : dom::array(comp_el)) {
+    dom::array comp_arr2; comp_el.get(comp_arr2);
+    for (auto s : comp_arr2) {
       node->any_of.push_back(compile_node(s, ctx));
     }
   }
   if (obj["oneOf"].get(comp_el) == SUCCESS && comp_el.is<dom::array>()) {
-    for (auto s : dom::array(comp_el)) {
+    dom::array comp_arr3; comp_el.get(comp_arr3);
+    for (auto s : comp_arr3) {
       node->one_of.push_back(compile_node(s, ctx));
     }
   }
@@ -445,16 +597,20 @@ static schema_node_ptr compile_node(dom::element el,
   // $defs / definitions
   dom::element defs_el;
   if (obj["$defs"].get(defs_el) == SUCCESS && defs_el.is<dom::object>()) {
-    for (auto [key, val] : dom::object(defs_el)) {
+    dom::object defs_obj; defs_el.get(defs_obj); for (auto [key, val] : defs_obj) {
       std::string def_path = "#/$defs/" + std::string(key);
-      ctx.defs[def_path] = compile_node(val, ctx);
+      auto compiled = compile_node(val, ctx);
+      ctx.defs[def_path] = compiled;
+      node->defs[std::string(key)] = compiled;
     }
   }
   if (obj["definitions"].get(defs_el) == SUCCESS &&
       defs_el.is<dom::object>()) {
-    for (auto [key, val] : dom::object(defs_el)) {
+    dom::object defs_obj; defs_el.get(defs_obj); for (auto [key, val] : defs_obj) {
       std::string def_path = "#/definitions/" + std::string(key);
-      ctx.defs[def_path] = compile_node(val, ctx);
+      auto compiled = compile_node(val, ctx);
+      ctx.defs[def_path] = compiled;
+      node->defs[std::string(key)] = compiled;
     }
   }
 
@@ -538,79 +694,106 @@ static void validate_node(const schema_node_ptr& node,
     return;
   }
 
-  // $ref
+  // $ref — Draft 2020-12: $ref is not a short-circuit, sibling keywords still apply
+  bool ref_resolved = false;
   if (!node->ref.empty()) {
     // First check defs map
     auto it = ctx.defs.find(node->ref);
     if (it != ctx.defs.end()) {
       validate_node(it->second, value, path, ctx, errors, all_errors);
-      return;
+      ref_resolved = true;
     }
     // Try JSON Pointer resolution from root (e.g., "#/properties/foo")
     if (node->ref.size() > 1 && node->ref[0] == '#' &&
         node->ref[1] == '/') {
-      // Walk the schema tree following the pointer
-      std::string pointer = node->ref.substr(2);
-      schema_node_ptr current = ctx.root;
-      bool resolved = true;
-      size_t pos = 0;
-      while (pos < pointer.size() && current) {
-        size_t next = pointer.find('/', pos);
-        std::string segment =
-            pointer.substr(pos, next == std::string::npos ? next : next - pos);
-        // Unescape JSON Pointer: ~1 -> /, ~0 -> ~
-        std::string key;
-        for (size_t i = 0; i < segment.size(); ++i) {
-          if (segment[i] == '~' && i + 1 < segment.size()) {
-            if (segment[i + 1] == '1') { key += '/'; ++i; }
-            else if (segment[i + 1] == '0') { key += '~'; ++i; }
-            else key += segment[i];
+      // Decode JSON Pointer segments
+      auto decode_pointer_segment = [](const std::string& seg) -> std::string {
+        // Percent-decode first
+        std::string pct;
+        for (size_t i = 0; i < seg.size(); ++i) {
+          if (seg[i] == '%' && i + 2 < seg.size()) {
+            char h = seg[i+1], l = seg[i+2];
+            auto hex = [](char c) -> int {
+              if (c >= '0' && c <= '9') return c - '0';
+              if (c >= 'a' && c <= 'f') return 10 + c - 'a';
+              if (c >= 'A' && c <= 'F') return 10 + c - 'A';
+              return -1;
+            };
+            int hv = hex(h), lv = hex(l);
+            if (hv >= 0 && lv >= 0) {
+              pct += static_cast<char>(hv * 16 + lv);
+              i += 2;
+            } else {
+              pct += seg[i];
+            }
           } else {
-            key += segment[i];
+            pct += seg[i];
           }
         }
-        // Navigate the compiled schema tree
-        if (key == "properties" && !current->properties.empty()) {
-          // Next segment is the property name
-          pos = (next == std::string::npos) ? pointer.size() : next + 1;
-          next = pointer.find('/', pos);
-          std::string prop_name = pointer.substr(
-              pos, next == std::string::npos ? next : next - pos);
+        // Then JSON Pointer unescape: ~1 -> /, ~0 -> ~
+        std::string out;
+        for (size_t i = 0; i < pct.size(); ++i) {
+          if (pct[i] == '~' && i + 1 < pct.size()) {
+            if (pct[i + 1] == '1') { out += '/'; ++i; }
+            else if (pct[i + 1] == '0') { out += '~'; ++i; }
+            else out += pct[i];
+          } else {
+            out += pct[i];
+          }
+        }
+        return out;
+      };
+
+      // Split pointer into segments
+      std::string pointer = node->ref.substr(2);
+      std::vector<std::string> segments;
+      size_t spos = 0;
+      while (spos < pointer.size()) {
+        size_t snext = pointer.find('/', spos);
+        segments.push_back(decode_pointer_segment(
+            pointer.substr(spos, snext == std::string::npos ? snext : snext - spos)));
+        spos = (snext == std::string::npos) ? pointer.size() : snext + 1;
+      }
+
+      // Walk the schema tree
+      schema_node_ptr current = ctx.root;
+      bool resolved = true;
+      for (size_t si = 0; si < segments.size() && current; ++si) {
+        const auto& key = segments[si];
+
+        if (key == "properties" && si + 1 < segments.size()) {
+          const auto& prop_name = segments[++si];
           auto pit = current->properties.find(prop_name);
           if (pit != current->properties.end()) {
             current = pit->second;
-          } else {
-            resolved = false; break;
-          }
+          } else { resolved = false; break; }
         } else if (key == "items" && current->items_schema) {
           current = current->items_schema;
         } else if (key == "$defs" || key == "definitions") {
-          // Next segment is the def name — already in ctx.defs
-          pos = (next == std::string::npos) ? pointer.size() : next + 1;
-          next = pointer.find('/', pos);
-          std::string def_name = pointer.substr(
-              pos, next == std::string::npos ? next : next - pos);
-          std::string full_ref = "#/" + key + "/" + def_name;
-          auto dit = ctx.defs.find(full_ref);
-          if (dit != ctx.defs.end()) {
-            current = dit->second;
-          } else {
-            resolved = false; break;
-          }
+          if (si + 1 < segments.size()) {
+            const auto& def_name = segments[++si];
+            // Navigate into node's defs map
+            auto dit = current->defs.find(def_name);
+            if (dit != current->defs.end()) {
+              current = dit->second;
+            } else {
+              // Fallback: try ctx.defs with full path
+              std::string full_ref = "#/" + key + "/" + def_name;
+              auto cit = ctx.defs.find(full_ref);
+              if (cit != ctx.defs.end()) {
+                current = cit->second;
+              } else { resolved = false; break; }
+            }
+          } else { resolved = false; break; }
         } else if (key == "allOf" || key == "anyOf" || key == "oneOf") {
-          pos = (next == std::string::npos) ? pointer.size() : next + 1;
-          next = pointer.find('/', pos);
-          std::string idx_str = pointer.substr(
-              pos, next == std::string::npos ? next : next - pos);
-          size_t idx = std::stoul(idx_str);
-          auto& vec = (key == "allOf") ? current->all_of
-                    : (key == "anyOf") ? current->any_of
-                    : current->one_of;
-          if (idx < vec.size()) {
-            current = vec[idx];
-          } else {
-            resolved = false; break;
-          }
+          if (si + 1 < segments.size()) {
+            size_t idx = std::stoul(segments[++si]);
+            auto& vec = (key == "allOf") ? current->all_of
+                      : (key == "anyOf") ? current->any_of
+                      : current->one_of;
+            if (idx < vec.size()) { current = vec[idx]; }
+            else { resolved = false; break; }
+          } else { resolved = false; break; }
         } else if (key == "not" && current->not_schema) {
           current = current->not_schema;
         } else if (key == "if" && current->if_schema) {
@@ -623,34 +806,29 @@ static void validate_node(const schema_node_ptr& node,
                    current->additional_properties_schema) {
           current = current->additional_properties_schema;
         } else if (key == "prefixItems") {
-          pos = (next == std::string::npos) ? pointer.size() : next + 1;
-          next = pointer.find('/', pos);
-          std::string idx_str = pointer.substr(
-              pos, next == std::string::npos ? next : next - pos);
-          size_t idx = std::stoul(idx_str);
-          if (idx < current->prefix_items.size()) {
-            current = current->prefix_items[idx];
-          } else {
-            resolved = false; break;
-          }
+          if (si + 1 < segments.size()) {
+            size_t idx = std::stoul(segments[++si]);
+            if (idx < current->prefix_items.size()) { current = current->prefix_items[idx]; }
+            else { resolved = false; break; }
+          } else { resolved = false; break; }
         } else {
           resolved = false; break;
         }
-        pos = (next == std::string::npos) ? pointer.size() : next + 1;
       }
       if (resolved && current) {
         validate_node(current, value, path, ctx, errors, all_errors);
-        return;
+        ref_resolved = true;
       }
     }
     // Self-reference: "#"
-    if (node->ref == "#" && ctx.root) {
+    if (!ref_resolved && node->ref == "#" && ctx.root) {
       validate_node(ctx.root, value, path, ctx, errors, all_errors);
-      return;
+      ref_resolved = true;
+    }
+    if (!ref_resolved) {
+      errors.push_back({error_code::ref_not_found, path,
+                        "cannot resolve $ref: " + node->ref});
     }
-    errors.push_back({error_code::ref_not_found, path,
-                      "cannot resolve $ref: " + node->ref});
-    return;
   }
 
   // type
@@ -676,7 +854,7 @@ static void validate_node(const schema_node_ptr& node,
 
   // enum — use pre-minified values (no re-parsing)
   if (!node->enum_values_minified.empty()) {
-    std::string val_str = std::string(minify(value));
+    std::string val_str = canonical_json(value);
     bool found = false;
     for (const auto& ev : node->enum_values_minified) {
       if (ev == val_str) {
@@ -692,7 +870,7 @@ static void validate_node(const schema_node_ptr& node,
 
   // const
   if (node->const_value_raw.has_value()) {
-    std::string val_str = std::string(minify(value));
+    std::string val_str = canonical_json(value);
     if (val_str != node->const_value_raw.value()) {
       errors.push_back({error_code::const_mismatch, path,
                         "value does not match const"});
@@ -758,7 +936,7 @@ static void validate_node(const schema_node_ptr& node,
                             std::to_string(node->max_length.value())});
     }
     if (node->compiled_pattern) {
-      if (!std::regex_search(sv.begin(), sv.end(), *node->compiled_pattern)) {
+      if (!re2::RE2::PartialMatch(re2::StringPiece(sv.data(), sv.size()), *node->compiled_pattern)) {
         errors.push_back({error_code::pattern_mismatch, path,
                           "string does not match pattern: " +
                               node->pattern.value()});
@@ -776,7 +954,7 @@ static void validate_node(const schema_node_ptr& node,
 
   // Array validations
   if (actual_type == "array" && value.is<dom::array>()) {
-    auto arr = dom::array(value);
+    dom::array arr; value.get(arr);
     uint64_t arr_size = 0;
     for ([[maybe_unused]] auto _ : arr) ++arr_size;
 
@@ -797,7 +975,7 @@ static void validate_node(const schema_node_ptr& node,
       std::set<std::string> seen;
       bool has_dup = false;
       for (auto item : arr) {
-        auto s = std::string(minify(item));
+        auto s = canonical_json(item);
         if (!seen.insert(s).second) {
           has_dup = true;
           break;
@@ -815,19 +993,41 @@ static void validate_node(const schema_node_ptr& node,
       for (auto item : arr) {
         if (idx < node->prefix_items.size()) {
           validate_node(node->prefix_items[idx], item,
-                        path + "/" + std::to_string(idx), ctx, errors);
+                        path + "/" + std::to_string(idx), ctx, errors, all_errors);
         } else if (node->items_schema) {
           validate_node(node->items_schema, item,
-                        path + "/" + std::to_string(idx), ctx, errors);
+                        path + "/" + std::to_string(idx), ctx, errors, all_errors);
         }
         ++idx;
       }
     }
+
+    // contains / minContains / maxContains
+    if (node->contains_schema) {
+      uint64_t match_count = 0;
+      for (auto item : arr) {
+        std::vector<validation_error> tmp;
+        validate_node(node->contains_schema, item, path, ctx, tmp, false);
+        if (tmp.empty()) ++match_count;
+      }
+      uint64_t min_c = node->min_contains.value_or(1);
+      uint64_t max_c = node->max_contains.value_or(arr_size);
+      if (match_count < min_c) {
+        errors.push_back({error_code::min_items_violation, path,
+                          "contains: " + std::to_string(match_count) +
+                              " matches, minimum " + std::to_string(min_c)});
+      }
+      if (match_count > max_c) {
+        errors.push_back({error_code::max_items_violation, path,
+                          "contains: " + std::to_string(match_count) +
+                              " matches, maximum " + std::to_string(max_c)});
+      }
+    }
   }
 
   // Object validations
   if (actual_type == "object" && value.is<dom::object>()) {
-    auto obj = dom::object(value);
+    dom::object obj; value.get(obj);
     uint64_t prop_count = 0;
     for ([[maybe_unused]] auto _ : obj) ++prop_count;
 
@@ -867,15 +1067,11 @@ static void validate_node(const schema_node_ptr& node,
         matched = true;
       }
 
-      // Check patternProperties
-      for (const auto& [pat, pat_schema] : node->pattern_properties) {
-        try {
-          std::regex re(pat);
-          if (std::regex_search(key_str, re)) {
-            validate_node(pat_schema, val, path + "/" + key_str, ctx, errors, all_errors);
-            matched = true;
-          }
-        } catch (...) {
+      // Check patternProperties (use cached compiled regex)
+      for (const auto& pp : node->pattern_properties) {
+        if (pp.compiled && re2::RE2::PartialMatch(key_str, *pp.compiled)) {
+          validate_node(pp.schema, val, path + "/" + key_str, ctx, errors, all_errors);
+          matched = true;
         }
       }
 
@@ -892,6 +1088,43 @@ static void validate_node(const schema_node_ptr& node,
         }
       }
     }
+
+    // propertyNames
+    if (node->property_names_schema) {
+      for (auto [key, val] : obj) {
+        // Create a string element to validate the key
+        std::string key_json = "\"" + std::string(key) + "\"";
+        dom::parser key_parser;
+        auto key_result = key_parser.parse(key_json);
+        if (!key_result.error()) {
+          validate_node(node->property_names_schema, key_result.value(),
+                        path, ctx, errors, all_errors);
+        }
+      }
+    }
+
+    // dependentRequired
+    for (const auto& [prop, deps] : node->dependent_required) {
+      dom::element dummy;
+      if (obj[prop].get(dummy) == SUCCESS) {
+        for (const auto& dep : deps) {
+          dom::element dep_dummy;
+          if (obj[dep].get(dep_dummy) != SUCCESS) {
+            errors.push_back({error_code::required_property_missing, path,
+                              "property '" + prop + "' requires '" + dep +
+                                  "' to be present"});
+          }
+        }
+      }
+    }
+
+    // dependentSchemas
+    for (const auto& [prop, schema] : node->dependent_schemas) {
+      dom::element dummy;
+      if (obj[prop].get(dummy) == SUCCESS) {
+        validate_node(schema, value, path, ctx, errors, all_errors);
+      }
+    }
   }
 
   // allOf
@@ -967,6 +1200,369 @@ static void validate_node(const schema_node_ptr& node,
   }
 }
 
+// --- Codegen compiler ---
+static void cg_compile(const schema_node* n, cg::plan& p,
+                        std::vector<cg::ins>& out) {
+  if (!n) return;
+  if (n->boolean_schema.has_value()) {
+    if (!*n->boolean_schema) out.push_back({cg::op::EXPECT_NULL});
+    return;
+  }
+  // Composition fallback
+  if (!n->ref.empty() || !n->all_of.empty() || !n->any_of.empty() ||
+      !n->one_of.empty() || n->not_schema || n->if_schema) {
+    uintptr_t ptr = reinterpret_cast<uintptr_t>(n);
+    out.push_back({cg::op::COMPOSITION, (uint32_t)(ptr & 0xFFFFFFFF),
+                   (uint32_t)((ptr >> 32) & 0xFFFFFFFF)});
+    return;
+  }
+  // Type
+  if (!n->types.empty()) {
+    if (n->types.size() == 1) {
+      auto& t = n->types[0];
+      if (t=="object") out.push_back({cg::op::EXPECT_OBJECT});
+      else if (t=="array") out.push_back({cg::op::EXPECT_ARRAY});
+      else if (t=="string") out.push_back({cg::op::EXPECT_STRING});
+      else if (t=="number") out.push_back({cg::op::EXPECT_NUMBER});
+      else if (t=="integer") out.push_back({cg::op::EXPECT_INTEGER});
+      else if (t=="boolean") out.push_back({cg::op::EXPECT_BOOLEAN});
+      else if (t=="null") out.push_back({cg::op::EXPECT_NULL});
+    } else {
+      uint32_t i = (uint32_t)p.type_sets.size();
+      p.type_sets.push_back(n->types);
+      out.push_back({cg::op::EXPECT_TYPE_MULTI, i});
+    }
+  }
+  // Enum
+  if (!n->enum_values_minified.empty()) {
+    bool all_str = true;
+    for (auto& e : n->enum_values_minified)
+      if (e.empty() || e[0]!='"') { all_str=false; break; }
+    uint32_t i = (uint32_t)p.enum_sets.size();
+    p.enum_sets.push_back(n->enum_values_minified);
+    out.push_back({all_str ? cg::op::CHECK_ENUM_STR : cg::op::CHECK_ENUM, i});
+  }
+  if (n->const_value_raw.has_value()) {
+    uint32_t i=(uint32_t)p.strings.size();
+    p.strings.push_back(*n->const_value_raw);
+    out.push_back({cg::op::CHECK_CONST, i});
+  }
+  // Numeric
+  if (n->minimum.has_value()) { uint32_t i=(uint32_t)p.doubles.size(); p.doubles.push_back(*n->minimum); out.push_back({cg::op::CHECK_MINIMUM,i}); }
+  if (n->maximum.has_value()) { uint32_t i=(uint32_t)p.doubles.size(); p.doubles.push_back(*n->maximum); out.push_back({cg::op::CHECK_MAXIMUM,i}); }
+  if (n->exclusive_minimum.has_value()) { uint32_t i=(uint32_t)p.doubles.size(); p.doubles.push_back(*n->exclusive_minimum); out.push_back({cg::op::CHECK_EX_MINIMUM,i}); }
+  if (n->exclusive_maximum.has_value()) { uint32_t i=(uint32_t)p.doubles.size(); p.doubles.push_back(*n->exclusive_maximum); out.push_back({cg::op::CHECK_EX_MAXIMUM,i}); }
+  if (n->multiple_of.has_value()) { uint32_t i=(uint32_t)p.doubles.size(); p.doubles.push_back(*n->multiple_of); out.push_back({cg::op::CHECK_MULTIPLE_OF,i}); }
+  // String
+  if (n->min_length.has_value()) out.push_back({cg::op::CHECK_MIN_LENGTH,(uint32_t)*n->min_length});
+  if (n->max_length.has_value()) out.push_back({cg::op::CHECK_MAX_LENGTH,(uint32_t)*n->max_length});
+  if (n->compiled_pattern) { uint32_t i=(uint32_t)p.regexes.size(); p.regexes.push_back(n->compiled_pattern); out.push_back({cg::op::CHECK_PATTERN,i}); }
+  if (n->format.has_value()) {
+    uint32_t i=(uint32_t)p.format_ids.size();
+    uint8_t fid=255;
+    auto& f=*n->format;
+    if(f=="email")fid=0;else if(f=="date")fid=1;else if(f=="date-time")fid=2;
+    else if(f=="time")fid=3;else if(f=="ipv4")fid=4;else if(f=="ipv6")fid=5;
+    else if(f=="uri"||f=="uri-reference")fid=6;else if(f=="uuid")fid=7;
+    else if(f=="hostname")fid=8;
+    p.format_ids.push_back(fid);
+    out.push_back({cg::op::CHECK_FORMAT,i});
+  }
+  // Array
+  if (n->min_items.has_value()) out.push_back({cg::op::CHECK_MIN_ITEMS,(uint32_t)*n->min_items});
+  if (n->max_items.has_value()) out.push_back({cg::op::CHECK_MAX_ITEMS,(uint32_t)*n->max_items});
+  if (n->unique_items) out.push_back({cg::op::CHECK_UNIQUE_ITEMS});
+  if (n->items_schema) {
+    uint32_t si=(uint32_t)p.subs.size();
+    p.subs.emplace_back();
+    std::vector<cg::ins> sub_code;
+    cg_compile(n->items_schema.get(), p, sub_code);
+    sub_code.push_back({cg::op::END});
+    p.subs[si] = std::move(sub_code);
+    out.push_back({cg::op::ARRAY_ITEMS, si});
+  }
+  // Object
+  for (auto& r : n->required) { uint32_t i=(uint32_t)p.strings.size(); p.strings.push_back(r); out.push_back({cg::op::CHECK_REQUIRED,i}); }
+  if (n->min_properties.has_value()) out.push_back({cg::op::CHECK_MIN_PROPS,(uint32_t)*n->min_properties});
+  if (n->max_properties.has_value()) out.push_back({cg::op::CHECK_MAX_PROPS,(uint32_t)*n->max_properties});
+  // additional_properties_schema requires tree walker — bail out to COMPOSITION
+  if (n->additional_properties_schema) {
+    out.push_back({cg::op::COMPOSITION, 0, 0});
+    return;
+  }
+  if (!n->properties.empty() || (n->additional_properties_bool.has_value() && !*n->additional_properties_bool)) {
+    out.push_back({cg::op::OBJ_PROPS_START});
+    if (n->additional_properties_bool.has_value() && !*n->additional_properties_bool)
+      out.push_back({cg::op::CHECK_NO_ADDITIONAL});
+    for (auto& [name, schema] : n->properties) {
+      uint32_t ni=(uint32_t)p.strings.size(); p.strings.push_back(name);
+      uint32_t si=(uint32_t)p.subs.size();
+      p.subs.emplace_back();
+      std::vector<cg::ins> sub_code;
+      cg_compile(schema.get(), p, sub_code);
+      sub_code.push_back({cg::op::END});
+      p.subs[si] = std::move(sub_code);
+      out.push_back({cg::op::OBJ_PROP, ni, si});
+    }
+    out.push_back({cg::op::OBJ_PROPS_END});
+  }
+}
+
+// --- Codegen executor ---
+static const char* fmt_names[]={"email","date","date-time","time","ipv4","ipv6","uri","uuid","hostname"};
+
+static bool cg_exec(const cg::plan& p, const std::vector<cg::ins>& code,
+                     dom::element value) {
+  auto t = type_of_sv(value);
+  for (size_t i=0; i<code.size(); ++i) {
+    auto& c = code[i];
+    switch(c.o) {
+    case cg::op::END: return true;
+    case cg::op::EXPECT_OBJECT: if(t!="object") return false; break;
+    case cg::op::EXPECT_ARRAY: if(t!="array") return false; break;
+    case cg::op::EXPECT_STRING: if(t!="string") return false; break;
+    case cg::op::EXPECT_NUMBER: if(t!="number"&&t!="integer") return false; break;
+    case cg::op::EXPECT_INTEGER: if(t!="integer") return false; break;
+    case cg::op::EXPECT_BOOLEAN: if(t!="boolean") return false; break;
+    case cg::op::EXPECT_NULL: if(t!="null") return false; break;
+    case cg::op::EXPECT_TYPE_MULTI: {
+      auto& ts=p.type_sets[c.a]; bool m=false;
+      for(auto& ty:ts){if(t==ty||(ty=="number"&&(t=="integer"||t=="number"))){m=true;break;}}
+      if(!m) return false; break;
+    }
+    case cg::op::CHECK_MINIMUM: if(t=="integer"||t=="number"){if(to_double(value)<p.doubles[c.a])return false;} break;
+    case cg::op::CHECK_MAXIMUM: if(t=="integer"||t=="number"){if(to_double(value)>p.doubles[c.a])return false;} break;
+    case cg::op::CHECK_EX_MINIMUM: if(t=="integer"||t=="number"){if(to_double(value)<=p.doubles[c.a])return false;} break;
+    case cg::op::CHECK_EX_MAXIMUM: if(t=="integer"||t=="number"){if(to_double(value)>=p.doubles[c.a])return false;} break;
+    case cg::op::CHECK_MULTIPLE_OF: if(t=="integer"||t=="number"){double v=to_double(value),d=p.doubles[c.a],r=std::fmod(v,d);if(std::abs(r)>1e-8&&std::abs(r-d)>1e-8)return false;} break;
+    case cg::op::CHECK_MIN_LENGTH: if(t=="string"){std::string_view sv;value.get(sv);if(utf8_length(sv)<c.a)return false;} break;
+    case cg::op::CHECK_MAX_LENGTH: if(t=="string"){std::string_view sv;value.get(sv);if(utf8_length(sv)>c.a)return false;} break;
+    case cg::op::CHECK_PATTERN: if(t=="string"){std::string_view sv;value.get(sv);if(!re2::RE2::PartialMatch(re2::StringPiece(sv.data(),sv.size()),*p.regexes[c.a]))return false;} break;
+    case cg::op::CHECK_FORMAT: if(t=="string"){std::string_view sv;value.get(sv);uint8_t f=p.format_ids[c.a];if(f<9&&!check_format(sv,fmt_names[f]))return false;} break;
+    case cg::op::CHECK_MIN_ITEMS: if(t=="array"){dom::array a;value.get(a);uint64_t s=0;for([[maybe_unused]]auto _:a)++s;if(s<c.a)return false;} break;
+    case cg::op::CHECK_MAX_ITEMS: if(t=="array"){dom::array a;value.get(a);uint64_t s=0;for([[maybe_unused]]auto _:a)++s;if(s>c.a)return false;} break;
+    case cg::op::CHECK_UNIQUE_ITEMS: if(t=="array"){dom::array a;value.get(a);std::set<std::string> seen;for(auto x:a)if(!seen.insert(canonical_json(x)).second)return false;} break;
+    case cg::op::ARRAY_ITEMS: if(t=="array"){dom::array a;value.get(a);for(auto x:a)if(!cg_exec(p,p.subs[c.a],x))return false;} break;
+    case cg::op::CHECK_REQUIRED: if(t=="object"){dom::object o;value.get(o);dom::element d;if(o[p.strings[c.a]].get(d)!=SUCCESS)return false;} break;
+    case cg::op::CHECK_MIN_PROPS: if(t=="object"){dom::object o;value.get(o);uint64_t n=0;for([[maybe_unused]]auto _:o)++n;if(n<c.a)return false;} break;
+    case cg::op::CHECK_MAX_PROPS: if(t=="object"){dom::object o;value.get(o);uint64_t n=0;for([[maybe_unused]]auto _:o)++n;if(n>c.a)return false;} break;
+    case cg::op::OBJ_PROPS_START: if(t=="object"){
+      dom::object o; value.get(o);
+      // collect prop defs
+      struct pd{std::string_view nm;uint32_t si;};
+      std::vector<pd> props; bool no_add=false;
+      size_t j=i+1;
+      for(;j<code.size()&&code[j].o!=cg::op::OBJ_PROPS_END;++j){
+        if(code[j].o==cg::op::OBJ_PROP) props.push_back({p.strings[code[j].a],code[j].b});
+        else if(code[j].o==cg::op::CHECK_NO_ADDITIONAL) no_add=true;
+      }
+      for(auto [key,val]:o){
+        bool matched=false;
+        for(auto& pp:props){if(key==pp.nm){if(!cg_exec(p,p.subs[pp.si],val))return false;matched=true;break;}}
+        if(!matched&&no_add)return false;
+      }
+      i=j; break;
+    } else { /* skip to OBJ_PROPS_END */ size_t j=i+1; for(;j<code.size()&&code[j].o!=cg::op::OBJ_PROPS_END;++j); i=j; } break;
+    case cg::op::OBJ_PROP: case cg::op::OBJ_PROPS_END: case cg::op::CHECK_NO_ADDITIONAL: break;
+    case cg::op::CHECK_ENUM_STR: {
+      auto& es=p.enum_sets[c.a]; bool f=false;
+      if(t=="string"){std::string_view sv;value.get(sv);for(auto& e:es)if(e.size()==sv.size()+2&&e[0]=='"'&&e.back()=='"'&&e.compare(1,sv.size(),sv)==0){f=true;break;}}
+      if(!f){std::string v=canonical_json(value);for(auto& e:es)if(e==v){f=true;break;}}
+      if(!f)return false; break;
+    }
+    case cg::op::CHECK_ENUM: {
+      auto& es=p.enum_sets[c.a]; bool f=false;
+      if(t=="string"){std::string_view sv;value.get(sv);for(auto& e:es)if(e.size()==sv.size()+2&&e[0]=='"'&&e.back()=='"'&&e.compare(1,sv.size(),sv)==0){f=true;break;}}
+      if(!f&&value.is<int64_t>()){int64_t v;value.get(v);auto s=std::to_string(v);for(auto& e:es)if(e==s){f=true;break;}}
+      if(!f){std::string v=canonical_json(value);for(auto& e:es)if(e==v){f=true;break;}}
+      if(!f)return false; break;
+    }
+    case cg::op::CHECK_CONST: if(canonical_json(value)!=p.strings[c.a])return false; break;
+    case cg::op::COMPOSITION: return false; // fallback to tree walker
+    }
+  }
+  return true;
+}
+
+// --- On Demand fast path executor ---
+// Uses simdjson On Demand API to avoid materializing the full DOM tree.
+// Returns: true = valid, false = invalid OR unsupported (fallback to DOM).
+
+static std::string_view od_type(simdjson::ondemand::value& v) {
+  switch (v.type()) {
+    case simdjson::ondemand::json_type::object: return "object";
+    case simdjson::ondemand::json_type::array: return "array";
+    case simdjson::ondemand::json_type::string: return "string";
+    case simdjson::ondemand::json_type::boolean: return "boolean";
+    case simdjson::ondemand::json_type::null: return "null";
+    case simdjson::ondemand::json_type::number: {
+      simdjson::ondemand::number_type nt;
+      if (v.get_number_type().get(nt) == SUCCESS &&
+          nt == simdjson::ondemand::number_type::floating_point_number)
+        return "number";
+      return "integer";
+    }
+  }
+  return "unknown";
+}
+
+static bool od_exec(const cg::plan& p, const std::vector<cg::ins>& code,
+                     simdjson::ondemand::value value) {
+  auto t = od_type(value);
+  for (size_t i = 0; i < code.size(); ++i) {
+    auto& c = code[i];
+    switch (c.o) {
+    case cg::op::END: return true;
+    case cg::op::EXPECT_OBJECT: if(t!="object") return false; break;
+    case cg::op::EXPECT_ARRAY: if(t!="array") return false; break;
+    case cg::op::EXPECT_STRING: if(t!="string") return false; break;
+    case cg::op::EXPECT_NUMBER: if(t!="number"&&t!="integer") return false; break;
+    case cg::op::EXPECT_INTEGER: if(t!="integer") return false; break;
+    case cg::op::EXPECT_BOOLEAN: if(t!="boolean") return false; break;
+    case cg::op::EXPECT_NULL: if(t!="null") return false; break;
+    case cg::op::EXPECT_TYPE_MULTI: {
+      auto& ts=p.type_sets[c.a]; bool m=false;
+      for(auto& ty:ts){if(t==ty||(ty=="number"&&(t=="integer"||t=="number"))){m=true;break;}}
+      if(!m) return false; break;
+    }
+    case cg::op::CHECK_MINIMUM:
+    case cg::op::CHECK_MAXIMUM:
+    case cg::op::CHECK_EX_MINIMUM:
+    case cg::op::CHECK_EX_MAXIMUM:
+    case cg::op::CHECK_MULTIPLE_OF: {
+      if (t=="integer"||t=="number") {
+        double v;
+        if (t=="integer") { int64_t iv; if(value.get(iv)!=SUCCESS) return false; v=(double)iv; }
+        else { if(value.get(v)!=SUCCESS) return false; }
+        double d=p.doubles[c.a];
+        if(c.o==cg::op::CHECK_MINIMUM && v<d) return false;
+        if(c.o==cg::op::CHECK_MAXIMUM && v>d) return false;
+        if(c.o==cg::op::CHECK_EX_MINIMUM && v<=d) return false;
+        if(c.o==cg::op::CHECK_EX_MAXIMUM && v>=d) return false;
+        if(c.o==cg::op::CHECK_MULTIPLE_OF){double r=std::fmod(v,d);if(std::abs(r)>1e-8&&std::abs(r-d)>1e-8)return false;}
+      }
+      break;
+    }
+    case cg::op::CHECK_MIN_LENGTH: if(t=="string"){std::string_view sv; if(value.get(sv)!=SUCCESS) return false; if(utf8_length(sv)<c.a) return false;} break;
+    case cg::op::CHECK_MAX_LENGTH: if(t=="string"){std::string_view sv; if(value.get(sv)!=SUCCESS) return false; if(utf8_length(sv)>c.a) return false;} break;
+    case cg::op::CHECK_PATTERN: if(t=="string"){std::string_view sv; if(value.get(sv)!=SUCCESS) return false; if(!re2::RE2::PartialMatch(re2::StringPiece(sv.data(),sv.size()),*p.regexes[c.a]))return false;} break;
+    case cg::op::CHECK_FORMAT: if(t=="string"){std::string_view sv; if(value.get(sv)!=SUCCESS) return false; uint8_t f=p.format_ids[c.a]; if(f<9&&!check_format(sv,fmt_names[f]))return false;} break;
+    case cg::op::CHECK_MIN_ITEMS: if(t=="array"){
+      simdjson::ondemand::array a; if(value.get(a)!=SUCCESS) return false;
+      uint64_t s=0; for(auto x:a){(void)x;++s;} if(s<c.a) return false;
+    } break;
+    case cg::op::CHECK_MAX_ITEMS: if(t=="array"){
+      simdjson::ondemand::array a; if(value.get(a)!=SUCCESS) return false;
+      uint64_t s=0; for(auto x:a){(void)x;++s;} if(s>c.a) return false;
+    } break;
+    case cg::op::ARRAY_ITEMS: if(t=="array"){
+      simdjson::ondemand::array a; if(value.get(a)!=SUCCESS) return false;
+      for(auto elem:a){
+        simdjson::ondemand::value v; if(elem.get(v)!=SUCCESS) return false;
+        if(!od_exec(p,p.subs[c.a],v)) return false;
+      }
+    } break;
+    case cg::op::CHECK_REQUIRED: if(t=="object"){
+      simdjson::ondemand::object o; if(value.get(o)!=SUCCESS) return false;
+      auto f = o.find_field_unordered(p.strings[c.a]);
+      if(f.error()) return false;
+    } break;
+    case cg::op::CHECK_MIN_PROPS: if(t=="object"){
+      simdjson::ondemand::object o; if(value.get(o)!=SUCCESS) return false;
+      uint64_t n=0; for(auto f:o){(void)f;++n;} if(n<c.a) return false;
+    } break;
+    case cg::op::CHECK_MAX_PROPS: if(t=="object"){
+      simdjson::ondemand::object o; if(value.get(o)!=SUCCESS) return false;
+      uint64_t n=0; for(auto f:o){(void)f;++n;} if(n>c.a) return false;
+    } break;
+    case cg::op::OBJ_PROPS_START: if(t=="object"){
+      simdjson::ondemand::object o; if(value.get(o)!=SUCCESS) return false;
+      struct pd{std::string_view nm;uint32_t si;};
+      std::vector<pd> props; bool no_add=false;
+      size_t j=i+1;
+      for(;j<code.size()&&code[j].o!=cg::op::OBJ_PROPS_END;++j){
+        if(code[j].o==cg::op::OBJ_PROP) props.push_back({p.strings[code[j].a],code[j].b});
+        else if(code[j].o==cg::op::CHECK_NO_ADDITIONAL) no_add=true;
+      }
+      for(auto field:o){
+        simdjson::ondemand::raw_json_string rk; if(field.key().get(rk)!=SUCCESS) return false;
+        std::string_view key = field.unescaped_key();
+        bool matched=false;
+        for(auto& pp:props){
+          if(key==pp.nm){
+            simdjson::ondemand::value fv; if(field.value().get(fv)!=SUCCESS) return false;
+            if(!od_exec(p,p.subs[pp.si],fv)) return false;
+            matched=true; break;
+          }
+        }
+        if(!matched&&no_add) return false;
+      }
+      i=j; break;
+    } else { size_t j=i+1; for(;j<code.size()&&code[j].o!=cg::op::OBJ_PROPS_END;++j); i=j; } break;
+    case cg::op::OBJ_PROP: case cg::op::OBJ_PROPS_END: case cg::op::CHECK_NO_ADDITIONAL: break;
+
+    // These require full materialization — bail to DOM path
+    case cg::op::CHECK_UNIQUE_ITEMS:
+    case cg::op::CHECK_ENUM_STR:
+    case cg::op::CHECK_ENUM:
+    case cg::op::CHECK_CONST:
+    case cg::op::COMPOSITION:
+      return false;
+    }
+  }
+  return true;
+}
+
+// Determine if a codegen plan can use On Demand (no enum/const/uniqueItems)
+static bool plan_supports_ondemand(const cg::plan& p) {
+  for (auto& c : p.code) {
+    if (c.o == cg::op::CHECK_UNIQUE_ITEMS || c.o == cg::op::CHECK_ENUM_STR ||
+        c.o == cg::op::CHECK_ENUM || c.o == cg::op::CHECK_CONST ||
+        c.o == cg::op::COMPOSITION)
+      return false;
+  }
+  // Also check sub-plans
+  for (auto& sub : p.subs) {
+    for (auto& c : sub) {
+      if (c.o == cg::op::CHECK_UNIQUE_ITEMS || c.o == cg::op::CHECK_ENUM_STR ||
+          c.o == cg::op::CHECK_ENUM || c.o == cg::op::CHECK_CONST ||
+          c.o == cg::op::COMPOSITION)
+        return false;
+    }
+  }
+  return true;
+}
+
+// Free padding: check if buffer is near a page boundary
+// On modern systems, pages are at least 4096 bytes. If we're far enough
+// from the end of a page, we can read 64 bytes beyond without a fault.
+static long get_page_size() {
+#ifdef _WIN32
+  SYSTEM_INFO si; GetSystemInfo(&si); return si.dwPageSize;
+#else
+  static long ps = sysconf(_SC_PAGESIZE);
+  return ps;
+#endif
+}
+
+static bool near_page_boundary(const char* buf, size_t len) {
+  return ((reinterpret_cast<uintptr_t>(buf + len - 1) % get_page_size())
+          + REQUIRED_PADDING >= static_cast<uintptr_t>(get_page_size()));
+}
+
+// Zero-copy validate with free padding (Lemire's trick).
+// Almost never allocates — only if buffer is near a page boundary.
+static simdjson::padded_string_view get_free_padded_view(
+    const char* data, size_t length, simdjson::padded_string& fallback) {
+  if (near_page_boundary(data, length)) {
+    // Rare: near page boundary, must copy
+    fallback = simdjson::padded_string(data, length);
+    return fallback;
+  }
+  // Common: free padding available, zero-copy
+  return simdjson::padded_string_view(data, length, length + REQUIRED_PADDING);
+}
+
 schema_ref compile(std::string_view schema_json) {
   auto ctx = std::make_shared<compiled_schema>();
   ctx->raw_schema = std::string(schema_json);
@@ -980,6 +1576,11 @@ schema_ref compile(std::string_view schema_json) {
 
   ctx->root = compile_node(doc, *ctx);
 
+  // Generate codegen plan
+  cg_compile(ctx->root.get(), ctx->gen_plan, ctx->gen_plan.code);
+  ctx->gen_plan.code.push_back({cg::op::END});
+  ctx->use_ondemand = plan_supports_ondemand(ctx->gen_plan);
+
   schema_ref ref;
   ref.impl = ctx;
   return ref;
@@ -991,14 +1592,46 @@ validation_result validate(const schema_ref& schema, std::string_view json,
     return {false, {{error_code::invalid_schema, "", "schema not compiled"}}};
   }
 
-  auto padded = simdjson::padded_string(json);
-  auto result = schema.impl->doc_parser.parse(padded);
+  // Free padding trick: avoid padded_string copy when possible
+  simdjson::padded_string fallback;
+  auto psv = get_free_padded_view(json.data(), json.size(), fallback);
+
+  // Ultra-fast path: On Demand (no DOM materialization)
+  static constexpr size_t OD_THRESHOLD = 32;
+  if (schema.impl->use_ondemand && !schema.impl->gen_plan.code.empty() &&
+      json.size() >= OD_THRESHOLD) {
+    auto od_result = tl_od_parser().iterate(psv);
+    if (!od_result.error()) {
+      simdjson::ondemand::value root_val;
+      if (od_result.get_value().get(root_val) == SUCCESS) {
+        if (od_exec(schema.impl->gen_plan, schema.impl->gen_plan.code, root_val)) {
+          return {true, {}};
+        }
+      }
+    }
+    // Need fresh view for DOM parse (On Demand consumed it)
+    psv = get_free_padded_view(json.data(), json.size(), fallback);
+  }
+
+  auto& dom_p = tl_dom_parser();
+  auto result = dom_p.parse(psv);
   if (result.error()) {
     return {false, {{error_code::invalid_json, "", "invalid JSON document"}}};
   }
 
+  // Fast path: codegen bytecode execution (DOM)
+  if (!schema.impl->use_ondemand && !schema.impl->gen_plan.code.empty()) {
+    if (cg_exec(schema.impl->gen_plan, schema.impl->gen_plan.code,
+                result.value())) {
+      return {true, {}};
+    }
+    // Codegen said invalid OR hit COMPOSITION — fall through to tree walker
+  }
+
+  // Slow path: re-parse + tree walker with error details
+  auto result2 = dom_p.parse(psv);
   std::vector<validation_error> errors;
-  validate_node(schema.impl->root, result.value(), "", *schema.impl, errors,
+  validate_node(schema.impl->root, result2.value(), "", *schema.impl, errors,
                 opts.all_errors);
 
   return {errors.empty(), std::move(errors)};
@@ -1014,4 +1647,22 @@ validation_result validate(std::string_view schema_json,
   return validate(s, json, opts);
 }
 
+
+bool is_valid_prepadded(const schema_ref& schema, const char* data, size_t length) {
+  if (!schema.impl || !schema.impl->root) return false;
+
+  simdjson::padded_string fallback;
+  auto psv = get_free_padded_view(data, length, fallback);
+  auto result = tl_dom_parser().parse(psv);
+  if (result.error()) return false;
+
+  if (!schema.impl->gen_plan.code.empty()) {
+    return cg_exec(schema.impl->gen_plan, schema.impl->gen_plan.code, result.value());
+  }
+
+  std::vector<validation_error> errors;
+  validate_node(schema.impl->root, result.value(), "", *schema.impl, errors, false);
+  return errors.empty();
+}
+
 }  // namespace ata