ata-validator 0.12.1 → 0.12.2

package/binding/ata_napi.cpp

@@ -1203,8 +1203,15 @@ static napi_value RawFastValidate(napi_env env, napi_callback_info info) {
         }
       }
     } else {
-      // String — must copy (can't pre-pad strings)
-      size_t len;
+      napi_valuetype vtype;
+      napi_typeof(env, args[1], &vtype);
+      if (vtype != napi_string) {
+        napi_throw_type_error(env, nullptr,
+          "rawFastValidate() requires a Buffer, TypedArray, or string. For parsed objects, use validate() or isValidObject().");
+        return nullptr;
+      }
+      // String, must copy (can't pre-pad strings)
+      size_t len = 0;
       napi_get_value_string_utf8(env, args[1], nullptr, 0, &len);
       if (len <= 4096) {
         char buf[4097];
@@ -1267,7 +1274,14 @@ static napi_value RawBatchValidate(napi_env env, napi_callback_info info) {
           valid = ata::validate(g_fast_schemas[slot],
                     std::string_view(static_cast<const char*>(data), length)).valid;
       } else {
-        size_t len;
+        napi_valuetype vtype;
+        napi_typeof(env, item, &vtype);
+        if (vtype != napi_string) {
+          napi_throw_type_error(env, nullptr,
+            "rawNDJSONValidate() batch elements must be Buffer, TypedArray, or string");
+          return nullptr;
+        }
+        size_t len = 0;
         napi_get_value_string_utf8(env, item, nullptr, 0, &len);
         std::string buf(len, '\0');
         napi_get_value_string_utf8(env, item, buf.data(), len + 1, &len);

package/include/ata.h

@@ -8,16 +8,16 @@
 #include <variant>
 #include <vector>
 
-#define ATA_VERSION "0.10.3"
+#define ATA_VERSION "0.10.4"
 
 namespace ata {
 
 inline constexpr uint32_t VERSION_MAJOR = 0;
 inline constexpr uint32_t VERSION_MINOR = 10;
-inline constexpr uint32_t VERSION_REVISION = 3;
+inline constexpr uint32_t VERSION_REVISION = 4;
 
 inline constexpr std::string_view version() noexcept {
-  return "0.10.3";
+  return "0.10.4";
 }
 
 enum class error_code : uint8_t {
@@ -55,6 +55,8 @@ struct validation_error {
   error_code code;
   std::string path;
   std::string message;
+  std::string expected;
+  std::string actual;
 };
 
 struct validation_result {

package/index.js

@@ -693,19 +693,37 @@ class Validator {
         this.isValid = (buf) => {
           self._ensureNative();
           const slot = self._fastSlot;
-          self.isValid = (b) => { if (typeof b === 'string') b = Buffer.from(b); return native.rawFastValidate(slot, b); };
+          self.isValid = (b) => {
+            if (typeof b === 'string') b = Buffer.from(b);
+            else if (!(b instanceof Uint8Array)) throw new TypeError('isValid() requires a Buffer, Uint8Array, or string. For parsed objects, use isValidObject().');
+            return native.rawFastValidate(slot, b);
+          };
           return self.isValid(buf);
         };
         this.countValid = (ndjsonBuf) => {
           self._ensureNative();
           const slot = self._fastSlot;
-          self.countValid = (b) => { if (typeof b === 'string') b = Buffer.from(b); const r = native.rawNDJSONValidate(slot, b); let c = 0; for (let i = 0; i < r.length; i++) if (r[i]) c++; return c; };
+          self.countValid = (b) => {
+            if (typeof b === 'string') b = Buffer.from(b);
+            else if (!(b instanceof Uint8Array)) throw new TypeError('countValid() requires a Buffer, Uint8Array, or string');
+            const r = native.rawNDJSONValidate(slot, b);
+            let c = 0;
+            for (let i = 0; i < r.length; i++) if (r[i]) c++;
+            return c;
+          };
           return self.countValid(ndjsonBuf);
         };
         this.batchIsValid = (buffers) => {
           self._ensureNative();
           const slot = self._fastSlot;
-          self.batchIsValid = (bufs) => { let v = 0; for (const b of bufs) if (native.rawFastValidate(slot, b)) v++; return v; };
+          self.batchIsValid = (bufs) => {
+            let v = 0;
+            for (const b of bufs) {
+              if (!(b instanceof Uint8Array)) throw new TypeError('batchIsValid() requires Buffer or Uint8Array elements');
+              if (native.rawFastValidate(slot, b)) v++;
+            }
+            return v;
+          };
           return self.batchIsValid(buffers);
         };
       }
@@ -732,6 +750,7 @@ class Validator {
         const slot = this._fastSlot;
         this.isValid = (buf) => {
           if (typeof buf === 'string') buf = Buffer.from(buf);
+          else if (!(buf instanceof Uint8Array)) throw new TypeError('isValid() requires a Buffer, Uint8Array, or string. For parsed objects, use isValidObject().');
           return native.rawFastValidate(slot, buf);
         };
       }
@@ -739,6 +758,7 @@ class Validator {
         const slot = this._fastSlot;
         this.countValid = (ndjsonBuf) => {
           if (typeof ndjsonBuf === 'string') ndjsonBuf = Buffer.from(ndjsonBuf);
+          else if (!(ndjsonBuf instanceof Uint8Array)) throw new TypeError('countValid() requires a Buffer, Uint8Array, or string');
           const results = native.rawNDJSONValidate(slot, ndjsonBuf);
           let count = 0;
           for (let i = 0; i < results.length; i++) if (results[i]) count++;
@@ -750,6 +770,7 @@ class Validator {
         this.batchIsValid = (buffers) => {
           let valid = 0;
           for (const buf of buffers) {
+            if (!(buf instanceof Uint8Array)) throw new TypeError('batchIsValid() requires Buffer or Uint8Array elements');
             if (native.rawFastValidate(slot, buf)) valid++;
           }
           return valid;
@@ -825,6 +846,7 @@ class Validator {
     if (!jsFn || !jsFn._source) return null;
     const src = jsFn._source;
     const hybridSrc = jsFn._hybridSource || "";
+    const preambleSrc = jsFn._preambleSource || "";
 
     // Also capture error function source for zero-compile standalone load
     const jsErrFn = compileToJSCodegenWithErrors(
@@ -835,6 +857,7 @@ class Validator {
     return `// Auto-generated by ata-validator — do not edit
 'use strict';
 ${_CP_LEN_SOURCE}
+${preambleSrc}
 const boolFn = function(d) {
   ${src}
 };
@@ -1025,6 +1048,8 @@ ${exports}`;
   // Raw NAPI fast path for Buffer/Uint8Array
   isValid(input) {
     if (!native) throw new Error('Native addon required for isValid() — install build tools or use validate() instead');
+    if (typeof input === 'string') input = Buffer.from(input);
+    else if (!(input instanceof Uint8Array)) throw new TypeError('isValid() requires a Buffer, Uint8Array, or string. For parsed objects, use isValidObject().');
     this._ensureNative();
     return native.rawFastValidate(this._fastSlot, input);
   }

package/lib/js-compiler.js

@@ -827,7 +827,7 @@ function compileToJSCodegen(schema, schemaMap) {
     }
   }
 
-  const ctx = { varCounter: 0, helpers: [], helperCode: [], closureVars: ['_cpLen'], closureVals: [_cpLen], rootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors, rootSchema: schema }
+  const ctx = { varCounter: 0, helpers: [], helperCode: [], preamble: [], closureVars: ['_cpLen'], closureVals: [_cpLen], rootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors, rootSchema: schema }
   const lines = []
   genCode(schema, 'd', lines, ctx)
 
@@ -864,24 +864,30 @@ function compileToJSCodegen(schema, schemaMap) {
     hybridBody = replaceTopLevel(checkStr + '\n  return R')
   }
 
+  const preambleStr = ctx.preamble && ctx.preamble.length ? ctx.preamble.join('\n  ') + '\n  ' : ''
+
   try {
     let boolFn
     if (closureNames.length > 0) {
-      const factory = new Function(...closureNames, `return function(d){${body}}`)
+      const factory = new Function(...closureNames, `${preambleStr}return function(d){${body}}`)
       boolFn = factory(...closureValues)
+    } else if (preambleStr) {
+      const factory = new Function(`${preambleStr}return function(d){${body}}`)
+      boolFn = factory()
     } else {
       boolFn = new Function('d', body)
     }
 
     // Build hybrid: same body, return R instead of true, return E(d) instead of false.
     try {
-      const hybridFactory = new Function(...closureNames, 'R', 'E', `return function(d){${hybridBody}}`)
+      const hybridFactory = new Function(...closureNames, 'R', 'E', `${preambleStr}return function(d){${hybridBody}}`)
       boolFn._hybridFactory = (R, E) => hybridFactory(...closureValues, R, E)
     } catch {}
 
     // Store source for standalone compilation (includes regex inline for file output)
     const helperStr = ctx.helperCode.length ? ctx.helperCode.join('\n  ') + '\n  ' : ''
     boolFn._source = helperStr + body
+    boolFn._preambleSource = preambleStr
     boolFn._hybridSource = helperStr + hybridBody
 
     return boolFn
@@ -984,15 +990,21 @@ function tryGenCombined(schema, access, ctx) {
       return `{${prelude}if(typeof ${v2}!=='string')return false;const _lv=${v2}.length;if(_lv<${M}||_lv>${X * 2})return false;if(_lv<${M * 2}||_lv>${X}){const _cp=_cpLen(${v2});if(_cp<${M}||_cp>${X})return false}}`
     }
     const conds = [`typeof _v!=='string'`]
-    if (schema.minLength !== undefined) {
+    if (schema.minLength !== undefined && schema.minLength > 0) {
       const M = schema.minLength
       conds.push(`_v.length<${M}`)
-      conds.push(`_v.length<${M * 2}&&_cpLen(_v)<${M}`)
+      // For M=1, length<1 already catches all failures (any non-empty string has cpLen>=1).
+      if (M > 1) conds.push(`_v.length<${M * 2}&&_cpLen(_v)<${M}`)
     }
     if (schema.maxLength !== undefined) {
       const X = schema.maxLength
-      conds.push(`_v.length>${X * 2}`)
-      conds.push(`_v.length>${X}&&_cpLen(_v)>${X}`)
+      // For X=0, only empty string passes, length>0 fails — no cpLen needed.
+      if (X === 0) {
+        conds.push(`_v.length>0`)
+      } else {
+        conds.push(`_v.length>${X * 2}`)
+        conds.push(`_v.length>${X}&&_cpLen(_v)>${X}`)
+      }
     }
     if (conds.length < 2) return null
     return bind(conds)
@@ -1263,14 +1275,20 @@ function genCode(schema, v, lines, ctx, knownType) {
     const body = `{const ${lv}=${v}.length;if(${lv}<${M}||${lv}>${X * 2})return false;if(${lv}<${M * 2}||${lv}>${X}){const _cp=_cpLen(${v});if(_cp<${M}||_cp>${X})return false}}`
     lines.push(isStr ? body : `if(typeof ${v}==='string')${body}`)
   } else {
-    if (schema.minLength !== undefined) {
+    if (schema.minLength !== undefined && schema.minLength > 0) {
       const M = schema.minLength
-      const body = `if(${v}.length<${M})return false;if(${v}.length<${M * 2}&&_cpLen(${v})<${M})return false`
+      // M==1: length<1 already catches empty strings (any non-empty string has cpLen>=1).
+      const body = M === 1
+        ? `if(${v}.length<1)return false`
+        : `if(${v}.length<${M})return false;if(${v}.length<${M * 2}&&_cpLen(${v})<${M})return false`
       lines.push(isStr ? body : `if(typeof ${v}==='string'){${body}}`)
     }
     if (schema.maxLength !== undefined) {
       const X = schema.maxLength
-      const body = `if(${v}.length>${X * 2})return false;if(${v}.length>${X}&&_cpLen(${v})>${X})return false`
+      // X==0: only empty string passes, no cpLen needed.
+      const body = X === 0
+        ? `if(${v}.length>0)return false`
+        : `if(${v}.length>${X * 2})return false;if(${v}.length>${X}&&_cpLen(${v})>${X})return false`
       lines.push(isStr ? body : `if(typeof ${v}==='string'){${body}}`)
     }
   }
@@ -1603,37 +1621,59 @@ function genCode(schema, v, lines, ctx, knownType) {
     }
   }
 
-  // anyOf — need function wrappers since genCode uses return false
+  // anyOf — branch fns hoisted when safe, inline fallback when recursive.
   // Skip standard anyOf if unevaluatedProperties will handle it (single-pass optimization)
   if (schema.anyOf && schema.unevaluatedProperties === undefined) {
-    const fns = []
+    const fi = ctx.varCounter++
+    const branchBodies = []
+    let canHoist = !!ctx.preamble
     for (let i = 0; i < schema.anyOf.length; i++) {
       const subLines = []
       genCode(schema.anyOf[i], '_av', subLines, ctx)
-      if (subLines.length === 0) {
-        fns.push(`function(_av){return true}`)
-      } else {
-        fns.push(`function(_av){${subLines.join(';')};return true}`)
-      }
+      const body = subLines.length === 0 ? 'return true' : `${subLines.join(';')};return true`
+      if (/\b_validate\b/.test(body)) canHoist = false
+      branchBodies.push(body)
+    }
+    if (canHoist) {
+      const names = branchBodies.map((body, i) => {
+        const name = `_af${fi}_b${i}`
+        ctx.preamble.push(`function ${name}(_av){${body}}`)
+        return name
+      })
+      const checks = names.map(n => `${n}(${v})`).join('||')
+      lines.push(`if(!(${checks}))return false`)
+    } else {
+      const fns = branchBodies.map(body => `function(_av){${body}}`)
+      lines.push(`{const _af${fi}=[${fns.join(',')}];let _am${fi}=false;for(let _ai=0;_ai<_af${fi}.length;_ai++){if(_af${fi}[_ai](${v})){_am${fi}=true;break}}if(!_am${fi})return false}`)
     }
-    const fi = ctx.varCounter++
-    lines.push(`{const _af${fi}=[${fns.join(',')}];let _am${fi}=false;for(let _ai=0;_ai<_af${fi}.length;_ai++){if(_af${fi}[_ai](${v})){_am${fi}=true;break}}if(!_am${fi})return false}`)
   }
 
-  // oneOf
+  // oneOf — branch fns hoisted to factory scope when safe (no recursion/ref).
+  // Falls back to inline closures if any branch touches recursive validation.
   if (schema.oneOf) {
-    const fns = []
+    const fi = ctx.varCounter++
+    const branchBodies = []
+    let canHoist = !!ctx.preamble
     for (let i = 0; i < schema.oneOf.length; i++) {
       const subLines = []
       genCode(schema.oneOf[i], '_ov', subLines, ctx)
-      if (subLines.length === 0) {
-        fns.push(`function(_ov){return true}`)
-      } else {
-        fns.push(`function(_ov){${subLines.join(';')};return true}`)
-      }
+      const body = subLines.length === 0 ? 'return true' : `${subLines.join(';')};return true`
+      // _validate is the recursive entry — hoisting branches above it breaks scope.
+      if (/\b_validate\b/.test(body)) canHoist = false
+      branchBodies.push(body)
+    }
+    if (canHoist) {
+      const names = branchBodies.map((body, i) => {
+        const name = `_of${fi}_b${i}`
+        ctx.preamble.push(`function ${name}(_ov){${body}}`)
+        return name
+      })
+      const calls = names.map(n => `if(${n}(${v})){_oc${fi}++;if(_oc${fi}>1)return false}`).join(';')
+      lines.push(`{let _oc${fi}=0;${calls};if(_oc${fi}!==1)return false}`)
+    } else {
+      const fns = branchBodies.map(body => `function(_ov){${body}}`)
+      lines.push(`{const _of${fi}=[${fns.join(',')}];let _oc${fi}=0;for(let _oi=0;_oi<_of${fi}.length;_oi++){if(_of${fi}[_oi](${v}))_oc${fi}++;if(_oc${fi}>1)return false}if(_oc${fi}!==1)return false}`)
     }
-    const fi = ctx.varCounter++
-    lines.push(`{const _of${fi}=[${fns.join(',')}];let _oc${fi}=0;for(let _oi=0;_oi<_of${fi}.length;_oi++){if(_of${fi}[_oi](${v}))_oc${fi}++;if(_oc${fi}>1)return false}if(_oc${fi}!==1)return false}`)
   }
 
   // not

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "0.12.1",
+  "version": "0.12.2",
   "description": "Ultra-fast JSON Schema validator. 5x faster validation, 159,000x 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

@@ -391,13 +391,29 @@ struct od_plan {
 #ifndef ATA_NO_RE2
   re2::RE2* pattern = nullptr;        // borrowed pointer from schema_node
 #endif
+  // Inline digit pattern: ^[0-9]+$ / ^[0-9]{N}$ / ^[0-9]{N,M}$ / ^\d+$ etc.
+  // When set, supersedes the RE2 pattern call.
+  struct digit_pattern_t { uint32_t min_len; uint32_t max_len; };
+  std::optional<digit_pattern_t> digit_pattern;
   uint8_t format_id = 255;            // 255 = no format check
 
   // Object — single iterate with merged required+property lookup
+  // fast_kind allows the obj iterator to skip the recursive od_exec_plan call
+  // (and its inner type().get() + switch) for primitive sub-plans, dispatching
+  // straight to inline constraint code.
+  enum class fast_kind : uint8_t {
+    OTHER = 0,    // recurse via od_exec_plan
+    INTEGER,      // value.get(int64)  + numeric range/multipleOf
+    STRING,       // value.get(string) + length/pattern/format/enum
+    BOOLEAN,      // value.get(bool)
+    OBJECT,       // value.get(object) + nested obj iteration (skips type detect)
+    ARRAY,        // value.get(array) + element iteration (skips type detect)
+  };
   struct prop_entry {
     std::string key;
     int required_idx = -1;            // bit index for required tracking, or -1
     std::shared_ptr<od_plan> sub;     // property sub-plan, or nullptr
+    fast_kind fk = fast_kind::OTHER;  // inline dispatch hint, set at compile time
   };
   struct obj_plan {
     std::vector<prop_entry> entries;  // merged required + properties — single scan
@@ -414,6 +430,17 @@ struct od_plan {
   };
   std::shared_ptr<arr_plan> array;
 
+  // Enum: primitive-only set membership. Complex (object/array) enums fall back.
+  struct enum_constraint {
+    std::vector<std::string> strings;   // unescaped string values
+    std::vector<int64_t> integers;
+    std::vector<double> doubles;
+    bool has_null = false;
+    bool has_true = false;
+    bool has_false = false;
+  };
+  std::shared_ptr<enum_constraint> enum_check;
+
   // If false, schema uses unsupported features — must fall back to DOM path.
   bool supported = true;
 };
@@ -1360,8 +1387,10 @@ static void validate_node(const schema_node_ptr& node,
           expected += json_type_name(static_cast<json_type>(b));
         }
       }
+      std::string actual = std::string(type_of_sv(value));
       errors.push_back({error_code::type_mismatch, path,
-                        "expected type " + expected + ", got " + std::string(type_of_sv(value))});
+                        "expected type " + expected + ", got " + actual,
+                        expected, actual});
       ATA_CHECK_EARLY();
     }
   }
@@ -2399,6 +2428,59 @@ static simdjson::padded_string_view get_free_padded_view(
   return simdjson::padded_string_view(data, length, length + REQUIRED_PADDING);
 }
 
+// Recognize common digit-only regex patterns: ^[0-9]+$, ^[0-9]{N}$, ^[0-9]{N,M}$
+// (and \d variants). Returns true if recognized, fills min_n/max_n.
+static bool parse_digit_pattern(const std::string& p,
+                                uint32_t& min_n, uint32_t& max_n) {
+  if (p.size() < 6) return false;
+  if (p.front() != '^' || p.back() != '$') return false;
+  std::string_view body(p.data() + 1, p.size() - 2);
+  size_t pos = 0;
+  if (body.size() >= 5 && body.compare(0, 5, "[0-9]") == 0) {
+    pos = 5;
+  } else if (body.size() >= 2 && body[0] == '\\' && body[1] == 'd') {
+    pos = 2;
+  } else {
+    return false;
+  }
+  if (pos >= body.size()) return false;
+  char q = body[pos];
+  if (q == '+' && pos + 1 == body.size()) {
+    min_n = 1; max_n = UINT32_MAX; return true;
+  }
+  if (q == '*' && pos + 1 == body.size()) {
+    min_n = 0; max_n = UINT32_MAX; return true;
+  }
+  if (q != '{') return false;
+  size_t close = body.find('}', pos);
+  if (close == std::string_view::npos || close + 1 != body.size()) return false;
+  auto inner = body.substr(pos + 1, close - pos - 1);
+  if (inner.empty()) return false;
+  size_t comma = inner.find(',');
+  auto parse_num = [](std::string_view s, uint32_t& out) -> bool {
+    if (s.empty()) return false;
+    uint64_t v = 0;
+    for (char c : s) {
+      if (c < '0' || c > '9') return false;
+      v = v * 10 + (c - '0');
+      if (v > UINT32_MAX) return false;
+    }
+    out = static_cast<uint32_t>(v);
+    return true;
+  };
+  if (comma == std::string_view::npos) {
+    if (!parse_num(inner, min_n)) return false;
+    max_n = min_n;
+  } else {
+    auto a = inner.substr(0, comma);
+    auto b = inner.substr(comma + 1);
+    if (!parse_num(a, min_n)) return false;
+    if (b.empty()) max_n = UINT32_MAX;
+    else if (!parse_num(b, max_n)) return false;
+  }
+  return true;
+}
+
 // Build an od_plan from a schema_node tree.
 static od_plan_ptr compile_od_plan(const schema_node_ptr& node) {
   if (!node) return nullptr;
@@ -2412,7 +2494,6 @@ static od_plan_ptr compile_od_plan(const schema_node_ptr& node) {
 
   // Unsupported features → fall back to DOM
   if (!node->ref.empty() ||
-      !node->enum_values_minified.empty() ||
       node->const_value_raw.has_value() ||
       node->unique_items ||
       !node->all_of.empty() ||
@@ -2431,6 +2512,47 @@ static od_plan_ptr compile_od_plan(const schema_node_ptr& node) {
     return plan;
   }
 
+  // Enum: handle primitive enums on the on-demand path. Complex enum values
+  // (objects, arrays, escaped strings) fall back to DOM.
+  if (!node->enum_values_minified.empty()) {
+    auto ec = std::make_shared<od_plan::enum_constraint>();
+    for (const auto& ev : node->enum_values_minified) {
+      if (ev.empty()) { plan->supported = false; return plan; }
+      char c = ev[0];
+      if (c == '"') {
+        if (ev.size() < 2 || ev.back() != '"') { plan->supported = false; return plan; }
+        bool has_escape = false;
+        for (size_t i = 1; i + 1 < ev.size(); i++) {
+          if (ev[i] == '\\') { has_escape = true; break; }
+        }
+        if (has_escape) { plan->supported = false; return plan; }
+        ec->strings.push_back(ev.substr(1, ev.size() - 2));
+      } else if (c == '-' || (c >= '0' && c <= '9')) {
+        bool is_int = true;
+        for (size_t i = (c == '-' ? 1 : 0); i < ev.size(); i++) {
+          if (ev[i] < '0' || ev[i] > '9') { is_int = false; break; }
+        }
+        if (is_int) {
+          try { ec->integers.push_back(std::stoll(ev)); }
+          catch (...) { plan->supported = false; return plan; }
+        } else {
+          try { ec->doubles.push_back(std::stod(ev)); }
+          catch (...) { plan->supported = false; return plan; }
+        }
+      } else if (ev == "true") {
+        ec->has_true = true;
+      } else if (ev == "false") {
+        ec->has_false = true;
+      } else if (ev == "null") {
+        ec->has_null = true;
+      } else {
+        plan->supported = false;
+        return plan;
+      }
+    }
+    plan->enum_check = std::move(ec);
+  }
+
   plan->type_mask = node->type_mask;
   if (node->minimum) { plan->num_flags |= od_plan::HAS_MIN; plan->num_min = *node->minimum; }
   if (node->maximum) { plan->num_flags |= od_plan::HAS_MAX; plan->num_max = *node->maximum; }
@@ -2442,6 +2564,16 @@ static od_plan_ptr compile_od_plan(const schema_node_ptr& node) {
 #ifndef ATA_NO_RE2
   plan->pattern = node->compiled_pattern.get();
 #endif
+  // Try to recognize the pattern as an inlined digit check; if so, skip RE2.
+  if (node->pattern.has_value()) {
+    uint32_t min_n, max_n;
+    if (parse_digit_pattern(*node->pattern, min_n, max_n)) {
+      plan->digit_pattern = od_plan::digit_pattern_t{min_n, max_n};
+#ifndef ATA_NO_RE2
+      plan->pattern = nullptr;
+#endif
+    }
+  }
   plan->format_id = node->format_id;
 
   // Object plan — build hash lookup for O(1) per-field dispatch
@@ -2477,7 +2609,46 @@ static od_plan_ptr compile_od_plan(const schema_node_ptr& node) {
         op->entries[it->second].sub = std::move(sub);
       } else {
         key_to_idx[key] = op->entries.size();
-        op->entries.push_back({key, -1, std::move(sub)});
+        op->entries.push_back({key, -1, std::move(sub), od_plan::fast_kind::OTHER});
+      }
+    }
+    // Compute fast_kind for each entry post-hoc — lets the obj iterator
+    // skip the recursive od_exec_plan call (and its type().get + switch)
+    // for primitive properties, and also skip type detection for nested
+    // objects / primitive arrays.
+    for (auto& e : op->entries) {
+      if (!e.sub) continue;
+      // Nested object: dispatch directly to value.get(obj) + iteration helper.
+      if (e.sub->object && !e.sub->array) {
+        e.fk = od_plan::fast_kind::OBJECT;
+        continue;
+      }
+      // Array: dispatch directly to value.get(arr) + element iteration helper.
+      if (e.sub->array && !e.sub->object) {
+        e.fk = od_plan::fast_kind::ARRAY;
+        continue;
+      }
+      if (e.sub->object || e.sub->array) continue;  // unusual: both, skip
+      uint8_t m = e.sub->type_mask;
+      uint8_t s_bit = json_type_bit(json_type::string);
+      uint8_t i_bit = json_type_bit(json_type::integer);
+      uint8_t n_bit = json_type_bit(json_type::number);
+      uint8_t b_bit = json_type_bit(json_type::boolean);
+      if (m == s_bit) e.fk = od_plan::fast_kind::STRING;
+      else if (m == i_bit || m == (i_bit | n_bit)) e.fk = od_plan::fast_kind::INTEGER;
+      else if (m == b_bit) e.fk = od_plan::fast_kind::BOOLEAN;
+      else if (m == 0 && e.sub->enum_check) {
+        // Untyped enum: infer from enum value shapes
+        auto& ec = *e.sub->enum_check;
+        bool only_str = !ec.strings.empty() && ec.integers.empty() && ec.doubles.empty()
+                        && !ec.has_null && !ec.has_true && !ec.has_false;
+        bool only_int = ec.strings.empty() && !ec.integers.empty() && ec.doubles.empty()
+                        && !ec.has_null && !ec.has_true && !ec.has_false;
+        bool only_bool = ec.strings.empty() && ec.integers.empty() && ec.doubles.empty()
+                         && !ec.has_null && (ec.has_true || ec.has_false);
+        if (only_str) e.fk = od_plan::fast_kind::STRING;
+        else if (only_int) e.fk = od_plan::fast_kind::INTEGER;
+        else if (only_bool) e.fk = od_plan::fast_kind::BOOLEAN;
       }
     }
     plan->object = std::move(op);
@@ -2517,11 +2688,18 @@ static inline uint64_t utf8_length_fast(std::string_view s) {
 
 // Execute an od_plan against a simdjson On-Demand value.
 // Each value consumed exactly once. Uses simdjson types directly — no od_type() overhead.
-static bool od_exec_plan(const od_plan& plan, simdjson::ondemand::value value) {
-  // Use simdjson type directly — skip od_type() conversion + get_number_type()
+// `pre_type` is an optional caller-supplied type hint; when set, the value.type().get
+// simdjson call is skipped (saves ~3-5 ns per recursion). Used by fast_kind::OBJECT
+// / ARRAY dispatch where the type is already established at compile time.
+static bool od_exec_plan(const od_plan& plan, simdjson::ondemand::value value,
+                         std::optional<simdjson::ondemand::json_type> pre_type = std::nullopt) {
   using sjt = simdjson::ondemand::json_type;
   sjt st;
-  if (value.type().get(st) != SUCCESS) return false;
+  if (pre_type) {
+    st = *pre_type;
+  } else {
+    if (value.type().get(st) != SUCCESS) return false;
+  }
 
   // Type check using simdjson type directly
   if (plan.type_mask) {
@@ -2552,11 +2730,12 @@ static bool od_exec_plan(const od_plan& plan, simdjson::ondemand::value value) {
 
   switch (st) {
   case sjt::number: {
-    if (!plan.num_flags) break;  // No numeric constraints
+    bool need_value = plan.num_flags || plan.enum_check;
+    if (!need_value) break;
     double v;
-    // Try integer first (more common), fall back to double
     int64_t iv;
-    if (value.get(iv) == SUCCESS) {
+    bool got_int = (value.get(iv) == SUCCESS);
+    if (got_int) {
       v = static_cast<double>(iv);
     } else if (value.get(v) != SUCCESS) {
       return false;
@@ -2570,6 +2749,20 @@ static bool od_exec_plan(const od_plan& plan, simdjson::ondemand::value value) {
       double r = std::fmod(v, plan.num_mul);
       if (std::abs(r) > 1e-8 && std::abs(r - plan.num_mul) > 1e-8) return false;
     }
+    if (plan.enum_check) {
+      auto& ec = *plan.enum_check;
+      bool match = false;
+      if (got_int) {
+        for (auto i : ec.integers) if (i == iv) { match = true; break; }
+      }
+      if (!match) {
+        for (auto d : ec.doubles) if (d == v) { match = true; break; }
+      }
+      if (!match && got_int) {
+        for (auto d : ec.doubles) if (d == v) { match = true; break; }
+      }
+      if (!match) return false;
+    }
     break;
   }
   case sjt::string: {
@@ -2580,8 +2773,16 @@ static bool od_exec_plan(const od_plan& plan, simdjson::ondemand::value value) {
       if (plan.min_length && len < *plan.min_length) return false;
       if (plan.max_length && len > *plan.max_length) return false;
     }
+    if (plan.digit_pattern) {
+      auto& dp = *plan.digit_pattern;
+      if (sv.size() < dp.min_len || sv.size() > dp.max_len) return false;
+      const uint8_t* p = reinterpret_cast<const uint8_t*>(sv.data());
+      for (size_t i = 0, n = sv.size(); i < n; i++) {
+        if (p[i] < '0' || p[i] > '9') return false;
+      }
+    }
 #ifndef ATA_NO_RE2
-    if (plan.pattern) {
+    else if (plan.pattern) {
       if (!re2::RE2::PartialMatch(re2::StringPiece(sv.data(), sv.size()), *plan.pattern))
         return false;
     }
@@ -2589,6 +2790,17 @@ static bool od_exec_plan(const od_plan& plan, simdjson::ondemand::value value) {
     if (plan.format_id != 255) {
       if (!check_format_by_id(sv, plan.format_id)) return false;
     }
+    if (plan.enum_check) {
+      auto& ec = *plan.enum_check;
+      bool match = false;
+      for (auto& s : ec.strings) {
+        if (sv.size() == s.size() && std::memcmp(sv.data(), s.data(), s.size()) == 0) {
+          match = true;
+          break;
+        }
+      }
+      if (!match) return false;
+    }
     break;
   }
   case sjt::object: {
@@ -2601,25 +2813,140 @@ 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;
-      if (field.unescaped_key().get(key)) continue;
+      // Fast key compare: use raw_json_string against schema keys directly,
+      // skipping the unescape pass. Schema keys are assumed to have no
+      // unescaped quotes (true for any well-formed JSON Schema).
+      simdjson::ondemand::raw_json_string raw_key;
+      if (field.key().get(raw_key) != SUCCESS) continue;
       prop_count++;
 
-      // Single merged scan: required + property in one pass
       bool matched = false;
       for (auto& e : op.entries) {
-        if (key == e.key) {
+        if (raw_key.unsafe_is_equal(e.key)) {
           if (e.required_idx >= 0)
             required_found |= (1ULL << e.required_idx);
           if (e.sub) {
-            simdjson::ondemand::value fv;
-            if (field.value().get(fv) != SUCCESS) return false;
-            if (!od_exec_plan(*e.sub, fv)) return false;
+            // Fast dispatch: skip recursive od_exec_plan + type().get + switch
+            // for primitive sub-plans. Mirrors the constraint code in od_exec_plan.
+            switch (e.fk) {
+              case od_plan::fast_kind::INTEGER: {
+                int64_t iv;
+                if (field.value().get(iv) != SUCCESS) return false;
+                auto& sub = *e.sub;
+                uint8_t f = sub.num_flags;
+                double v = static_cast<double>(iv);
+                if ((f & od_plan::HAS_MIN) && v < sub.num_min) return false;
+                if ((f & od_plan::HAS_MAX) && v > sub.num_max) return false;
+                if ((f & od_plan::HAS_EX_MIN) && v <= sub.num_ex_min) return false;
+                if ((f & od_plan::HAS_EX_MAX) && v >= sub.num_ex_max) return false;
+                if (f & od_plan::HAS_MUL) {
+                  double r = std::fmod(v, sub.num_mul);
+                  if (std::abs(r) > 1e-8 && std::abs(r - sub.num_mul) > 1e-8) return false;
+                }
+                if (sub.enum_check) {
+                  bool em = false;
+                  for (auto i2 : sub.enum_check->integers) if (i2 == iv) { em = true; break; }
+                  if (!em) for (auto d : sub.enum_check->doubles) if (d == v) { em = true; break; }
+                  if (!em) return false;
+                }
+                break;
+              }
+              case od_plan::fast_kind::STRING: {
+                std::string_view sv;
+                if (field.value().get(sv) != SUCCESS) return false;
+                auto& sub = *e.sub;
+                if (sub.min_length || sub.max_length) {
+                  uint64_t len = utf8_length_fast(sv);
+                  if (sub.min_length && len < *sub.min_length) return false;
+                  if (sub.max_length && len > *sub.max_length) return false;
+                }
+                if (sub.digit_pattern) {
+                  auto& dp = *sub.digit_pattern;
+                  if (sv.size() < dp.min_len || sv.size() > dp.max_len) return false;
+                  const uint8_t* sp = reinterpret_cast<const uint8_t*>(sv.data());
+                  for (size_t i = 0, n = sv.size(); i < n; i++) {
+                    if (sp[i] < '0' || sp[i] > '9') return false;
+                  }
+                }
+#ifndef ATA_NO_RE2
+                else if (sub.pattern) {
+                  if (!re2::RE2::PartialMatch(re2::StringPiece(sv.data(), sv.size()), *sub.pattern))
+                    return false;
+                }
+#endif
+                if (sub.format_id != 255) {
+                  if (!check_format_by_id(sv, sub.format_id)) return false;
+                }
+                if (sub.enum_check) {
+                  bool em = false;
+                  for (auto& s : sub.enum_check->strings) {
+                    if (sv.size() == s.size() && std::memcmp(sv.data(), s.data(), s.size()) == 0) {
+                      em = true;
+                      break;
+                    }
+                  }
+                  if (!em) return false;
+                }
+                break;
+              }
+              case od_plan::fast_kind::BOOLEAN: {
+                bool bv;
+                if (field.value().get(bv) != SUCCESS) return false;
+                if (e.sub->enum_check) {
+                  if (bv ? !e.sub->enum_check->has_true : !e.sub->enum_check->has_false) return false;
+                }
+                break;
+              }
+              case od_plan::fast_kind::OBJECT: {
+                simdjson::ondemand::value fv;
+                if (field.value().get(fv) != SUCCESS) return false;
+                if (!od_exec_plan(*e.sub, fv,
+                                  simdjson::ondemand::json_type::object)) return false;
+                break;
+              }
+              case od_plan::fast_kind::ARRAY: {
+                simdjson::ondemand::value fv;
+                if (field.value().get(fv) != SUCCESS) return false;
+                if (!od_exec_plan(*e.sub, fv,
+                                  simdjson::ondemand::json_type::array)) return false;
+                break;
+              }
+              case od_plan::fast_kind::OTHER:
+              default: {
+                simdjson::ondemand::value fv;
+                if (field.value().get(fv) != SUCCESS) return false;
+                if (!od_exec_plan(*e.sub, fv)) return false;
+              }
+            }
           }
           matched = true;
           break;
         }
       }
+      // Safety net: if no match via raw byte compare, the JSON key may be
+      // escaped (e.g., "aname"). Fall back to a properly-unescaped
+      // compare so escaped keys still match the unescaped schema keys.
+      if (!matched) {
+        std::string_view raw_view = field.escaped_key();
+        if (raw_view.find('\\') != std::string_view::npos) {
+          std::string_view ukey;
+          if (field.unescaped_key().get(ukey) == SUCCESS) {
+            for (auto& e : op.entries) {
+              if (ukey == e.key) {
+                if (e.required_idx >= 0)
+                  required_found |= (1ULL << e.required_idx);
+                if (e.sub) {
+                  simdjson::ondemand::value fv;
+                  if (field.value().get(fv) != SUCCESS) return false;
+                  if (!od_exec_plan(*e.sub, fv)) return false;
+                }
+                matched = true;
+                break;
+              }
+            }
+          }
+        }
+      }
       if (!matched && op.no_additional) return false;
     }
 
@@ -2647,6 +2974,18 @@ static bool od_exec_plan(const od_plan& plan, simdjson::ondemand::value value) {
     if (ap.max_items && count > *ap.max_items) return false;
     break;
   }
+  case sjt::boolean: {
+    if (plan.enum_check) {
+      bool b;
+      if (value.get(b) != SUCCESS) return false;
+      if (b ? !plan.enum_check->has_true : !plan.enum_check->has_false) return false;
+    }
+    break;
+  }
+  case sjt::null: {
+    if (plan.enum_check && !plan.enum_check->has_null) return false;
+    break;
+  }
   default:
     break;
   }