ata-validator 0.7.3 → 0.9.0

package/src/ata.cpp

@@ -8,7 +8,9 @@
 #include <algorithm>
 #include <cmath>
 #include <cstring>
+#ifndef ATA_NO_RE2
 #include <re2/re2.h>
+#endif
 #include <set>
 #include <unordered_map>
 
@@ -53,11 +55,15 @@ static bool fast_check_email(std::string_view s) {
 }
 
 static bool fast_check_date(std::string_view s) {
-  // YYYY-MM-DD
-  return s.size() == 10 && is_digit(s[0]) && is_digit(s[1]) &&
-         is_digit(s[2]) && is_digit(s[3]) && s[4] == '-' &&
-         is_digit(s[5]) && is_digit(s[6]) && s[7] == '-' &&
-         is_digit(s[8]) && is_digit(s[9]);
+  // YYYY-MM-DD with range validation
+  if (s.size() != 10 || !is_digit(s[0]) || !is_digit(s[1]) ||
+      !is_digit(s[2]) || !is_digit(s[3]) || s[4] != '-' ||
+      !is_digit(s[5]) || !is_digit(s[6]) || s[7] != '-' ||
+      !is_digit(s[8]) || !is_digit(s[9]))
+    return false;
+  int month = (s[5] - '0') * 10 + (s[6] - '0');
+  int day = (s[8] - '0') * 10 + (s[9] - '0');
+  return month >= 1 && month <= 12 && day >= 1 && day <= 31;
 }
 
 static bool fast_check_time(std::string_view s) {
@@ -274,7 +280,9 @@ struct schema_node {
   std::optional<uint64_t> min_length;
   std::optional<uint64_t> max_length;
   std::optional<std::string> pattern;
+#ifndef ATA_NO_RE2
   std::shared_ptr<re2::RE2> compiled_pattern;  // cached compiled regex (RE2)
+#endif
 
   // array
   std::optional<uint64_t> min_items;
@@ -301,7 +309,9 @@ struct schema_node {
   struct pattern_prop {
     std::string pattern;
     schema_node_ptr schema;
+#ifndef ATA_NO_RE2
     std::shared_ptr<re2::RE2> compiled;
+#endif
   };
   std::vector<pattern_prop> pattern_properties;
 
@@ -326,6 +336,8 @@ struct schema_node {
 
   // $ref
   std::string ref;
+  std::string dynamic_ref;    // $dynamicRef value (e.g. "#items")
+  std::string id;             // $id — resource boundary marker
 
   // $defs — stored on node for pointer navigation
   std::unordered_map<std::string, schema_node_ptr> defs;
@@ -351,7 +363,9 @@ struct plan {
   std::vector<ins> code;
   std::vector<double> doubles;
   std::vector<std::string> strings;
+#ifndef ATA_NO_RE2
   std::vector<std::shared_ptr<re2::RE2>> regexes;
+#endif
   std::vector<std::vector<std::string>> enum_sets;
   std::vector<uint8_t> type_masks;
   std::vector<uint8_t> format_ids;
@@ -374,7 +388,9 @@ struct od_plan {
 
   // String — single value.get(sv) then all checks
   std::optional<uint64_t> min_length, max_length;
+#ifndef ATA_NO_RE2
   re2::RE2* pattern = nullptr;        // borrowed pointer from schema_node
+#endif
   uint8_t format_id = 255;            // 255 = no format check
 
   // Object — single iterate with merged required+property lookup
@@ -408,10 +424,22 @@ struct compiled_schema {
   schema_node_ptr root;
   std::unordered_map<std::string, schema_node_ptr> defs;
   std::string raw_schema;
+  std::string compile_error;  // non-empty if compilation failed
   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
   od_plan_ptr od;              // On-Demand execution plan
+
+  // anchor resolution
+  std::unordered_map<std::string, schema_node_ptr> anchors;
+  std::unordered_map<std::string,
+    std::unordered_map<std::string, schema_node_ptr>> resource_dynamic_anchors;
+  bool has_dynamic_refs = false;
+  std::string current_resource_id;  // compile-time only
+
+  // compile-time warnings (misplaced keywords, etc.)
+  std::vector<schema_warning> warnings;
+  std::string compile_path;  // current JSON pointer during compilation
 };
 
 // Thread-local persistent parsers — reused across all validate calls on the
@@ -462,6 +490,64 @@ static schema_node_ptr compile_node(dom::element el,
     }
   }
 
+  // $id — must come before $anchor/$dynamicAnchor so current_resource_id is set
+  std::string prev_resource = ctx.current_resource_id;
+  {
+    dom::element id_el;
+    if (obj["$id"].get(id_el) == SUCCESS) {
+      std::string_view sv;
+      if (id_el.get(sv) == SUCCESS) {
+        node->id = std::string(sv);
+        ctx.current_resource_id = node->id;
+        ctx.defs[node->id] = node;
+      }
+    }
+  }
+
+  // $anchor — register in flat anchor map
+  {
+    dom::element anchor_el;
+    if (obj["$anchor"].get(anchor_el) == SUCCESS) {
+      std::string_view sv;
+      if (anchor_el.get(sv) == SUCCESS) {
+        ctx.anchors[std::string(sv)] = node;
+      }
+    }
+  }
+
+  // $dynamicAnchor — register in both flat anchors and per-resource map
+  {
+    dom::element da_el;
+    if (obj["$dynamicAnchor"].get(da_el) == SUCCESS) {
+      std::string_view sv;
+      if (da_el.get(sv) == SUCCESS) {
+        std::string name(sv);
+        ctx.anchors[name] = node;
+        ctx.resource_dynamic_anchors[ctx.current_resource_id][name] = node;
+      }
+    }
+  }
+
+  // $dynamicRef
+  {
+    dom::element dr_el;
+    if (obj["$dynamicRef"].get(dr_el) == SUCCESS) {
+      std::string_view sv;
+      if (dr_el.get(sv) == SUCCESS) {
+        std::string dr_val(sv);
+        // If the $dynamicRef starts with "#" (fragment-only) and we're inside
+        // a non-root resource, qualify it with the current resource ID so
+        // validation can resolve it correctly.
+        if (!dr_val.empty() && dr_val[0] == '#' &&
+            !ctx.current_resource_id.empty()) {
+          dr_val = ctx.current_resource_id + dr_val;
+        }
+        node->dynamic_ref = dr_val;
+        ctx.has_dynamic_refs = true;
+      }
+    }
+  }
+
   // type
   dom::element type_el;
   if (obj["type"].get(type_el) == SUCCESS) {
@@ -516,10 +602,15 @@ static schema_node_ptr compile_node(dom::element el,
     std::string_view sv;
     if (str_el.get(sv) == SUCCESS) {
       node->pattern = std::string(sv);
+#ifdef ATA_NO_RE2
+      ctx.compile_error = "pattern keyword requires RE2 support (built with ATA_NO_RE2)";
+      return node;
+#else
       auto re = std::make_shared<re2::RE2>(node->pattern.value());
       if (re->ok()) {
         node->compiled_pattern = std::move(re);
       }
+#endif
     }
   }
 
@@ -636,6 +727,10 @@ static schema_node_ptr compile_node(dom::element el,
   dom::element pp_el;
   if (obj["patternProperties"].get(pp_el) == SUCCESS &&
       pp_el.is<dom::object>()) {
+#ifdef ATA_NO_RE2
+    ctx.compile_error = "patternProperties keyword requires RE2 support (built with ATA_NO_RE2)";
+    return node;
+#else
     dom::object pp_obj; pp_el.get(pp_obj);
     for (auto [key, val] : pp_obj) {
       schema_node::pattern_prop pp;
@@ -647,6 +742,7 @@ static schema_node_ptr compile_node(dom::element el,
       }
       node->pattern_properties.push_back(std::move(pp));
     }
+#endif
   }
 
   // format
@@ -659,15 +755,6 @@ static schema_node_ptr compile_node(dom::element el,
     }
   }
 
-  // $id (register in defs for potential resolution)
-  dom::element id_el;
-  if (obj["$id"].get(id_el) == SUCCESS) {
-    std::string_view sv;
-    if (id_el.get(sv) == SUCCESS) {
-      ctx.defs[std::string(sv)] = node;
-    }
-  }
-
   // enum — pre-minify each value at compile time
   dom::element enum_el;
   if (obj["enum"].get(enum_el) == SUCCESS) {
@@ -743,17 +830,199 @@ static schema_node_ptr compile_node(dom::element el,
     }
   }
 
+  // Warn about keywords used at the wrong type level.
+  // Only check when an explicit "type" is declared (type_mask != 0).
+  if (node->type_mask != 0) {
+    const uint8_t array_bit = json_type_bit(json_type::array);
+    const uint8_t string_bit = json_type_bit(json_type::string);
+    const uint8_t number_bits = json_type_bit(json_type::number) |
+                                json_type_bit(json_type::integer);
+    const uint8_t object_bit = json_type_bit(json_type::object);
+
+    auto warn = [&](const char* keyword, const char* expected_type) {
+      ctx.warnings.push_back({
+        ctx.compile_path,
+        std::string(keyword) + " has no effect on type \"" +
+        (node->type_mask & json_type_bit(json_type::string) ? "string" :
+         node->type_mask & json_type_bit(json_type::boolean) ? "boolean" :
+         node->type_mask & json_type_bit(json_type::number) ? "number" :
+         node->type_mask & object_bit ? "object" :
+         node->type_mask & array_bit ? "array" : "unknown") +
+        "\", only applies to " + expected_type
+      });
+    };
+
+    // Array keywords on non-array type
+    if (!(node->type_mask & array_bit)) {
+      if (node->min_items.has_value()) warn("minItems", "array");
+      if (node->max_items.has_value()) warn("maxItems", "array");
+      if (node->unique_items) warn("uniqueItems", "array");
+      if (!node->prefix_items.empty()) warn("prefixItems", "array");
+      if (node->items_schema) warn("items", "array");
+      if (node->contains_schema) warn("contains", "array");
+    }
+
+    // String keywords on non-string type
+    if (!(node->type_mask & string_bit)) {
+      if (node->min_length.has_value()) warn("minLength", "string");
+      if (node->max_length.has_value()) warn("maxLength", "string");
+      if (node->pattern.has_value()) warn("pattern", "string");
+    }
+
+    // Numeric keywords on non-numeric type
+    if (!(node->type_mask & number_bits)) {
+      if (node->minimum.has_value()) warn("minimum", "number");
+      if (node->maximum.has_value()) warn("maximum", "number");
+      if (node->exclusive_minimum.has_value()) warn("exclusiveMinimum", "number");
+      if (node->exclusive_maximum.has_value()) warn("exclusiveMaximum", "number");
+      if (node->multiple_of.has_value()) warn("multipleOf", "number");
+    }
+
+    // Object keywords on non-object type
+    if (!(node->type_mask & object_bit)) {
+      if (!node->properties.empty()) warn("properties", "object");
+      if (!node->required.empty()) warn("required", "object");
+    }
+  }
+
+  ctx.current_resource_id = prev_resource;
   return node;
 }
 
 // --- Validation ---
 
+using dynamic_scope_t = std::vector<const std::unordered_map<std::string, schema_node_ptr>*>;
+
+// Decode a single JSON Pointer segment (percent-decode, then ~1->/, ~0->~)
+static std::string decode_pointer_segment(const std::string& seg) {
+  std::string pct;
+  for (size_t i = 0; i < seg.size(); ++i) {
+    if (seg[i] == '%' && i + 2 < seg.size()) {
+      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(seg[i+1]), lv = hex(seg[i+2]);
+      if (hv >= 0 && lv >= 0) {
+        pct += static_cast<char>(hv * 16 + lv);
+        i += 2;
+      } else {
+        pct += seg[i];
+      }
+    } else {
+      pct += seg[i];
+    }
+  }
+  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;
+}
+
+// Walk a JSON Pointer (without leading #) within a given schema node.
+// Returns the resolved node, or nullptr if not found.
+static schema_node_ptr walk_json_pointer(const schema_node_ptr& root_node,
+                                          const std::string& pointer) {
+  if (pointer.empty()) return root_node;
+
+  std::vector<std::string> segments;
+  size_t spos = 0;
+  // pointer starts with "/" — skip leading slash
+  if (!pointer.empty() && pointer[0] == '/') spos = 1;
+  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() + 1 : snext + 1;
+  }
+
+  schema_node_ptr current = root_node;
+  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 { return nullptr; }
+    } else if (key == "items" && current->items_schema) {
+      current = current->items_schema;
+    } else if (key == "$defs" || key == "definitions") {
+      if (si + 1 < segments.size()) {
+        const auto& def_name = segments[++si];
+        auto dit = current->defs.find(def_name);
+        if (dit != current->defs.end()) { current = dit->second; }
+        else { return nullptr; }
+      } else { return nullptr; }
+    } else if (key == "allOf" || key == "anyOf" || key == "oneOf") {
+      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 { return nullptr; }
+      } else { return nullptr; }
+    } else if (key == "not" && current->not_schema) {
+      current = current->not_schema;
+    } else if (key == "if" && current->if_schema) {
+      current = current->if_schema;
+    } else if (key == "then" && current->then_schema) {
+      current = current->then_schema;
+    } else if (key == "else" && current->else_schema) {
+      current = current->else_schema;
+    } else if (key == "additionalProperties" &&
+               current->additional_properties_schema) {
+      current = current->additional_properties_schema;
+    } else if (key == "prefixItems") {
+      if (si + 1 < segments.size()) {
+        size_t idx = std::stoul(segments[++si]);
+        if (idx < current->prefix_items.size()) { current = current->prefix_items[idx]; }
+        else { return nullptr; }
+      } else { return nullptr; }
+    } else if (key == "contains" && current->contains_schema) {
+      current = current->contains_schema;
+    } else if (key == "propertyNames" && current->property_names_schema) {
+      current = current->property_names_schema;
+    } else {
+      return nullptr;
+    }
+  }
+  return current;
+}
+
+// Find an anchor (non-pointer fragment) within a specific resource node by
+// searching its sub-tree.  Used for resolving "base#anchor" references.
+static schema_node_ptr find_anchor_in_resource(const compiled_schema& ctx,
+                                                const std::string& resource_id,
+                                                const std::string& anchor_name) {
+  // Look up in per-resource dynamic anchors first
+  auto rit = ctx.resource_dynamic_anchors.find(resource_id);
+  if (rit != ctx.resource_dynamic_anchors.end()) {
+    auto ait = rit->second.find(anchor_name);
+    if (ait != rit->second.end()) return ait->second;
+  }
+  // Fallback to flat anchors (which includes $anchor entries)
+  auto ait = ctx.anchors.find(anchor_name);
+  if (ait != ctx.anchors.end()) return ait->second;
+  return nullptr;
+}
+
 static void validate_node(const schema_node_ptr& node,
                            dom::element value,
                            const std::string& path,
                            const compiled_schema& ctx,
                            std::vector<validation_error>& errors,
-                           bool all_errors = true);
+                           bool all_errors = true,
+                           dynamic_scope_t* dynamic_scope = nullptr);
 
 // Fast boolean-only tree walker — no error collection, no string allocation.
 // Uses [[likely]]/[[unlikely]] hints. Returns true if valid.
@@ -808,14 +1077,27 @@ static uint64_t utf8_length(std::string_view s) {
   return count;
 }
 
+// Recursion depth guard — prevents stack overflow on self-referencing schemas
+struct DepthGuard {
+  static thread_local int depth;
+  bool overflow;
+  DepthGuard() : overflow(++depth > 100) {}
+  ~DepthGuard() { --depth; }
+};
+thread_local int DepthGuard::depth = 0;
+
 static void validate_node(const schema_node_ptr& node,
                            dom::element value,
                            const std::string& path,
                            const compiled_schema& ctx,
                            std::vector<validation_error>& errors,
-                           bool all_errors) {
+                           bool all_errors,
+                           dynamic_scope_t* dynamic_scope) {
   if (!node) return;
 
+  DepthGuard guard;
+  if (guard.overflow) return;
+
   // Boolean schema
   if (node->boolean_schema.has_value()) {
     if (!node->boolean_schema.value()) {
@@ -825,136 +1107,116 @@ static void validate_node(const schema_node_ptr& node,
     return;
   }
 
+  // Dynamic scope tracking: push this resource's dynamic anchors
+  bool pushed_scope = false;
+  if (dynamic_scope && !node->id.empty()) {
+    auto it = ctx.resource_dynamic_anchors.find(node->id);
+    if (it != ctx.resource_dynamic_anchors.end()) {
+      dynamic_scope->push_back(&it->second);
+      pushed_scope = true;
+    }
+  }
+
   // $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);
+    // Self-reference: "#"
+    if (node->ref == "#" && ctx.root) {
+      validate_node(ctx.root, value, path, ctx, errors, all_errors, dynamic_scope);
       ref_resolved = true;
     }
-    // Try JSON Pointer resolution from root (e.g., "#/properties/foo")
-    if (node->ref.size() > 1 && node->ref[0] == '#' &&
-        node->ref[1] == '/') {
-      // 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 {
-            pct += seg[i];
-          }
-        }
-        // 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];
+    // Check for "base#fragment" pattern (e.g. "first#/$defs/stuff", "tree.json")
+    if (!ref_resolved) {
+      std::string base_uri;
+      std::string fragment;
+      size_t hash_pos = node->ref.find('#');
+      if (hash_pos != std::string::npos) {
+        base_uri = node->ref.substr(0, hash_pos);
+        fragment = node->ref.substr(hash_pos + 1);
+      } else {
+        base_uri = node->ref;
+      }
+
+      // Helper: push base resource's dynamic anchors to scope, validate, pop
+      auto validate_with_resource_scope = [&](const schema_node_ptr& target,
+                                               const std::string& resource_id) {
+        bool scope_pushed = false;
+        if (dynamic_scope && !resource_id.empty()) {
+          auto rit = ctx.resource_dynamic_anchors.find(resource_id);
+          if (rit != ctx.resource_dynamic_anchors.end()) {
+            dynamic_scope->push_back(&rit->second);
+            scope_pushed = true;
           }
         }
-        return out;
+        validate_node(target, value, path, ctx, errors, all_errors, dynamic_scope);
+        if (scope_pushed) dynamic_scope->pop_back();
       };
 
-      // 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 if (key == "items" && current->items_schema) {
-          current = current->items_schema;
-        } else if (key == "$defs" || key == "definitions") {
-          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;
+      if (!base_uri.empty()) {
+        // Resolve base URI to a resource via defs
+        auto it = ctx.defs.find(base_uri);
+        if (it != ctx.defs.end()) {
+          schema_node_ptr target = it->second;
+          if (!fragment.empty()) {
+            if (fragment[0] == '/') {
+              // JSON Pointer within the resource
+              auto resolved = walk_json_pointer(target, fragment);
+              if (resolved) {
+                validate_with_resource_scope(resolved, base_uri);
+                ref_resolved = true;
+              }
             } 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; }
+              // Anchor lookup within the resource
+              auto resolved = find_anchor_in_resource(ctx, base_uri, fragment);
+              if (resolved) {
+                validate_with_resource_scope(resolved, base_uri);
+                ref_resolved = true;
+              }
             }
-          } else { resolved = false; break; }
-        } else if (key == "allOf" || key == "anyOf" || key == "oneOf") {
-          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) {
-          current = current->if_schema;
-        } else if (key == "then" && current->then_schema) {
-          current = current->then_schema;
-        } else if (key == "else" && current->else_schema) {
-          current = current->else_schema;
-        } else if (key == "additionalProperties" &&
-                   current->additional_properties_schema) {
-          current = current->additional_properties_schema;
-        } else if (key == "prefixItems") {
-          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 {
+            // No fragment, just the base resource (it pushes its own scope)
+            validate_node(target, value, path, ctx, errors, all_errors, dynamic_scope);
+            ref_resolved = true;
+          }
+        }
+      } else if (!fragment.empty()) {
+        // "#fragment" — no base URI
+        if (fragment[0] == '/') {
+          // JSON Pointer from root
+          auto resolved = walk_json_pointer(ctx.root, fragment);
+          if (resolved) {
+            validate_node(resolved, value, path, ctx, errors, all_errors, dynamic_scope);
+            ref_resolved = true;
+          }
         } else {
-          resolved = false; break;
+          // Anchor lookup
+          auto ait = ctx.anchors.find(fragment);
+          if (ait != ctx.anchors.end()) {
+            validate_node(ait->second, value, path, ctx, errors, all_errors, dynamic_scope);
+            ref_resolved = true;
+          }
         }
       }
-      if (resolved && current) {
-        validate_node(current, value, path, ctx, errors, all_errors);
+    }
+    // Fallback: try defs map directly (handles bare $id references like "list")
+    if (!ref_resolved) {
+      auto it = ctx.defs.find(node->ref);
+      if (it != ctx.defs.end()) {
+        validate_node(it->second, value, path, ctx, errors, all_errors, dynamic_scope);
         ref_resolved = true;
       }
     }
-    // Self-reference: "#"
-    if (!ref_resolved && node->ref == "#" && ctx.root) {
-      validate_node(ctx.root, value, path, ctx, errors, all_errors);
-      ref_resolved = true;
+    // Fallback: relative URI resolution — match ref against defs keys by suffix
+    if (!ref_resolved && !node->ref.empty() && node->ref[0] != '#') {
+      std::string suffix = "/" + node->ref;
+      for (const auto& [key, def_node] : ctx.defs) {
+        if (key.size() >= suffix.size() &&
+            key.compare(key.size() - suffix.size(), suffix.size(), suffix) == 0) {
+          validate_node(def_node, value, path, ctx, errors, all_errors, dynamic_scope);
+          ref_resolved = true;
+          break;
+        }
+      }
     }
     if (!ref_resolved) {
       errors.push_back({error_code::ref_not_found, path,
@@ -962,6 +1224,132 @@ static void validate_node(const schema_node_ptr& node,
     }
   }
 
+  // $dynamicRef — Draft 2020-12 dynamic scope resolution
+  if (!node->dynamic_ref.empty()) {
+    bool dref_resolved = false;
+
+    // Parse the $dynamicRef value into base URI and fragment
+    std::string dr_base;
+    std::string dr_fragment;
+    {
+      size_t hash_pos = node->dynamic_ref.find('#');
+      if (hash_pos != std::string::npos) {
+        dr_base = node->dynamic_ref.substr(0, hash_pos);
+        dr_fragment = node->dynamic_ref.substr(hash_pos + 1);
+      } else {
+        dr_base = node->dynamic_ref;
+      }
+    }
+
+    // Helper: push base resource's dynamic anchors to scope temporarily
+    auto push_resource_scope = [&](const std::string& resource_id) -> bool {
+      if (dynamic_scope && !resource_id.empty()) {
+        auto rit = ctx.resource_dynamic_anchors.find(resource_id);
+        if (rit != ctx.resource_dynamic_anchors.end()) {
+          dynamic_scope->push_back(&rit->second);
+          return true;
+        }
+      }
+      return false;
+    };
+
+    // If fragment is a JSON pointer (starts with /), resolve like $ref
+    if (!dr_fragment.empty() && dr_fragment[0] == '/') {
+      schema_node_ptr base_node = dr_base.empty() ? ctx.root : nullptr;
+      if (!dr_base.empty()) {
+        auto it = ctx.defs.find(dr_base);
+        if (it != ctx.defs.end()) base_node = it->second;
+      }
+      if (base_node) {
+        auto resolved = walk_json_pointer(base_node, dr_fragment);
+        if (resolved) {
+          bool dr_scope_pushed = push_resource_scope(dr_base);
+          validate_node(resolved, value, path, ctx, errors, all_errors, dynamic_scope);
+          if (dr_scope_pushed) dynamic_scope->pop_back();
+          dref_resolved = true;
+        }
+      }
+    }
+
+    // If fragment is an anchor name (not a JSON pointer)
+    if (!dref_resolved && !dr_fragment.empty() && dr_fragment[0] != '/') {
+      std::string anchor_name = dr_fragment;
+
+      // Initial resolution: find the anchor
+      schema_node_ptr target = nullptr;
+
+      if (!dr_base.empty()) {
+        // Resolve base URI first, then find anchor in that resource
+        auto it = ctx.defs.find(dr_base);
+        if (it != ctx.defs.end()) {
+          target = find_anchor_in_resource(ctx, dr_base, anchor_name);
+        }
+      } else {
+        // No base URI — look up in flat anchors map
+        auto ait = ctx.anchors.find(anchor_name);
+        if (ait != ctx.anchors.end()) {
+          target = ait->second;
+        }
+      }
+
+      if (target) {
+        // Check if the initially resolved target is itself a $dynamicAnchor
+        // (the "bookend" requirement). Only do dynamic scope walk if the
+        // initial target's resource has a $dynamicAnchor with this name.
+        bool is_dynamic_at_initial = false;
+        if (!dr_base.empty()) {
+          // We resolved via a specific base URI
+          auto rit = ctx.resource_dynamic_anchors.find(dr_base);
+          if (rit != ctx.resource_dynamic_anchors.end() &&
+              rit->second.count(anchor_name)) {
+            is_dynamic_at_initial = true;
+          }
+        } else {
+          // No base URI — check if ANY resource has this as $dynamicAnchor
+          // and the target matches (i.e., the initially resolved node IS a
+          // $dynamicAnchor node)
+          for (const auto& [rid, rmap] : ctx.resource_dynamic_anchors) {
+            auto ait2 = rmap.find(anchor_name);
+            if (ait2 != rmap.end() && ait2->second == target) {
+              is_dynamic_at_initial = true;
+              break;
+            }
+          }
+        }
+
+        // Dynamic scope walk: find first override in dynamic scope
+        if (is_dynamic_at_initial && dynamic_scope) {
+          for (size_t i = 0; i < dynamic_scope->size(); ++i) {
+            auto dit = (*dynamic_scope)[i]->find(anchor_name);
+            if (dit != (*dynamic_scope)[i]->end()) {
+              target = dit->second;
+              break;
+            }
+          }
+        }
+
+        bool dr_scope_pushed = push_resource_scope(dr_base);
+        validate_node(target, value, path, ctx, errors, all_errors, dynamic_scope);
+        if (dr_scope_pushed) dynamic_scope->pop_back();
+        dref_resolved = true;
+      }
+    }
+
+    // Bare $dynamicRef without fragment (unusual, but handle it)
+    if (!dref_resolved && dr_fragment.empty() && !dr_base.empty()) {
+      auto it = ctx.defs.find(dr_base);
+      if (it != ctx.defs.end()) {
+        validate_node(it->second, value, path, ctx, errors, all_errors, dynamic_scope);
+        dref_resolved = true;
+      }
+    }
+
+    if (!dref_resolved) {
+      errors.push_back({error_code::ref_not_found, path,
+                        "cannot resolve $dynamicRef: " + node->dynamic_ref});
+    }
+  }
+
   // type
   if (node->type_mask) {
     if (!type_matches_mask(value, node->type_mask)) {
@@ -1061,6 +1449,7 @@ static void validate_node(const schema_node_ptr& node,
                             " > maxLength " +
                             std::to_string(node->max_length.value())});
     }
+#ifndef ATA_NO_RE2
     if (node->compiled_pattern) {
       if (!re2::RE2::PartialMatch(re2::StringPiece(sv.data(), sv.size()), *node->compiled_pattern)) {
         errors.push_back({error_code::pattern_mismatch, path,
@@ -1068,6 +1457,7 @@ static void validate_node(const schema_node_ptr& node,
                               node->pattern.value()});
       }
     }
+#endif
 
     if (node->format.has_value()) {
       if (!check_format_by_id(sv, node->format_id)) {
@@ -1139,10 +1529,10 @@ 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, all_errors);
+                        path + "/" + std::to_string(idx), ctx, errors, all_errors, dynamic_scope);
         } else if (node->items_schema) {
           validate_node(node->items_schema, item,
-                        path + "/" + std::to_string(idx), ctx, errors, all_errors);
+                        path + "/" + std::to_string(idx), ctx, errors, all_errors, dynamic_scope);
         }
         ++idx;
       }
@@ -1209,16 +1599,18 @@ static void validate_node(const schema_node_ptr& node,
       // Check properties
       auto it = node->properties.find(key_str);
       if (it != node->properties.end()) {
-        validate_node(it->second, val, path + "/" + key_str, ctx, errors, all_errors);
+        validate_node(it->second, val, path + "/" + key_str, ctx, errors, all_errors, dynamic_scope);
         matched = true;
       }
 
       // Check patternProperties (use cached compiled regex)
       for (const auto& pp : node->pattern_properties) {
+#ifndef ATA_NO_RE2
         if (pp.compiled && re2::RE2::PartialMatch(key_str, *pp.compiled)) {
-          validate_node(pp.schema, val, path + "/" + key_str, ctx, errors, all_errors);
+          validate_node(pp.schema, val, path + "/" + key_str, ctx, errors, all_errors, dynamic_scope);
           matched = true;
         }
+#endif
       }
 
       // additionalProperties (only if not matched by properties or patternProperties)
@@ -1230,7 +1622,7 @@ static void validate_node(const schema_node_ptr& node,
                "additional property not allowed: " + key_str});
         } else if (node->additional_properties_schema) {
           validate_node(node->additional_properties_schema, val,
-                        path + "/" + key_str, ctx, errors);
+                        path + "/" + key_str, ctx, errors, all_errors, dynamic_scope);
         }
       }
     }
@@ -1259,12 +1651,14 @@ static void validate_node(const schema_node_ptr& node,
             errors.push_back({error_code::max_length_violation, path,
                               "propertyNames: key too long: " + std::string(key_sv)});
           }
+#ifndef ATA_NO_RE2
           if (pn->compiled_pattern) {
             if (!re2::RE2::PartialMatch(re2::StringPiece(key_sv.data(), key_sv.size()), *pn->compiled_pattern)) {
               errors.push_back({error_code::pattern_mismatch, path,
                                 "propertyNames: key does not match pattern: " + std::string(key_sv)});
             }
           }
+#endif
           if (pn->format.has_value() && !check_format_by_id(key_sv, pn->format_id)) {
             errors.push_back({error_code::format_mismatch, path,
                               "propertyNames: key does not match format: " + std::string(key_sv)});
@@ -1276,7 +1670,7 @@ static void validate_node(const schema_node_ptr& node,
           std::string key_json = "\"" + std::string(key) + "\"";
           auto key_result = tl_dom_key_parser().parse(key_json);
           if (!key_result.error()) {
-            validate_node(pn, key_result.value(), path, ctx, errors, all_errors);
+            validate_node(pn, key_result.value_unsafe(), path, ctx, errors, all_errors, dynamic_scope);
           }
         }
       }
@@ -1301,7 +1695,7 @@ static void validate_node(const schema_node_ptr& node,
     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);
+        validate_node(schema, value, path, ctx, errors, all_errors, dynamic_scope);
       }
     }
   }
@@ -1310,7 +1704,7 @@ static void validate_node(const schema_node_ptr& node,
   if (!node->all_of.empty()) {
     for (const auto& sub : node->all_of) {
       std::vector<validation_error> sub_errors;
-      validate_node(sub, value, path, ctx, sub_errors, all_errors);
+      validate_node(sub, value, path, ctx, sub_errors, all_errors, dynamic_scope);
       if (!sub_errors.empty()) {
         errors.push_back({error_code::all_of_failed, path,
                           "allOf subschema failed"});
@@ -1324,7 +1718,7 @@ static void validate_node(const schema_node_ptr& node,
     bool any_valid = false;
     for (const auto& sub : node->any_of) {
       std::vector<validation_error> sub_errors;
-      validate_node(sub, value, path, ctx, sub_errors, all_errors);
+      validate_node(sub, value, path, ctx, sub_errors, all_errors, dynamic_scope);
       if (sub_errors.empty()) {
         any_valid = true;
         break;
@@ -1341,7 +1735,7 @@ static void validate_node(const schema_node_ptr& node,
     int match_count = 0;
     for (const auto& sub : node->one_of) {
       std::vector<validation_error> sub_errors;
-      validate_node(sub, value, path, ctx, sub_errors, all_errors);
+      validate_node(sub, value, path, ctx, sub_errors, all_errors, dynamic_scope);
       if (sub_errors.empty()) ++match_count;
     }
     if (match_count != 1) {
@@ -1354,7 +1748,7 @@ static void validate_node(const schema_node_ptr& node,
   // not
   if (node->not_schema) {
     std::vector<validation_error> sub_errors;
-    validate_node(node->not_schema, value, path, ctx, sub_errors, all_errors);
+    validate_node(node->not_schema, value, path, ctx, sub_errors, all_errors, dynamic_scope);
     if (sub_errors.empty()) {
       errors.push_back({error_code::not_failed, path,
                         "value should not match 'not' schema"});
@@ -1364,19 +1758,21 @@ static void validate_node(const schema_node_ptr& node,
   // if/then/else
   if (node->if_schema) {
     std::vector<validation_error> if_errors;
-    validate_node(node->if_schema, value, path, ctx, if_errors, all_errors);
+    validate_node(node->if_schema, value, path, ctx, if_errors, all_errors, dynamic_scope);
     if (if_errors.empty()) {
       // if passed → validate then
       if (node->then_schema) {
-        validate_node(node->then_schema, value, path, ctx, errors, all_errors);
+        validate_node(node->then_schema, value, path, ctx, errors, all_errors, dynamic_scope);
       }
     } else {
       // if failed → validate else
       if (node->else_schema) {
-        validate_node(node->else_schema, value, path, ctx, errors, all_errors);
+        validate_node(node->else_schema, value, path, ctx, errors, all_errors, dynamic_scope);
       }
     }
   }
+
+  if (pushed_scope) dynamic_scope->pop_back();
 }
 
 // Fast boolean-only tree walker — stripped of all error collection.
@@ -1387,14 +1783,27 @@ static bool validate_fast(const schema_node_ptr& node,
                            const compiled_schema& ctx) {
   if (!node) [[unlikely]] return true;
 
+  DepthGuard guard;
+  if (guard.overflow) [[unlikely]] return true;
+
   if (node->boolean_schema.has_value()) [[unlikely]]
     return node->boolean_schema.value();
 
+  // $dynamicRef — bail to tree walker
+  if (!node->dynamic_ref.empty()) [[unlikely]] return false;
+
   // $ref
   if (!node->ref.empty()) [[unlikely]] {
     auto it = ctx.defs.find(node->ref);
     if (it != ctx.defs.end()) {
       if (!validate_fast(it->second, value, ctx)) return false;
+    } else if (node->ref.size() > 1 && node->ref[0] == '#' && node->ref[1] != '/') {
+      auto ait = ctx.anchors.find(node->ref.substr(1));
+      if (ait != ctx.anchors.end()) {
+        if (!validate_fast(ait->second, value, ctx)) return false;
+      } else {
+        return false;
+      }
     } else if (node->ref == "#" && ctx.root) {
       if (!validate_fast(ctx.root, value, ctx)) return false;
     } else {
@@ -1444,10 +1853,12 @@ static bool validate_fast(const schema_node_ptr& node,
     uint64_t len = utf8_length(sv);
     if (node->min_length.has_value() && len < node->min_length.value()) return false;
     if (node->max_length.has_value() && len > node->max_length.value()) return false;
+#ifndef ATA_NO_RE2
     if (node->compiled_pattern) {
       if (!re2::RE2::PartialMatch(re2::StringPiece(sv.data(), sv.size()), *node->compiled_pattern))
         return false;
     }
+#endif
     if (node->format.has_value() && !check_format_by_id(sv, node->format_id)) return false;
   }
 
@@ -1532,11 +1943,13 @@ static bool validate_fast(const schema_node_ptr& node,
       }
 
       for (const auto& pp : node->pattern_properties) {
+#ifndef ATA_NO_RE2
         if (pp.compiled && re2::RE2::PartialMatch(
             re2::StringPiece(key_sv.data(), key_sv.size()), *pp.compiled)) {
           if (!validate_fast(pp.schema, val, ctx)) return false;
           matched = true;
         }
+#endif
       }
 
       if (!matched) {
@@ -1615,8 +2028,9 @@ static void cg_compile(const schema_node* n, cg::plan& p,
     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) {
+  if (!n->ref.empty() || !n->dynamic_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)});
@@ -1670,7 +2084,9 @@ static void cg_compile(const schema_node* n, cg::plan& p,
   // 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});
+#ifndef ATA_NO_RE2
   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}); }
+#endif
   if (n->format.has_value()) {
     uint32_t i=(uint32_t)p.format_ids.size();
     p.format_ids.push_back(n->format_id);
@@ -1744,7 +2160,11 @@ static bool cg_exec(const cg::plan& p, const std::vector<cg::ins>& code,
     case cg::op::CHECK_MULTIPLE_OF: if(t_numeric){double d=p.doubles[c.a],r=std::fmod(t_dval,d);if(std::abs(r)>1e-8&&std::abs(r-d)>1e-8)return false;} break;
     case cg::op::CHECK_MIN_LENGTH: if(t==et::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==et::STRING){std::string_view sv;value.get(sv);if(utf8_length(sv)>c.a)return false;} break;
+#ifndef ATA_NO_RE2
     case cg::op::CHECK_PATTERN: if(t==et::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;
+#else
+    case cg::op::CHECK_PATTERN: break;
+#endif
     case cg::op::CHECK_FORMAT: if(t==et::STRING){std::string_view sv;value.get(sv);if(!check_format_by_id(sv,p.format_ids[c.a]))return false;} break;
     case cg::op::CHECK_MIN_ITEMS: if(t==et::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==et::ARRAY){dom::array a;value.get(a);uint64_t s=0;for([[maybe_unused]]auto _:a)++s;if(s>c.a)return false;} break;
@@ -1796,7 +2216,9 @@ static bool cg_exec(const cg::plan& p, const std::vector<cg::ins>& code,
 // Returns: true = valid, false = invalid OR unsupported (fallback to DOM).
 
 static json_type od_type(simdjson::ondemand::value& v) {
-  switch (v.type()) {
+  simdjson::ondemand::json_type jt;
+  if (v.type().get(jt)) return json_type::null_value;
+  switch (jt) {
     case simdjson::ondemand::json_type::object: return json_type::object;
     case simdjson::ondemand::json_type::array: return json_type::array;
     case simdjson::ondemand::json_type::string: return json_type::string;
@@ -1854,7 +2276,11 @@ static bool od_exec(const cg::plan& p, const std::vector<cg::ins>& code,
     }
     case cg::op::CHECK_MIN_LENGTH: if(t==json_type::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==json_type::string){std::string_view sv; if(value.get(sv)!=SUCCESS) return false; if(utf8_length(sv)>c.a) return false;} break;
+#ifndef ATA_NO_RE2
     case cg::op::CHECK_PATTERN: if(t==json_type::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;
+#else
+    case cg::op::CHECK_PATTERN: break;
+#endif
     case cg::op::CHECK_FORMAT: if(t==json_type::string){std::string_view sv; if(value.get(sv)!=SUCCESS) return false; if(!check_format_by_id(sv,p.format_ids[c.a]))return false;} break;
     case cg::op::CHECK_MIN_ITEMS: if(t==json_type::array){
       simdjson::ondemand::array a; if(value.get(a)!=SUCCESS) return false;
@@ -1895,7 +2321,8 @@ static bool od_exec(const cg::plan& p, const std::vector<cg::ins>& code,
       }
       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();
+        std::string_view key;
+        if (field.unescaped_key().get(key)) continue;
         bool matched=false;
         for(auto& pp:props){
           if(key==pp.nm){
@@ -2012,7 +2439,9 @@ static od_plan_ptr compile_od_plan(const schema_node_ptr& node) {
   if (node->multiple_of) { plan->num_flags |= od_plan::HAS_MUL; plan->num_mul = *node->multiple_of; }
   plan->min_length = node->min_length;
   plan->max_length = node->max_length;
+#ifndef ATA_NO_RE2
   plan->pattern = node->compiled_pattern.get();
+#endif
   plan->format_id = node->format_id;
 
   // Object plan — build hash lookup for O(1) per-field dispatch
@@ -2151,10 +2580,12 @@ static bool od_exec_plan(const od_plan& plan, simdjson::ondemand::value value) {
       if (plan.min_length && len < *plan.min_length) return false;
       if (plan.max_length && len > *plan.max_length) return false;
     }
+#ifndef ATA_NO_RE2
     if (plan.pattern) {
       if (!re2::RE2::PartialMatch(re2::StringPiece(sv.data(), sv.size()), *plan.pattern))
         return false;
     }
+#endif
     if (plan.format_id != 255) {
       if (!check_format_by_id(sv, plan.format_id)) return false;
     }
@@ -2170,7 +2601,8 @@ static bool od_exec_plan(const od_plan& plan, simdjson::ondemand::value value) {
     uint64_t prop_count = 0;
 
     for (auto field : obj) {
-      std::string_view key = field.unescaped_key();
+      std::string_view key;
+      if (field.unescaped_key().get(key)) continue;
       prop_count++;
 
       // Single merged scan: required + property in one pass
@@ -2231,10 +2663,14 @@ schema_ref compile(std::string_view schema_json) {
   if (result.error()) {
     return schema_ref{nullptr};
   }
-  doc = result.value();
+  doc = result.value_unsafe();
 
   ctx->root = compile_node(doc, *ctx);
 
+  if (!ctx->compile_error.empty()) {
+    return schema_ref{nullptr};
+  }
+
   // Generate codegen plan
   cg_compile(ctx->root.get(), ctx->gen_plan, ctx->gen_plan.code);
   ctx->gen_plan.code.push_back({cg::op::END});
@@ -2243,6 +2679,7 @@ schema_ref compile(std::string_view schema_json) {
 
   schema_ref ref;
   ref.impl = ctx;
+  ref.warnings = std::move(ctx->warnings);
   return ref;
 }
 
@@ -2282,7 +2719,7 @@ validation_result validate(const schema_ref& schema, std::string_view json,
   // 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())) {
+                result.value_unsafe())) {
       return {true, {}};
     }
     // Codegen said invalid OR hit COMPOSITION — fall through to tree walker
@@ -2290,8 +2727,24 @@ validation_result validate(const schema_ref& schema, std::string_view json,
 
   // Slow path: tree walker with error details (reuse already-parsed DOM)
   std::vector<validation_error> errors;
-  validate_node(schema.impl->root, result.value(), "", *schema.impl, errors,
-                opts.all_errors);
+  if (schema.impl->has_dynamic_refs) {
+    dynamic_scope_t scope;
+    auto rit = schema.impl->resource_dynamic_anchors.find("");
+    if (rit != schema.impl->resource_dynamic_anchors.end()) {
+      scope.push_back(&rit->second);
+    }
+    if (!schema.impl->root->id.empty()) {
+      auto iit = schema.impl->resource_dynamic_anchors.find(schema.impl->root->id);
+      if (iit != schema.impl->resource_dynamic_anchors.end()) {
+        scope.push_back(&iit->second);
+      }
+    }
+    validate_node(schema.impl->root, result.value_unsafe(), "", *schema.impl, errors,
+                  opts.all_errors, &scope);
+  } else {
+    validate_node(schema.impl->root, result.value_unsafe(), "", *schema.impl, errors,
+                  opts.all_errors);
+  }
 
   return {errors.empty(), std::move(errors)};
 }
@@ -2332,10 +2785,10 @@ bool is_valid_prepadded(const schema_ref& schema, const char* data, size_t lengt
   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());
+    return cg_exec(schema.impl->gen_plan, schema.impl->gen_plan.code, result.value_unsafe());
   }
 
-  return validate_fast(schema.impl->root, result.value(), *schema.impl);
+  return validate_fast(schema.impl->root, result.value_unsafe(), *schema.impl);
 }
 
 bool is_valid_buf(const schema_ref& schema, const uint8_t* data, size_t length) {