ata-validator 0.8.0 → 0.9.0

package/README.md

@@ -13,7 +13,7 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 | **validate(obj)** valid | 22ns | 102ns | **ata 4.6x faster** |
 | **validate(obj)** invalid | 87ns | 182ns | **ata 2.1x faster** |
 | **isValidObject(obj)** | 21ns | 100ns | **ata 4.7x faster** |
-| **Schema compilation** | 695ns | 1.30ms | **ata 1,867x faster** |
+| **Schema compilation** | 453ns | 1.24ms | **ata 2,729x faster** |
 | **First validation** | 2.07μs | 1.11ms | **ata 534x faster** |
 
 ### Complex Schema (patternProperties + dependentSchemas + propertyNames + additionalProperties)
@@ -54,7 +54,7 @@ Three-tier hybrid codegen: static schemas compile to zero-overhead key checks, d
 |---|---|---|---|---|---|
 | **validate (valid)** | **9ns** | 38ns | 50ns | 334ns | 326ns |
 | **validate (invalid)** | **37ns** | 103ns | 4ns | 11.8μs | 842ns |
-| **compilation** | **584ns** | 1.20ms | 52μs | — | — |
+| **compilation** | **453ns** | 1.24ms | 52μs | — | — |
 | **first validation** | **2.1μs** | 1.11ms | 54μs | — | — |
 
 > Different categories: ata/ajv/typebox are JSON Schema validators, zod/valibot are schema-builder DSLs. [Benchmark code](benchmark/bench_all_mitata.mjs)
@@ -71,7 +71,7 @@ Three-tier hybrid codegen: static schemas compile to zero-overhead key checks, d
 
 | Scenario | ata | ajv | |
 |---|---|---|---|
-| **Serverless cold start** (50 schemas) | 0.1ms | 23ms | **ata 230x faster** |
+| **Serverless cold start** (50 schemas) | 0.087ms | 3.67ms | **ata 42x faster** |
 | **ReDoS protection** (`^(a+)+$`) | 0.3ms | 765ms | **ata immune (RE2)** |
 | **Batch NDJSON** (10K items, multi-core) | 13.4M/sec | 5.1M/sec | **ata 2.6x faster** |
 | **Fastify startup** (5 routes) | 0.5ms | 6.0ms | **ata 12x faster** |
@@ -88,14 +88,26 @@ Three-tier hybrid codegen: static schemas compile to zero-overhead key checks, d
 
 **Adaptive simdjson**: For large documents (>8KB) with selective schemas, simdjson On Demand seeks only the needed fields - skipping irrelevant data at GB/s speeds.
 
+### $dynamicRef / $dynamicAnchor / $anchor
+
+| Scenario | ata | ajv | |
+|---|---|---|---|
+| **$dynamicRef tree** valid | 22ns | 54ns | **ata 2.4x faster** |
+| **$dynamicRef tree** invalid | 70ns | 76ns | **ata 1.1x faster** |
+| **$dynamicRef override** valid | 2.6ns | 183ns | **ata 70x faster** |
+| **$dynamicRef override** invalid | 48ns | 185ns | **ata 3.8x faster** |
+| **$anchor array** valid | 2.3ns | 3.1ns | **ata 1.4x faster** |
+
+Self-recursive named functions for $dynamicRef, compile-time cross-schema resolution, zero-wrapper hybrid path. [Benchmark code](benchmark/bench_dynamicref_vs_ajv.mjs)
+
 ### JSON Schema Test Suite
 
-**96.9%** pass rate (1109/1144) on official [JSON Schema Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite) (Draft 2020-12).
+**95.3%** pass rate (1170/1227) on official [JSON Schema Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite) (Draft 2020-12). **95.3%** on [@exodus/schemasafe](https://github.com/ExodusMovement/schemasafe) test suite.
 
 ## When to use ata
 
-- **High-throughput `validate(obj)`** - 6.8x faster than ajv on complex schemas, 38x faster than zod
-- **Complex schemas** - `patternProperties`, `dependentSchemas`, `propertyNames`, `unevaluatedProperties` all inline JS codegen (6.8x faster than ajv)
+- **High-throughput `validate(obj)`** - 3.1x faster than ajv, 38x faster than zod
+- **Complex schemas** - `patternProperties`, `dependentSchemas`, `propertyNames`, `unevaluatedProperties` all inline JS codegen
 - **Multi-schema projects** - cross-schema `$ref` with `$id` registry, `addSchema()` API
 - **Draft 7 migration** - auto-detects `$schema`, normalizes Draft 7 keywords transparently
 - **Serverless / cold starts** - 6,904x faster compilation, 5,148x faster first validation
@@ -106,12 +118,13 @@ Three-tier hybrid codegen: static schemas compile to zero-overhead key checks, d
 
 ## When to use ajv
 
-- **`$dynamicRef`** - not yet supported in ata
 - **Existing ajv ecosystem** - plugins, custom keywords, large community
+- **Full unevaluatedProperties/Items** - ata covers most cases but some edge cases remain
 
 ## Features
 
-- **Hybrid validator**: 6.8x faster than ajv valid, 6.0x faster invalid on complex schemas - jsFn boolean guard for valid path (zero allocation), combined codegen with pre-allocated errors for invalid path. Schema compilation cache for repeated schemas
+- **Hybrid validator**: 4.1x faster than ajv, up to 70x faster on $dynamicRef - zero-wrapper hybrid path for valid data (no allocation), combined codegen for error collection. Schema compilation cache for repeated schemas
+- **$dynamicRef / $dynamicAnchor / $anchor**: Full Draft 2020-12 dynamic reference support. Self-recursive named functions, compile-time cross-schema resolution (42/42 spec tests)
 - **Cross-schema `$ref`**: `schemas` option and `addSchema()` API. Compile-time resolution with `$id` registry, zero runtime overhead
 - **Draft 7 support**: Auto-detects `$schema` field, normalizes `dependencies`/`additionalItems`/`definitions` transparently
 - **Multi-core**: Parallel validation across all CPU cores - 13.4M validations/sec

package/binding/ata_napi.cpp

@@ -17,6 +17,7 @@
 #include <vector>
 
 #include "ata.h"
+#include <simdjson.h>
 
 // ============================================================================
 // V8 Direct Object Traversal Engine
@@ -797,6 +798,67 @@ static void validate_napi(const schema_node_ptr& node,
 // N-API Binding
 // ============================================================================
 
+// ============================================================================
+// simdjson DOM to V8 JS Object conversion
+// ============================================================================
+
+static Napi::Value dom_to_napi(Napi::Env env, simdjson::dom::element el) {
+  using namespace simdjson;
+  switch (el.type()) {
+    case dom::element_type::OBJECT: {
+      auto obj = Napi::Object::New(env);
+      for (auto [key, val] : dom::object(el)) {
+        obj.Set(std::string(key), dom_to_napi(env, val));
+      }
+      return obj;
+    }
+    case dom::element_type::ARRAY: {
+      dom::array arr = el;
+      auto jsArr = Napi::Array::New(env, arr.size());
+      uint32_t i = 0;
+      for (auto val : arr) {
+        jsArr.Set(i++, dom_to_napi(env, val));
+      }
+      return jsArr;
+    }
+    case dom::element_type::STRING: {
+      std::string_view sv;
+      el.get(sv);
+      return Napi::String::New(env, sv.data(), sv.length());
+    }
+    case dom::element_type::INT64: {
+      int64_t v;
+      el.get(v);
+      return Napi::Number::New(env, static_cast<double>(v));
+    }
+    case dom::element_type::UINT64: {
+      uint64_t v;
+      el.get(v);
+      return Napi::Number::New(env, static_cast<double>(v));
+    }
+    case dom::element_type::DOUBLE: {
+      double v;
+      el.get(v);
+      return Napi::Number::New(env, v);
+    }
+    case dom::element_type::BOOL: {
+      bool v;
+      el.get(v);
+      return Napi::Boolean::New(env, v);
+    }
+    case dom::element_type::NULL_VALUE:
+      return env.Null();
+    default:
+      return env.Undefined();
+  }
+}
+
+// Thread-local simdjson DOM parser for parseJSON / validateAndParse
+static simdjson::dom::parser& tl_dom_parser() {
+  thread_local simdjson::dom::parser parser;
+  return parser;
+}
+
 static Napi::Object make_result(Napi::Env env,
                                 const ata::validation_result& result) {
   Napi::Object obj = Napi::Object::New(env);
@@ -822,7 +884,8 @@ class CompiledSchema : public Napi::ObjectWrap<CompiledSchema> {
         {InstanceMethod("validate", &CompiledSchema::Validate),
          InstanceMethod("validateJSON", &CompiledSchema::ValidateJSON),
          InstanceMethod("validateDirect", &CompiledSchema::ValidateDirect),
-         InstanceMethod("isValidJSON", &CompiledSchema::IsValidJSON)});
+         InstanceMethod("isValidJSON", &CompiledSchema::IsValidJSON),
+         InstanceMethod("validateAndParse", &CompiledSchema::ValidateAndParse)});
     auto* constructor = new Napi::FunctionReference();
     *constructor = Napi::Persistent(func);
     env.SetInstanceData(constructor);
@@ -944,6 +1007,77 @@ class CompiledSchema : public Napi::ObjectWrap<CompiledSchema> {
     return ValidateDirectImpl(env, info[0]);
   }
 
+  // Parse JSON with simdjson, validate against schema, return parsed JS object
+  Napi::Value ValidateAndParse(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    if (info.Length() < 1) {
+      Napi::TypeError::New(env, "JSON string or Buffer expected")
+          .ThrowAsJavaScriptException();
+      return env.Undefined();
+    }
+
+    const char* data;
+    size_t len;
+
+    if (info[0].IsBuffer()) {
+      auto buf = info[0].As<Napi::Buffer<char>>();
+      data = buf.Data();
+      len = buf.Length();
+    } else if (info[0].IsString()) {
+      auto [d, l] = extract_string(env, info[0]);
+      data = d;
+      len = l;
+    } else {
+      Napi::TypeError::New(env, "JSON string or Buffer expected")
+          .ThrowAsJavaScriptException();
+      return env.Undefined();
+    }
+
+    // Parse with simdjson
+    simdjson::padded_string padded(data, len);
+    auto& parser = tl_dom_parser();
+    auto doc_result = parser.parse(padded);
+    if (doc_result.error()) {
+      auto obj = Napi::Object::New(env);
+      obj.Set("valid", false);
+      obj.Set("value", env.Null());
+      auto errors = Napi::Array::New(env, 1);
+      auto err = Napi::Object::New(env);
+      err.Set("code", Napi::Number::New(env, static_cast<int>(ata::error_code::invalid_json)));
+      err.Set("path", Napi::String::New(env, ""));
+      err.Set("message", Napi::String::New(env, "Invalid JSON"));
+      errors[0u] = err;
+      obj.Set("errors", errors);
+      return obj;
+    }
+
+    // Validate
+    auto valResult = ata::validate(schema_, std::string_view(data, len));
+
+    // Convert DOM to JS object
+    Napi::Value jsValue = dom_to_napi(env, doc_result.value());
+
+    // Build result
+    auto obj = Napi::Object::New(env);
+    obj.Set("valid", valResult.valid);
+    obj.Set("value", jsValue);
+    if (valResult.valid) {
+      obj.Set("errors", Napi::Array::New(env, 0));
+    } else {
+      Napi::Array errors = Napi::Array::New(env, valResult.errors.size());
+      for (size_t i = 0; i < valResult.errors.size(); ++i) {
+        Napi::Object err = Napi::Object::New(env);
+        err.Set("code",
+                Napi::Number::New(env, static_cast<int>(valResult.errors[i].code)));
+        err.Set("path", Napi::String::New(env, valResult.errors[i].path));
+        err.Set("message", Napi::String::New(env, valResult.errors[i].message));
+        errors[i] = err;
+      }
+      obj.Set("errors", errors);
+    }
+    return obj;
+  }
+
  private:
   Napi::Value ValidateDirectImpl(Napi::Env env, Napi::Value value) {
     compiled_schema_internal ctx;
@@ -996,6 +1130,44 @@ Napi::Value GetVersion(const Napi::CallbackInfo& info) {
   return Napi::String::New(info.Env(), std::string(ata::version()));
 }
 
+// Standalone JSON parser using simdjson — returns parsed JS object
+Napi::Value ParseJSON(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1) {
+    Napi::TypeError::New(env, "JSON string or Buffer expected")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  const char* data;
+  size_t len;
+
+  if (info[0].IsBuffer()) {
+    auto buf = info[0].As<Napi::Buffer<char>>();
+    data = buf.Data();
+    len = buf.Length();
+  } else if (info[0].IsString()) {
+    auto [d, l] = CompiledSchema::extract_string(env, info[0]);
+    data = d;
+    len = l;
+  } else {
+    Napi::TypeError::New(env, "JSON string or Buffer expected")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  // Parse with simdjson using thread-local parser
+  simdjson::padded_string padded(data, len);
+  auto& parser = tl_dom_parser();
+  auto result = parser.parse(padded);
+  if (result.error()) {
+    Napi::Error::New(env, "Invalid JSON").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  return dom_to_napi(env, result.value());
+}
+
 // --- Thread Pool ---
 class ThreadPool {
 public:
@@ -1531,6 +1703,7 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
   CompiledSchema::Init(env, exports);
   exports.Set("validate", Napi::Function::New(env, ValidateOneShot));
   exports.Set("version", Napi::Function::New(env, GetVersion));
+  exports.Set("parseJSON", Napi::Function::New(env, ParseJSON));
   exports.Set("fastRegister", Napi::Function::New(env, FastRegister));
   exports.Set("fastValidate", Napi::Function::New(env, FastValidateSlow));
 

package/include/ata.h

@@ -8,14 +8,16 @@
 #include <variant>
 #include <vector>
 
+#define ATA_VERSION "0.9.0"
+
 namespace ata {
 
 inline constexpr uint32_t VERSION_MAJOR = 0;
-inline constexpr uint32_t VERSION_MINOR = 4;
-inline constexpr uint32_t VERSION_REVISION = 3;
+inline constexpr uint32_t VERSION_MINOR = 9;
+inline constexpr uint32_t VERSION_REVISION = 0;
 
 inline constexpr std::string_view version() noexcept {
-  return "0.4.3";
+  return "0.9.0";
 }
 
 enum class error_code : uint8_t {
@@ -64,8 +66,14 @@ struct validation_result {
 
 struct compiled_schema;
 
+struct schema_warning {
+  std::string path;
+  std::string message;
+};
+
 struct schema_ref {
   std::shared_ptr<compiled_schema> impl;
+  std::vector<schema_warning> warnings;
 
   explicit operator bool() const noexcept { return impl != nullptr; }
 };

package/index.js

@@ -264,6 +264,10 @@ function buildPreprocessCodegen(schema, options) {
 // Schema compilation cache: same schema string -> reuse compiled functions
 const _compileCache = new Map();
 
+// Object identity cache: same schema object reference -> reuse entire compiled state
+// Skips JSON.stringify, cache lookup, and all setup. Near-zero cost for repeated schemas.
+const _identityCache = new WeakMap();
+
 const SIMDJSON_PADDING = 64;
 const VALID_RESULT = Object.freeze({ valid: true, errors: Object.freeze([]) });
 
@@ -322,12 +326,18 @@ class Validator {
     const options = opts || {};
     const schemaObj = typeof schema === "string" ? JSON.parse(schema) : schema;
 
+    // Ultra-fast path: same schema object reference -> return cached instance
+    // JS constructor returning an object makes `new` return that object
+    // Cost: one WeakMap lookup. No property copy, no setup, nothing.
+    if (!opts && typeof schema === "object" && schema !== null) {
+      const hit = _identityCache.get(schema);
+      if (hit) return hit;
+    }
+
     // Draft 7 normalization — convert keywords to 2020-12 equivalents in-place
     normalizeDraft7(schemaObj);
 
-    const schemaStr = JSON.stringify(schemaObj);
-
-    this._schemaStr = schemaStr;
+    this._schemaStr = null; // lazy: computed on first use
     this._schemaObj = schemaObj;
     this._options = options;
     this._initialized = false;
@@ -358,6 +368,11 @@ class Validator {
       this._ensureCompiled();
       return this.isValidJSON(jsonStr);
     };
+    this.validateAndParse = (jsonStr) => {
+      if (!native) throw new Error('Native addon required for validateAndParse()');
+      this._ensureCompiled();
+      return this.validateAndParse(jsonStr);
+    };
     this.isValid = (buf) => {
       if (!native) throw new Error('Native addon required for isValid() — use validate() or isValidObject() instead');
       this._ensureCompiled();
@@ -407,6 +422,9 @@ class Validator {
     const schemaObj = this._schemaObj;
     const options = this._options;
 
+    // Lazy stringify — only computed here, not in constructor
+    if (!this._schemaStr) this._schemaStr = JSON.stringify(schemaObj);
+
     // Check cache first -- reuse compiled functions for same schema
     const sm = this._schemaMap.size > 0 ? this._schemaMap : null;
     const mapKey = this._schemaMap.size > 0
@@ -475,7 +493,7 @@ class Validator {
       }
       // errFn: use JS codegen if safe, else lazy-native fallback
       // For unevaluated schemas without errFn, use jsFn as boolean-only fallback
-      const hasUnevaluated = schemaObj && JSON.stringify(schemaObj).includes('unevaluatedProperties') || JSON.stringify(schemaObj).includes('unevaluatedItems')
+      const hasUnevaluated = schemaObj && (schemaObj.unevaluatedProperties !== undefined || schemaObj.unevaluatedItems !== undefined || this._schemaStr.includes('unevaluatedProperties') || this._schemaStr.includes('unevaluatedItems'))
       const hasDynRef = this._schemaStr.includes('"$dynamicRef"') || this._schemaStr.includes('"$dynamicAnchor"')
       const errFn =
         safeErrFn ||
@@ -616,6 +634,17 @@ class Validator {
               return false;
             }
           };
+      // validateAndParse: requires native addon for simdjson parsing
+      if (native) {
+        const self = this;
+        this.validateAndParse = (jsonStr) => {
+          self._ensureNative();
+          self.validateAndParse = (s) => self._compiled.validateAndParse(s);
+          return self.validateAndParse(jsonStr);
+        };
+      } else {
+        this.validateAndParse = () => { throw new Error('Native addon required for validateAndParse()'); };
+      }
       // Buffer APIs: lazy native init — only compile native schema on first buffer call.
       // This keeps cold start fast (JS codegen only) for users who only use validate().
       if (native) {
@@ -657,6 +686,7 @@ class Validator {
       this.isValidObject = (data) => _validate(data).valid;
       this.validateJSON = (jsonStr) => this._compiled.validateJSON(jsonStr);
       this.isValidJSON = (jsonStr) => this._compiled.isValidJSON(jsonStr);
+      this.validateAndParse = (jsonStr) => this._compiled.validateAndParse(jsonStr);
       {
         const slot = this._fastSlot;
         this.isValid = (buf) => {
@@ -685,6 +715,11 @@ class Validator {
         };
       }
     }
+
+    // Save to identity cache for ultra-fast reuse with same schema object
+    if (this._schemaObj && typeof this._schemaObj === 'object') {
+      _identityCache.set(this._schemaObj, this);
+    }
   }
 
   _ensureNative() {
@@ -861,6 +896,14 @@ module.exports = { boolFn, hybridFactory, errFn };
       }
     };
 
+    v.validateAndParse = native
+      ? (jsonStr) => {
+          v._ensureNative();
+          v.validateAndParse = (s) => v._compiled.validateAndParse(s);
+          return v.validateAndParse(jsonStr);
+        }
+      : () => { throw new Error('Native addon required for validateAndParse()'); };
+
     // Standard Schema V1
     Object.defineProperty(v, "~standard", {
       value: Object.freeze({
@@ -1060,10 +1103,31 @@ Validator.loadBundle = function (mods, schemas, opts) {
   });
 };
 
+const parseJSON = native ? native.parseJSON : JSON.parse;
+
+// Ultra-fast compile: returns validate function directly, no Validator wrapper
+// WeakMap cached — second call with same schema object is ~3ns
+const _compileFnCache = new WeakMap();
+function compile(schema, opts) {
+  if (!opts && typeof schema === 'object' && schema !== null) {
+    const hit = _compileFnCache.get(schema);
+    if (hit) return hit;
+  }
+  const v = new Validator(schema, opts);
+  v._ensureCompiled();
+  const fn = v.validate;
+  if (!opts && typeof schema === 'object' && schema !== null) {
+    _compileFnCache.set(schema, fn);
+  }
+  return fn;
+}
+
 module.exports = {
   Validator,
+  compile,
   validate,
   version,
   createPaddedBuffer,
   SIMDJSON_PADDING,
+  parseJSON,
 };

package/lib/js-compiler.js

@@ -805,8 +805,8 @@ function compileToJSCodegen(schema, schemaMap) {
   if (ctx.usesRecursion) {
     // Self-recursive: wrap in named function
     body = `function _validate(d){\n  ${checkStr}\n  return true\n  }\n  return _validate(d)`
-    const hybridCheck = replaceTopLevel(checkStr + '\n  return R')
-    hybridBody = `function _validate(d){\n  ${hybridCheck}\n  }\n  return _validate(d)`
+    // Hybrid: keep _validate as boolean, wrap only the outer call
+    hybridBody = `function _validate(d){\n  ${checkStr}\n  return true\n  }\n  return _validate(d)?R:E(d)`
   } else {
     body = checkStr + '\n  return true'
     hybridBody = replaceTopLevel(checkStr + '\n  return R')
@@ -872,6 +872,84 @@ function replaceTopLevel(code) {
   return result
 }
 
+// Returns true if a property sub-schema will generate 2+ lines that each access v,
+// meaning a local variable hoist is worthwhile.
+function needsLocal(schema) {
+  if (typeof schema !== 'object' || schema === null) return false
+  // If it has $ref, allOf, anyOf etc., genCode handles it — don't hoist
+  if (schema.$ref || schema.allOf || schema.anyOf || schema.oneOf || schema.if) return false
+  if (schema.properties || schema.items || schema.prefixItems) return false
+  const types = schema.type ? (Array.isArray(schema.type) ? schema.type : [schema.type]) : null
+  if (!types || types.length !== 1) return false
+  const t = types[0]
+  let checkCount = 1 // type check itself
+  if (t === 'string') {
+    if (schema.minLength !== undefined) checkCount++
+    if (schema.maxLength !== undefined) checkCount++
+    if (schema.pattern) checkCount++
+    if (schema.format) checkCount++
+  } else if (t === 'integer' || t === 'number') {
+    if (schema.minimum !== undefined) checkCount++
+    if (schema.maximum !== undefined) checkCount++
+    if (schema.exclusiveMinimum !== undefined) checkCount++
+    if (schema.exclusiveMaximum !== undefined) checkCount++
+    if (schema.multipleOf !== undefined) checkCount++
+  }
+  return checkCount >= 2
+}
+
+// Try to generate a single combined check for simple leaf schemas.
+// Returns a string like "{const _v=d["x"];if(typeof _v!=='string'||_v.length<1||_v.length>100)return false}"
+// or null if the schema is too complex.
+function tryGenCombined(schema, access, ctx) {
+  if (typeof schema !== 'object' || schema === null) return null
+  // Only handle simple leaf schemas with a single type and basic constraints
+  if (schema.$ref || schema.allOf || schema.anyOf || schema.oneOf || schema.if) return null
+  if (schema.properties || schema.items || schema.prefixItems || schema.patternProperties) return null
+  if (schema.enum || schema.const !== undefined) return null
+  if (schema.not || schema.dependentRequired || schema.dependentSchemas) return null
+  const types = schema.type ? (Array.isArray(schema.type) ? schema.type : [schema.type]) : null
+  if (!types || types.length !== 1) return null
+  const t = types[0]
+
+  if (t === 'string') {
+    const conds = [`typeof _v!=='string'`]
+    if (schema.minLength !== undefined) conds.push(`_v.length<${schema.minLength}`)
+    if (schema.maxLength !== undefined) conds.push(`_v.length>${schema.maxLength}`)
+    if (conds.length < 2 && !schema.pattern && !schema.format) return null // not worth combining
+    // pattern and format need separate statements, fall back if present
+    if (schema.pattern || schema.format) return null
+    const vi = ctx.varCounter++
+    return `{const _v=${access};if(${conds.join('||')})return false}`
+  }
+
+  if (t === 'integer') {
+    const conds = [`!Number.isInteger(_v)`]
+    if (schema.minimum !== undefined) conds.push(`_v<${schema.minimum}`)
+    if (schema.maximum !== undefined) conds.push(`_v>${schema.maximum}`)
+    if (schema.exclusiveMinimum !== undefined) conds.push(`_v<=${schema.exclusiveMinimum}`)
+    if (schema.exclusiveMaximum !== undefined) conds.push(`_v>=${schema.exclusiveMaximum}`)
+    if (schema.multipleOf !== undefined) conds.push(`_v%${schema.multipleOf}!==0`)
+    if (conds.length < 2) return null
+    const vi = ctx.varCounter++
+    return `{const _v=${access};if(${conds.join('||')})return false}`
+  }
+
+  if (t === 'number') {
+    const conds = [`typeof _v!=='number'||!isFinite(_v)`]
+    if (schema.minimum !== undefined) conds.push(`_v<${schema.minimum}`)
+    if (schema.maximum !== undefined) conds.push(`_v>${schema.maximum}`)
+    if (schema.exclusiveMinimum !== undefined) conds.push(`_v<=${schema.exclusiveMinimum}`)
+    if (schema.exclusiveMaximum !== undefined) conds.push(`_v>=${schema.exclusiveMaximum}`)
+    if (schema.multipleOf !== undefined) conds.push(`_v%${schema.multipleOf}!==0`)
+    if (conds.length < 2) return null
+    const vi = ctx.varCounter++
+    return `{const _v=${access};if(${conds.join('||')})return false}`
+  }
+
+  return null
+}
+
 // knownType: if parent already verified the type, skip redundant guards.
 // 'object' = we know v is a non-null non-array object
 // 'array'  = we know v is an array
@@ -884,8 +962,10 @@ function genCode(schema, v, lines, ctx, knownType) {
   // Only when THIS schema has unevaluated keywords directly (not via $ref target)
   const hasSiblings = schema.$ref && (schema.unevaluatedProperties !== undefined || schema.unevaluatedItems !== undefined)
   if (schema.$ref) {
-    // Self-reference "#" — no-op (permissive) to avoid infinite recursion
+    // Self-reference "#" — recursive call to root validator
     if (schema.$ref === '#') {
+      ctx.usesRecursion = true
+      lines.push(`if(!_validate(${v}))return false`)
       if (!hasSiblings) return
     }
     // 1. Local ref
@@ -961,20 +1041,32 @@ function genCode(schema, v, lines, ctx, knownType) {
   let effectiveType = knownType
   if (types) {
     if (!knownType) {
-      // Emit the type check
-      const conds = types.map(t => {
-        switch (t) {
-          case 'object': return `(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
-          case 'array': return `Array.isArray(${v})`
-          case 'string': return `typeof ${v}==='string'`
-          case 'number': return `(typeof ${v}==='number'&&isFinite(${v}))`
-          case 'integer': return `Number.isInteger(${v})`
-          case 'boolean': return `(${v}===true||${v}===false)`
-          case 'null': return `${v}===null`
-          default: return 'true'
+      // Emit the type check — use direct negation for single types (avoids !() wrapper)
+      if (types.length === 1) {
+        switch (types[0]) {
+          case 'object': lines.push(`if(typeof ${v}!=='object'||${v}===null||Array.isArray(${v}))return false`); break
+          case 'array': lines.push(`if(!Array.isArray(${v}))return false`); break
+          case 'string': lines.push(`if(typeof ${v}!=='string')return false`); break
+          case 'number': lines.push(`if(typeof ${v}!=='number'||!isFinite(${v}))return false`); break
+          case 'integer': lines.push(`if(!Number.isInteger(${v}))return false`); break
+          case 'boolean': lines.push(`if(typeof ${v}!=='boolean')return false`); break
+          case 'null': lines.push(`if(${v}!==null)return false`); break
         }
-      })
-      lines.push(`if(!(${conds.join('||')}))return false`)
+      } else {
+        const conds = types.map(t => {
+          switch (t) {
+            case 'object': return `(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
+            case 'array': return `Array.isArray(${v})`
+            case 'string': return `typeof ${v}==='string'`
+            case 'number': return `(typeof ${v}==='number'&&isFinite(${v}))`
+            case 'integer': return `Number.isInteger(${v})`
+            case 'boolean': return `typeof ${v}==='boolean'`
+            case 'null': return `${v}===null`
+            default: return 'true'
+          }
+        })
+        lines.push(`if(!(${conds.join('||')}))return false`)
+      }
     }
     // If single type, downstream checks can skip guards
     if (types.length === 1) effectiveType = types[0]
@@ -1291,14 +1383,31 @@ function genCode(schema, v, lines, ctx, knownType) {
   if (schema.properties) {
     for (const [key, prop] of Object.entries(schema.properties)) {
       if (requiredSet.has(key) && isObj) {
-        // Required + type:object — property exists, use destructured local
-        genCode(prop, hoisted[key] || `${v}[${JSON.stringify(key)}]`, lines, ctx)
+        // Required + type:object — hoist to local to reduce repeated property lookups
+        const access = hoisted[key] || `${v}[${JSON.stringify(key)}]`
+        const combined = tryGenCombined(prop, access, ctx)
+        if (combined) {
+          lines.push(combined)
+        } else if (needsLocal(prop)) {
+          const oi = ctx.varCounter++
+          const local = `_r${oi}`
+          lines.push(`{const ${local}=${access}`)
+          genCode(prop, local, lines, ctx)
+          lines.push(`}`)
+        } else {
+          genCode(prop, access, lines, ctx)
+        }
       } else if (isObj) {
         // Optional — hoist to local, check undefined
         const oi = ctx.varCounter++
         const local = `_o${oi}`
         lines.push(`{const ${local}=${v}[${JSON.stringify(key)}];if(${local}!==undefined){`)
-        genCode(prop, local, lines, ctx)
+        const combined = tryGenCombined(prop, local, ctx)
+        if (combined) {
+          lines.push(combined)
+        } else {
+          genCode(prop, local, lines, ctx)
+        }
         lines.push(`}}`)
       } else {
         lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${JSON.stringify(key)} in ${v}){`)
@@ -1322,15 +1431,15 @@ function genCode(schema, v, lines, ctx, knownType) {
 
   // prefixItems
   if (schema.prefixItems) {
+    const pfxVar = ctx.varCounter++
     for (let i = 0; i < schema.prefixItems.length; i++) {
-      const elem = `_p${ctx.varCounter}_${i}`
+      const elem = `_p${pfxVar}_${i}`
       lines.push(isArr
         ? `if(${v}.length>${i}){const ${elem}=${v}[${i}]`
         : `if(Array.isArray(${v})&&${v}.length>${i}){const ${elem}=${v}[${i}]`)
       genCode(schema.prefixItems[i], elem, lines, ctx)
       lines.push(`}`)
     }
-    ctx.varCounter++
   }
 
   // contains — use helper function to avoid try/catch overhead
@@ -1642,23 +1751,73 @@ function genCode(schema, v, lines, ctx, knownType) {
           const inner = `for(var _k in ${v}){if(!${evVar}[_k])return false}`
           if (!ctx.deferredChecks) ctx.deferredChecks = []
           ctx.deferredChecks.push(isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
-        } else if (schema.patternProperties) {
-          // patternProperties: runtime key matching
-          const ei = ctx.varCounter++
-          const evVar = `_ev${ei}`
-          lines.push(`{const ${evVar}={}`)
-          for (const k of baseProps) lines.push(`${evVar}[${JSON.stringify(k)}]=1`)
-          const patterns = Object.keys(schema.patternProperties)
-          const reVars = []
-          for (const pat of patterns) {
-            const ri = ctx.varCounter++
-            ctx.closureVars.push(`_ure${ri}`)
-            ctx.closureVals.push(new RegExp(pat))
-            reVars.push(`_ure${ri}`)
+        } else {
+          // General fallback: collect all patternProperties from root + allOf sub-schemas + if
+          // and use runtime regex matching
+          const allPatterns = []
+          if (schema.patternProperties) {
+            allPatterns.push(...Object.keys(schema.patternProperties))
+          }
+          if (schema.allOf) {
+            for (const sub of schema.allOf) {
+              if (sub && sub.patternProperties) {
+                allPatterns.push(...Object.keys(sub.patternProperties))
+              }
+            }
+          }
+          // lone if (no then/else) still contributes annotations when it passes
+          if (schema.if && !schema.then && !schema.else && schema.if.patternProperties) {
+            allPatterns.push(...Object.keys(schema.if.patternProperties))
+          }
+          if (allPatterns.length > 0) {
+            const ei = ctx.varCounter++
+            const evVar = `_ev${ei}`
+            lines.push(`{const ${evVar}={}`)
+            for (const k of baseProps) lines.push(`${evVar}[${JSON.stringify(k)}]=1`)
+            const reVars = []
+            for (const pat of allPatterns) {
+              const ri = ctx.varCounter++
+              ctx.closureVars.push(`_ure${ri}`)
+              ctx.closureVals.push(new RegExp(pat))
+              reVars.push(`_ure${ri}`)
+            }
+            if (schema.if && !schema.then && !schema.else) {
+              // Lone if: run the if check first; if it passes, its patternProperties contribute
+              const ifLines2 = []
+              genCode(schema.if, '_iv2', ifLines2, ctx)
+              const ufi = ctx.varCounter++
+              const ifFn = ifLines2.length === 0
+                ? `function(_iv2){return true}`
+                : `function(_iv2){${ifLines2.join(';')};return true}`
+              // Mark keys matching if's patterns as evaluated only when if passes
+              const ifPatterns = schema.if.patternProperties ? Object.keys(schema.if.patternProperties) : []
+              const ifReVars = []
+              for (const pat of ifPatterns) {
+                const ri = ctx.varCounter++
+                ctx.closureVars.push(`_ure${ri}`)
+                ctx.closureVals.push(new RegExp(pat))
+                ifReVars.push(`_ure${ri}`)
+              }
+              const rootReVars = []
+              if (schema.patternProperties) {
+                for (const pat of Object.keys(schema.patternProperties)) {
+                  const ri = ctx.varCounter++
+                  ctx.closureVars.push(`_ure${ri}`)
+                  ctx.closureVals.push(new RegExp(pat))
+                  rootReVars.push(`_ure${ri}`)
+                }
+              }
+              const rootPatCheck = rootReVars.map(rv => `if(${rv}.test(_k))continue;`).join('')
+              const ifPatCheck = ifReVars.map(rv => `if(${rv}.test(_k))continue;`).join('')
+              const inner = `const _uif${ufi}=${ifFn};if(_uif${ufi}(${v})){for(var _k in ${v}){if(${evVar}[_k])continue;${rootPatCheck}${ifPatCheck}return false}}else{for(var _k in ${v}){if(${evVar}[_k])continue;${rootPatCheck}return false}}`
+              if (!ctx.deferredChecks) ctx.deferredChecks = []
+              ctx.deferredChecks.push(isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
+            } else {
+              const inner = `for(var _k in ${v}){if(${evVar}[_k])continue;${reVars.map(rv => `if(${rv}.test(_k)){${evVar}[_k]=1;continue}`).join('')}return false}`
+              if (!ctx.deferredChecks) ctx.deferredChecks = []
+              ctx.deferredChecks.push(isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
+            }
           }
-          const inner = `for(var _k in ${v}){if(${evVar}[_k])continue;${reVars.map(rv => `if(${rv}.test(_k)){${evVar}[_k]=1;continue}`).join('')}return false}`
-          if (!ctx.deferredChecks) ctx.deferredChecks = []
-          ctx.deferredChecks.push(isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
         }
       } else if (typeof schema.unevaluatedProperties === 'object') {
         // Tier 3 with schema: validate unknown keys against sub-schema
@@ -1710,7 +1869,12 @@ function genCode(schema, v, lines, ctx, knownType) {
   if (schema.unevaluatedItems !== undefined) {
     const evalResult = collectEvaluated(schema, ctx.schemaMap, ctx.rootDefs)
 
-    if (evalResult.allItems || schema.unevaluatedItems === true) {
+    // Check if allItems from anyOf/oneOf branches with `items` keyword needs dynamic tracking
+    const branchKw = schema.anyOf ? 'anyOf' : schema.oneOf ? 'oneOf' : null
+    const hasConditionalItems = evalResult.allItems && evalResult.dynamic && branchKw &&
+      schema[branchKw].some(sub => sub && typeof sub === 'object' && ((sub.items && typeof sub.items === 'object') || sub.items === true))
+
+    if (schema.unevaluatedItems === true || (evalResult.allItems && !hasConditionalItems)) {
       // All items evaluated or unevaluatedItems:true — no-op
     } else if (!evalResult.dynamic) {
       // Static: all evaluated items known at compile-time
@@ -1736,16 +1900,29 @@ function genCode(schema, v, lines, ctx, knownType) {
       }
     } else {
       // Dynamic: runtime tracking of max evaluated index
-      const baseIdx = evalResult.items || 0
+      // Compute baseIdx from unconditional sources only (root prefixItems/items, allOf)
+      let baseIdx = 0
+      if (schema.prefixItems) baseIdx = Math.max(baseIdx, schema.prefixItems.length)
+      if (schema.items && typeof schema.items === 'object') baseIdx = Infinity // items: schema → all evaluated
+      if (schema.allOf) {
+        for (const sub of schema.allOf) {
+          const subR = collectEvaluated(sub, ctx.schemaMap, ctx.rootDefs)
+          if (subR.items !== null) baseIdx = Math.max(baseIdx, subR.items)
+          if (subR.allItems) baseIdx = Infinity
+        }
+      }
+      if (baseIdx === Infinity) baseIdx = 0 // allItems already handled above
       const branchKeyword = schema.anyOf ? 'anyOf' : schema.oneOf ? 'oneOf' : null
 
       if (branchKeyword && (schema.unevaluatedItems === false || typeof schema.unevaluatedItems === 'object')) {
         // anyOf/oneOf: each branch may evaluate different number of items
         const branches = schema[branchKeyword]
         const branchMaxIdx = []
+        const branchAllItems = []
         for (const sub of branches) {
           const subR = collectEvaluated(sub, ctx.schemaMap, ctx.rootDefs)
           branchMaxIdx.push(subR.items || 0)
+          branchAllItems.push(subR.allItems)
         }
         // Runtime: find max evaluated index across all matching branches
         const fns = []
@@ -1759,7 +1936,10 @@ function genCode(schema, v, lines, ctx, knownType) {
         const evVar = `_eidx${ei}`
         lines.push(`{let ${evVar}=${baseIdx}`)
         lines.push(`const _bf${bfi}=[${fns.join(',')}]`)
-        const maxExprs = branchMaxIdx.map((m, i) => `_bi===${i}?${Math.max(m, baseIdx)}`).join(':') + `:${baseIdx}`
+        const maxExprs = branchMaxIdx.map((m, i) => {
+          if (branchAllItems[i]) return `_bi===${i}?${v}.length`
+          return `_bi===${i}?${Math.max(m, baseIdx)}`
+        }).join(':') + `:${baseIdx}`
         if (branchKeyword === 'oneOf') {
           lines.push(`for(let _bi=0;_bi<_bf${bfi}.length;_bi++){if(_bf${bfi}[_bi](${v})){${evVar}=${maxExprs};break}}`)
         } else {
@@ -1784,8 +1964,8 @@ function genCode(schema, v, lines, ctx, knownType) {
             lines.push('}')
           }
         }
-      } else if (schema.if && (schema.then || schema.else) && (schema.unevaluatedItems === false || typeof schema.unevaluatedItems === 'object')) {
-        // if/then/else: branch-specific max index
+      } else if (schema.if && (schema.unevaluatedItems === false || typeof schema.unevaluatedItems === 'object')) {
+        // if/then/else (or lone if): branch-specific max index
         const ifEval = collectEvaluated(schema.if, ctx.schemaMap, ctx.rootDefs)
         const thenEval = schema.then ? collectEvaluated(schema.then, ctx.schemaMap, ctx.rootDefs) : { items: null }
         const elseEval = schema.else ? collectEvaluated(schema.else, ctx.schemaMap, ctx.rootDefs) : { items: null }
@@ -1804,6 +1984,54 @@ function genCode(schema, v, lines, ctx, knownType) {
           const guard = isArr ? '' : `if(Array.isArray(${v}))`
           lines.push(`${guard}{const _uif${ufi}=${ifFn3};if(_uif${ufi}(${v})){if(${v}.length>${thenIdx})return false}else{if(${v}.length>${elseIdx})return false}}`)
         }
+      } else if ((schema.contains || (schema.allOf && schema.allOf.some(s => s && s.contains))) && (schema.unevaluatedItems === false || typeof schema.unevaluatedItems === 'object')) {
+        // contains + unevaluatedItems: per-item tracking of which items are matched by contains
+        // Collect contains from root and allOf sub-schemas
+        const allContains = []
+        if (schema.contains) allContains.push(schema.contains)
+        if (schema.allOf) {
+          for (const sub of schema.allOf) {
+            if (sub && sub.contains) allContains.push(sub.contains)
+          }
+        }
+        const ci = ctx.varCounter++
+        const evArr = `_cev${ci}`
+        const containsFns = []
+        for (const c of allContains) {
+          const cLines = []
+          genCode(c, '_cv', cLines, ctx)
+          containsFns.push(cLines.length === 0
+            ? `function(_cv){return true}`
+            : `function(_cv){${cLines.join(';')};return true}`)
+        }
+        const cfnArr = `_cfn${ci}`
+        lines.push(`{const ${cfnArr}=[${containsFns.join(',')}]`)
+        // Mark items evaluated by prefixItems
+        lines.push(`const ${evArr}=[]`)
+        if (baseIdx > 0) {
+          lines.push(`for(let _i=0;_i<${Math.min(baseIdx, 1000)};_i++)${evArr}[_i]=true`)
+        }
+        // Mark items matched by each contains function
+        lines.push(`if(Array.isArray(${v})){for(let _ci=0;_ci<${v}.length;_ci++){for(let _cj=0;_cj<${cfnArr}.length;_cj++){if(${cfnArr}[_cj](${v}[_ci])){${evArr}[_ci]=true;break}}}}`)
+        if (schema.unevaluatedItems === false) {
+          const inner = `if(Array.isArray(${v})){for(let _ci=0;_ci<${v}.length;_ci++){if(!${evArr}[_ci])return false}}`
+          if (!ctx.deferredChecks) ctx.deferredChecks = []
+          ctx.deferredChecks.push(inner + '}')
+        } else {
+          // unevaluatedItems: {schema}
+          const ui = ctx.varCounter++
+          const elemVar = `_ue${ui}`
+          const subLines = []
+          genCode(schema.unevaluatedItems, elemVar, subLines, ctx)
+          if (subLines.length > 0) {
+            const check = subLines.join(';')
+            const inner = `if(Array.isArray(${v})){for(let _ci=0;_ci<${v}.length;_ci++){if(!${evArr}[_ci]){const ${elemVar}=${v}[_ci];${check}}}}`
+            if (!ctx.deferredChecks) ctx.deferredChecks = []
+            ctx.deferredChecks.push(inner + '}')
+          } else {
+            lines.push('}')
+          }
+        }
       } else if (schema.unevaluatedItems === false) {
         // Fallback: use static base index (may not be fully correct for all dynamic cases)
         const maxIdx = evalResult.items || 0
@@ -1982,6 +2210,8 @@ function compileToJSCodegenWithErrors(schema, schemaMap) {
   if (typeof schema === 'object' && schema !== null) {
     const s = JSON.stringify(schema)
     if (s.includes('unevaluatedProperties') || s.includes('unevaluatedItems')) return null
+    // Bail on self-referencing schemas — error codegen doesn't support recursion
+    if (s.includes('"$ref":"#"')) return null
   }
   if (typeof schema === 'boolean') {
     return schema
@@ -2129,7 +2359,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         case 'string': return `typeof ${v}==='string'`
         case 'number': return `(typeof ${v}==='number'&&isFinite(${v}))`
         case 'integer': return `Number.isInteger(${v})`
-        case 'boolean': return `(${v}===true||${v}===false)`
+        case 'boolean': return `typeof ${v}==='boolean'`
         case 'null': return `${v}===null`
         default: return 'true'
       }
@@ -2463,6 +2693,8 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap) {
   if (typeof schema === 'object' && schema !== null) {
     const s = JSON.stringify(schema)
     if (s.includes('unevaluatedProperties') || s.includes('unevaluatedItems')) return null
+    // Bail on self-referencing schemas — combined codegen doesn't support recursion
+    if (s.includes('"$ref":"#"')) return null
   }
   if (typeof schema === 'boolean') {
     return schema
@@ -2633,7 +2865,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         case 'string': return `typeof ${v}==='string'`
         case 'number': return `(typeof ${v}==='number'&&isFinite(${v}))`
         case 'integer': return `Number.isInteger(${v})`
-        case 'boolean': return `(${v}===true||${v}===false)`
+        case 'boolean': return `typeof ${v}==='boolean'`
         case 'null': return `${v}===null`
         default: return 'true'
       }
@@ -3141,15 +3373,10 @@ function _collectEval(schema, result, defs, schemaMap, refStack, isRoot) {
     result.allItems = true
   }
 
-  // contains interaction with unevaluatedItems is complex
-  // At root level: contains + unevaluatedItems needs dynamic tracking
-  // In nested schemas: contains marks all items as evaluated
+  // contains: marks matching items as evaluated (not ALL items)
+  // Always set dynamic since which items match depends on the data
   if (schema.contains) {
-    if (isRoot && (schema.unevaluatedItems !== undefined)) {
-      result.dynamic = true
-    } else {
-      result.allItems = true
-    }
+    result.dynamic = true
   }
 
   // unevaluatedProperties: true/schema → all props evaluated (for nested schemas only)
@@ -3184,6 +3411,18 @@ function _collectEval(schema, result, defs, schemaMap, refStack, isRoot) {
     _collectEval(schema.if, result, defs, schemaMap, refStack)
     if (schema.then) _collectEval(schema.then, result, defs, schemaMap, refStack)
     if (schema.else) _collectEval(schema.else, result, defs, schemaMap, refStack)
+  } else if (schema.if) {
+    // Standalone if (no then/else) still produces annotations per spec
+    // Only collect properties and patterns, not deep items (contains etc.)
+    result.dynamic = true
+    if (schema.if.properties) {
+      for (const k of Object.keys(schema.if.properties)) {
+        if (!result.props.includes(k)) result.props.push(k)
+      }
+    }
+    if (schema.if.patternProperties) {
+      // patternProperties contribute to dynamic evaluation
+    }
   }
 
   // dependentSchemas → dynamic

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Ultra-fast JSON Schema validator. 4.7x faster validation, 1,800x faster compilation. Works without native addon. Cross-schema $ref, Draft 2020-12 + Draft 7, V8-optimized JS codegen, simdjson, RE2, multi-core. Standard Schema V1 compatible.",
   "main": "index.js",
   "module": "index.mjs",

package/src/ata.cpp

@@ -436,6 +436,10 @@ struct compiled_schema {
     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
@@ -826,6 +830,61 @@ 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;
 }
@@ -1611,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, dynamic_scope);
+            validate_node(pn, key_result.value_unsafe(), path, ctx, errors, all_errors, dynamic_scope);
           }
         }
       }
@@ -2157,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;
@@ -2260,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){
@@ -2539,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
@@ -2600,7 +2663,7 @@ 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);
 
@@ -2616,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;
 }
 
@@ -2655,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
@@ -2675,10 +2739,10 @@ validation_result validate(const schema_ref& schema, std::string_view json,
         scope.push_back(&iit->second);
       }
     }
-    validate_node(schema.impl->root, result.value(), "", *schema.impl, errors,
+    validate_node(schema.impl->root, result.value_unsafe(), "", *schema.impl, errors,
                   opts.all_errors, &scope);
   } else {
-    validate_node(schema.impl->root, result.value(), "", *schema.impl, errors,
+    validate_node(schema.impl->root, result.value_unsafe(), "", *schema.impl, errors,
                   opts.all_errors);
   }
 
@@ -2721,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) {