ata-validator 0.1.0 → 0.2.0

package/README.md

@@ -27,7 +27,7 @@ A blazing-fast C++ JSON Schema validator powered by [simdjson](https://github.co
 
 ### JSON Schema Test Suite
 
-**97.1%** pass rate on official [JSON Schema Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite) (Draft 2020-12).
+**97.6%** pass rate (803/823) on official [JSON Schema Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite) (Draft 2020-12).
 
 ## Features
 
@@ -170,8 +170,8 @@ int main(void) {
 | Type | `type` (string, number, integer, boolean, null, array, object, union) |
 | Numeric | `minimum`, `maximum`, `exclusiveMinimum`, `exclusiveMaximum`, `multipleOf` |
 | String | `minLength`, `maxLength`, `pattern`, `format` |
-| Array | `items`, `prefixItems`, `minItems`, `maxItems`, `uniqueItems` |
-| Object | `properties`, `required`, `additionalProperties`, `patternProperties`, `minProperties`, `maxProperties` |
+| Array | `items`, `prefixItems`, `minItems`, `maxItems`, `uniqueItems`, `contains`, `minContains`, `maxContains` |
+| Object | `properties`, `required`, `additionalProperties`, `patternProperties`, `minProperties`, `maxProperties`, `propertyNames`, `dependentRequired`, `dependentSchemas` |
 | Enum/Const | `enum`, `const` |
 | Composition | `allOf`, `anyOf`, `oneOf`, `not` |
 | Conditional | `if`, `then`, `else` |

package/binding/ata_napi.cpp

@@ -1,7 +1,7 @@
 #include <napi.h>
 
 #include <cmath>
-#include <regex>
+#include <re2/re2.h>
 #include <set>
 #include <string>
 #include <vector>
@@ -31,13 +31,16 @@ 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;
+  std::shared_ptr<re2::RE2> compiled_pattern;
 
   std::optional<uint64_t> min_items;
   std::optional<uint64_t> max_items;
   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;
 
   std::unordered_map<std::string, schema_node_ptr> properties;
   std::vector<std::string> required;
@@ -45,8 +48,16 @@ struct schema_node {
   schema_node_ptr additional_properties_schema;
   std::optional<uint64_t> min_properties;
   std::optional<uint64_t> max_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;
 
-  std::vector<std::pair<std::string, schema_node_ptr>> pattern_properties;
+  struct pattern_prop {
+    std::string pattern;
+    schema_node_ptr schema;
+    std::shared_ptr<re2::RE2> compiled;
+  };
+  std::vector<pattern_prop> pattern_properties;
 
   std::optional<std::string> enum_values_raw;
   std::vector<std::string> enum_values_minified;
@@ -65,6 +76,8 @@ struct schema_node {
 
   std::string ref;
 
+  std::unordered_map<std::string, schema_node_ptr> defs;
+
   std::optional<bool> boolean_schema;
 };
 
@@ -73,6 +86,89 @@ struct compiled_schema_internal {
   std::unordered_map<std::string, schema_node_ptr> defs;
 };
 
+// --- Fast format validators (no regex) ---
+
+static bool nb_is_digit(char c) { return c >= '0' && c <= '9'; }
+static bool nb_is_alpha(char c) {
+  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
+}
+static bool nb_is_alnum(char c) { return nb_is_alpha(c) || nb_is_digit(c); }
+static bool nb_is_hex(char c) {
+  return nb_is_digit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
+}
+
+static bool napi_check_format(const std::string& sv, const std::string& fmt) {
+  if (fmt == "email") {
+    auto at = sv.find('@');
+    if (at == std::string::npos || at == 0 || at == sv.size() - 1) return false;
+    auto dot = sv.find('.', at + 1);
+    return dot != std::string::npos && dot != at + 1 && dot != sv.size() - 1 &&
+           (sv.size() - dot - 1) >= 2;
+  }
+  if (fmt == "date") {
+    return sv.size() == 10 && nb_is_digit(sv[0]) && nb_is_digit(sv[1]) &&
+           nb_is_digit(sv[2]) && nb_is_digit(sv[3]) && sv[4] == '-' &&
+           nb_is_digit(sv[5]) && nb_is_digit(sv[6]) && sv[7] == '-' &&
+           nb_is_digit(sv[8]) && nb_is_digit(sv[9]);
+  }
+  if (fmt == "time") {
+    if (sv.size() < 8) return false;
+    return nb_is_digit(sv[0]) && nb_is_digit(sv[1]) && sv[2] == ':' &&
+           nb_is_digit(sv[3]) && nb_is_digit(sv[4]) && sv[5] == ':' &&
+           nb_is_digit(sv[6]) && nb_is_digit(sv[7]);
+  }
+  if (fmt == "date-time") {
+    if (sv.size() < 19) return false;
+    if (!napi_check_format(sv.substr(0, 10), "date")) return false;
+    if (sv[10] != 'T' && sv[10] != 't' && sv[10] != ' ') return false;
+    return napi_check_format(sv.substr(11), "time");
+  }
+  if (fmt == "ipv4") {
+    int parts = 0, val = 0, digits = 0;
+    for (size_t i = 0; i <= sv.size(); ++i) {
+      if (i == sv.size() || sv[i] == '.') {
+        if (digits == 0 || val > 255) return false;
+        ++parts; val = 0; digits = 0;
+      } else if (nb_is_digit(sv[i])) {
+        val = val * 10 + (sv[i] - '0'); ++digits;
+        if (digits > 3) return false;
+      } else {
+        return false;
+      }
+    }
+    return parts == 4;
+  }
+  if (fmt == "ipv6") return sv.find(':') != std::string::npos;
+  if (fmt == "uri" || fmt == "uri-reference") {
+    if (sv.size() < 3 || !nb_is_alpha(sv[0])) return false;
+    size_t i = 1;
+    while (i < sv.size() && (nb_is_alnum(sv[i]) || sv[i] == '+' || sv[i] == '-' || sv[i] == '.')) ++i;
+    return i < sv.size() && sv[i] == ':' && i + 1 < sv.size();
+  }
+  if (fmt == "uuid") {
+    if (sv.size() != 36) return false;
+    for (size_t i = 0; i < 36; ++i) {
+      if (i == 8 || i == 13 || i == 18 || i == 23) {
+        if (sv[i] != '-') return false;
+      } else {
+        if (!nb_is_hex(sv[i])) return false;
+      }
+    }
+    return true;
+  }
+  if (fmt == "hostname") {
+    if (sv.empty() || sv.size() > 253) return false;
+    size_t label_len = 0;
+    for (size_t i = 0; i < sv.size(); ++i) {
+      if (sv[i] == '.') { if (label_len == 0) return false; label_len = 0; }
+      else if (nb_is_alnum(sv[i]) || sv[i] == '-') { ++label_len; if (label_len > 63) return false; }
+      else return false;
+    }
+    return label_len > 0;
+  }
+  return true;
+}
+
 // --- V8 Direct Validator ---
 
 static std::string napi_type_of(Napi::Value val) {
@@ -115,17 +211,66 @@ static uint64_t utf8_codepoint_length(const std::string& s) {
 }
 
 // Serialize a Napi::Value to a minified JSON string (for enum/const comparison)
-static std::string napi_to_json(Napi::Env env, Napi::Value val) {
-  auto json = env.Global().Get("JSON").As<Napi::Object>();
-  auto stringify = json.Get("stringify").As<Napi::Function>();
-  auto result = stringify.Call(json, {val});
-  if (result.IsString()) {
-    return result.As<Napi::String>().Utf8Value();
+// Canonical JSON: sort object keys for semantic equality comparison
+static std::string napi_canonical_json(Napi::Env env, Napi::Value val) {
+  if (val.IsNull() || val.IsUndefined()) return "null";
+  if (val.IsBoolean()) return val.As<Napi::Boolean>().Value() ? "true" : "false";
+  if (val.IsNumber()) {
+    double d = val.As<Napi::Number>().DoubleValue();
+    if (d == static_cast<int64_t>(d) && std::abs(d) <= 9007199254740991.0) {
+      return std::to_string(static_cast<int64_t>(d));
+    }
+    auto json = env.Global().Get("JSON").As<Napi::Object>();
+    auto stringify = json.Get("stringify").As<Napi::Function>();
+    auto r = stringify.Call(json, {val});
+    return r.IsString() ? r.As<Napi::String>().Utf8Value() : "null";
+  }
+  if (val.IsString()) {
+    // JSON-encode the string
+    auto json = env.Global().Get("JSON").As<Napi::Object>();
+    auto stringify = json.Get("stringify").As<Napi::Function>();
+    auto r = stringify.Call(json, {val});
+    return r.IsString() ? r.As<Napi::String>().Utf8Value() : "null";
+  }
+  if (val.IsArray()) {
+    auto arr = val.As<Napi::Array>();
+    std::string r = "[";
+    for (uint32_t i = 0; i < arr.Length(); ++i) {
+      if (i) r += ',';
+      r += napi_canonical_json(env, arr.Get(i));
+    }
+    r += ']';
+    return r;
+  }
+  if (val.IsObject()) {
+    auto obj = val.As<Napi::Object>();
+    auto keys = obj.GetPropertyNames();
+    std::vector<std::string> sorted_keys;
+    for (uint32_t i = 0; i < keys.Length(); ++i) {
+      sorted_keys.push_back(keys.Get(i).As<Napi::String>().Utf8Value());
+    }
+    std::sort(sorted_keys.begin(), sorted_keys.end());
+    std::string r = "{";
+    for (size_t i = 0; i < sorted_keys.size(); ++i) {
+      if (i) r += ',';
+      // JSON-encode the key
+      auto json = env.Global().Get("JSON").As<Napi::Object>();
+      auto stringify = json.Get("stringify").As<Napi::Function>();
+      auto k = stringify.Call(json, {Napi::String::New(env, sorted_keys[i])});
+      r += k.As<Napi::String>().Utf8Value();
+      r += ':';
+      r += napi_canonical_json(env, obj.Get(sorted_keys[i]));
+    }
+    r += '}';
+    return r;
   }
-  if (val.IsUndefined()) return "null";
   return "null";
 }
 
+static std::string napi_to_json(Napi::Env env, Napi::Value val) {
+  return napi_canonical_json(env, val);
+}
+
 static void validate_napi(const schema_node_ptr& node,
                            Napi::Value value,
                            Napi::Env env,
@@ -150,63 +295,80 @@ static void validate_napi(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_napi(it->second, value, env, path, ctx, errors);
-      return;
+      ref_resolved = true;
     }
-    // JSON Pointer resolution from root
-    if (node->ref.size() > 1 && node->ref[0] == '#' &&
+    if (!ref_resolved && node->ref.size() > 1 && node->ref[0] == '#' &&
         node->ref[1] == '/') {
+      // Decode JSON Pointer segments
+      auto decode_seg = [](const std::string& seg) -> std::string {
+        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;
+      };
       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_seg(
+            pointer.substr(spos, snext == std::string::npos ? snext : snext - spos)));
+        spos = (snext == std::string::npos) ? pointer.size() : snext + 1;
+      }
       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);
-        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];
-          } else {
-            key += segment[i];
-          }
-        }
-        if (key == "properties" && !current->properties.empty()) {
-          pos = (next == std::string::npos) ? pointer.size() : next + 1;
-          next = pointer.find('/', pos);
-          std::string prop = pointer.substr(
-              pos, next == std::string::npos ? next : next - pos);
-          auto pit = current->properties.find(prop);
+      for (size_t si = 0; si < segments.size() && current; ++si) {
+        const auto& key = segments[si];
+        if (key == "properties" && si + 1 < segments.size()) {
+          auto pit = current->properties.find(segments[++si]);
           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") {
-          pos = (next == std::string::npos) ? pointer.size() : next + 1;
-          next = pointer.find('/', pos);
-          std::string def = pointer.substr(
-              pos, next == std::string::npos ? next : next - pos);
-          auto dit = ctx.defs.find("#/" + key + "/" + def);
-          if (dit != ctx.defs.end()) current = dit->second;
-          else { resolved = false; break; }
+          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 {
+              auto cit = ctx.defs.find("#/" + key + "/" + def_name);
+              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_s = pointer.substr(
-              pos, next == std::string::npos ? next : next - pos);
-          size_t idx = std::stoul(idx_s);
-          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) {
@@ -219,28 +381,26 @@ static void validate_napi(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_s = pointer.substr(
-              pos, next == std::string::npos ? next : next - pos);
-          size_t idx = std::stoul(idx_s);
-          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_napi(current, value, env, path, ctx, errors);
-        return;
+        ref_resolved = true;
       }
     }
-    if (node->ref == "#" && ctx.root) {
+    if (!ref_resolved && node->ref == "#" && ctx.root) {
       validate_napi(ctx.root, value, env, path, ctx, errors);
-      return;
+      ref_resolved = true;
+    }
+    if (!ref_resolved) {
+      errors.push_back({ata::error_code::ref_not_found, path,
+                        "cannot resolve $ref: " + node->ref});
     }
-    errors.push_back({ata::error_code::ref_not_found, path,
-                      "cannot resolve $ref: " + node->ref});
-    return;
   }
 
   auto actual_type = napi_type_of(value);
@@ -356,7 +516,7 @@ static void validate_napi(const schema_node_ptr& node,
                             std::to_string(node->max_length.value())});
     }
     if (node->compiled_pattern) {
-      if (!std::regex_search(sv, *node->compiled_pattern)) {
+      if (!re2::RE2::PartialMatch(sv, *node->compiled_pattern)) {
         errors.push_back({ata::error_code::pattern_mismatch, path,
                           "string does not match pattern: " +
                               node->pattern.value()});
@@ -364,40 +524,7 @@ static void validate_napi(const schema_node_ptr& node,
     }
     if (node->format.has_value()) {
       const auto& fmt = node->format.value();
-      bool format_ok = true;
-      if (fmt == "email") {
-        static const std::regex email_re(
-            R"([a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,})");
-        format_ok = std::regex_match(sv, email_re);
-      } else if (fmt == "uri" || fmt == "uri-reference") {
-        static const std::regex uri_re(R"([a-zA-Z][a-zA-Z0-9+\-.]*:.+)");
-        format_ok = std::regex_match(sv, uri_re);
-      } else if (fmt == "date") {
-        static const std::regex date_re(R"(\d{4}-\d{2}-\d{2})");
-        format_ok = std::regex_match(sv, date_re);
-      } else if (fmt == "date-time") {
-        static const std::regex dt_re(
-            R"(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+\-]\d{2}:\d{2})?)");
-        format_ok = std::regex_match(sv, dt_re);
-      } else if (fmt == "time") {
-        static const std::regex time_re(
-            R"(\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+\-]\d{2}:\d{2})?)");
-        format_ok = std::regex_match(sv, time_re);
-      } else if (fmt == "ipv4") {
-        static const std::regex ipv4_re(
-            R"((\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3}))");
-        format_ok = std::regex_match(sv, ipv4_re);
-      } else if (fmt == "ipv6") {
-        format_ok = sv.find(':') != std::string::npos;
-      } else if (fmt == "uuid") {
-        static const std::regex uuid_re(
-            R"([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})");
-        format_ok = std::regex_match(sv, uuid_re);
-      } else if (fmt == "hostname") {
-        static const std::regex host_re(
-            R"([a-zA-Z0-9]([a-zA-Z0-9\-]*[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9\-]*[a-zA-Z0-9])?)*)");
-        format_ok = std::regex_match(sv, host_re);
-      }
+      bool format_ok = napi_check_format(sv, fmt);
       if (!format_ok) {
         errors.push_back({ata::error_code::format_mismatch, path,
                           "string does not match format: " + fmt});
@@ -449,6 +576,28 @@ static void validate_napi(const schema_node_ptr& node,
                       path + "/" + std::to_string(i), ctx, errors);
       }
     }
+
+    // contains / minContains / maxContains
+    if (node->contains_schema) {
+      uint64_t match_count = 0;
+      for (uint32_t i = 0; i < arr_size; ++i) {
+        std::vector<ata::validation_error> tmp;
+        validate_napi(node->contains_schema, arr.Get(i), env, path, ctx, tmp);
+        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({ata::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({ata::error_code::max_items_violation, path,
+                          "contains: " + std::to_string(match_count) +
+                              " matches, maximum " + std::to_string(max_c)});
+      }
+    }
   }
 
   // Object validations
@@ -493,15 +642,11 @@ static void validate_napi(const schema_node_ptr& node,
         matched = true;
       }
 
-      for (const auto& [pat, pat_schema] : node->pattern_properties) {
-        try {
-          std::regex re(pat);
-          if (std::regex_search(key_str, re)) {
-            validate_napi(pat_schema, val, env, path + "/" + key_str, ctx,
-                          errors);
-            matched = true;
-          }
-        } catch (...) {
+      for (const auto& pp : node->pattern_properties) {
+        if (pp.compiled && re2::RE2::PartialMatch(key_str, *pp.compiled)) {
+          validate_napi(pp.schema, val, env, path + "/" + key_str, ctx,
+                        errors);
+          matched = true;
         }
       }
 
@@ -517,6 +662,35 @@ static void validate_napi(const schema_node_ptr& node,
         }
       }
     }
+
+    // propertyNames
+    if (node->property_names_schema) {
+      for (uint32_t i = 0; i < prop_count; ++i) {
+        Napi::Value key_val = keys.Get(i);
+        validate_napi(node->property_names_schema, key_val, env, path, ctx,
+                      errors);
+      }
+    }
+
+    // dependentRequired
+    for (const auto& [prop, deps] : node->dependent_required) {
+      if (obj.HasOwnProperty(prop)) {
+        for (const auto& dep : deps) {
+          if (!obj.HasOwnProperty(dep)) {
+            errors.push_back({ata::error_code::required_property_missing, path,
+                              "property '" + prop + "' requires '" + dep +
+                                  "' to be present"});
+          }
+        }
+      }
+    }
+
+    // dependentSchemas
+    for (const auto& [prop, schema] : node->dependent_schemas) {
+      if (obj.HasOwnProperty(prop)) {
+        validate_napi(schema, value, env, path, ctx, errors);
+      }
+    }
   }
 
   // allOf
@@ -618,7 +792,8 @@ class CompiledSchema : public Napi::ObjectWrap<CompiledSchema> {
         env, "CompiledSchema",
         {InstanceMethod("validate", &CompiledSchema::Validate),
          InstanceMethod("validateJSON", &CompiledSchema::ValidateJSON),
-         InstanceMethod("validateDirect", &CompiledSchema::ValidateDirect)});
+         InstanceMethod("validateDirect", &CompiledSchema::ValidateDirect),
+         InstanceMethod("isValidJSON", &CompiledSchema::IsValidJSON)});
     auto* constructor = new Napi::FunctionReference();
     *constructor = Napi::Persistent(func);
     env.SetInstanceData(constructor);
@@ -671,6 +846,17 @@ class CompiledSchema : public Napi::ObjectWrap<CompiledSchema> {
     return make_result(env, result);
   }
 
+  // Fast boolean-only validation — no error object creation
+  Napi::Value IsValidJSON(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    if (info.Length() < 1 || !info[0].IsString()) {
+      return Napi::Boolean::New(env, false);
+    }
+    std::string json = info[0].As<Napi::String>().Utf8Value();
+    auto result = ata::validate(schema_, json);
+    return Napi::Boolean::New(env, result.valid);
+  }
+
   // Explicit direct validation (always V8 traversal, never stringify)
   Napi::Value ValidateDirect(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();

package/binding.gyp

@@ -10,7 +10,11 @@
       "include_dirs": [
         "<!@(node -p \"require('node-addon-api').include\")",
         "include",
-        "deps/simdjson"
+        "deps/simdjson",
+        "<!@(node -e \"var p=process.platform,a=process.arch;if(p==='darwin'){console.log(a==='arm64'?'/opt/homebrew/opt/re2/include':'/usr/local/opt/re2/include');console.log(a==='arm64'?'/opt/homebrew/opt/abseil/include':'/usr/local/opt/abseil/include')}else{console.log('/usr/include')}\")"
+      ],
+      "libraries": [
+        "<!@(node -e \"var p=process.platform,a=process.arch;if(p==='darwin'){var pre=a==='arm64'?'/opt/homebrew/opt/re2':'/usr/local/opt/re2';console.log('-L'+pre+'/lib -lre2')}else{console.log('-lre2')}\")"
       ],
       "dependencies": [
         "<!(node -p \"require('node-addon-api').gyp\")"
@@ -26,6 +30,13 @@
             "CLANG_CXX_LANGUAGE_STANDARD": "c++20",
             "MACOSX_DEPLOYMENT_TARGET": "12.0"
           }
+        }],
+        ["OS=='win'", {
+          "msvs_settings": {
+            "VCCLCompilerTool": {
+              "AdditionalOptions": ["/std:c++20", "/EHsc"]
+            }
+          }
         }]
       ]
     }

package/compat.d.ts

@@ -0,0 +1,23 @@
+interface AjvError {
+  instancePath: string;
+  schemaPath: string;
+  keyword: string;
+  params: Record<string, unknown>;
+  message: string;
+}
+
+interface ValidateFunction {
+  (data: unknown): boolean;
+  errors: AjvError[] | null;
+  schema: object;
+}
+
+declare class Ata {
+  constructor(opts?: Record<string, unknown>);
+  compile(schema: object): ValidateFunction;
+  validate(schema: object, data: unknown): boolean;
+  addSchema(schema: object, key?: string): this;
+  getSchema(key: string): ValidateFunction | undefined;
+}
+
+export = Ata;

package/index.d.ts

@@ -0,0 +1,37 @@
+export interface ValidationError {
+  code: number;
+  path: string;
+  message: string;
+}
+
+export interface ValidationResult {
+  valid: boolean;
+  errors: ValidationError[];
+}
+
+export interface StandardSchemaV1Props {
+  version: 1;
+  vendor: "ata-validator";
+  validate(
+    value: unknown
+  ):
+    | { value: unknown }
+    | { issues: Array<{ message: string; path?: ReadonlyArray<{ key: PropertyKey }> }> };
+}
+
+export class Validator {
+  constructor(schema: object | string);
+  validate(data: unknown): ValidationResult;
+  validateJSON(jsonString: string): ValidationResult;
+  isValidJSON(jsonString: string): boolean;
+
+  /** Standard Schema V1 interface — compatible with Fastify, tRPC, TanStack, etc. */
+  readonly "~standard": StandardSchemaV1Props;
+}
+
+export function validate(
+  schema: object | string,
+  data: unknown
+): ValidationResult;
+
+export function version(): string;