ata-validator 0.4.8 → 0.4.10

package/binding/ata_napi.cpp

@@ -28,7 +28,7 @@ using schema_node_ptr = std::shared_ptr<schema_node>;
 
 // MUST match layout in src/ata.cpp exactly (reinterpret_cast)
 struct schema_node {
-  std::vector<std::string> types;
+  uint8_t type_mask = 0;
 
   std::optional<double> minimum;
   std::optional<double> maximum;
@@ -67,11 +67,11 @@ struct schema_node {
   };
   std::vector<pattern_prop> pattern_properties;
 
-  std::optional<std::string> enum_values_raw;
   std::vector<std::string> enum_values_minified;
   std::optional<std::string> const_value_raw;
 
   std::optional<std::string> format;
+  uint8_t format_id = 255;
 
   std::vector<schema_node_ptr> all_of;
   std::vector<schema_node_ptr> any_of;
@@ -413,46 +413,39 @@ static void validate_napi(const schema_node_ptr& node,
 
   auto actual_type = napi_type_of(value);
 
-  // type
-  if (!node->types.empty()) {
-    bool match = false;
-    for (const auto& t : node->types) {
-      if (napi_type_matches(value, t)) {
-        match = true;
-        break;
-      }
-    }
-    if (!match) {
+  // type — uses bitmask matching ata.cpp json_type enum order:
+  //   0=string, 1=number, 2=integer, 3=boolean, 4=null_value, 5=object, 6=array
+  if (node->type_mask) {
+    uint8_t val_bits = 0;
+    if (actual_type == "string")       val_bits = 1u << 0;
+    else if (actual_type == "number")  val_bits = 1u << 1;
+    else if (actual_type == "integer") val_bits = (1u << 2) | (1u << 1); // integer matches number
+    else if (actual_type == "boolean") val_bits = 1u << 3;
+    else if (actual_type == "null")    val_bits = 1u << 4;
+    else if (actual_type == "object")  val_bits = 1u << 5;
+    else if (actual_type == "array")   val_bits = 1u << 6;
+    if (!(val_bits & node->type_mask)) {
+      static const char* type_names[] = {"string","number","integer","boolean","null","object","array"};
       std::string expected;
-      for (size_t i = 0; i < node->types.size(); ++i) {
-        if (i > 0) expected += ", ";
-        expected += node->types[i];
+      for (int b = 0; b < 7; ++b) {
+        if (node->type_mask & (1u << b)) {
+          if (!expected.empty()) expected += ", ";
+          expected += type_names[b];
+        }
       }
       errors.push_back({ata::error_code::type_mismatch, path,
                         "expected type " + expected + ", got " + actual_type});
     }
   }
 
-  // enum
-  if (node->enum_values_raw.has_value()) {
+  // enum — compare against pre-minified canonical values
+  if (!node->enum_values_minified.empty()) {
     std::string val_json = napi_to_json(env, value);
-    // Parse enum from raw and compare
     bool found = false;
-    // We need to compare against each element in the enum array
-    // The enum_values_raw is a JSON array string like [1,2,3]
-    // We'll use JSON.parse in JS to handle this
-    auto json_obj = env.Global().Get("JSON").As<Napi::Object>();
-    auto parse_fn = json_obj.Get("parse").As<Napi::Function>();
-    auto enum_arr = parse_fn.Call(json_obj,
-        {Napi::String::New(env, node->enum_values_raw.value())});
-    if (enum_arr.IsArray()) {
-      auto arr = enum_arr.As<Napi::Array>();
-      for (uint32_t i = 0; i < arr.Length(); ++i) {
-        std::string elem_json = napi_to_json(env, arr.Get(i));
-        if (elem_json == val_json) {
-          found = true;
-          break;
-        }
+    for (const auto& ev : node->enum_values_minified) {
+      if (ev == val_json) {
+        found = true;
+        break;
       }
     }
     if (!found) {
@@ -1048,7 +1041,7 @@ static ThreadPool& pool() {
 
 // --- Fast Validation Registry ---
 // Global schema slots for V8 Fast API (bypasses NAPI overhead)
-static constexpr size_t MAX_FAST_SLOTS = 256;
+static constexpr size_t MAX_FAST_SLOTS = 4096;
 static ata::schema_ref g_fast_schemas[MAX_FAST_SLOTS];
 static std::string g_fast_schema_jsons[MAX_FAST_SLOTS];
 static uint32_t g_fast_slot_count = 0;

package/binding.gyp

@@ -11,10 +11,10 @@
         "<!@(node -p \"require('node-addon-api').include\")",
         "include",
         "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')}\")"
+        "<!@(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');console.log(a==='arm64'?'/opt/homebrew/opt/mimalloc/include':'/usr/local/opt/mimalloc/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')}\")"
+        "<!@(node -e \"var p=process.platform,a=process.arch;if(p==='darwin'){var pre=a==='arm64'?'/opt/homebrew/opt/re2':'/usr/local/opt/re2';var mi=a==='arm64'?'/opt/homebrew/opt/mimalloc':'/usr/local/opt/mimalloc';console.log('-L'+pre+'/lib -lre2 -L'+mi+'/lib -lmimalloc')}else{console.log('-lre2')}\")"
       ],
       "dependencies": [
         "<!(node -p \"require('node-addon-api').gyp\")"

package/index.js

@@ -211,6 +211,7 @@ class Validator {
     // Pure JS fast path — no NAPI, runs in V8 JIT
     // Set ATA_FORCE_NAPI=1 to disable JS codegen (for correctness testing)
     const schemaObj = typeof schema === "string" ? JSON.parse(schema) : schema;
+    this._schemaObj = schemaObj;
     const jsFn = process.env.ATA_FORCE_NAPI
       ? null
       : (compileToJSCodegen(schemaObj) || compileToJS(schemaObj));
@@ -330,6 +331,107 @@ class Validator {
     });
   }
 
+  // --- Standalone pre-compilation ---
+  // Generate a JS module string that can be written to a file.
+  // On next startup, load with Validator.fromStandalone() — zero compile time.
+  toStandalone() {
+    const jsFn = this._jsFn;
+    if (!jsFn || !jsFn._source) return null;
+    const src = jsFn._source;
+    const hybridSrc = jsFn._hybridSource || '';
+
+    // Also capture error function source for zero-compile standalone load
+    const jsErrFn = compileToJSCodegenWithErrors(
+      typeof this._schemaObj === 'object' ? this._schemaObj : {}
+    );
+    const errSrc = jsErrFn && jsErrFn._errSource ? jsErrFn._errSource : '';
+
+    return `// Auto-generated by ata-validator — do not edit
+'use strict';
+const boolFn = function(d) {
+  ${src}
+};
+const hybridFactory = function(R, E) {
+  return function(d) {
+    ${hybridSrc}
+  };
+};
+${errSrc ? `const errFn = function(d, _all) {\n  ${errSrc}\n};` : 'const errFn = null;'}
+module.exports = { boolFn, hybridFactory, errFn };
+`;
+  }
+
+  // Load a pre-compiled standalone module. Zero schema compilation.
+  // No NAPI, no native compile — pure JS. Startup in microseconds.
+  // Usage: const v = Validator.fromStandalone(require('./compiled.js'), schema, opts)
+  static fromStandalone(mod, schema, opts) {
+    const options = opts || {};
+    const schemaObj = typeof schema === "string" ? JSON.parse(schema) : schema;
+
+    // Create a lightweight instance — skip NAPI compile entirely
+    const v = Object.create(Validator.prototype);
+    v._jsFn = mod.boolFn;
+    v._compiled = null;
+    v._fastSlot = -1;
+
+    // Mutators
+    const applyDefaults = buildDefaultsApplier(schemaObj);
+    const applyCoerce = options.coerceTypes ? buildCoercer(schemaObj) : null;
+    const applyRemove = options.removeAdditional ? buildRemover(schemaObj) : null;
+    const mutators = [applyRemove, applyCoerce, applyDefaults].filter(Boolean);
+    const preprocess = mutators.length === 0 ? null
+      : mutators.length === 1 ? mutators[0]
+      : (data) => { for (let i = 0; i < mutators.length; i++) mutators[i](data); };
+    v._preprocess = preprocess;
+
+    // Error function — use pre-compiled from standalone if available, else compile
+    let errFn = (d) => ({ valid: false, errors: [{ code: 'validation_failed', path: '', message: 'validation failed' }] });
+    if (mod.errFn) {
+      errFn = (d) => mod.errFn(d, true);
+    } else {
+      const jsErrFn = compileToJSCodegenWithErrors(schemaObj);
+      if (jsErrFn) {
+        try { jsErrFn({}, true); errFn = (d) => jsErrFn(d, true); } catch {}
+      }
+    }
+
+    // Hybrid or speculative
+    const hybridFn = mod.hybridFactory
+      ? mod.hybridFactory(VALID_RESULT, errFn)
+      : null;
+
+    v.validate = hybridFn
+      ? (preprocess ? (data) => { preprocess(data); return hybridFn(data); } : hybridFn)
+      : (preprocess
+          ? (data) => { preprocess(data); return mod.boolFn(data) ? VALID_RESULT : errFn(data); }
+          : (data) => mod.boolFn(data) ? VALID_RESULT : errFn(data));
+    v.isValidObject = mod.boolFn;
+    v.isValidJSON = (jsonStr) => {
+      try { return mod.boolFn(JSON.parse(jsonStr)); } catch { return false; }
+    };
+    v.validateJSON = (jsonStr) => {
+      try {
+        const obj = JSON.parse(jsonStr);
+        return hybridFn ? hybridFn(obj) : (mod.boolFn(obj) ? VALID_RESULT : errFn(obj));
+      } catch { return { valid: false, errors: [{ code: 'invalid_json', path: '', message: 'invalid JSON' }] }; }
+    };
+
+    // Standard Schema V1
+    Object.defineProperty(v, "~standard", {
+      value: Object.freeze({
+        version: 1, vendor: "ata-validator",
+        validate(value) {
+          const result = v.validate(value);
+          if (result.valid) return { value };
+          return { issues: result.errors.map(e => ({ message: e.message, path: parsePointerPath(e.path) })) };
+        },
+      }),
+      writable: false, enumerable: false, configurable: false,
+    });
+
+    return v;
+  }
+
   // Fallback methods — only used when JS codegen is unavailable
   validate(data) {
     if (this._preprocess) this._preprocess(data);
@@ -384,4 +486,106 @@ function version() {
   return native.version();
 }
 
+// Bundle multiple validators into a single JS file for fast startup.
+// Usage:
+//   const bundle = Validator.bundle([schema1, schema2, ...]);
+//   fs.writeFileSync('validators.js', bundle);
+//   // On startup:
+//   const validators = Validator.loadBundle(require('./validators.js'), [schema1, schema2, ...]);
+Validator.bundle = function(schemas, opts) {
+  const parts = schemas.map(schema => {
+    const v = new Validator(schema, opts);
+    const standalone = v.toStandalone();
+    if (!standalone) return 'null';
+    return '(function(){' + standalone.replace("'use strict';", '').replace('module.exports = ', 'return ') + '})()';
+  });
+  return "'use strict';\nmodule.exports = [\n" + parts.join(',\n') + '\n];\n';
+};
+
+// Zero-dependency self-contained bundle — no require('ata-validator') needed at runtime.
+Validator.bundleStandalone = function(schemas, opts) {
+  const R = "Object.freeze({valid:true,errors:Object.freeze([])})";
+  const fns = schemas.map(schema => {
+    const v = new Validator(schema, opts);
+    const jsFn = v._jsFn;
+    if (!jsFn || !jsFn._hybridSource) return 'null';
+    const jsErrFn = compileToJSCodegenWithErrors(
+      typeof schema === 'string' ? JSON.parse(schema) : schema
+    );
+    const errBody = jsErrFn && jsErrFn._errSource
+      ? jsErrFn._errSource
+      : "return{valid:false,errors:[{code:'error',path:'',message:'validation failed'}]}";
+    return `(function(R){var E=function(d){var _all=true;${errBody}};return function(d){${jsFn._hybridSource}}})(R)`;
+  });
+  return `'use strict';\nvar R=${R};\nmodule.exports=[${fns.join(',')}];\n`;
+};
+
+// Compact bundle: deduplicated code. Shared template functions + per-schema params.
+// Much smaller file → faster V8 parse → faster startup.
+Validator.bundleCompact = function(schemas, opts) {
+  // Analyze schemas and group by structure
+  const entries = schemas.map(schema => {
+    const v = new Validator(schema, opts);
+    const jsFn = v._jsFn;
+    if (!jsFn || !jsFn._hybridSource) return null;
+    const jsErrFn = compileToJSCodegenWithErrors(
+      typeof schema === 'string' ? JSON.parse(schema) : schema
+    );
+    return {
+      hybrid: jsFn._hybridSource,
+      err: jsErrFn && jsErrFn._errSource ? jsErrFn._errSource : null,
+    };
+  });
+
+  // Deduplicate function bodies — many schemas produce identical or near-identical code
+  const bodyMap = new Map(); // body → index
+  const bodies = [];
+  const errMap = new Map();
+  const errBodies = [];
+
+  const indices = entries.map(e => {
+    if (!e) return [-1, -1];
+    let hi = bodyMap.get(e.hybrid);
+    if (hi === undefined) { hi = bodies.length; bodies.push(e.hybrid); bodyMap.set(e.hybrid, hi); }
+    let ei = -1;
+    if (e.err) {
+      ei = errMap.get(e.err);
+      if (ei === undefined) { ei = errBodies.length; errBodies.push(e.err); errMap.set(e.err, ei); }
+    }
+    return [hi, ei];
+  });
+
+  // Generate compact bundle
+  let out = "'use strict';\n";
+  out += "var R=Object.freeze({valid:true,errors:Object.freeze([])});\n";
+
+  // Shared hybrid factories
+  out += "var H=[\n";
+  out += bodies.map(b => `function(R,E){return function(d){${b}}}`).join(',\n');
+  out += "\n];\n";
+
+  // Shared error functions
+  out += "var EF=[\n";
+  out += errBodies.map(b => `function(d){var _all=true;${b}}`).join(',\n');
+  out += "\n];\n";
+
+  // Build validators from shared templates
+  out += "module.exports=[";
+  out += indices.map(([hi, ei]) => {
+    if (hi < 0) return 'null';
+    if (ei >= 0) return `H[${hi}](R,EF[${ei}])`;
+    return `H[${hi}](R,function(){return{valid:false,errors:[]}})`;
+  }).join(',');
+  out += "];\n";
+
+  return out;
+};
+
+Validator.loadBundle = function(mods, schemas, opts) {
+  return schemas.map((schema, i) => {
+    if (mods[i]) return Validator.fromStandalone(mods[i], schema, opts);
+    return new Validator(schema, opts);
+  });
+};
+
 module.exports = { Validator, validate, version, createPaddedBuffer, SIMDJSON_PADDING };

package/lib/js-compiler.js

@@ -531,14 +531,16 @@ function compileToJSCodegen(schema) {
     const boolFn = new Function('d', body)
 
     // Build hybrid: same body, return R instead of true, return E(d) instead of false.
-    // V8 optimizes this identically to jsFn — E(d) is dead code on valid path.
-    // 83M ops/sec vs 26M for combined. Invalid path: 34M vs 6M.
     const hybridBody = replaceTopLevel(helperStr + checkStr + '\n  return R')
     try {
       const factory = new Function('R', 'E', `return function(d){${hybridBody}}`)
       boolFn._hybridFactory = factory
     } catch {}
 
+    // Store source for standalone compilation (pre-build to file)
+    boolFn._source = body
+    boolFn._hybridSource = hybridBody
+
     return boolFn
   } catch {
     return null
@@ -940,7 +942,9 @@ function compileToJSCodegenWithErrors(schema) {
     lines.join('\n  ') +
     `\n  return{valid:_e.length===0,errors:_e}`
   try {
-    return new Function('d', '_all', body)
+    const fn = new Function('d', '_all', body)
+    fn._errSource = body
+    return fn
   } catch {
     return null
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "description": "Ultra-fast JSON Schema validator. Beats ajv on every valid-path benchmark: 1.1x–2.7x faster validate(obj), 151x faster compilation, 5.9x faster parallel batch. Speculative validation with V8-optimized JS codegen, simdjson, multi-core. Standard Schema V1 compatible.",
   "main": "index.js",
   "types": "index.d.ts",

package/src/ata.cpp

@@ -1,5 +1,10 @@
 #include "ata.h"
 
+// mimalloc: faster new/delete for small allocations.
+#if __has_include(<mimalloc-new-delete.h>)
+#include <mimalloc-new-delete.h>
+#endif
+
 #include <algorithm>
 #include <cmath>
 #include <re2/re2.h>
@@ -123,17 +128,20 @@ static bool fast_check_hostname(std::string_view s) {
   return label_len > 0;
 }
 
-static bool check_format(std::string_view sv, const std::string& fmt) {
-  if (fmt == "email") return fast_check_email(sv);
-  if (fmt == "date") return fast_check_date(sv);
-  if (fmt == "date-time") return fast_check_datetime(sv);
-  if (fmt == "time") return fast_check_time(sv);
-  if (fmt == "ipv4") return fast_check_ipv4(sv);
-  if (fmt == "ipv6") return sv.find(':') != std::string_view::npos;
-  if (fmt == "uri" || fmt == "uri-reference") return fast_check_uri(sv);
-  if (fmt == "uuid") return fast_check_uuid(sv);
-  if (fmt == "hostname") return fast_check_hostname(sv);
-  return true;  // unknown formats pass
+// Check format by pre-resolved numeric ID — no string comparisons.
+static bool check_format_by_id(std::string_view sv, uint8_t fid) {
+  switch (fid) {
+    case 0: return fast_check_email(sv);
+    case 1: return fast_check_date(sv);
+    case 2: return fast_check_datetime(sv);
+    case 3: return fast_check_time(sv);
+    case 4: return fast_check_ipv4(sv);
+    case 5: return sv.find(':') != std::string_view::npos;
+    case 6: return fast_check_uri(sv);
+    case 7: return fast_check_uuid(sv);
+    case 8: return fast_check_hostname(sv);
+    default: return true;  // unknown formats pass
+  }
 }
 
 namespace ata {
@@ -177,14 +185,74 @@ static std::string canonical_json(dom::element el) {
   }
 }
 
+// JSON Schema type enum — avoids string comparisons on the hot path.
+enum class json_type : uint8_t {
+  string, number, integer, boolean, null_value, object, array
+};
+
+static json_type json_type_from_sv(std::string_view s) {
+  if (s == "string")  return json_type::string;
+  if (s == "number")  return json_type::number;
+  if (s == "integer") return json_type::integer;
+  if (s == "boolean") return json_type::boolean;
+  if (s == "null")    return json_type::null_value;
+  if (s == "object")  return json_type::object;
+  if (s == "array")   return json_type::array;
+  return json_type::string; // fallback
+}
+
+static const char* json_type_name(json_type t) {
+  switch (t) {
+    case json_type::string:     return "string";
+    case json_type::number:     return "number";
+    case json_type::integer:    return "integer";
+    case json_type::boolean:    return "boolean";
+    case json_type::null_value: return "null";
+    case json_type::object:     return "object";
+    case json_type::array:      return "array";
+  }
+  return "unknown";
+}
+
+// Bitmask for O(1) type checking: one bit per json_type value.
+static uint8_t json_type_bit(json_type t) { return 1u << static_cast<uint8_t>(t); }
+
+// Map dom::element_type to a json_type bitmask (number matches integer too).
+static uint8_t element_type_mask(dom::element_type t) {
+  switch (t) {
+    case dom::element_type::STRING:     return json_type_bit(json_type::string);
+    case dom::element_type::INT64:
+    case dom::element_type::UINT64:     return json_type_bit(json_type::integer) | json_type_bit(json_type::number);
+    case dom::element_type::DOUBLE:     return json_type_bit(json_type::number);
+    case dom::element_type::BOOL:       return json_type_bit(json_type::boolean);
+    case dom::element_type::NULL_VALUE: return json_type_bit(json_type::null_value);
+    case dom::element_type::ARRAY:      return json_type_bit(json_type::array);
+    case dom::element_type::OBJECT:     return json_type_bit(json_type::object);
+  }
+  return 0;
+}
+
+// Resolve format string to numeric ID at compile time.
+static uint8_t format_id_from_string(const std::string& f) {
+  if (f == "email")          return 0;
+  if (f == "date")           return 1;
+  if (f == "date-time")      return 2;
+  if (f == "time")           return 3;
+  if (f == "ipv4")           return 4;
+  if (f == "ipv6")           return 5;
+  if (f == "uri" || f == "uri-reference") return 6;
+  if (f == "uuid")           return 7;
+  if (f == "hostname")       return 8;
+  return 255;
+}
+
 // Forward declarations
 struct schema_node;
 using schema_node_ptr = std::shared_ptr<schema_node>;
 
 struct schema_node {
-  // type constraint: "string", "number", "integer", "boolean", "null",
-  // "object", "array"
-  std::vector<std::string> types;
+  // type constraint — bitmask for O(1) type checking
+  uint8_t type_mask = 0;  // bit per json_type value
 
   // numeric
   std::optional<double> minimum;
@@ -229,12 +297,12 @@ struct schema_node {
   std::vector<pattern_prop> pattern_properties;
 
   // enum / const
-  std::optional<std::string> enum_values_raw;  // raw JSON array string
   std::vector<std::string> enum_values_minified;  // pre-minified enum values
   std::optional<std::string> const_value_raw;  // raw JSON value string
 
   // format
   std::optional<std::string> format;
+  uint8_t format_id = 255;  // pre-resolved format ID (255 = unknown/pass)
 
   // composition
   std::vector<schema_node_ptr> all_of;
@@ -276,7 +344,7 @@ struct plan {
   std::vector<std::string> strings;
   std::vector<std::shared_ptr<re2::RE2>> regexes;
   std::vector<std::vector<std::string>> enum_sets;
-  std::vector<std::vector<std::string>> type_sets;
+  std::vector<uint8_t> type_masks;
   std::vector<uint8_t> format_ids;
   std::vector<std::vector<ins>> subs;
 };
@@ -297,6 +365,10 @@ static dom::parser& tl_dom_parser() {
   thread_local dom::parser p;
   return p;
 }
+static dom::parser& tl_dom_key_parser() {
+  thread_local dom::parser p;
+  return p;
+}
 static simdjson::ondemand::parser& tl_od_parser() {
   thread_local simdjson::ondemand::parser p;
   return p;
@@ -341,12 +413,12 @@ static schema_node_ptr compile_node(dom::element el,
     if (type_el.is<std::string_view>()) {
       std::string_view sv;
       type_el.get(sv);
-      node->types.emplace_back(sv);
+      node->type_mask |= json_type_bit(json_type_from_sv(sv));
     } else if (type_el.is<dom::array>()) {
       dom::array type_arr; type_el.get(type_arr); for (auto t : type_arr) {
         std::string_view sv;
         if (t.get(sv) == SUCCESS) {
-          node->types.emplace_back(sv);
+          node->type_mask |= json_type_bit(json_type_from_sv(sv));
         }
       }
     }
@@ -526,7 +598,10 @@ static schema_node_ptr compile_node(dom::element el,
   dom::element fmt_el;
   if (obj["format"].get(fmt_el) == SUCCESS) {
     std::string_view sv;
-    if (fmt_el.get(sv) == SUCCESS) node->format = std::string(sv);
+    if (fmt_el.get(sv) == SUCCESS) {
+      node->format = std::string(sv);
+      node->format_id = format_id_from_string(node->format.value());
+    }
   }
 
   // $id (register in defs for potential resolution)
@@ -541,7 +616,6 @@ static schema_node_ptr compile_node(dom::element el,
   // enum — pre-minify each value at compile time
   dom::element enum_el;
   if (obj["enum"].get(enum_el) == SUCCESS) {
-    node->enum_values_raw = canonical_json(enum_el);
     if (enum_el.is<dom::array>()) {
       dom::array enum_arr; enum_el.get(enum_arr); for (auto e : enum_arr) {
         node->enum_values_minified.push_back(canonical_json(e));
@@ -635,41 +709,37 @@ static bool validate_fast(const schema_node_ptr& node,
 // Macro for early termination
 #define ATA_CHECK_EARLY() if (!all_errors && !errors.empty()) return
 
+using et = dom::element_type;
+
+
 // Use string_view to avoid allocations in hot path
 static std::string_view type_of_sv(dom::element el) {
   switch (el.type()) {
-    case dom::element_type::STRING:    return "string";
-    case dom::element_type::INT64:
-    case dom::element_type::UINT64:    return "integer";
-    case dom::element_type::DOUBLE:    return "number";
-    case dom::element_type::BOOL:      return "boolean";
-    case dom::element_type::NULL_VALUE:return "null";
-    case dom::element_type::ARRAY:     return "array";
-    case dom::element_type::OBJECT:    return "object";
+    case et::STRING:    return "string";
+    case et::INT64:
+    case et::UINT64:    return "integer";
+    case et::DOUBLE:    return "number";
+    case et::BOOL:      return "boolean";
+    case et::NULL_VALUE:return "null";
+    case et::ARRAY:     return "array";
+    case et::OBJECT:    return "object";
   }
   return "unknown";
 }
 
-static std::string type_of(dom::element el) {
-  return std::string(type_of_sv(el));
-}
 
-static bool type_matches(dom::element el, const std::string& type) {
-  auto actual = type_of_sv(el);
-  if (actual == type) return true;
-  if (type == "number" && (actual == "integer" || actual == "number"))
-    return true;
-  return false;
+// O(1) type check: test element's type bits against the schema's type_mask.
+static bool type_matches_mask(dom::element el, uint8_t type_mask) {
+  return (element_type_mask(el.type()) & type_mask) != 0;
 }
 
 static double to_double(dom::element el) {
-  double v = 0;
-  if (el.get(v) == SUCCESS) return v;
-  int64_t i = 0;
-  if (el.get(i) == SUCCESS) return static_cast<double>(i);
-  uint64_t u = 0;
-  if (el.get(u) == SUCCESS) return static_cast<double>(u);
-  return 0;
+  switch (el.type()) {
+    case et::DOUBLE:  { double v; el.get(v); return v; }
+    case et::INT64:   { int64_t v; el.get(v); return static_cast<double>(v); }
+    case et::UINT64:  { uint64_t v; el.get(v); return static_cast<double>(v); }
+    default: return 0;
+  }
 }
 
 // Count UTF-8 codepoints — branchless: count non-continuation bytes
@@ -838,22 +908,17 @@ static void validate_node(const schema_node_ptr& node,
   }
 
   // type
-  if (!node->types.empty()) {
-    bool match = false;
-    for (const auto& t : node->types) {
-      if (type_matches(value, t)) {
-        match = true;
-        break;
-      }
-    }
-    if (!match) {
+  if (node->type_mask) {
+    if (!type_matches_mask(value, node->type_mask)) {
       std::string expected;
-      for (size_t i = 0; i < node->types.size(); ++i) {
-        if (i > 0) expected += ", ";
-        expected += node->types[i];
+      for (int b = 0; b < 7; ++b) {
+        if (node->type_mask & (1u << b)) {
+          if (!expected.empty()) expected += ", ";
+          expected += json_type_name(static_cast<json_type>(b));
+        }
       }
       errors.push_back({error_code::type_mismatch, path,
-                        "expected type " + expected + ", got " + type_of(value)});
+                        "expected type " + expected + ", got " + std::string(type_of_sv(value))});
       ATA_CHECK_EARLY();
     }
   }
@@ -886,8 +951,8 @@ static void validate_node(const schema_node_ptr& node,
 
   ATA_CHECK_EARLY();
   // Numeric validations
-  auto actual_type = type_of(value);
-  if (actual_type == "integer" || actual_type == "number") {
+  auto vtype = value.type();
+  if (vtype == et::INT64 || vtype == et::UINT64 || vtype == et::DOUBLE) {
     double v = to_double(value);
     if (node->minimum.has_value() && v < node->minimum.value()) {
       errors.push_back({error_code::minimum_violation, path,
@@ -924,7 +989,7 @@ static void validate_node(const schema_node_ptr& node,
   }
 
   // String validations
-  if (actual_type == "string") {
+  if (vtype == et::STRING) {
     std::string_view sv;
     value.get(sv);
     uint64_t len = utf8_length(sv);
@@ -950,7 +1015,7 @@ static void validate_node(const schema_node_ptr& node,
     }
 
     if (node->format.has_value()) {
-      if (!check_format(sv, node->format.value())) {
+      if (!check_format_by_id(sv, node->format_id)) {
         errors.push_back({error_code::format_mismatch, path,
                           "string does not match format: " +
                               node->format.value()});
@@ -959,10 +1024,14 @@ static void validate_node(const schema_node_ptr& node,
   }
 
   // Array validations
-  if (actual_type == "array" && value.is<dom::array>()) {
+  if (vtype == et::ARRAY) {
     dom::array arr; value.get(arr);
-    uint64_t arr_size = 0;
-    for ([[maybe_unused]] auto _ : arr) ++arr_size;
+    uint64_t arr_size = arr.size();
+    if(arr_size == 0xFFFFFF) [[unlikely]]	{
+      // Fallback for large arrays where size() saturates — count manually to avoid overflow
+      arr_size = 0;
+      for ([[maybe_unused]] auto _ : arr) ++arr_size;
+    }
 
     if (node->min_items.has_value() && arr_size < node->min_items.value()) {
       errors.push_back({error_code::min_items_violation, path,
@@ -978,13 +1047,29 @@ static void validate_node(const schema_node_ptr& node,
     }
 
     if (node->unique_items) {
-      std::set<std::string> seen;
       bool has_dup = false;
-      for (auto item : arr) {
-        auto s = canonical_json(item);
-        if (!seen.insert(s).second) {
-          has_dup = true;
-          break;
+      // Fast path: check if all items are the same simple type
+      auto first_it = arr.begin();
+      if (first_it != arr.end()) {
+        auto first_type = (*first_it).type();
+        bool all_same = true;
+        for (auto item : arr) { if (item.type() != first_type) { all_same = false; break; } }
+        if (all_same && first_type == et::STRING) {
+          std::set<std::string_view> seen;
+          for (auto item : arr) {
+            std::string_view sv; item.get(sv);
+            if (!seen.insert(sv).second) { has_dup = true; break; }
+          }
+        } else if (all_same && (first_type == et::INT64 || first_type == et::UINT64 || first_type == et::DOUBLE)) {
+          std::set<double> seen;
+          for (auto item : arr) {
+            if (!seen.insert(to_double(item)).second) { has_dup = true; break; }
+          }
+        } else {
+          std::set<std::string> seen;
+          for (auto item : arr) {
+            if (!seen.insert(canonical_json(item)).second) { has_dup = true; break; }
+          }
         }
       }
       if (has_dup) {
@@ -1012,9 +1097,7 @@ static void validate_node(const schema_node_ptr& node,
     if (node->contains_schema) {
       uint64_t match_count = 0;
       for (auto item : arr) {
-        std::vector<validation_error> tmp;
-        validate_node(node->contains_schema, item, path, ctx, tmp, false);
-        if (tmp.empty()) ++match_count;
+        if (validate_fast(node->contains_schema, item, ctx)) ++match_count;
       }
       uint64_t min_c = node->min_contains.value_or(1);
       uint64_t max_c = node->max_contains.value_or(arr_size);
@@ -1032,24 +1115,26 @@ static void validate_node(const schema_node_ptr& node,
   }
 
   // Object validations
-  if (actual_type == "object" && value.is<dom::object>()) {
+  if (vtype == et::OBJECT) {
     dom::object obj; value.get(obj);
-    uint64_t prop_count = 0;
-    for ([[maybe_unused]] auto _ : obj) ++prop_count;
 
-    if (node->min_properties.has_value() &&
-        prop_count < node->min_properties.value()) {
-      errors.push_back({error_code::min_properties_violation, path,
-                        "object has " + std::to_string(prop_count) +
-                            " properties, minimum " +
-                            std::to_string(node->min_properties.value())});
-    }
-    if (node->max_properties.has_value() &&
-        prop_count > node->max_properties.value()) {
-      errors.push_back({error_code::max_properties_violation, path,
-                        "object has " + std::to_string(prop_count) +
-                            " properties, maximum " +
-                            std::to_string(node->max_properties.value())});
+    if (node->min_properties.has_value() || node->max_properties.has_value()) {
+      uint64_t prop_count = 0;
+      for ([[maybe_unused]] auto _ : obj) ++prop_count;
+      if (node->min_properties.has_value() &&
+          prop_count < node->min_properties.value()) {
+        errors.push_back({error_code::min_properties_violation, path,
+                          "object has " + std::to_string(prop_count) +
+                              " properties, minimum " +
+                              std::to_string(node->min_properties.value())});
+      }
+      if (node->max_properties.has_value() &&
+          prop_count > node->max_properties.value()) {
+        errors.push_back({error_code::max_properties_violation, path,
+                          "object has " + std::to_string(prop_count) +
+                              " properties, maximum " +
+                              std::to_string(node->max_properties.value())});
+      }
     }
 
     // required
@@ -1094,17 +1179,50 @@ static void validate_node(const schema_node_ptr& node,
         }
       }
     }
-
-    // propertyNames
+    // propertyNames — validate key as string directly when possible
     if (node->property_names_schema) {
-      for (auto [key, val] : obj) {
-        // Create a string element to validate the key
-        std::string key_json = "\"" + std::string(key) + "\"";
-        dom::parser key_parser;
-        auto key_result = key_parser.parse(key_json);
-        if (!key_result.error()) {
-          validate_node(node->property_names_schema, key_result.value(),
-                        path, ctx, errors, all_errors);
+      auto pn = node->property_names_schema;
+      bool string_only = pn->ref.empty() && pn->all_of.empty() &&
+          pn->any_of.empty() && pn->one_of.empty() && !pn->not_schema &&
+          !pn->if_schema && pn->enum_values_minified.empty() &&
+          !pn->const_value_raw.has_value();
+      if (string_only) {
+        // Fast path: validate string constraints on key directly
+        for (auto [key, val] : obj) {
+          std::string_view key_sv(key);
+          if (pn->type_mask && !(pn->type_mask & json_type_bit(json_type::string))) {
+            errors.push_back({error_code::type_mismatch, path,
+                              "propertyNames: key is string but schema requires different type"});
+            continue;
+          }
+          uint64_t len = utf8_length(key_sv);
+          if (pn->min_length.has_value() && len < pn->min_length.value()) {
+            errors.push_back({error_code::min_length_violation, path,
+                              "propertyNames: key too short: " + std::string(key_sv)});
+          }
+          if (pn->max_length.has_value() && len > pn->max_length.value()) {
+            errors.push_back({error_code::max_length_violation, path,
+                              "propertyNames: key too long: " + std::string(key_sv)});
+          }
+          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)});
+            }
+          }
+          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)});
+          }
+        }
+      } else {
+        // Fallback: parse key as JSON string element
+        for (auto [key, val] : obj) {
+          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);
+          }
         }
       }
     }
@@ -1230,12 +1348,8 @@ static bool validate_fast(const schema_node_ptr& node,
   }
 
   // type
-  if (!node->types.empty()) {
-    bool match = false;
-    for (const auto& t : node->types) {
-      if (type_matches(value, t)) { match = true; break; }
-    }
-    if (!match) [[unlikely]] return false;
+  if (node->type_mask) {
+    if (!type_matches_mask(value, node->type_mask)) [[unlikely]] return false;
   }
 
   // enum
@@ -1253,10 +1367,10 @@ static bool validate_fast(const schema_node_ptr& node,
     if (canonical_json(value) != node->const_value_raw.value()) [[unlikely]] return false;
   }
 
-  auto actual_type = type_of_sv(value);
+  auto vtype = value.type();
 
   // Numeric
-  if (actual_type == "integer" || actual_type == "number") {
+  if (vtype == et::INT64 || vtype == et::UINT64 || vtype == et::DOUBLE) {
     double v = to_double(value);
     if (node->minimum.has_value() && v < node->minimum.value()) return false;
     if (node->maximum.has_value() && v > node->maximum.value()) return false;
@@ -1269,7 +1383,7 @@ static bool validate_fast(const schema_node_ptr& node,
   }
 
   // String
-  if (actual_type == "string") {
+  if (vtype == et::STRING) {
     std::string_view sv;
     value.get(sv);
     uint64_t len = utf8_length(sv);
@@ -1279,22 +1393,38 @@ static bool validate_fast(const schema_node_ptr& node,
       if (!re2::RE2::PartialMatch(re2::StringPiece(sv.data(), sv.size()), *node->compiled_pattern))
         return false;
     }
-    if (node->format.has_value() && !check_format(sv, node->format.value())) return false;
+    if (node->format.has_value() && !check_format_by_id(sv, node->format_id)) return false;
   }
 
   // Array
-  if (actual_type == "array" && value.is<dom::array>()) {
+  if (vtype == et::ARRAY) {
     dom::array arr; value.get(arr);
-    uint64_t arr_size = 0;
-    for ([[maybe_unused]] auto _ : arr) ++arr_size;
+    uint64_t arr_size = arr.size();
+    if(arr_size == 0xFFFFFF) [[unlikely]]	{
+      // Fallback for large arrays where size() saturates — count manually to avoid overflow
+      arr_size = 0;
+      for ([[maybe_unused]] auto _ : arr) ++arr_size;
+    }
 
     if (node->min_items.has_value() && arr_size < node->min_items.value()) return false;
     if (node->max_items.has_value() && arr_size > node->max_items.value()) return false;
 
     if (node->unique_items) {
-      std::set<std::string> seen;
-      for (auto item : arr) {
-        if (!seen.insert(canonical_json(item)).second) return false;
+      auto first_it = arr.begin();
+      if (first_it != arr.end()) {
+        auto first_type = (*first_it).type();
+        bool all_same = true;
+        for (auto item : arr) { if (item.type() != first_type) { all_same = false; break; } }
+        if (all_same && first_type == et::STRING) {
+          std::set<std::string_view> seen;
+          for (auto item : arr) { std::string_view sv; item.get(sv); if (!seen.insert(sv).second) return false; }
+        } else if (all_same && (first_type == et::INT64 || first_type == et::UINT64 || first_type == et::DOUBLE)) {
+          std::set<double> seen;
+          for (auto item : arr) { if (!seen.insert(to_double(item)).second) return false; }
+        } else {
+          std::set<std::string> seen;
+          for (auto item : arr) { if (!seen.insert(canonical_json(item)).second) return false; }
+        }
       }
     }
 
@@ -1321,7 +1451,7 @@ static bool validate_fast(const schema_node_ptr& node,
   }
 
   // Object
-  if (actual_type == "object" && value.is<dom::object>()) {
+  if (vtype == et::OBJECT) {
     dom::object obj; value.get(obj);
 
     if (node->min_properties.has_value() || node->max_properties.has_value()) {
@@ -1438,19 +1568,27 @@ static void cg_compile(const schema_node* n, cg::plan& p,
     return;
   }
   // Type
-  if (!n->types.empty()) {
-    if (n->types.size() == 1) {
-      auto& t = n->types[0];
-      if (t=="object") out.push_back({cg::op::EXPECT_OBJECT});
-      else if (t=="array") out.push_back({cg::op::EXPECT_ARRAY});
-      else if (t=="string") out.push_back({cg::op::EXPECT_STRING});
-      else if (t=="number") out.push_back({cg::op::EXPECT_NUMBER});
-      else if (t=="integer") out.push_back({cg::op::EXPECT_INTEGER});
-      else if (t=="boolean") out.push_back({cg::op::EXPECT_BOOLEAN});
-      else if (t=="null") out.push_back({cg::op::EXPECT_NULL});
+  if (n->type_mask) {
+    int popcount = __builtin_popcount(n->type_mask);
+    if (popcount == 1) {
+      // Single type — emit specific opcode
+      for (int b = 0; b < 7; ++b) {
+        if (n->type_mask & (1u << b)) {
+          switch (static_cast<json_type>(b)) {
+            case json_type::object:     out.push_back({cg::op::EXPECT_OBJECT}); break;
+            case json_type::array:      out.push_back({cg::op::EXPECT_ARRAY}); break;
+            case json_type::string:     out.push_back({cg::op::EXPECT_STRING}); break;
+            case json_type::number:     out.push_back({cg::op::EXPECT_NUMBER}); break;
+            case json_type::integer:    out.push_back({cg::op::EXPECT_INTEGER}); break;
+            case json_type::boolean:    out.push_back({cg::op::EXPECT_BOOLEAN}); break;
+            case json_type::null_value: out.push_back({cg::op::EXPECT_NULL}); break;
+          }
+          break;
+        }
+      }
     } else {
-      uint32_t i = (uint32_t)p.type_sets.size();
-      p.type_sets.push_back(n->types);
+      uint32_t i = (uint32_t)p.type_masks.size();
+      p.type_masks.push_back(n->type_mask);
       out.push_back({cg::op::EXPECT_TYPE_MULTI, i});
     }
   }
@@ -1480,13 +1618,7 @@ static void cg_compile(const schema_node* n, cg::plan& p,
   if (n->compiled_pattern) { uint32_t i=(uint32_t)p.regexes.size(); p.regexes.push_back(n->compiled_pattern); out.push_back({cg::op::CHECK_PATTERN,i}); }
   if (n->format.has_value()) {
     uint32_t i=(uint32_t)p.format_ids.size();
-    uint8_t fid=255;
-    auto& f=*n->format;
-    if(f=="email")fid=0;else if(f=="date")fid=1;else if(f=="date-time")fid=2;
-    else if(f=="time")fid=3;else if(f=="ipv4")fid=4;else if(f=="ipv6")fid=5;
-    else if(f=="uri"||f=="uri-reference")fid=6;else if(f=="uuid")fid=7;
-    else if(f=="hostname")fid=8;
-    p.format_ids.push_back(fid);
+    p.format_ids.push_back(n->format_id);
     out.push_back({cg::op::CHECK_FORMAT,i});
   }
   // Array
@@ -1530,44 +1662,43 @@ static void cg_compile(const schema_node* n, cg::plan& p,
 }
 
 // --- Codegen executor ---
-static const char* fmt_names[]={"email","date","date-time","time","ipv4","ipv6","uri","uuid","hostname"};
 
 static bool cg_exec(const cg::plan& p, const std::vector<cg::ins>& code,
                      dom::element value) {
-  auto t = type_of_sv(value);
+  auto t = value.type();
+  bool t_numeric = (t == et::INT64 || t == et::UINT64 || t == et::DOUBLE);
+  double t_dval = t_numeric ? to_double(value) : 0.0;
   for (size_t i=0; i<code.size(); ++i) {
     auto& c = code[i];
     switch(c.o) {
     case cg::op::END: return true;
-    case cg::op::EXPECT_OBJECT: if(t!="object") return false; break;
-    case cg::op::EXPECT_ARRAY: if(t!="array") return false; break;
-    case cg::op::EXPECT_STRING: if(t!="string") return false; break;
-    case cg::op::EXPECT_NUMBER: if(t!="number"&&t!="integer") return false; break;
-    case cg::op::EXPECT_INTEGER: if(t!="integer") return false; break;
-    case cg::op::EXPECT_BOOLEAN: if(t!="boolean") return false; break;
-    case cg::op::EXPECT_NULL: if(t!="null") return false; break;
+    case cg::op::EXPECT_OBJECT: if(t!=et::OBJECT) return false; break;
+    case cg::op::EXPECT_ARRAY: if(t!=et::ARRAY) return false; break;
+    case cg::op::EXPECT_STRING: if(t!=et::STRING) return false; break;
+    case cg::op::EXPECT_NUMBER: if(!t_numeric) return false; break;
+    case cg::op::EXPECT_INTEGER: if(t!=et::INT64&&t!=et::UINT64) return false; break;
+    case cg::op::EXPECT_BOOLEAN: if(t!=et::BOOL) return false; break;
+    case cg::op::EXPECT_NULL: if(t!=et::NULL_VALUE) return false; break;
     case cg::op::EXPECT_TYPE_MULTI: {
-      auto& ts=p.type_sets[c.a]; bool m=false;
-      for(auto& ty:ts){if(t==ty||(ty=="number"&&(t=="integer"||t=="number"))){m=true;break;}}
-      if(!m) return false; break;
-    }
-    case cg::op::CHECK_MINIMUM: if(t=="integer"||t=="number"){if(to_double(value)<p.doubles[c.a])return false;} break;
-    case cg::op::CHECK_MAXIMUM: if(t=="integer"||t=="number"){if(to_double(value)>p.doubles[c.a])return false;} break;
-    case cg::op::CHECK_EX_MINIMUM: if(t=="integer"||t=="number"){if(to_double(value)<=p.doubles[c.a])return false;} break;
-    case cg::op::CHECK_EX_MAXIMUM: if(t=="integer"||t=="number"){if(to_double(value)>=p.doubles[c.a])return false;} break;
-    case cg::op::CHECK_MULTIPLE_OF: if(t=="integer"||t=="number"){double v=to_double(value),d=p.doubles[c.a],r=std::fmod(v,d);if(std::abs(r)>1e-8&&std::abs(r-d)>1e-8)return false;} break;
-    case cg::op::CHECK_MIN_LENGTH: if(t=="string"){std::string_view sv;value.get(sv);if(utf8_length(sv)<c.a)return false;} break;
-    case cg::op::CHECK_MAX_LENGTH: if(t=="string"){std::string_view sv;value.get(sv);if(utf8_length(sv)>c.a)return false;} break;
-    case cg::op::CHECK_PATTERN: if(t=="string"){std::string_view sv;value.get(sv);if(!re2::RE2::PartialMatch(re2::StringPiece(sv.data(),sv.size()),*p.regexes[c.a]))return false;} break;
-    case cg::op::CHECK_FORMAT: if(t=="string"){std::string_view sv;value.get(sv);uint8_t f=p.format_ids[c.a];if(f<9&&!check_format(sv,fmt_names[f]))return false;} break;
-    case cg::op::CHECK_MIN_ITEMS: if(t=="array"){dom::array a;value.get(a);uint64_t s=0;for([[maybe_unused]]auto _:a)++s;if(s<c.a)return false;} break;
-    case cg::op::CHECK_MAX_ITEMS: if(t=="array"){dom::array a;value.get(a);uint64_t s=0;for([[maybe_unused]]auto _:a)++s;if(s>c.a)return false;} break;
-    case cg::op::CHECK_UNIQUE_ITEMS: if(t=="array"){dom::array a;value.get(a);std::set<std::string> seen;for(auto x:a)if(!seen.insert(canonical_json(x)).second)return false;} break;
-    case cg::op::ARRAY_ITEMS: if(t=="array"){dom::array a;value.get(a);for(auto x:a)if(!cg_exec(p,p.subs[c.a],x))return false;} break;
-    case cg::op::CHECK_REQUIRED: if(t=="object"){dom::object o;value.get(o);dom::element d;if(o[p.strings[c.a]].get(d)!=SUCCESS)return false;} break;
-    case cg::op::CHECK_MIN_PROPS: if(t=="object"){dom::object o;value.get(o);uint64_t n=0;for([[maybe_unused]]auto _:o)++n;if(n<c.a)return false;} break;
-    case cg::op::CHECK_MAX_PROPS: if(t=="object"){dom::object o;value.get(o);uint64_t n=0;for([[maybe_unused]]auto _:o)++n;if(n>c.a)return false;} break;
-    case cg::op::OBJ_PROPS_START: if(t=="object"){
+      if(!(element_type_mask(t) & p.type_masks[c.a])) return false; break;
+    }
+    case cg::op::CHECK_MINIMUM: if(t_numeric&&t_dval<p.doubles[c.a])return false; break;
+    case cg::op::CHECK_MAXIMUM: if(t_numeric&&t_dval>p.doubles[c.a])return false; break;
+    case cg::op::CHECK_EX_MINIMUM: if(t_numeric&&t_dval<=p.doubles[c.a])return false; break;
+    case cg::op::CHECK_EX_MAXIMUM: if(t_numeric&&t_dval>=p.doubles[c.a])return false; break;
+    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;
+    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;
+    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;
+    case cg::op::CHECK_UNIQUE_ITEMS: if(t==et::ARRAY){dom::array a;value.get(a);std::set<std::string> seen;for(auto x:a)if(!seen.insert(canonical_json(x)).second)return false;} break;
+    case cg::op::ARRAY_ITEMS: if(t==et::ARRAY){dom::array a;value.get(a);for(auto x:a)if(!cg_exec(p,p.subs[c.a],x))return false;} break;
+    case cg::op::CHECK_REQUIRED: if(t==et::OBJECT){dom::object o;value.get(o);dom::element d;if(o[p.strings[c.a]].get(d)!=SUCCESS)return false;} break;
+    case cg::op::CHECK_MIN_PROPS: if(t==et::OBJECT){dom::object o;value.get(o);uint64_t n=0;for([[maybe_unused]]auto _:o)++n;if(n<c.a)return false;} break;
+    case cg::op::CHECK_MAX_PROPS: if(t==et::OBJECT){dom::object o;value.get(o);uint64_t n=0;for([[maybe_unused]]auto _:o)++n;if(n>c.a)return false;} break;
+    case cg::op::OBJ_PROPS_START: if(t==et::OBJECT){
       dom::object o; value.get(o);
       // collect prop defs
       struct pd{std::string_view nm;uint32_t si;};
@@ -1587,13 +1718,13 @@ static bool cg_exec(const cg::plan& p, const std::vector<cg::ins>& code,
     case cg::op::OBJ_PROP: case cg::op::OBJ_PROPS_END: case cg::op::CHECK_NO_ADDITIONAL: break;
     case cg::op::CHECK_ENUM_STR: {
       auto& es=p.enum_sets[c.a]; bool f=false;
-      if(t=="string"){std::string_view sv;value.get(sv);for(auto& e:es)if(e.size()==sv.size()+2&&e[0]=='"'&&e.back()=='"'&&e.compare(1,sv.size(),sv)==0){f=true;break;}}
+      if(t==et::STRING){std::string_view sv;value.get(sv);for(auto& e:es)if(e.size()==sv.size()+2&&e[0]=='"'&&e.back()=='"'&&e.compare(1,sv.size(),sv)==0){f=true;break;}}
       if(!f){std::string v=canonical_json(value);for(auto& e:es)if(e==v){f=true;break;}}
       if(!f)return false; break;
     }
     case cg::op::CHECK_ENUM: {
       auto& es=p.enum_sets[c.a]; bool f=false;
-      if(t=="string"){std::string_view sv;value.get(sv);for(auto& e:es)if(e.size()==sv.size()+2&&e[0]=='"'&&e.back()=='"'&&e.compare(1,sv.size(),sv)==0){f=true;break;}}
+      if(t==et::STRING){std::string_view sv;value.get(sv);for(auto& e:es)if(e.size()==sv.size()+2&&e[0]=='"'&&e.back()=='"'&&e.compare(1,sv.size(),sv)==0){f=true;break;}}
       if(!f&&value.is<int64_t>()){int64_t v;value.get(v);auto s=std::to_string(v);for(auto& e:es)if(e==s){f=true;break;}}
       if(!f){std::string v=canonical_json(value);for(auto& e:es)if(e==v){f=true;break;}}
       if(!f)return false; break;
@@ -1609,51 +1740,53 @@ static bool cg_exec(const cg::plan& p, const std::vector<cg::ins>& code,
 // Uses simdjson On Demand API to avoid materializing the full DOM tree.
 // Returns: true = valid, false = invalid OR unsupported (fallback to DOM).
 
-static std::string_view od_type(simdjson::ondemand::value& v) {
+static json_type od_type(simdjson::ondemand::value& v) {
   switch (v.type()) {
-    case simdjson::ondemand::json_type::object: return "object";
-    case simdjson::ondemand::json_type::array: return "array";
-    case simdjson::ondemand::json_type::string: return "string";
-    case simdjson::ondemand::json_type::boolean: return "boolean";
-    case simdjson::ondemand::json_type::null: return "null";
+    case simdjson::ondemand::json_type::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;
+    case simdjson::ondemand::json_type::boolean: return json_type::boolean;
+    case simdjson::ondemand::json_type::null: return json_type::null_value;
     case simdjson::ondemand::json_type::number: {
       simdjson::ondemand::number_type nt;
       if (v.get_number_type().get(nt) == SUCCESS &&
           nt == simdjson::ondemand::number_type::floating_point_number)
-        return "number";
-      return "integer";
+        return json_type::number;
+      return json_type::integer;
     }
   }
-  return "unknown";
+  return json_type::string;
 }
 
 static bool od_exec(const cg::plan& p, const std::vector<cg::ins>& code,
                      simdjson::ondemand::value value) {
   auto t = od_type(value);
+  bool t_numeric = (t == json_type::integer || t == json_type::number);
   for (size_t i = 0; i < code.size(); ++i) {
     auto& c = code[i];
     switch (c.o) {
     case cg::op::END: return true;
-    case cg::op::EXPECT_OBJECT: if(t!="object") return false; break;
-    case cg::op::EXPECT_ARRAY: if(t!="array") return false; break;
-    case cg::op::EXPECT_STRING: if(t!="string") return false; break;
-    case cg::op::EXPECT_NUMBER: if(t!="number"&&t!="integer") return false; break;
-    case cg::op::EXPECT_INTEGER: if(t!="integer") return false; break;
-    case cg::op::EXPECT_BOOLEAN: if(t!="boolean") return false; break;
-    case cg::op::EXPECT_NULL: if(t!="null") return false; break;
+    case cg::op::EXPECT_OBJECT: if(t!=json_type::object) return false; break;
+    case cg::op::EXPECT_ARRAY: if(t!=json_type::array) return false; break;
+    case cg::op::EXPECT_STRING: if(t!=json_type::string) return false; break;
+    case cg::op::EXPECT_NUMBER: if(!t_numeric) return false; break;
+    case cg::op::EXPECT_INTEGER: if(t!=json_type::integer) return false; break;
+    case cg::op::EXPECT_BOOLEAN: if(t!=json_type::boolean) return false; break;
+    case cg::op::EXPECT_NULL: if(t!=json_type::null_value) return false; break;
     case cg::op::EXPECT_TYPE_MULTI: {
-      auto& ts=p.type_sets[c.a]; bool m=false;
-      for(auto& ty:ts){if(t==ty||(ty=="number"&&(t=="integer"||t=="number"))){m=true;break;}}
-      if(!m) return false; break;
+      // integer matches both "integer" and "number" type constraints
+      uint8_t tbits = json_type_bit(t);
+      if (t == json_type::integer) tbits |= json_type_bit(json_type::number);
+      if(!(tbits & p.type_masks[c.a])) return false; break;
     }
     case cg::op::CHECK_MINIMUM:
     case cg::op::CHECK_MAXIMUM:
     case cg::op::CHECK_EX_MINIMUM:
     case cg::op::CHECK_EX_MAXIMUM:
     case cg::op::CHECK_MULTIPLE_OF: {
-      if (t=="integer"||t=="number") {
+      if (t_numeric) {
         double v;
-        if (t=="integer") { int64_t iv; if(value.get(iv)!=SUCCESS) return false; v=(double)iv; }
+        if (t==json_type::integer) { int64_t iv; if(value.get(iv)!=SUCCESS) return false; v=(double)iv; }
         else { if(value.get(v)!=SUCCESS) return false; }
         double d=p.doubles[c.a];
         if(c.o==cg::op::CHECK_MINIMUM && v<d) return false;
@@ -1664,39 +1797,39 @@ static bool od_exec(const cg::plan& p, const std::vector<cg::ins>& code,
       }
       break;
     }
-    case cg::op::CHECK_MIN_LENGTH: if(t=="string"){std::string_view sv; if(value.get(sv)!=SUCCESS) return false; if(utf8_length(sv)<c.a) return false;} break;
-    case cg::op::CHECK_MAX_LENGTH: if(t=="string"){std::string_view sv; if(value.get(sv)!=SUCCESS) return false; if(utf8_length(sv)>c.a) return false;} break;
-    case cg::op::CHECK_PATTERN: if(t=="string"){std::string_view sv; if(value.get(sv)!=SUCCESS) return false; if(!re2::RE2::PartialMatch(re2::StringPiece(sv.data(),sv.size()),*p.regexes[c.a]))return false;} break;
-    case cg::op::CHECK_FORMAT: if(t=="string"){std::string_view sv; if(value.get(sv)!=SUCCESS) return false; uint8_t f=p.format_ids[c.a]; if(f<9&&!check_format(sv,fmt_names[f]))return false;} break;
-    case cg::op::CHECK_MIN_ITEMS: if(t=="array"){
+    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;
+    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;
+    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;
       uint64_t s=0; for(auto x:a){(void)x;++s;} if(s<c.a) return false;
     } break;
-    case cg::op::CHECK_MAX_ITEMS: if(t=="array"){
+    case cg::op::CHECK_MAX_ITEMS: if(t==json_type::array){
       simdjson::ondemand::array a; if(value.get(a)!=SUCCESS) return false;
       uint64_t s=0; for(auto x:a){(void)x;++s;} if(s>c.a) return false;
     } break;
-    case cg::op::ARRAY_ITEMS: if(t=="array"){
+    case cg::op::ARRAY_ITEMS: if(t==json_type::array){
       simdjson::ondemand::array a; if(value.get(a)!=SUCCESS) return false;
       for(auto elem:a){
         simdjson::ondemand::value v; if(elem.get(v)!=SUCCESS) return false;
         if(!od_exec(p,p.subs[c.a],v)) return false;
       }
     } break;
-    case cg::op::CHECK_REQUIRED: if(t=="object"){
+    case cg::op::CHECK_REQUIRED: if(t==json_type::object){
       simdjson::ondemand::object o; if(value.get(o)!=SUCCESS) return false;
       auto f = o.find_field_unordered(p.strings[c.a]);
       if(f.error()) return false;
     } break;
-    case cg::op::CHECK_MIN_PROPS: if(t=="object"){
+    case cg::op::CHECK_MIN_PROPS: if(t==json_type::object){
       simdjson::ondemand::object o; if(value.get(o)!=SUCCESS) return false;
       uint64_t n=0; for(auto f:o){(void)f;++n;} if(n<c.a) return false;
     } break;
-    case cg::op::CHECK_MAX_PROPS: if(t=="object"){
+    case cg::op::CHECK_MAX_PROPS: if(t==json_type::object){
       simdjson::ondemand::object o; if(value.get(o)!=SUCCESS) return false;
       uint64_t n=0; for(auto f:o){(void)f;++n;} if(n>c.a) return false;
     } break;
-    case cg::op::OBJ_PROPS_START: if(t=="object"){
+    case cg::op::OBJ_PROPS_START: if(t==json_type::object){
       simdjson::ondemand::object o; if(value.get(o)!=SUCCESS) return false;
       struct pd{std::string_view nm;uint32_t si;};
       std::vector<pd> props; bool no_add=false;
@@ -1849,10 +1982,9 @@ validation_result validate(const schema_ref& schema, std::string_view json,
     // Codegen said invalid OR hit COMPOSITION — fall through to tree walker
   }
 
-  // Slow path: re-parse + tree walker with error details
-  auto result2 = dom_p.parse(psv);
+  // Slow path: tree walker with error details (reuse already-parsed DOM)
   std::vector<validation_error> errors;
-  validate_node(schema.impl->root, result2.value(), "", *schema.impl, errors,
+  validate_node(schema.impl->root, result.value(), "", *schema.impl, errors,
                 opts.all_errors);
 
   return {errors.empty(), std::move(errors)};